CNF.hpp

/*
  Copyright by K.E. in germany
*/

#pragma once
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <sstream>
#include <string>
#include <stdio.h>

enum CnfType{
    Integer = 0,
    Double,
    Bool,
    Name,
    Word
};

struct DataContainer{
    int primitiveType;
    char* name;
    DataContainer() {}
    DataContainer(int i, int pType, const char* _name){
        data.i = i;
        primitiveType = pType;
        name = (char*)_name;
    }
    DataContainer(double d, int pType, const char* _name){
        data.d = d;
        primitiveType = pType;
        name = (char*)_name;
    }
    DataContainer(bool b, int pType, const char* _name){
        data.b = b;
        primitiveType = pType;
        name = (char*)_name;
    }
    DataContainer(char* c, int pType, const char* _name){
        data.c = c;
        primitiveType = pType;
        name = (char*)_name;
    }

    union uData{
        int i;
        double d;
        bool b;
        char* c;
    };

    size_t lineStoreNum;
    uData data;
    template<class T>
    void getData(T& var){
        if (primitiveType == 0)      var = data.i;
        else if (primitiveType == 1) var = data.d;
        else if (primitiveType == 2) var = data.b;
    }

    void getData(char*& var){
        if (primitiveType == 4) var = data.c;
    }

    void printData(){
        if (primitiveType == 0)
            std::cout << "Integer Value: '" << data.i << "' Primitive Data Type: '" << primitiveType << "' Line Store Number: '" << lineStoreNum << "' Var Name: '" << name << "'" << std::endl;
        if (primitiveType == 1)
            std::cout << "Double Value: '" << data.d << "' Primitive Data Type: '" << primitiveType << "' Line Store Number: '" << lineStoreNum << "' Var Name: '" << name << "'" << std::endl;
        if (primitiveType == 2)
            std::cout << "Bool State: '" << data.b << "' Primitive Data Type: '" << primitiveType << "' Line Store Number: '" << lineStoreNum << "' Var Name: '" << name << "'" << std::endl;
        if (primitiveType == 4)
            std::cout << "Word: '" << data.c << "' Primitive Data Type: '" << primitiveType << "' Line Store Number: '" << lineStoreNum << "' Var Name: '" << name << "'" << std::endl;
    }
};

class CNFDataContainer{
public:
    DataContainer* i, *d, *b, *c;
public:
    size_t sizeIntArray, sizeDoubleArray, sizeBoolArray, sizeCharWArray, sizeArrays;
    CNFDataContainer() { sizeIntArray = 0; sizeDoubleArray = 0; sizeBoolArray = 0; sizeCharWArray = 0; sizeArrays = 0; }
    CNFDataContainer(size_t _sizeIntArray, size_t _sizeDoubleArray, size_t _sizeBoolArray, size_t _sizeWordArray, size_t _sizeArrays, DataContainer* ints, DataContainer* doubles, DataContainer* bools, DataContainer* words){
        i = ints;
        d = doubles;
        b = bools;
        c = words;
        sizeIntArray = _sizeIntArray;
        sizeDoubleArray = _sizeDoubleArray;
        sizeBoolArray = _sizeBoolArray;
        sizeCharWArray = _sizeWordArray;
        sizeArrays = _sizeArrays;
    }

    void push_back(DataContainer& data){
        DataContainer* tmp;
        switch (data.primitiveType){
        case 0:
            tmp = this->i;
            this->i = new DataContainer[++this->sizeIntArray];
            for (size_t i = 0; i < this->sizeIntArray - 1; i++)
                this->i[i] = tmp[i];
            this->i[this->sizeIntArray - 1] = data;
            delete[] tmp;
            break;
        case 1:
            tmp = this->d;
            this->d = new DataContainer[++this->sizeDoubleArray];
            for (size_t i = 0; i < this->sizeDoubleArray - 1; i++)
                this->d[i] = tmp[i];
            this->d[this->sizeDoubleArray - 1] = data;
            delete[] tmp;
            break;
        case 2:
            tmp = this->b;
            this->b = new DataContainer[++this->sizeBoolArray];
            for (size_t i = 0; i < this->sizeBoolArray - 1; i++)
                this->b[i] = tmp[i];
            this->b[this->sizeBoolArray - 1] = data;
            delete[] tmp;
            break;
        case 4:
            tmp = this->c;
            this->c = new DataContainer[++this->sizeCharWArray];
            for (size_t i = 0; i < this->sizeCharWArray - 1; i++)
                this->c[i] = tmp[i];
            this->c[this->sizeCharWArray - 1] = data;
            delete[] tmp;
            break;
        }

        this->sizeArrays++;
    }

