SHARE
TWEET

CNF.hpp

a guest Apr 19th, 2019 121 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /*
  2.   Copyright by K.E. in germany
  3. */
  4.  
  5. #pragma once
  6. #include <iostream>
  7. #include <cstdio>
  8. #include <cstdlib>
  9. #include <sstream>
  10. #include <string>
  11. #include <stdio.h>
  12.  
  13. enum CnfType{
  14.     Integer = 0,
  15.     Double,
  16.     Bool,
  17.     Name,
  18.     Word
  19. };
  20.  
  21. struct DataContainer{
  22.     int primitiveType;
  23.     char* name;
  24.     DataContainer() {}
  25.     DataContainer(int i, int pType, const char* _name){
  26.         data.i = i;
  27.         primitiveType = pType;
  28.         name = (char*)_name;
  29.     }
  30.     DataContainer(double d, int pType, const char* _name){
  31.         data.d = d;
  32.         primitiveType = pType;
  33.         name = (char*)_name;
  34.     }
  35.     DataContainer(bool b, int pType, const char* _name){
  36.         data.b = b;
  37.         primitiveType = pType;
  38.         name = (char*)_name;
  39.     }
  40.     DataContainer(char* c, int pType, const char* _name){
  41.         data.c = c;
  42.         primitiveType = pType;
  43.         name = (char*)_name;
  44.     }
  45.  
  46.     union uData{
  47.         int i;
  48.         double d;
  49.         bool b;
  50.         char* c;
  51.     };
  52.  
  53.     size_t lineStoreNum;
  54.     uData data;
  55.     template<class T>
  56.     void getData(T& var){
  57.         if (primitiveType == 0)      var = data.i;
  58.         else if (primitiveType == 1) var = data.d;
  59.         else if (primitiveType == 2) var = data.b;
  60.     }
  61.  
  62.     void getData(char*& var){
  63.         if (primitiveType == 4) var = data.c;
  64.     }
  65.  
  66.     void printData(){
  67.         if (primitiveType == 0)
  68.             std::cout << "Integer Value: '" << data.i << "' Primitive Data Type: '" << primitiveType << "' Line Store Number: '" << lineStoreNum << "' Var Name: '" << name << "'" << std::endl;
  69.         if (primitiveType == 1)
  70.             std::cout << "Double Value: '" << data.d << "' Primitive Data Type: '" << primitiveType << "' Line Store Number: '" << lineStoreNum << "' Var Name: '" << name << "'" << std::endl;
  71.         if (primitiveType == 2)
  72.             std::cout << "Bool State: '" << data.b << "' Primitive Data Type: '" << primitiveType << "' Line Store Number: '" << lineStoreNum << "' Var Name: '" << name << "'" << std::endl;
  73.         if (primitiveType == 4)
  74.             std::cout << "Word: '" << data.c << "' Primitive Data Type: '" << primitiveType << "' Line Store Number: '" << lineStoreNum << "' Var Name: '" << name << "'" << std::endl;
  75.     }
  76. };
  77.  
  78. class CNFDataContainer{
  79. public:
  80.     DataContainer* i, *d, *b, *c;
  81. public:
  82.     size_t sizeIntArray, sizeDoubleArray, sizeBoolArray, sizeCharWArray, sizeArrays;
  83.     CNFDataContainer() { sizeIntArray = 0; sizeDoubleArray = 0; sizeBoolArray = 0; sizeCharWArray = 0; sizeArrays = 0; }
  84.     CNFDataContainer(size_t _sizeIntArray, size_t _sizeDoubleArray, size_t _sizeBoolArray, size_t _sizeWordArray, size_t _sizeArrays, DataContainer* ints, DataContainer* doubles, DataContainer* bools, DataContainer* words){
  85.         i = ints;
  86.         d = doubles;
  87.         b = bools;
  88.         c = words;
  89.         sizeIntArray = _sizeIntArray;
  90.         sizeDoubleArray = _sizeDoubleArray;
  91.         sizeBoolArray = _sizeBoolArray;
  92.         sizeCharWArray = _sizeWordArray;
  93.         sizeArrays = _sizeArrays;
  94.     }
  95.  
  96.     void push_back(DataContainer& data){
  97.         DataContainer* tmp;
  98.         switch (data.primitiveType){
  99.         case 0:
  100.             tmp = this->i;
  101.             this->i = new DataContainer[++this->sizeIntArray];
  102.             for (size_t i = 0; i < this->sizeIntArray - 1; i++)
  103.                 this->i[i] = tmp[i];
  104.             this->i[this->sizeIntArray - 1] = data;
  105.             delete[] tmp;
  106.             break;
  107.         case 1:
  108.             tmp = this->d;
  109.             this->d = new DataContainer[++this->sizeDoubleArray];
  110.             for (size_t i = 0; i < this->sizeDoubleArray - 1; i++)
  111.                 this->d[i] = tmp[i];
  112.             this->d[this->sizeDoubleArray - 1] = data;
  113.             delete[] tmp;
  114.             break;
  115.         case 2:
  116.             tmp = this->b;
  117.             this->b = new DataContainer[++this->sizeBoolArray];
  118.             for (size_t i = 0; i < this->sizeBoolArray - 1; i++)
  119.                 this->b[i] = tmp[i];
  120.             this->b[this->sizeBoolArray - 1] = data;
  121.             delete[] tmp;
  122.             break;
  123.         case 4:
  124.             tmp = this->c;
  125.             this->c = new DataContainer[++this->sizeCharWArray];
  126.             for (size_t i = 0; i < this->sizeCharWArray - 1; i++)
  127.                 this->c[i] = tmp[i];
  128.             this->c[this->sizeCharWArray - 1] = data;
  129.             delete[] tmp;
  130.             break;
  131.         }
  132.  
  133.         this->sizeArrays++;
  134.     }
  135.  
  136.     template<class T>
  137.     void push_back(const char* name, const int primitiveType, T value){
  138.         DataContainer* tmp;
  139.         DataContainer newData;
  140.         switch (primitiveType){
  141.         case 0:
  142.             tmp = this->i;
  143.             this->i = new DataContainer[++this->sizeIntArray];
  144.             for (size_t i = 0; i < this->sizeIntArray - 1; i++)
  145.                 this->i[i] = tmp[i];
  146.             newData.name = (char*)name;
  147.             newData.primitiveType = primitiveType;
  148.             newData.lineStoreNum = this->sizeArrays;
  149.             newData.data.i = value;
  150.             this->i[this->sizeIntArray - 1] = newData;
  151.             if(tmp == nullptr)
  152.                 delete[] tmp;
  153.             break;
  154.         case 1:
  155.             tmp = this->d;
  156.             this->d = new DataContainer[++this->sizeDoubleArray];
  157.             for (size_t i = 0; i < this->sizeDoubleArray - 1; i++)
  158.                 this->d[i] = tmp[i];
  159.             newData.name = (char*)name;
  160.             newData.primitiveType = primitiveType;
  161.             newData.lineStoreNum = this->sizeArrays;
  162.             newData.data.d = value;
  163.             this->d[this->sizeDoubleArray - 1] = newData;
  164.             if (tmp == nullptr)
  165.                 delete[] tmp;
  166.             break;
  167.         case 2:
  168.             tmp = this->b;
  169.             this->b = new DataContainer[++this->sizeBoolArray];
  170.             for (size_t i = 0; i < this->sizeBoolArray - 1; i++)
  171.                 this->b[i] = tmp[i];
  172.             newData.name = (char*)name;
  173.             newData.primitiveType = primitiveType;
  174.             newData.lineStoreNum = this->sizeArrays;
  175.             newData.data.b = value;
  176.             this->b[this->sizeBoolArray - 1] = newData;
  177.             if (tmp == nullptr)
  178.                 delete[] tmp;
  179.             break;
  180.         }
  181.  
  182.         this->sizeArrays++;
  183.     }
  184.  
  185.     void push_back(const char* name, const int primitiveType, const char* word){
  186.         DataContainer* tmp;
  187.         DataContainer newData;
  188.         tmp = this->c;
  189.         this->c = new DataContainer[++this->sizeCharWArray];
  190.         for (size_t i = 0; i < this->sizeCharWArray - 1; i++)
  191.             this->c[i] = tmp[i];
  192.         newData.name = (char*)name;
  193.         newData.primitiveType = primitiveType;
  194.         newData.lineStoreNum = this->sizeArrays;
  195.         newData.data.c = (char*)word;
  196.         this->c[this->sizeCharWArray - 1] = newData;
  197.         if (tmp == nullptr)
  198.             delete[] tmp;
  199.         this->sizeArrays++;
  200.     }
  201.  
  202.     void pop_back(const int primitiveType){
  203.         DataContainer* tmp;
  204.         switch (primitiveType){
  205.         case 0:
  206.             if (this->sizeIntArray <= NULL) return;
  207.             tmp = this->i;
  208.             this->i = new DataContainer[--this->sizeIntArray];
  209.             for (size_t i = 0; i < this->sizeIntArray; i++)
  210.                 this->i[i] = tmp[i];
  211.             if (tmp == nullptr)
  212.                 delete[] tmp;
  213.             break;
  214.         case 1:
  215.             if (this->sizeDoubleArray <= NULL) return;
  216.             tmp = this->d;
  217.             this->d = new DataContainer[--this->sizeDoubleArray];
  218.             for (size_t i = 0; i < this->sizeDoubleArray; i++)
  219.                 this->d[i] = tmp[i];
  220.             if (tmp == nullptr)
  221.                 delete[] tmp;;
  222.             break;
  223.         case 2:
  224.             if (this->sizeBoolArray <= NULL) return;
  225.             tmp = this->b;
  226.             this->b = new DataContainer[--this->sizeBoolArray];
  227.             for (size_t i = 0; i < this->sizeBoolArray; i++)
  228.                 this->b[i] = tmp[i];
  229.             if (tmp == nullptr)
  230.                 delete[] tmp;
  231.             break;
  232.         case 4:
  233.             if (this->sizeCharWArray <= NULL) return;
  234.             tmp = this->c;
  235.             this->c = new DataContainer[--this->sizeCharWArray];
  236.             for (size_t i = 0; i < this->sizeCharWArray; i++)
  237.                 this->c[i] = tmp[i];
  238.             if (tmp == nullptr)
  239.                 delete[] tmp;
  240.             break;
  241.         }
  242.  
  243.         this->sizeArrays--;
  244.     }
  245.  
  246.     void push_front(DataContainer& data){
  247.         DataContainer* tmp;
  248.         size_t lineStoreNum;
  249.         switch (data.primitiveType){
  250.         case 0:
  251.             lineStoreNum = this->i[0].lineStoreNum;
  252.             tmp = this->i;
  253.             this->i = new DataContainer[++this->sizeIntArray];
  254.             data.lineStoreNum = lineStoreNum;
  255.             this->i[0] = data;
  256.             for (size_t i = 1; i < this->sizeIntArray; i++)
  257.                 this->i[i] = tmp[i - 1];
  258.             if (tmp == nullptr)
  259.                 delete[] tmp;
  260.             break;
  261.         case 1:
  262.             lineStoreNum = this->d[0].lineStoreNum;
  263.             tmp = this->d;
  264.             this->d = new DataContainer[++this->sizeDoubleArray];
  265.             data.lineStoreNum = lineStoreNum;
  266.             this->d[0] = data;
  267.             for (size_t i = 1; i < this->sizeDoubleArray; i++)
  268.                 this->d[i] = tmp[i - 1];
  269.             if (tmp == nullptr)
  270.                 delete[] tmp;
  271.             break;
  272.         case 2:
  273.             lineStoreNum = this->b[0].lineStoreNum;
  274.             tmp = this->b;
  275.             this->b = new DataContainer[++this->sizeBoolArray];
  276.             data.lineStoreNum = lineStoreNum;
  277.             this->b[0] = data;
  278.             for (size_t i = 1; i < this->sizeBoolArray; i++)
  279.                 this->b[i] = tmp[i - 1];
  280.             if (tmp == nullptr)
  281.                 delete[] tmp;
  282.             break;
  283.         case 4:
  284.             lineStoreNum = this->c[0].lineStoreNum;
  285.             tmp = this->c;
  286.             this->c = new DataContainer[++this->sizeCharWArray];
  287.             data.lineStoreNum = lineStoreNum;
  288.             this->c[0] = data;
  289.             for (size_t i = 1; i < this->sizeCharWArray; i++)
  290.                 this->c[i] = tmp[i - 1];
  291.             if (tmp == nullptr)
  292.                 delete[] tmp;
  293.             break;
  294.         }
  295.  
  296.         switch (data.primitiveType){
  297.         case 0:
  298.             for (size_t i = 1; i < this->sizeIntArray; i++)
  299.                 if (lineStoreNum <= this->i[i].lineStoreNum)
  300.                     this->i[i].lineStoreNum++;
  301.             for (size_t i = 0; i < this->sizeDoubleArray; i++)
  302.                 if (lineStoreNum <= this->d[i].lineStoreNum)
  303.                     this->d[i].lineStoreNum++;
  304.             for (size_t i = 0; i < this->sizeBoolArray; i++)
  305.                 if (lineStoreNum <= this->b[i].lineStoreNum)
  306.                     this->b[i].lineStoreNum++;
  307.             for (size_t i = 0; i < this->sizeCharWArray; i++)
  308.                 if (lineStoreNum <= this->c[i].lineStoreNum)
  309.                     this->c[i].lineStoreNum++;
  310.             break;
  311.         case 1:
  312.             for (size_t i = 0; i < this->sizeIntArray; i++)
  313.                 if (lineStoreNum <= this->i[i].lineStoreNum)
  314.                     this->i[i].lineStoreNum++;
  315.             for (size_t i = 1; i < this->sizeDoubleArray; i++)
  316.                 if (lineStoreNum <= this->d[i].lineStoreNum)
  317.                     this->d[i].lineStoreNum++;
  318.             for (size_t i = 0; i < this->sizeBoolArray; i++)
  319.                 if (lineStoreNum <= this->b[i].lineStoreNum)
  320.                     this->b[i].lineStoreNum++;
  321.             for (size_t i = 0; i < this->sizeCharWArray; i++)
  322.                 if (lineStoreNum <= this->c[i].lineStoreNum)
  323.                     this->c[i].lineStoreNum++;
  324.             break;
  325.         case 2:
  326.             for (size_t i = 0; i < this->sizeIntArray; i++)
  327.                 if (lineStoreNum <= this->i[i].lineStoreNum)
  328.                     this->i[i].lineStoreNum++;
  329.             for (size_t i = 0; i < this->sizeDoubleArray; i++)
  330.                 if (lineStoreNum <= this->d[i].lineStoreNum)
  331.                     this->d[i].lineStoreNum++;
  332.             for (size_t i = 1; i < this->sizeBoolArray; i++)
  333.                 if (lineStoreNum <= this->b[i].lineStoreNum)
  334.                     this->b[i].lineStoreNum++;
  335.             for (size_t i = 0; i < this->sizeCharWArray; i++)
  336.                 if (lineStoreNum <= this->c[i].lineStoreNum)
  337.                     this->c[i].lineStoreNum++;
  338.             break;
  339.         case 4:
  340.             for (size_t i = 0; i < this->sizeIntArray; i++)
  341.                 if (lineStoreNum <= this->i[i].lineStoreNum)
  342.                     this->i[i].lineStoreNum++;
  343.             for (size_t i = 0; i < this->sizeDoubleArray; i++)
  344.                 if (lineStoreNum <= this->d[i].lineStoreNum)
  345.                     this->d[i].lineStoreNum++;
  346.             for (size_t i = 0; i < this->sizeBoolArray; i++)
  347.                 if (lineStoreNum <= this->b[i].lineStoreNum)
  348.                     this->b[i].lineStoreNum++;
  349.             for (size_t i = 1; i < this->sizeCharWArray; i++)
  350.                 if (lineStoreNum <= this->c[i].lineStoreNum)
  351.                     this->c[i].lineStoreNum++;
  352.             break;
  353.         }
  354.  
  355.         this->sizeArrays++;
  356.     }
  357.  
  358.     template<class T>
  359.     void push_front(const char* name, const int primitiveType, T value){
  360.         DataContainer* tmp;
  361.         DataContainer newData;
  362.         int lineStoreNum;
  363.         switch (primitiveType){
  364.         case 0:
  365.             lineStoreNum = this->i[0].lineStoreNum;
  366.             tmp = this->i;
  367.             this->i = new DataContainer[++this->sizeIntArray];
  368.             newData.name = (char*)name;
  369.             newData.primitiveType = primitiveType;
  370.             newData.lineStoreNum = lineStoreNum;
  371.             newData.data.i = value;
  372.             this->i[0] = newData;
  373.             for (size_t i = 1; i < this->sizeIntArray; i++)
  374.                 this->i[i] = tmp[i - 1];
  375.             if (tmp == nullptr)
  376.                 delete[] tmp;
  377.             break;
  378.         case 1:
  379.             lineStoreNum = this->d[0].lineStoreNum;
  380.             tmp = this->d;
  381.             this->d = new DataContainer[++this->sizeDoubleArray];
  382.             newData.name = (char*)name;
  383.             newData.primitiveType = primitiveType;
  384.             newData.lineStoreNum = lineStoreNum;
  385.             newData.data.d = value;
  386.             this->d[0] = newData;
  387.             for (size_t i = 1; i < this->sizeDoubleArray; i++)
  388.                 this->d[i] = tmp[i - 1];
  389.             if (tmp == nullptr)
  390.                 delete[] tmp;
  391.             break;
  392.         case 2:
  393.             lineStoreNum = this->b[0].lineStoreNum;
  394.             tmp = this->b;
  395.             this->b = new DataContainer[++this->sizeBoolArray];
  396.             newData.name = (char*)name;
  397.             newData.primitiveType = primitiveType;
  398.             newData.lineStoreNum = lineStoreNum;
  399.             newData.data.b = value;
  400.             this->b[0] = newData;
  401.             for (size_t i = 1; i < this->sizeBoolArray; i++)
  402.                 this->b[i] = tmp[i - 1];
  403.             if (tmp == nullptr)
  404.                 delete[] tmp;
  405.             break;
  406.         }
  407.  
  408.         switch (primitiveType){
  409.         case 0:
  410.             for (size_t i = 1; i < this->sizeIntArray; i++)
  411.                 if (lineStoreNum <= this->i[i].lineStoreNum)
  412.                     this->i[i].lineStoreNum++;
  413.             for (size_t i = 0; i < this->sizeDoubleArray; i++)
  414.                 if (lineStoreNum <= this->d[i].lineStoreNum)
  415.                     this->d[i].lineStoreNum++;
  416.             for (size_t i = 0; i < this->sizeBoolArray; i++)
  417.                 if (lineStoreNum <= this->b[i].lineStoreNum)
  418.                     this->b[i].lineStoreNum++;
  419.             for (size_t i = 0; i < this->sizeCharWArray; i++)
  420.                 if (lineStoreNum <= this->c[i].lineStoreNum)
  421.                     this->c[i].lineStoreNum++;
  422.             break;
  423.         case 1:
  424.             for (size_t i = 0; i < this->sizeIntArray; i++)
  425.                 if (lineStoreNum <= this->i[i].lineStoreNum)
  426.                     this->i[i].lineStoreNum++;
  427.             for (size_t i = 1; i < this->sizeDoubleArray; i++)
  428.                 if (lineStoreNum <= this->d[i].lineStoreNum)
  429.                     this->d[i].lineStoreNum++;
  430.             for (size_t i = 0; i < this->sizeBoolArray; i++)
  431.                 if (lineStoreNum <= this->b[i].lineStoreNum)
  432.                     this->b[i].lineStoreNum++;
  433.             for (size_t i = 0; i < this->sizeCharWArray; i++)
  434.                 if (lineStoreNum <= this->c[i].lineStoreNum)
  435.                     this->c[i].lineStoreNum++;
  436.             break;
  437.         case 2:
  438.             for (size_t i = 0; i < this->sizeIntArray; i++)
  439.                 if (lineStoreNum <= this->i[i].lineStoreNum)
  440.                     this->i[i].lineStoreNum++;
  441.             for (size_t i = 0; i < this->sizeDoubleArray; i++)
  442.                 if (lineStoreNum <= this->d[i].lineStoreNum)
  443.                     this->d[i].lineStoreNum++;
  444.             for (size_t i = 1; i < this->sizeBoolArray; i++)
  445.                 if (lineStoreNum <= this->b[i].lineStoreNum)
  446.                     this->b[i].lineStoreNum++;
  447.             for (size_t i = 0; i < this->sizeCharWArray; i++)
  448.                 if (lineStoreNum <= this->c[i].lineStoreNum)
  449.                     this->c[i].lineStoreNum++;
  450.             break;
  451.         }
  452.  
  453.         this->sizeArrays++;
  454.     }
  455.  
  456.     void push_front(const char* name, const int primitiveType, const char* word){
  457.         DataContainer* tmp;
  458.         DataContainer newData;
  459.         size_t lineStoreNum;
  460.         lineStoreNum = this->c[0].lineStoreNum;
  461.         tmp = this->c;
  462.         this->c = new DataContainer[++this->sizeCharWArray];
  463.         newData.name = (char*)name;
  464.         newData.primitiveType = primitiveType;
  465.         newData.lineStoreNum = lineStoreNum;
  466.         newData.data.c = (char*)word;
  467.         this->c[0] = newData;
  468.         for (size_t i = 1; i < this->sizeCharWArray; i++)
  469.             this->c[i] = tmp[i - 1];
  470.         for (size_t i = 0; i < this->sizeIntArray; i++)
  471.             if (lineStoreNum <= this->i[i].lineStoreNum)
  472.                 this->i[i].lineStoreNum++;
  473.         for (size_t i = 0; i < this->sizeDoubleArray; i++)
  474.             if (lineStoreNum <= this->d[i].lineStoreNum)
  475.                 this->d[i].lineStoreNum++;
  476.         for (size_t i = 0; i < this->sizeBoolArray; i++)
  477.             if (lineStoreNum <= this->b[i].lineStoreNum)
  478.                 this->b[i].lineStoreNum++;
  479.         for (size_t i = 1; i < this->sizeCharWArray; i++)
  480.             if (lineStoreNum <= this->c[i].lineStoreNum)
  481.                 this->c[i].lineStoreNum++;
  482.         if (tmp == nullptr)
  483.             delete[] tmp;
  484.         this->sizeArrays++;
  485.     }
  486.  
  487.     void pop_front(const int primitiveType){
  488.         DataContainer* tmp;
  489.         switch (primitiveType)
  490.         {
  491.         case 0:
  492.             tmp = this->i;
  493.             this->i = new DataContainer[--this->sizeIntArray];
  494.             for (size_t i = 1; i < this->sizeIntArray; i++)
  495.                 this->i[i - 1] = tmp[i];
  496.             if (tmp == nullptr)
  497.                 delete[] tmp;
  498.             break;
  499.         case 1:
  500.             tmp = this->d;
  501.             this->d = new DataContainer[--this->sizeDoubleArray];
  502.             for (size_t i = 1; i < this->sizeDoubleArray; i++)
  503.                 this->d[i - 1] = tmp[i];
  504.             if (tmp == nullptr)
  505.                 delete[] tmp;
  506.             break;
  507.         case 2:
  508.             tmp = this->b;
  509.             this->b = new DataContainer[--this->sizeBoolArray];
  510.             for (size_t i = 1; i < this->sizeBoolArray; i++)
  511.                 this->b[i - 1] = tmp[i];
  512.             if (tmp == nullptr)
  513.                 delete[] tmp;
  514.             break;
  515.         case 4:
  516.             tmp = this->c;
  517.             this->c = new DataContainer[--this->sizeCharWArray];
  518.             for (size_t i = 1; i < this->sizeCharWArray; i++)
  519.                 this->c[i - 1] = tmp[i];
  520.             if (tmp == nullptr)
  521.                 delete[] tmp;
  522.             break;
  523.         }
  524.  
  525.         this->sizeArrays--;
  526.     }
  527.  
  528.     DataContainer at(const int primitiveType, size_t index){
  529.         DataContainer tmp;
  530.         switch (primitiveType){
  531.         case 0:
  532.             if (index > this->sizeIntArray) break;
  533.             tmp = this->i[index];
  534.             break;
  535.         case 1:
  536.             if (index > this->sizeDoubleArray) break;
  537.             tmp = this->d[index];
  538.             break;
  539.         case 2:
  540.             if (index > this->sizeBoolArray) break;
  541.             tmp = this->b[index];
  542.             break;
  543.         case 4:
  544.             if (index > this->sizeCharWArray) break;
  545.             tmp = this->c[index];
  546.             break;
  547.         }
  548.  
  549.         return tmp;
  550.     }
  551.  
  552.     void freeMemory() {
  553.         this->i = new DataContainer[1];
  554.         this->d = new DataContainer[1];
  555.         this->b = new DataContainer[1];
  556.         this->c = new DataContainer[1];
  557.  
  558.         delete[] this->i;
  559.         delete[] this->d;
  560.         delete[] this->b;
  561.         delete[] this->c;
  562.  
  563.         this->sizeArrays = NULL;
  564.         this->sizeIntArray = NULL;
  565.         this->sizeDoubleArray = NULL;
  566.         this->sizeBoolArray = NULL;
  567.         this->sizeCharWArray = NULL;
  568.     }
  569. };
  570.  
  571. class CNF{
  572.     DataContainer* data;
  573.  
  574.     bool checkInt(char data){
  575.         return (data == '0' || data == '1' || data == '2'
  576.             || data == '3' || data == '4' || data == '5'
  577.             || data == '6' || data == '7' || data == '8'
  578.             || data == '9');
  579.     }
  580.  
  581.     bool checkLetter(char data){
  582.         return !checkInt(data);
  583.     }
  584.  
  585.     char* readFile(const char* filePath){
  586.         FILE* file;
  587.         fopen_s(&file, filePath, "rb");
  588.         //file = fopen(filePath, "rb");
  589.         if (file == nullptr)
  590.         {
  591.             std::cerr << "READFILE::ERROR::FILE_NOT_EXIST" << std::endl;
  592.             return (char*)"ERROR";
  593.         }
  594.         fseek(file, 0, SEEK_END);
  595.         size_t len = ftell(file);
  596.         rewind(file);
  597.         char* buf = (char*)malloc(sizeof(char) * (len + 1));
  598.         if (buf == nullptr)
  599.         {
  600.             fclose(file);
  601.             std::cerr << "READFILE::ERROR::CAN_NOT_ALLOCATE_MEMORY" << std::endl;
  602.             return (char*)"ERROR";
  603.         }
  604.         size_t bytesRead = fread(buf, sizeof(char), len, file);
  605.         buf[bytesRead] = '\0';
  606.         fclose(file);
  607.         return buf;
  608.     }
  609.  
  610.     void writeFile(char* buffer, const char* filePath, const char* mode){
  611.         FILE* file;
  612.         fopen_s(&file, filePath, mode);
  613.         //file = fopen(filePath, mode);
  614.         if (file == nullptr){
  615.             std::cerr << "WRITEFILE::ERROR::FILE_NOT_EXIST_OR_CREATE_ERROR" << std::endl;
  616.             return;
  617.         }
  618.  
  619.         if (fprintf(file, buffer) < 0){
  620.             std::cerr << "WRITEFILE::ERROR::CAN_NOT_WRITE_TO_FILE" << std::endl;
  621.             return;
  622.         } else if (fprintf(file, "\n") < 0){
  623.             std::cerr << "WRITEFILE::ERROR::CAN_NOT_WRITE_TO_FILE" << std::endl;
  624.             return;
  625.         }
  626.         fclose(file);
  627.     }
  628.  
  629. public:
  630.  
  631.     int* ints = { nullptr };
  632.     double* doubles = { nullptr };
  633.     bool* bools = { nullptr };
  634.     std::string* names = { nullptr };
  635.     std::string* words = { nullptr };
  636.  
  637.     CnfType* primitiveTypeArray = { nullptr };
  638.     const char* filePath = "";
  639.  
  640.     size_t sizeArrays = 0;
  641.     size_t sizeIntArray = 0;
  642.     size_t sizeDoubleArray = 0;
  643.     size_t sizeBoolArray = 0;
  644.     size_t sizeCharNArray = 0;
  645.     size_t sizeCharWArray = 0;
  646.  
  647.     void readCnfFile(const char* filePath){
  648.         std::stringstream sstr = std::stringstream();
  649.  
  650.         char* data = readFile(filePath);
  651.         size_t count_int = 0;
  652.         size_t count_bool = 0;
  653.         size_t count_double = 0;
  654.         size_t count_words = 0;
  655.         size_t count_names = 0;
  656.         size_t size_cd = (size_t)strlen(data);
  657.         bool break_bool = false;
  658.  
  659.         size_t inInts = 0;
  660.         size_t inDoubles = 0;
  661.         size_t inBools = 0;
  662.         size_t inNames = 0;
  663.         size_t inWords = 0;
  664.         size_t inCnfType = 0;
  665.  
  666.         int* ints;
  667.         double* doubles;
  668.         bool* bools;
  669.         std::string* names;
  670.         std::string* words;
  671.         CnfType* primitiveTypeArray;
  672.  
  673.         std::string buf;
  674.         char* cBuf;
  675.         double dBuf;
  676.         bool isDouble = false;
  677.  
  678.         for (int i = 0; i < size_cd; i++){
  679.             break_bool = false;
  680.             if (data[i] == '=' && data[i + 1] == ':'){
  681.                 count_names++; i += 2;
  682.                 if (checkLetter(data[i])){
  683.                     if (data[i] == 't' || data[i] == 'T'){
  684.                         for (int x = i; x < i + 5; x++){
  685.                             sstr << data[x];
  686.                         }
  687.                         sstr >> buf;
  688.                         if (buf == "true;" | buf == "True;" || buf == "TRUE;"){
  689.                             count_bool++;
  690.                             i += 6;
  691.                             sstr.flush();
  692.                             sstr = std::stringstream();
  693.                         } else{
  694.                             sstr.flush();
  695.                             sstr = std::stringstream();
  696.                             for (int x = i; x < size_cd; x++)
  697.                                 if (data[x] == ';') { count_words++; i = x + 1; break; }
  698.                         }
  699.                     } else if (data[i] == 'f' || data[i] == 'F'){
  700.                         for (int x = i; x < i + 6; x++){
  701.                             sstr << data[x];
  702.                         }
  703.                         sstr >> buf;
  704.                         if (buf == "false;" | buf == "False;" || buf == "FALSE;"){
  705.                             count_bool++;
  706.                             i += 7;
  707.                             sstr.flush();
  708.                             sstr = std::stringstream();
  709.                         } else{
  710.                             sstr.flush();
  711.                             sstr = std::stringstream();
  712.                             for (int x = i; x < size_cd; x++)
  713.                                 if (data[x] == ';') { count_words++; i = x + 1; break; }
  714.                         }
  715.                     } else{
  716.                         for (int x = i; x < size_cd; x++)
  717.                             if (data[x] == ';') { count_words++; i = x + 1; break; }
  718.                     }
  719.                 } else if (checkInt(data[i])){
  720.                     for (int x = i; x < size_cd; x++){
  721.                         if (break_bool) break;
  722.                         if (data[x] == '.'){
  723.                             count_double++;
  724.                             for (int y = x; y < size_cd; y++)
  725.                                 if (data[y] == ';') { i = y + 1; break_bool = true; break; }
  726.                         } else if (data[x] == ';') { i = x + 1; count_int++; break; }
  727.                     }
  728.                 }
  729.             }
  730.         }
  731.  
  732.  
  733.         size_t count_CnfType = count_int + count_double + count_bool + count_words;
  734.  
  735.         this->ints = new int[count_int];
  736.         this->doubles = new double[count_double];
  737.         this->bools = new bool[count_bool];
  738.         this->names = new std::string[count_names];
  739.         this->words = new std::string[count_words];
  740.         this->primitiveTypeArray = new CnfType[count_CnfType];
  741.         this->filePath = filePath;
  742.  
  743.         ints = new int[count_int];
  744.         doubles = new double[count_double];
  745.         bools = new bool[count_bool];
  746.         names = new std::string[count_names];
  747.         words = new std::string[count_words];
  748.         primitiveTypeArray = new CnfType[count_CnfType];
  749.  
  750.         this->sizeIntArray = count_int;
  751.         this->sizeDoubleArray = count_double;
  752.         this->sizeBoolArray = count_bool;
  753.         this->sizeCharNArray = count_names;
  754.         this->sizeCharWArray = count_words;
  755.         this->sizeArrays = count_CnfType;
  756.  
  757.         if (count_CnfType == 0){
  758.             std::cout << "ERROR!" << std::endl;
  759.             return;
  760.         }
  761.  
  762.         for (int i = 0; i < count_int; i++) { this->ints[i] = 0; }
  763.         for (int i = 0; i < count_double; i++) { this->doubles[i] = 0; }
  764.         for (int i = 0; i < count_bool; i++) { this->bools[i] = 0; }
  765.         for (int i = 0; i < count_names; i++) { this->names[i] = "0"; }
  766.         for (int i = 0; i < count_words; i++) { this->words[i] = "0"; }
  767.  
  768.         sstr = std::stringstream();
  769.         buf = std::string();
  770.  
  771.         for (int i = 0; i < size_cd; i++){
  772.             if (data[i] == '\n')
  773.                 i++;
  774.             if (data[i] == '\r')
  775.                 i++;
  776.             if (data[i - 1] == ' ')
  777.                 for (int x = i; x < size_cd; x++, i++)
  778.                     if (data[x] == '=') break;
  779.             if (data[i] == '=' && data[i + 1] == ':'){
  780.                 names[inNames].push_back(' ');
  781.                 names[inNames++].pop_back();
  782.                 i += 2;
  783.                 if (checkLetter(data[i]))
  784.                 {
  785.                     for (int x = i; x < size_cd; x++){
  786.                         if (data[x] == ';'){
  787.                             if (buf == "true" || buf == "True" || buf == "TRUE"){
  788.                                 bools[inBools++] = true;
  789.                                 primitiveTypeArray[inCnfType++] = CnfType::Bool;
  790.                                 i = x + 1;
  791.                             } else if (buf == "false" || buf == "False" || buf == "FALSE"){
  792.                                 bools[inBools++] = false;
  793.                                 primitiveTypeArray[inCnfType++] = CnfType::Bool;
  794.                                 i = x + 1;
  795.                             } else{
  796.                                 words[inWords++] = buf;
  797.                                 primitiveTypeArray[inCnfType++] = CnfType::Word;
  798.                                 i = x + 1;
  799.                                 cBuf = new char;
  800.                             }
  801.                             buf = std::string();
  802.                             break;
  803.                         }
  804.                         buf.push_back(data[x]);
  805.                     }
  806.                 }
  807.                 else if (checkInt(data[i])){
  808.                     for (int x = i; x < size_cd; x++){
  809.                         if (data[x] == '.') isDouble = true;
  810.                         if (data[x] == ';'){
  811.                             sstr >> dBuf;
  812.                             if (isDouble) { isDouble = false; doubles[inDoubles++] = dBuf; primitiveTypeArray[inCnfType++] = CnfType::Double; }
  813.                             else { ints[inInts++] = (int)dBuf; primitiveTypeArray[inCnfType++] = CnfType::Integer; }
  814.                             sstr.flush();
  815.                             sstr = std::stringstream();
  816.                             i = x + 1;
  817.                             break;
  818.                         } else
  819.                             sstr << data[x];
  820.                     }
  821.                 }
  822.             }
  823.             if (i != size_cd){
  824.                 if (data[i] != '\r'){
  825.                     if (data[i] != '\n'){
  826.                         names[inNames].push_back(data[i]);
  827.                     }
  828.                 }
  829.             }
  830.         }
  831.  
  832.         this->ints = ints;
  833.         this->doubles = doubles;
  834.         this->bools = bools;
  835.         this->names = names;
  836.         this->words = words;
  837.         this->primitiveTypeArray = primitiveTypeArray;
  838.     }
  839.  
  840.     void writeCnfFile(CNFDataContainer& data, const char* path){
  841.         std::string buf = std::string();
  842.  
  843.         size_t outInts = 0;
  844.         size_t outDoubles = 0;
  845.         size_t outBools = 0;
  846.         size_t outWords = 0;
  847.         size_t outNames = 0;
  848.         size_t countLoop = 0;
  849.  
  850.         for (int i = 0; i < data.sizeArrays;){
  851.             for (int x = 0; x < data.sizeIntArray; x++){
  852.                 if (data.i[x].lineStoreNum == i){
  853.                     buf.append(data.i[x].name);
  854.                     buf.append("=:");
  855.                     buf.append(std::to_string(data.i[x].data.i));
  856.                     buf.append(";\n");
  857.                     outInts++;
  858.                     outNames++;
  859.                     i++;
  860.                     break;
  861.                 }
  862.             }
  863.             for (int x = 0; x < data.sizeDoubleArray; x++){
  864.                 if (data.d[x].lineStoreNum == i){
  865.                     buf.append(data.d[x].name);
  866.                     buf.append("=:");
  867.                     buf.append(std::to_string(data.d[x].data.d));
  868.                     buf.append(";\n");
  869.                     outDoubles++;
  870.                     outNames++;
  871.                     i++;
  872.                     break;
  873.                 }
  874.             }
  875.             for (int x = 0; x < data.sizeBoolArray; x++){
  876.                 if (data.b[x].lineStoreNum == i){
  877.                     buf.append(data.b[x].name);
  878.                     buf.append("=:");
  879.                     if (data.b[x].data.b == true)
  880.                         buf.append("true");
  881.                     else
  882.                         buf.append("false");
  883.                     buf.append(";\n");
  884.                     outBools++;
  885.                     outNames++;
  886.                     i++;
  887.                     break;
  888.                 }
  889.             }
  890.             for (int x = 0; x < data.sizeCharWArray; x++){
  891.                 if (data.c[x].lineStoreNum == i){
  892.                     buf.append(data.c[x].name);
  893.                     buf.append("=:");
  894.                     buf.append(data.c[x].data.c);
  895.                     buf.append(";\n");
  896.                     outWords++;
  897.                     outNames++;
  898.                     i++;
  899.                     break;
  900.                 }
  901.             }
  902.         }
  903.         writeFile((char*)buf.c_str(), path, "w");
  904.     }
  905.  
  906.     DataContainer* getData(CnfType cnfType){
  907.         int counter = 0;
  908.         switch (cnfType){
  909.         case Integer:
  910.             data = new DataContainer[sizeIntArray];
  911.             for (int i = 0; i < sizeIntArray; i++){
  912.                 data[i].primitiveType = Integer;
  913.                 data[i].data.i = ints[i];
  914.             }
  915.             for (int i = 0; i < sizeCharNArray; i++){
  916.                 if (primitiveTypeArray[i] == Integer) { data[counter].name = (char*)names[i].c_str(); data[counter].lineStoreNum = i; counter++; }
  917.             }
  918.             break;
  919.         case Double:
  920.             data = new DataContainer[sizeDoubleArray];
  921.             for (int i = 0; i < sizeDoubleArray; i++){
  922.                 data[i].primitiveType = Double;
  923.                 data[i].data.d = doubles[i];
  924.             }
  925.             for (int i = 0; i < sizeCharNArray; i++){
  926.                 if (primitiveTypeArray[i] == Double) { data[counter].name = (char*)names[i].c_str(); data[counter].lineStoreNum = i; counter++; }
  927.             }
  928.             break;
  929.         case Bool:
  930.             data = new DataContainer[sizeBoolArray];
  931.             for (int i = 0; i < sizeBoolArray; i++){
  932.                 data[i].primitiveType = Bool;
  933.                 data[i].data.b = bools[i];
  934.             }
  935.             for (int i = 0; i < sizeCharNArray; i++){
  936.                 if (primitiveTypeArray[i] == Bool) { data[counter].name = (char*)names[i].c_str(); data[counter].lineStoreNum = i; counter++; }
  937.             }
  938.             break;
  939.         case Word:
  940.             data = new DataContainer[sizeCharWArray];
  941.             for (int i = 0; i < sizeCharWArray; i++){
  942.                 data[i].primitiveType = Word;
  943.                 data[i].data.c = (char*)words[i].c_str();
  944.             }
  945.             for (int i = 0; i < sizeCharNArray; i++){
  946.                 if (primitiveTypeArray[i] == Word) { data[counter].name = (char*)names[i].c_str(); data[counter].lineStoreNum = i; counter++; }
  947.             }
  948.             break;
  949.         }
  950.         return data;
  951.     }
  952.  
  953.     CNFDataContainer convertToCNFDataContainer(){
  954.         DataContainer* ints, *doubles, *bools, *words;
  955.         ints = getData(Integer);
  956.         doubles = getData(Double);
  957.         bools = getData(Bool);
  958.         words = getData(Word);
  959.         CNFDataContainer tmp(this->sizeIntArray, this->sizeDoubleArray, this->sizeBoolArray, this->sizeCharWArray, this->sizeArrays, ints, doubles, bools, words);
  960.         return tmp;
  961.     }
  962. };
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top