Покритикуйте код

// XMLtoDBF.cpp : Defines the entry point for the console application.
//
#define _AFXDLL
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <afxdb.h>
#include <afxwin.h>
#include <sstream>
#include <io.h>
#include <odbcinst.h>
#include "stdafx.h"
using namespace std;
 
//global variable
/*
   globalTableName - is name of the output file and the table name.
   xml_string - is the string without a space, and all elements XML in a line, like 
   "<without a root><date>10.09.2012</date></root>.
*/
string globalTableName;
string xml_string;
 
//**********************************************************************************************************************
// The class describes a Row in FoxPro Databases.
class Row
{
public:
    void addValue(string data)
    {
/* 
   We get a some xml block, like "<size>60</size>" and We already have the instance of the class,
   our class has the table name and the markup,  our row type can have the CHAR type, the NUMERIC type, the DATE type,
   and make the parsing.
   "end" is the keyword, it means a empty row
*/
        string::size_type positionBegin;
        string::size_type positionEnd;
        string::size_type lenghtFirstTag;
        string::size_type cutSize;
        string unParseStringBegin;
        string unParseStringEnd;
        unParseStringBegin = "<" + RowName + ">";
        unParseStringEnd = "</" + RowName + ">";
        positionBegin = data.find(unParseStringBegin);
        positionEnd = data.find(unParseStringEnd);
        lenghtFirstTag = unParseStringBegin.length();
 
        string year;
        string month;
        string day;
        string tmpString;
 
        if ((positionBegin != string::npos) && ( positionEnd != string::npos) && ((positionBegin + lenghtFirstTag)< positionEnd))
        {
            ++sizeValues;
            cutSize = positionEnd - (positionBegin + lenghtFirstTag);
            if (RowType == "CHAR")
            {
                Values.push_back("'" + data.substr(positionBegin + lenghtFirstTag, cutSize)+ "'");
            }
            if (RowType == "NUMERIC")
            {
                Values.push_back(data.substr(positionBegin + lenghtFirstTag, cutSize));
            }
            if (RowType == "DATE")
            {
                tmpString = data.substr(positionBegin + lenghtFirstTag, cutSize);
                year = tmpString.substr(0,4);
                tmpString.erase(0,4);
                month = tmpString.substr(0,2);
                tmpString.erase(0,2);
                day = tmpString.substr(0,2);
                Values.push_back("{^" + year + "/" + month + "/" + day +"}");
            }
        }
        if ((positionBegin + lenghtFirstTag) == positionEnd)
        {
            ++sizeValues;
            Values.push_back("end");
        }
    }
    void setRowName(string name)
    {
        RowName = name;
    }
    string getRowName ()
    {
        return RowName;
    }
    void setRowTypes(string type)
    {
        RowType = type;
    }
    string getRowType()
    {
        return RowType;
    }
    void setSizeBeforeDot (int size)
    {
        SizeBeforeDot = size;
    }
    void setSizeAfterDot (int size)
    {
        SizeAfterDot = size;
    }
    void createRowString()
    {
// In this function, We create SQL requests (ALTER TABLE). 
 
        TableName = globalTableName;
        firstValue = Values.begin();
        lastValue = Values.end();
 
        string select;
        stringstream strm1;
        stringstream strm2;
 
        if ((RowType == "N") || (RowType == "n") || (RowType == "NUMBER") || (RowType == "number") || //for numeric
             (RowType == "NUMERIC") || (RowType == "numeric"))
        {
            strm1 << SizeBeforeDot;
            strm2 << SizeAfterDot;
            select = "ALTER TABLE " + TableName + " ADD " + RowName + " " + "NUMERIC(" + strm1.str() + "," + strm2.str() + ");"; 
            SQLAlterTable = select;
        }
 
        if ((RowType == "char") || (RowType == "CHAR") || (RowType == "TEXT") || (RowType == "text")
             || (RowType == "C") || (RowType == "c")) // for char
        {
            strm1 << SizeBeforeDot;
            select = "ALTER TABLE " + TableName + " ADD " + RowName + " " + "CHAR(" + strm1.str() + ");"; 
            SQLAlterTable = select;
        }
 
        if ((RowType == "date") || (RowType == "DATE") || (RowType == "D") || (RowType == "d")) // for date
        {
            select = "ALTER TABLE " + TableName + " ADD " + RowName + " " + "DATE" +";"; 
            SQLAlterTable = select;
        }
 
    }
    string getSQLAlterTable()
    {
        return SQLAlterTable;
    }
    string getSQLValue()
// This function like a container, returns next value.
    {
        if (firstValue != lastValue)
        {
            if (firstValue == Values.begin())
            {
                string tmpString;
                tmpString = *firstValue;
                ++firstValue;
                return tmpString;
            }
            else
            {
                if (firstValue != lastValue)
                {
                    string tmpString;
                    tmpString = *firstValue;
                    ++firstValue;
                    return tmpString;
                }
            }   
        }
        else
            return "end";
    }
    int getsizeValues()
    {
        return sizeValues;
    }
    void setsizeValues()
    {
        sizeValues = 0;
    }
private:
    string TableName;
    string RowName;
    string RowType;
    int SizeBeforeDot;
    int SizeAfterDot;
    string SQLAlterTable;
    vector <string> Values;
    int sizeValues;                        // The number of values ​​in the container.
    vector <string>::iterator firstValue;
    vector <string>::iterator lastValue;
};
//**********************************************************************************************************************
 