    template<class T>
    void push_back(const char* name, const int primitiveType, T value){
        DataContainer* tmp;
        DataContainer newData;
        switch (primitiveType){
        case 0:
            tmp = this->i;
            this->i = new DataContainer[++this->sizeIntArray];
            for (size_t i = 0; i < this->sizeIntArray - 1; i++)
                this->i[i] = tmp[i];
            newData.name = (char*)name;
            newData.primitiveType = primitiveType;
            newData.lineStoreNum = this->sizeArrays;
            newData.data.i = value;
            this->i[this->sizeIntArray - 1] = newData;
            if(tmp == nullptr)
                delete[] tmp;
            break;
        case 1:
            tmp = this->d;
            this->d = new DataContainer[++this->sizeDoubleArray];
            for (size_t i = 0; i < this->sizeDoubleArray - 1; i++)
                this->d[i] = tmp[i];
            newData.name = (char*)name;
            newData.primitiveType = primitiveType;
            newData.lineStoreNum = this->sizeArrays;
            newData.data.d = value;
            this->d[this->sizeDoubleArray - 1] = newData;
            if (tmp == nullptr)
                delete[] tmp;
            break;
        case 2:
            tmp = this->b;
            this->b = new DataContainer[++this->sizeBoolArray];
            for (size_t i = 0; i < this->sizeBoolArray - 1; i++)
                this->b[i] = tmp[i];
            newData.name = (char*)name;
            newData.primitiveType = primitiveType;
            newData.lineStoreNum = this->sizeArrays;
            newData.data.b = value;
            this->b[this->sizeBoolArray - 1] = newData;
            if (tmp == nullptr)
                delete[] tmp;
            break;
        }

        this->sizeArrays++;
    }

    void push_back(const char* name, const int primitiveType, const char* word){
        DataContainer* tmp;
        DataContainer newData;
        tmp = this->c;
        this->c = new DataContainer[++this->sizeCharWArray];
        for (size_t i = 0; i < this->sizeCharWArray - 1; i++)
            this->c[i] = tmp[i];
        newData.name = (char*)name;
        newData.primitiveType = primitiveType;
        newData.lineStoreNum = this->sizeArrays;
        newData.data.c = (char*)word;
        this->c[this->sizeCharWArray - 1] = newData;
        if (tmp == nullptr)
            delete[] tmp;
        this->sizeArrays++;
    }

    void pop_back(const int primitiveType){
        DataContainer* tmp;
        switch (primitiveType){
        case 0:
            if (this->sizeIntArray <= NULL) return;
            tmp = this->i;
            this->i = new DataContainer[--this->sizeIntArray];
            for (size_t i = 0; i < this->sizeIntArray; i++)
                this->i[i] = tmp[i];
            if (tmp == nullptr)
                delete[] tmp;
            break;
        case 1:
            if (this->sizeDoubleArray <= NULL) return;
            tmp = this->d;
            this->d = new DataContainer[--this->sizeDoubleArray];
            for (size_t i = 0; i < this->sizeDoubleArray; i++)
                this->d[i] = tmp[i];
            if (tmp == nullptr)
                delete[] tmp;;
            break;
        case 2:
            if (this->sizeBoolArray <= NULL) return;
            tmp = this->b;
            this->b = new DataContainer[--this->sizeBoolArray];
            for (size_t i = 0; i < this->sizeBoolArray; i++)
                this->b[i] = tmp[i];
            if (tmp == nullptr)
                delete[] tmp;
            break;
        case 4:
            if (this->sizeCharWArray <= NULL) return;
            tmp = this->c;
            this->c = new DataContainer[--this->sizeCharWArray];
            for (size_t i = 0; i < this->sizeCharWArray; i++)
                this->c[i] = tmp[i];
            if (tmp == nullptr)
                delete[] tmp;
            break;
        }

        this->sizeArrays--;
    }

    void push_front(DataContainer& data){
        DataContainer* tmp;
        size_t lineStoreNum;
        switch (data.primitiveType){
        case 0:
            lineStoreNum = this->i[0].lineStoreNum;
            tmp = this->i;
            this->i = new DataContainer[++this->sizeIntArray];
            data.lineStoreNum = lineStoreNum;
            this->i[0] = data;
            for (size_t i = 1; i < this->sizeIntArray; i++)
                this->i[i] = tmp[i - 1];
            if (tmp == nullptr)
                delete[] tmp;
            break;
        case 1:
            lineStoreNum = this->d[0].lineStoreNum;
            tmp = this->d;
            this->d = new DataContainer[++this->sizeDoubleArray];
            data.lineStoreNum = lineStoreNum;
            this->d[0] = data;
            for (size_t i = 1; i < this->sizeDoubleArray; i++)
                this->d[i] = tmp[i - 1];
            if (tmp == nullptr)
                delete[] tmp;
            break;
        case 2:
            lineStoreNum = this->b[0].lineStoreNum;
            tmp = this->b;
            this->b = new DataContainer[++this->sizeBoolArray];
            data.lineStoreNum = lineStoreNum;
            this->b[0] = data;
            for (size_t i = 1; i < this->sizeBoolArray; i++)
                this->b[i] = tmp[i - 1];
            if (tmp == nullptr)
                delete[] tmp;
            break;
        case 4:
            lineStoreNum = this->c[0].lineStoreNum;
            tmp = this->c;
            this->c = new DataContainer[++this->sizeCharWArray];
            data.lineStoreNum = lineStoreNum;
            this->c[0] = data;
            for (size_t i = 1; i < this->sizeCharWArray; i++)
                this->c[i] = tmp[i - 1];
            if (tmp == nullptr)
                delete[] tmp;
            break;
        }

        switch (data.primitiveType){
        case 0:
            for (size_t i = 1; i < this->sizeIntArray; i++)
                if (lineStoreNum <= this->i[i].lineStoreNum)
                    this->i[i].lineStoreNum++;
            for (size_t i = 0; i < this->sizeDoubleArray; i++)
                if (lineStoreNum <= this->d[i].lineStoreNum)
                    this->d[i].lineStoreNum++;
            for (size_t i = 0; i < this->sizeBoolArray; i++)
                if (lineStoreNum <= this->b[i].lineStoreNum)
                    this->b[i].lineStoreNum++;
            for (size_t i = 0; i < this->sizeCharWArray; i++)
                if (lineStoreNum <= this->c[i].lineStoreNum)
                    this->c[i].lineStoreNum++;
            break;
        case 1:
            for (size_t i = 0; i < this->sizeIntArray; i++)
                if (lineStoreNum <= this->i[i].lineStoreNum)
                    this->i[i].lineStoreNum++;
            for (size_t i = 1; i < this->sizeDoubleArray; i++)
                if (lineStoreNum <= this->d[i].lineStoreNum)
                    this->d[i].lineStoreNum++;
            for (size_t i = 0; i < this->sizeBoolArray; i++)
                if (lineStoreNum <= this->b[i].lineStoreNum)
                    this->b[i].lineStoreNum++;
            for (size_t i = 0; i < this->sizeCharWArray; i++)
                if (lineStoreNum <= this->c[i].lineStoreNum)
                    this->c[i].lineStoreNum++;
            break;
        case 2:
            for (size_t i = 0; i < this->sizeIntArray; i++)
                if (lineStoreNum <= this->i[i].lineStoreNum)
                    this->i[i].lineStoreNum++;
            for (size_t i = 0; i < this->sizeDoubleArray; i++)
                if (lineStoreNum <= this->d[i].lineStoreNum)
                    this->d[i].lineStoreNum++;
            for (size_t i = 1; i < this->sizeBoolArray; i++)
                if (lineStoreNum <= this->b[i].lineStoreNum)
                    this->b[i].lineStoreNum++;
            for (size_t i = 0; i < this->sizeCharWArray; i++)
                if (lineStoreNum <= this->c[i].lineStoreNum)
                    this->c[i].lineStoreNum++;
            break;
        case 4:
            for (size_t i = 0; i < this->sizeIntArray; i++)
                if (lineStoreNum <= this->i[i].lineStoreNum)
                    this->i[i].lineStoreNum++;
            for (size_t i = 0; i < this->sizeDoubleArray; i++)
                if (lineStoreNum <= this->d[i].lineStoreNum)
                    this->d[i].lineStoreNum++;
            for (size_t i = 0; i < this->sizeBoolArray; i++)
                if (lineStoreNum <= this->b[i].lineStoreNum)
                    this->b[i].lineStoreNum++;
            for (size_t i = 1; i < this->sizeCharWArray; i++)
                if (lineStoreNum <= this->c[i].lineStoreNum)
                    this->c[i].lineStoreNum++;
            break;
        }

        this->sizeArrays++;
    }