//**********************************************************************************************************************
// This function parses the table struct and creates a new instance class "Row".
vector <Row> createTableObject  (vector <string> dataContainer)
{
    int position;
    int sizeBeforeDot;
    int sizeAfterDot;
    vector <string>::iterator begin = dataContainer.begin();
    vector <string>::iterator end = dataContainer.end();
    vector <Row> parseRow;
    string similarType;
    while (begin != end)
    {
        if ((*begin).find(";") != string::npos)
        {
            Row * tmpRow = new Row();
 
            tmpRow->setsizeValues();
 
            position = (*begin).find(";");
            tmpRow->setRowName((*begin).substr(0,position));
            (*begin).erase(0, position + 1);
 
            position = (*begin).find(";");
            similarType = (*begin).substr(0,position);
            if ((similarType == "N") || (similarType == "n") || (similarType == "NUMBER") || (similarType == "number") || //for numeric
                (similarType == "NUMERIC") || (similarType == "numeric"))
            {
                tmpRow->setRowTypes("NUMERIC");
                (*begin).erase(0, position + 1);
                position = (*begin).find(";");
                sizeBeforeDot = atoi((*begin).substr(0,position).c_str());
                (*begin).erase(0, position + 1);
                sizeAfterDot = atoi((*begin).c_str());
                sizeBeforeDot = sizeBeforeDot - sizeAfterDot;
                tmpRow->setSizeBeforeDot(sizeBeforeDot);
                tmpRow->setSizeAfterDot(sizeAfterDot);
            }
            if ((similarType == "char") || (similarType == "CHAR") || (similarType == "TEXT") || (similarType == "text")
                || (similarType == "C") || (similarType == "c")) // for char
            {
                tmpRow->setRowTypes("CHAR");
                (*begin).erase(0, position + 1);
                position = (*begin).find(";");
                sizeBeforeDot = atoi((*begin).substr(0,position).c_str());
                (*begin).erase(0, position + 1);
                sizeAfterDot = atoi((*begin).c_str());
                tmpRow->setSizeBeforeDot(sizeBeforeDot);
                tmpRow->setSizeAfterDot(sizeAfterDot);
            }
            if ((similarType == "date") || (similarType == "DATE") || (similarType == "D") || (similarType == "d"))  // for date
            {
                tmpRow->setRowTypes("DATE");
                (*begin).erase(0, position + 1);
                position = (*begin).find(";");
                sizeBeforeDot = atoi((*begin).substr(0,position).c_str());
                (*begin).erase(0, position + 1);
                sizeAfterDot = atoi((*begin).c_str());
                tmpRow->setSizeBeforeDot(sizeBeforeDot);
                tmpRow->setSizeAfterDot(sizeAfterDot);
            }
            parseRow.push_back(*tmpRow);
        }
        ++begin;
    }
return parseRow;
};
//**********************************************************************************************************************
 