    template<class T>
    void push_front(const char* name, const int primitiveType, T value){
        DataContainer* tmp;
        DataContainer newData;
        int lineStoreNum;
        switch (primitiveType){
        case 0:
            lineStoreNum = this->i[0].lineStoreNum;
            tmp = this->i;
            this->i = new DataContainer[++this->sizeIntArray];
            newData.name = (char*)name;
            newData.primitiveType = primitiveType;
            newData.lineStoreNum = lineStoreNum;
            newData.data.i = value;
            this->i[0] = newData;
            for (size_t i = 1; i < this->sizeIntArray; i++)
                this->i[i] = tmp[i - 1];
            if (tmp == nullptr)
                delete[] tmp;
            break;
        case 1:
            lineStoreNum = this->d[0].lineStoreNum;
            tmp = this->d;
            this->d = new DataContainer[++this->sizeDoubleArray];
            newData.name = (char*)name;
            newData.primitiveType = primitiveType;
            newData.lineStoreNum = lineStoreNum;
            newData.data.d = value;
            this->d[0] = newData;
            for (size_t i = 1; i < this->sizeDoubleArray; i++)
                this->d[i] = tmp[i - 1];
            if (tmp == nullptr)
                delete[] tmp;
            break;
        case 2:
            lineStoreNum = this->b[0].lineStoreNum;
            tmp = this->b;
            this->b = new DataContainer[++this->sizeBoolArray];
            newData.name = (char*)name;
            newData.primitiveType = primitiveType;
            newData.lineStoreNum = lineStoreNum;
            newData.data.b = value;
            this->b[0] = newData;
            for (size_t i = 1; i < this->sizeBoolArray; i++)
                this->b[i] = tmp[i - 1];
            if (tmp == nullptr)
                delete[] tmp;
            break;
        }

        switch (primitiveType){
        case 0:
            for (size_t i = 1; i < this->sizeIntArray; i++)
                if (lineStoreNum <= this->i[i].lineStoreNum)
                    this->i[i].lineStoreNum++;
            for (size_t i = 0; i < this->sizeDoubleArray; i++)
                if (lineStoreNum <= this->d[i].lineStoreNum)
                    this->d[i].lineStoreNum++;
            for (size_t i = 0; i < this->sizeBoolArray; i++)
                if (lineStoreNum <= this->b[i].lineStoreNum)
                    this->b[i].lineStoreNum++;
            for (size_t i = 0; i < this->sizeCharWArray; i++)
                if (lineStoreNum <= this->c[i].lineStoreNum)
                    this->c[i].lineStoreNum++;
            break;
        case 1:
            for (size_t i = 0; i < this->sizeIntArray; i++)
                if (lineStoreNum <= this->i[i].lineStoreNum)
                    this->i[i].lineStoreNum++;
            for (size_t i = 1; i < this->sizeDoubleArray; i++)
                if (lineStoreNum <= this->d[i].lineStoreNum)
                    this->d[i].lineStoreNum++;
            for (size_t i = 0; i < this->sizeBoolArray; i++)
                if (lineStoreNum <= this->b[i].lineStoreNum)
                    this->b[i].lineStoreNum++;
            for (size_t i = 0; i < this->sizeCharWArray; i++)
                if (lineStoreNum <= this->c[i].lineStoreNum)
                    this->c[i].lineStoreNum++;
            break;
        case 2:
            for (size_t i = 0; i < this->sizeIntArray; i++)
                if (lineStoreNum <= this->i[i].lineStoreNum)
                    this->i[i].lineStoreNum++;
            for (size_t i = 0; i < this->sizeDoubleArray; i++)
                if (lineStoreNum <= this->d[i].lineStoreNum)
                    this->d[i].lineStoreNum++;
            for (size_t i = 1; i < this->sizeBoolArray; i++)
                if (lineStoreNum <= this->b[i].lineStoreNum)
                    this->b[i].lineStoreNum++;
            for (size_t i = 0; i < this->sizeCharWArray; i++)
                if (lineStoreNum <= this->c[i].lineStoreNum)
                    this->c[i].lineStoreNum++;
            break;
        }

        this->sizeArrays++;
    }

    void push_front(const char* name, const int primitiveType, const char* word){
        DataContainer* tmp;
        DataContainer newData;
        size_t lineStoreNum;
        lineStoreNum = this->c[0].lineStoreNum;
        tmp = this->c;
        this->c = new DataContainer[++this->sizeCharWArray];
        newData.name = (char*)name;
        newData.primitiveType = primitiveType;
        newData.lineStoreNum = lineStoreNum;
        newData.data.c = (char*)word;
        this->c[0] = newData;
        for (size_t i = 1; i < this->sizeCharWArray; i++)
            this->c[i] = tmp[i - 1];
        for (size_t i = 0; i < this->sizeIntArray; i++)
            if (lineStoreNum <= this->i[i].lineStoreNum)
                this->i[i].lineStoreNum++;
        for (size_t i = 0; i < this->sizeDoubleArray; i++)
            if (lineStoreNum <= this->d[i].lineStoreNum)
                this->d[i].lineStoreNum++;
        for (size_t i = 0; i < this->sizeBoolArray; i++)
            if (lineStoreNum <= this->b[i].lineStoreNum)
                this->b[i].lineStoreNum++;
        for (size_t i = 1; i < this->sizeCharWArray; i++)
            if (lineStoreNum <= this->c[i].lineStoreNum)
                this->c[i].lineStoreNum++;
        if (tmp == nullptr)
            delete[] tmp;
        this->sizeArrays++;
    }

    void pop_front(const int primitiveType){
        DataContainer* tmp;
        switch (primitiveType)
        {
        case 0:
            tmp = this->i;
            this->i = new DataContainer[--this->sizeIntArray];
            for (size_t i = 1; i < this->sizeIntArray; i++)
                this->i[i - 1] = tmp[i];
            if (tmp == nullptr)
                delete[] tmp;
            break;
        case 1:
            tmp = this->d;
            this->d = new DataContainer[--this->sizeDoubleArray];
            for (size_t i = 1; i < this->sizeDoubleArray; i++)
                this->d[i - 1] = tmp[i];
            if (tmp == nullptr)
                delete[] tmp;
            break;
        case 2:
            tmp = this->b;
            this->b = new DataContainer[--this->sizeBoolArray];
            for (size_t i = 1; i < this->sizeBoolArray; i++)
                this->b[i - 1] = tmp[i];
            if (tmp == nullptr)
                delete[] tmp;
            break;
        case 4:
            tmp = this->c;
            this->c = new DataContainer[--this->sizeCharWArray];
            for (size_t i = 1; i < this->sizeCharWArray; i++)
                this->c[i - 1] = tmp[i];
            if (tmp == nullptr)
                delete[] tmp;
            break;
        }

        this->sizeArrays--;
    }

    DataContainer at(const int primitiveType, size_t index){
        DataContainer tmp;
        switch (primitiveType){
        case 0:
            if (index > this->sizeIntArray) break;
            tmp = this->i[index];
            break;
        case 1:
            if (index > this->sizeDoubleArray) break;
            tmp = this->d[index];
            break;
        case 2:
            if (index > this->sizeBoolArray) break;
            tmp = this->b[index];
            break;
        case 4:
            if (index > this->sizeCharWArray) break;
            tmp = this->c[index];
            break;
        }

        return tmp;
    }

    void freeMemory() {
        this->i = new DataContainer[1];
        this->d = new DataContainer[1];
        this->b = new DataContainer[1];
        this->c = new DataContainer[1];

        delete[] this->i;
        delete[] this->d;
        delete[] this->b;
        delete[] this->c;

        this->sizeArrays = NULL;
        this->sizeIntArray = NULL;
        this->sizeDoubleArray = NULL;
        this->sizeBoolArray = NULL;
        this->sizeCharWArray = NULL;
    }
};

class CNF{
    DataContainer* data;

    bool checkInt(char data){
        return (data == '0' || data == '1' || data == '2'
            || data == '3' || data == '4' || data == '5'
            || data == '6' || data == '7' || data == '8'
            || data == '9');
    }