//**********************************************************************************************************************
// The class describes a xml block. 
class XML_TREE
{
public :
    string name;
    string text;
    vector <XML_TREE*> Tree;
};
//**********************************************************************************************************************
 
//**********************************************************************************************************************
/* It is simple xml parser(recursive). If the father's name does not match the name of his son, the recursion, 
the son becomes the father, as an argument. If the father's name is the same as the name of his son, then recursively ascends upwards.
If there is a value, then its value is assigned to the recursive level where we are.
*/
void XML_Parse (XML_TREE * height_tree)
{
    string::size_type position1;
    string::size_type position2;
    string::size_type position3;
    string::size_type position4;
    string levelname("");
 
    while (height_tree->name != levelname)
    {
        position1 = xml_string.find("<");
        position2 = xml_string.find("</");
        if ((position1 == 0) && (position2 != position1))
        {
            string tmpString;
            position2 = xml_string.find(">");
            tmpString = xml_string.substr(position1 + 1, position2 - (position1 + 1));
            xml_string.erase(0, position2 + 1);
            XML_TREE * new_XML_TREE = new XML_TREE;
            new_XML_TREE->name = tmpString;
            height_tree->Tree.push_back(new_XML_TREE);
            XML_Parse(new_XML_TREE);
        }
        if (position1 != 0)
        {
            height_tree->text = xml_string.substr(0, position1);
            xml_string.erase(0, position1);
            
        }
        if ((position1 == 0) && (position2 == position1))
        {
            string tmpString;
            position2 = xml_string.find(">");
            tmpString = xml_string.substr(position1 + 2, position2 - (position1 + 2));
            xml_string.erase(0, position2 + 1);
            levelname = tmpString;
        }
    }
};
//**********************************************************************************************************************
/*
  The recursive function that compares the container with pointers to the class "Row", 
  if the name of XML unit does not match the name of the class, the recursive descent, if not then
  xml value in the class function "addValue".
*/
void compareXML_Struct (vector <Row> * createTableObject, XML_TREE * new_XML_TREE)
{
    vector <XML_TREE*>::iterator beginXML = new_XML_TREE->Tree.begin();
    vector <XML_TREE*>::iterator endXML = new_XML_TREE->Tree.end();
 
    vector <Row>::iterator beginStruct = createTableObject->begin();
    vector <Row>::iterator endStruct = createTableObject->end();
 
    if (new_XML_TREE->Tree.size() != 0)
    {
        while (beginXML != endXML)
        {
            compareXML_Struct (createTableObject,(*beginXML));
            ++beginXML;
        }
    }
    else
    {
        while (beginStruct != endStruct)
        {
            if (beginStruct->getRowName() == new_XML_TREE->name)
            {
                beginStruct->addValue("<" + beginStruct->getRowName() + ">" + new_XML_TREE->text + "</" + beginStruct->getRowName() + ">");
                string tmpstring;
                tmpstring = "<" + beginStruct->getRowName() + ">" + new_XML_TREE->text + "</" + beginStruct->getRowName() + ">";
            }
            ++beginStruct;
        }
    }
};
//**********************************************************************************************************************
 
//**********************************************************************************************************************
bool checkPathFile (string path)
{
    if (access(path.c_str(), 0) != -1)
    {
        cout << "The File : " + path + " is available" << endl;
        return true;
    }
    else
    {
        cout << "The File : " + path + " isn't available" << endl;
        cout << "Please press enter to exit" << endl;
        return false;
    }
};
//**********************************************************************************************************************
 
//**********************************************************************************************************************
bool checkPathDirectory (string path)
{
    if (access(path.c_str(), 0) != -1)
    {
        cout << "The Directory : " + path + " is available" << endl;
        return true;
    }
    else
    {
        cout << "The Directory : " + path + " isn't available" << endl;
        cout << "Please press enter to exit" << endl;
        return false;
    }
};
//**********************************************************************************************************************
// Checks output path, and saves name of a output file.
string checkAndParseOutFile (string path)
{
    string::size_type positionFileName;
    positionFileName = path.find_last_of('\\');
    if (positionFileName == string::npos)
    {
        string::size_type positionPoint;
        positionPoint = path.find(".");
        globalTableName = path.substr(0,positionPoint);
        return "Current Direcory";
    }
    else
    {
        ++positionFileName;
        string FileName(positionFileName, path.length() - positionFileName);
        string::size_type positionPoint;
        positionPoint = path.find(".");
        globalTableName = path.substr(positionFileName,positionPoint - positionFileName);
        return path.substr(0,positionFileName - 1);
    }
};
 