    bool checkLetter(char data){
        return !checkInt(data);
    }

    char* readFile(const char* filePath){
        FILE* file;
        fopen_s(&file, filePath, "rb");
        //file = fopen(filePath, "rb");
        if (file == nullptr)
        {
            std::cerr << "READFILE::ERROR::FILE_NOT_EXIST" << std::endl;
            return (char*)"ERROR";
        }
        fseek(file, 0, SEEK_END);
        size_t len = ftell(file);
        rewind(file);
        char* buf = (char*)malloc(sizeof(char) * (len + 1));
        if (buf == nullptr)
        {
            fclose(file);
            std::cerr << "READFILE::ERROR::CAN_NOT_ALLOCATE_MEMORY" << std::endl;
            return (char*)"ERROR";
        }
        size_t bytesRead = fread(buf, sizeof(char), len, file);
        buf[bytesRead] = '\0';
        fclose(file);
        return buf;
    }

    void writeFile(char* buffer, const char* filePath, const char* mode){
        FILE* file;
        fopen_s(&file, filePath, mode);
        //file = fopen(filePath, mode);
        if (file == nullptr){
            std::cerr << "WRITEFILE::ERROR::FILE_NOT_EXIST_OR_CREATE_ERROR" << std::endl;
            return;
        }

        if (fprintf(file, buffer) < 0){
            std::cerr << "WRITEFILE::ERROR::CAN_NOT_WRITE_TO_FILE" << std::endl;
            return;
        } else if (fprintf(file, "\n") < 0){
            std::cerr << "WRITEFILE::ERROR::CAN_NOT_WRITE_TO_FILE" << std::endl;
            return;
        }
        fclose(file);
    }

public:

    int* ints = { nullptr };
    double* doubles = { nullptr };
    bool* bools = { nullptr };
    std::string* names = { nullptr };
    std::string* words = { nullptr };

    CnfType* primitiveTypeArray = { nullptr };
    const char* filePath = "";

    size_t sizeArrays = 0;
    size_t sizeIntArray = 0;
    size_t sizeDoubleArray = 0;
    size_t sizeBoolArray = 0;
    size_t sizeCharNArray = 0;
    size_t sizeCharWArray = 0;

    void readCnfFile(const char* filePath){
        std::stringstream sstr = std::stringstream();

        char* data = readFile(filePath);
        size_t count_int = 0;
        size_t count_bool = 0;
        size_t count_double = 0;
        size_t count_words = 0;
        size_t count_names = 0;
        size_t size_cd = (size_t)strlen(data);
        bool break_bool = false;

        size_t inInts = 0;
        size_t inDoubles = 0;
        size_t inBools = 0;
        size_t inNames = 0;
        size_t inWords = 0;
        size_t inCnfType = 0;

        int* ints;
        double* doubles;
        bool* bools;
        std::string* names;
        std::string* words;
        CnfType* primitiveTypeArray;

        std::string buf;
        char* cBuf;
        double dBuf;
        bool isDouble = false;

        for (int i = 0; i < size_cd; i++){
            break_bool = false;
            if (data[i] == '=' && data[i + 1] == ':'){
                count_names++; i += 2;
                if (checkLetter(data[i])){
                    if (data[i] == 't' || data[i] == 'T'){
                        for (int x = i; x < i + 5; x++){
                            sstr << data[x];
                        }
                        sstr >> buf;
                        if (buf == "true;" | buf == "True;" || buf == "TRUE;"){
                            count_bool++;
                            i += 6;
                            sstr.flush();
                            sstr = std::stringstream();
                        } else{
                            sstr.flush();
                            sstr = std::stringstream();
                            for (int x = i; x < size_cd; x++)
                                if (data[x] == ';') { count_words++; i = x + 1; break; }
                        }
                    } else if (data[i] == 'f' || data[i] == 'F'){
                        for (int x = i; x < i + 6; x++){
                            sstr << data[x];
                        }
                        sstr >> buf;
                        if (buf == "false;" | buf == "False;" || buf == "FALSE;"){
                            count_bool++;
                            i += 7;
                            sstr.flush();
                            sstr = std::stringstream();
                        } else{
                            sstr.flush();
                            sstr = std::stringstream();
                            for (int x = i; x < size_cd; x++)
                                if (data[x] == ';') { count_words++; i = x + 1; break; }
                        }
                    } else{
                        for (int x = i; x < size_cd; x++)
                            if (data[x] == ';') { count_words++; i = x + 1; break; }
                    }
                } else if (checkInt(data[i])){
                    for (int x = i; x < size_cd; x++){
                        if (break_bool) break;
                        if (data[x] == '.'){
                            count_double++;
                            for (int y = x; y < size_cd; y++)
                                if (data[y] == ';') { i = y + 1; break_bool = true; break; }
                        } else if (data[x] == ';') { i = x + 1; count_int++; break; }
                    }
                }
            }
        }


        size_t count_CnfType = count_int + count_double + count_bool + count_words;

        this->ints = new int[count_int];
        this->doubles = new double[count_double];
        this->bools = new bool[count_bool];
        this->names = new std::string[count_names];
        this->words = new std::string[count_words];
        this->primitiveTypeArray = new CnfType[count_CnfType];
        this->filePath = filePath;

        ints = new int[count_int];
        doubles = new double[count_double];
        bools = new bool[count_bool];
        names = new std::string[count_names];
        words = new std::string[count_words];
        primitiveTypeArray = new CnfType[count_CnfType];

        this->sizeIntArray = count_int;
        this->sizeDoubleArray = count_double;
        this->sizeBoolArray = count_bool;
        this->sizeCharNArray = count_names;
        this->sizeCharWArray = count_words;
        this->sizeArrays = count_CnfType;

        if (count_CnfType == 0){
            std::cout << "ERROR!" << std::endl;
            return;
        }

        for (int i = 0; i < count_int; i++) { this->ints[i] = 0; }
        for (int i = 0; i < count_double; i++) { this->doubles[i] = 0; }
        for (int i = 0; i < count_bool; i++) { this->bools[i] = 0; }
        for (int i = 0; i < count_names; i++) { this->names[i] = "0"; }
        for (int i = 0; i < count_words; i++) { this->words[i] = "0"; }

        sstr = std::stringstream();
        buf = std::string();

        for (int i = 0; i < size_cd; i++){
            if (data[i] == '\n')
                i++;
            if (data[i] == '\r')
                i++;
            if (data[i - 1] == ' ')
                for (int x = i; x < size_cd; x++, i++)
                    if (data[x] == '=') break;
            if (data[i] == '=' && data[i + 1] == ':'){
                names[inNames].push_back(' ');
                names[inNames++].pop_back();
                i += 2;
                if (checkLetter(data[i]))
                {
                    for (int x = i; x < size_cd; x++){
                        if (data[x] == ';'){
                            if (buf == "true" || buf == "True" || buf == "TRUE"){
                                bools[inBools++] = true;
                                primitiveTypeArray[inCnfType++] = CnfType::Bool;
                                i = x + 1;
                            } else if (buf == "false" || buf == "False" || buf == "FALSE"){
                                bools[inBools++] = false;
                                primitiveTypeArray[inCnfType++] = CnfType::Bool;
                                i = x + 1;
                            } else{
                                words[inWords++] = buf;
                                primitiveTypeArray[inCnfType++] = CnfType::Word;
                                i = x + 1;
                                cBuf = new char;
                            }
                            buf = std::string();
                            break;
                        }
                        buf.push_back(data[x]);
                    }
                }
                else if (checkInt(data[i])){
                    for (int x = i; x < size_cd; x++){
                        if (data[x] == '.') isDouble = true;
                        if (data[x] == ';'){
                            sstr >> dBuf;
                            if (isDouble) { isDouble = false; doubles[inDoubles++] = dBuf; primitiveTypeArray[inCnfType++] = CnfType::Double; }
                            else { ints[inInts++] = (int)dBuf; primitiveTypeArray[inCnfType++] = CnfType::Integer; }
                            sstr.flush();
                            sstr = std::stringstream();
                            i = x + 1;
                            break;
                        } else
                            sstr << data[x];
                    }
                }
            }
            if (i != size_cd){
                if (data[i] != '\r'){
                    if (data[i] != '\n'){
                        names[inNames].push_back(data[i]);
                    }
                }
            }
        }

        this->ints = ints;
        this->doubles = doubles;
        this->bools = bools;
        this->names = names;
        this->words = words;
        this->primitiveTypeArray = primitiveTypeArray;
    }