int main(int argc, char *argv[])
{
    setlocale( LC_ALL,"Russian" );
    cout << "XMLtoDBF v 0.90b UkrPay 2012 by Dusheyko " << endl;
 
// Declaring system paths
// argv[1] - file of structure dbf
// argv[2] - input file
// argv[3] - output file    
    string NameOfFileStructure;
    string NameOfFileXML;
    string NameOfOutFile;
    string PathOutFile;
    NameOfOutFile = argv[3];
    NameOfFileStructure = argv[1];
    NameOfFileXML = argv[2];
//  NameOfOutFile = "D:\\table1.dbf";
//  NameOfFileStructure = "OPER.txt";
//  NameOfFileXML = "P1210191.aaa";
 
    if (argc != 4)
    {
        cout << "You entered invalid command-line arguments." << endl;
        cout << "Arguments : <file struction> <file xml> <out file *.dbf>";
        return -1;
    }
 
    if (!checkPathFile(NameOfFileXML))
    {
        _gettchar();
        return -1;
    }
 
    if (!checkPathFile(NameOfFileStructure))
    {
        _gettchar();
        return -1;
    }
 
    PathOutFile = checkAndParseOutFile(NameOfOutFile);
    if (PathOutFile != "Current Direcory")
    {
        if (!checkPathDirectory(PathOutFile))
        {
            _gettchar();
            return -1;
        }
    }
 
//checks for file
    string CheckFile("");
    char Choise[256];
    CheckFile = NameOfOutFile;
    if (access(CheckFile.c_str(), 0) != -1)
    {
        cout << "Do you want rewrite " << CheckFile << endl;
        cout << "Y / N :" << endl;
        cin.getline (Choise,256);
        if (Choise[0] == 'N' || Choise[0] == 'n')
        {
            cout << "Please save your file to the next start" << endl;
            _gettchar();
            return 0;
        }
    }
            
//Creates the structure
    string data;
    vector <string> dataContainer;
    ifstream infile (NameOfFileStructure);
    do 
    {
        infile >> data;
        dataContainer.push_back(data);
    } while (getline(infile,data));
    infile.close();
    infile.clear();
    vector<Row> TableObject;
    TableObject = createTableObject(dataContainer);
 
// Loads XML without Prolog
    infile.open (NameOfFileXML);
    string dataXMLinString("");
    string::size_type positionProlog;
    while (getline(infile,data))
    {
        positionProlog = data.find("<?");
        if (positionProlog != string::npos)
            continue;
 
        positionProlog = data.find("<!");
        if (positionProlog != string::npos)
            continue;
 
        positionProlog = data.find("<!--");
        if (positionProlog != string::npos)
            continue;
        
        dataXMLinString += data;
    }
    infile.close();
    infile.clear();
 
// Deletes all attributes in string
   string Block("");
   string::size_type beginBlock;
   string::size_type endBlock;
   string::size_type positionSpace;
   string::size_type positionAttSpace;
   do
   {
       beginBlock = dataXMLinString.find("<");
       endBlock   = dataXMLinString.find(">");
       if (beginBlock != string::npos)
       {
           Block         = dataXMLinString.substr(beginBlock, (endBlock - beginBlock) + 1);
           positionSpace = Block.find(" ");
 
           if (positionSpace != string::npos)
           {
               string::size_type positionBeginWithSpace = Block.find("< ");
               string::size_type positionEndWithSpace   = Block.find(" >");
 
               if (positionBeginWithSpace != string::npos)
               {
                   while(positionBeginWithSpace != string::npos)
                   {
                       Block.erase(positionBeginWithSpace + 1, 1);
                       positionBeginWithSpace = Block.find("< ");
                   }
               }
               if (positionEndWithSpace != string::npos)
               {
                   while(positionBeginWithSpace != string::npos)
                   {
                       Block.erase(positionBeginWithSpace - 1, 1);
                       positionBeginWithSpace = Block.find(" >");
                   }
               }
 
               positionSpace = Block.find(" ");
               if (positionSpace != string::npos)
               {
                   string::iterator MidleString = Block.begin() + positionSpace;
                   string::iterator EndString  = Block.end();
                   Block.erase (MidleString, EndString);
                   Block = "``" + Block;
                   Block = Block + "~~";
               }
               else
               {
                   Block = "``" + Block;
                   Block = Block + "~~";
               }
           }
           else
           {
               Block = "``" + Block;
               Block = Block + "~~";
           }
 
           beginBlock = Block.find("<");
           if (beginBlock != string::npos)
               Block.erase(beginBlock, 1);
 
           endBlock   = Block.find(">");
           if (endBlock != string::npos)
               Block.erase(endBlock, 1);
 
 
           endBlock   = dataXMLinString.find(">");
           dataXMLinString.insert(endBlock + 1,Block);
           beginBlock = dataXMLinString.find("<");
           endBlock   = dataXMLinString.find(">");
           dataXMLinString.erase(beginBlock,(endBlock - beginBlock) + 1);
       }
   } while (beginBlock != string::npos);
 
 
// Changes and Deletes temporary dividers "<" == "``", "<" == "~~"
    string::size_type positionDividers;
    do
    {
        positionDividers = dataXMLinString.find("``");
        if (positionDividers != string::npos)
        {
            dataXMLinString.insert(positionDividers + 2,"<");
            dataXMLinString.erase(positionDividers, 2);
        }
    }while (positionDividers != string::npos);
    do
    {
        positionDividers = dataXMLinString.find("~~");
        if (positionDividers != string::npos)
        {
            dataXMLinString.insert(positionDividers + 2,">");
            dataXMLinString.erase(positionDividers, 2);
        }
    }while (positionDividers != string::npos);
 
// Deletes all space in string
    do
    {
        positionSpace = dataXMLinString.find(" ");
        if (positionSpace != string::npos)
            dataXMLinString.erase(positionSpace, 1);
    }while (positionSpace != string::npos);
 
//Cretes root XML
    string::size_type rootBegin;
    string::size_type rootEnd;
    rootBegin = dataXMLinString.find("<");
    rootEnd = dataXMLinString.find(">");
    XML_TREE * new_XML_TREE = new XML_TREE;
    new_XML_TREE->name = dataXMLinString.substr(rootBegin + 1, rootEnd - rootBegin - 1);
    dataXMLinString.erase(rootBegin, rootEnd + 1);
    xml_string = dataXMLinString;
 
// Executes 
    XML_Parse(new_XML_TREE);
    compareXML_Struct(&TableObject,new_XML_TREE);
 
//Create SQL in Objects
    vector<Row>::iterator begin = TableObject.begin();
    vector<Row>::iterator end = TableObject.end();
    while (begin != end)
    {
        begin->createRowString();
        ++begin;
    }
    
// Get Current Directory path 
    CString CurrentDirectory;
    if (PathOutFile == "Current Direcory")
    {
        
        char cwd[1000];
        DWORD cwdsz = sizeof(cwd);
        int ret = GetCurrentDirectory(cwdsz, cwd);
        for (int i = 0; i < ret; i++)
        {
            if (cwd[i] == '\\')
                CurrentDirectory += "\\";
            CurrentDirectory += cwd[i];
        }
        CurrentDirectory = "SourceDB=" + CurrentDirectory + "\\";
    }
 
// Adding an ODBC data source with the SQLConfigDataSource (FoxPro)
    char *szDriver = "Microsoft Visual FoxPro Driver"; 
    CString tmpStr; 
    tmpStr="DSN=NewVFP1\\"; 
    tmpStr+="Description=VFP Data Source\\"; 
    tmpStr+=CurrentDirectory;
    tmpStr+="SourceType=DBF\\"; 
    tmpStr+="Collate=Machine\\"; 
    tmpStr+="BackgroundFetch=Yes\\"; 
    tmpStr+="Exclusive=No\\"; 
    char *szAttributes=tmpStr.GetBuffer(tmpStr.GetLength()); 
    for(int i=0;i<tmpStr.GetLength();i++) 
    { 
        if(*(szAttributes+i)==(int) '\\') 
        *(szAttributes+i)=NULL; 
    } 
    if (!SQLConfigDataSource(NULL, ODBC_ADD_DSN, szDriver, szAttributes))
    {
        cout << "Create config ODBC - ERROR" << endl;
    }
    else
    {
        cout << "Create config ODBC - OK" << endl;
    }
 
// Makes a connection with the new ODBC driver
    CDatabase cdbMyDB;
    cdbMyDB.OpenEx("DSN=NewVFP1");
    begin = TableObject.begin();
    end = TableObject.end();
 
// Fills the table
    string ForCreate;
    ForCreate = "CREATE TABLE " +  globalTableName + " (test CHAR(20));";
    cdbMyDB.ExecuteSQL(ForCreate.c_str());
 
    while (begin != end)
    {
        cdbMyDB.ExecuteSQL((begin->getSQLAlterTable()).c_str());
        ++begin;
    }
 
    ForCreate = "ALTER TABLE " + globalTableName + " DROP COLUMN test;";
    cdbMyDB.ExecuteSQL(ForCreate.c_str());
 
// Counts the maximum number of rows of columns 
    int counter(0);
    begin = TableObject.begin();
    end = TableObject.end();
    while (begin != end)
    {
        if (counter < begin->getsizeValues())
            counter = begin->getsizeValues();
        ++begin;
    }
 
// Creates SQL requests (INSERT) for one line 
    string SQLInsertColumn("");
    string SQLInsertValue("");
    string IfIsNullString("");
    string SQLExecuteString("");
 
    for (int i = 0; i < counter; i++)
    {
        begin = TableObject.begin();
        end = TableObject.end();
        SQLInsertColumn = "";
        SQLInsertValue = "";
        IfIsNullString ="";
        SQLExecuteString = "";
        while (begin != end)
        {
            if ((begin + 1) != end)
            {
                SQLInsertColumn = SQLInsertColumn + begin->getRowName() + ",";
                IfIsNullString = begin->getSQLValue();
                if (IfIsNullString != "end")
                {
                    SQLInsertValue  = SQLInsertValue + IfIsNullString + ",";
                }
                else
                {
                    if (begin->getRowType() == "NUMERIC")
                        SQLInsertValue  = SQLInsertValue + "0" + ",";
                    if (begin->getRowType() == "CHAR")
                        SQLInsertValue  = SQLInsertValue + "''" + ",";
                    if (begin->getRowType() == "DATE")
                        SQLInsertValue  = SQLInsertValue + "{}" + ",";
                }
                ++begin;
            }
            else
            {
                SQLInsertColumn = SQLInsertColumn + begin->getRowName();
                IfIsNullString = begin->getSQLValue();
                if (IfIsNullString != "end")
                {
                SQLInsertValue  = SQLInsertValue + IfIsNullString;
                }
                else
                {
                    if (begin->getRowType() == "NUMERIC")
                        SQLInsertValue  = SQLInsertValue + "0";
                    if (begin->getRowType() == "CHAR")
                        SQLInsertValue  = SQLInsertValue + "''";
                    if (begin->getRowType() == "DATE")
                        SQLInsertValue  = SQLInsertValue + "{}";
 
                }
                ++begin;
            }
        }
        SQLExecuteString = "INSERT INTO " + globalTableName + " (" + SQLInsertColumn + ") VALUES (" + SQLInsertValue + ");";
        cdbMyDB.ExecuteSQL(SQLExecuteString.c_str());
    }
    cdbMyDB.Close();  
 
// Copies the new database file in the output path. 
    if (PathOutFile != "Current Direcory")
    {
     std::ifstream in (globalTableName + ".dbf"); // open original file
     std::ofstream out(NameOfOutFile,std::ios::binary); 
     out << in.rdbuf(); 
     out.close(); 
     in.close();
    }
 
    cout << "All done";
    _gettchar();
    return 0;
}

vector<Row>::iterator begin = TableObject.begin();
* * vector<Row>::iterator end = TableObject.end();
* * while (begin != end)
* * {
* * * * begin->createRowString();
* * * * ++begin;
* * }