    void writeCnfFile(CNFDataContainer& data, const char* path){
        std::string buf = std::string();

        size_t outInts = 0;
        size_t outDoubles = 0;
        size_t outBools = 0;
        size_t outWords = 0;
        size_t outNames = 0;
        size_t countLoop = 0;

        for (int i = 0; i < data.sizeArrays;){
            for (int x = 0; x < data.sizeIntArray; x++){
                if (data.i[x].lineStoreNum == i){
                    buf.append(data.i[x].name);
                    buf.append("=:");
                    buf.append(std::to_string(data.i[x].data.i));
                    buf.append(";\n");
                    outInts++;
                    outNames++;
                    i++;
                    break;
                }
            }
            for (int x = 0; x < data.sizeDoubleArray; x++){
                if (data.d[x].lineStoreNum == i){
                    buf.append(data.d[x].name);
                    buf.append("=:");
                    buf.append(std::to_string(data.d[x].data.d));
                    buf.append(";\n");
                    outDoubles++;
                    outNames++;
                    i++;
                    break;
                }
            }
            for (int x = 0; x < data.sizeBoolArray; x++){
                if (data.b[x].lineStoreNum == i){
                    buf.append(data.b[x].name);
                    buf.append("=:");
                    if (data.b[x].data.b == true)
                        buf.append("true");
                    else
                        buf.append("false");
                    buf.append(";\n");
                    outBools++;
                    outNames++;
                    i++;
                    break;
                }
            }
            for (int x = 0; x < data.sizeCharWArray; x++){
                if (data.c[x].lineStoreNum == i){
                    buf.append(data.c[x].name);
                    buf.append("=:");
                    buf.append(data.c[x].data.c);
                    buf.append(";\n");
                    outWords++;
                    outNames++;
                    i++;
                    break;
                }
            }
        }
        writeFile((char*)buf.c_str(), path, "w");
    }

    DataContainer* getData(CnfType cnfType){
        int counter = 0;
        switch (cnfType){
        case Integer:
            data = new DataContainer[sizeIntArray];
            for (int i = 0; i < sizeIntArray; i++){
                data[i].primitiveType = Integer;
                data[i].data.i = ints[i];
            }
            for (int i = 0; i < sizeCharNArray; i++){
                if (primitiveTypeArray[i] == Integer) { data[counter].name = (char*)names[i].c_str(); data[counter].lineStoreNum = i; counter++; }
            }
            break;
        case Double:
            data = new DataContainer[sizeDoubleArray];
            for (int i = 0; i < sizeDoubleArray; i++){
                data[i].primitiveType = Double;
                data[i].data.d = doubles[i];
            }
            for (int i = 0; i < sizeCharNArray; i++){
                if (primitiveTypeArray[i] == Double) { data[counter].name = (char*)names[i].c_str(); data[counter].lineStoreNum = i; counter++; }
            }
            break;
        case Bool:
            data = new DataContainer[sizeBoolArray];
            for (int i = 0; i < sizeBoolArray; i++){
                data[i].primitiveType = Bool;
                data[i].data.b = bools[i];
            }
            for (int i = 0; i < sizeCharNArray; i++){
                if (primitiveTypeArray[i] == Bool) { data[counter].name = (char*)names[i].c_str(); data[counter].lineStoreNum = i; counter++; }
            }
            break;
        case Word:
            data = new DataContainer[sizeCharWArray];
            for (int i = 0; i < sizeCharWArray; i++){
                data[i].primitiveType = Word;
                data[i].data.c = (char*)words[i].c_str();
            }
            for (int i = 0; i < sizeCharNArray; i++){
                if (primitiveTypeArray[i] == Word) { data[counter].name = (char*)names[i].c_str(); data[counter].lineStoreNum = i; counter++; }
            }
            break;
        }
        return data;
    }

    CNFDataContainer convertToCNFDataContainer(){
        DataContainer* ints, *doubles, *bools, *words;
        ints = getData(Integer);
        doubles = getData(Double);
        bools = getData(Bool);
        words = getData(Word);
        CNFDataContainer tmp(this->sizeIntArray, this->sizeDoubleArray, this->sizeBoolArray, this->sizeCharWArray, this->sizeArrays, ints, doubles, bools, words);
        return tmp;
    }
};