区块链测试

#include <iterator>
#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
#include <list>
#include <string>

typedef std::vector<std::string>    RowData;
typedef std::list<RowData>            RowList;

class CSVReader {
public:
    CSVReader(std::string csv) :m_csv(csv){};
    
    RowData readRowData(std::istream& str)
    {
        std::string         line;
        std::getline(str, line);

        std::stringstream   lineStream(line);
        std::string         cell;

        RowData data;
        while (std::getline(lineStream, cell, ','))
        {
            data.push_back(cell);
        }
        return data;
    }
    
    std::string getCsv() { return m_csv; }
private:
    std::string m_csv;
};

class CSVWriter {
public:
    CSVWriter(std::string csv):m_csv(csv){};
    ~CSVWriter(){};
    
    bool writeRow(std::string rowdata) {
        std::ofstream   file(m_csv);
        if(!file.is_open()) return false;
        file << rowdata << std::endl;
        return true;
    }
    
    bool isExist() {
        std::ifstream   file(m_csv);
        if(!file) return false;
        return true;
    }    
    //std::share_ptr<std::ofstream> getstream() {
    //    return new std::ofstream(m_csv);
    //}
private:
    std::string m_csv;
};

class PlutoCSVReader : public CSVReader {
public:
    PlutoCSVReader(std::string csv) : CSVReader(csv), m_linenum(0) {};
    
    RowList readNewData()
    {
        RowList rowlist;
        std::ifstream   file(getCsv());
        if (!file) return rowlist;
        
        if (file.is_open())
        {
            // Move to end of the file, 
            file.seekg (-1, std::ios::end);
        
            char lastcharacter;
            file.get(lastcharacter);
            if(lastcharacter != 0x0a)
                return rowlist;
            
            file.seekg (0, std::ios::beg);
        }
        
        int loop = 0;
        while (file) {
            RowData row = this->readRowData(file);
            if (row.size() > 0 && ++loop > 1 && loop > m_linenum) {
                rowlist.push_back(row);
                m_linenum = loop;
            }
        }
        return rowlist;
    };
    
private:
    int m_linenum;
};

class PlutoCSVWriter : public CSVWriter {
public:
    PlutoCSVWriter(std::string csv, std::string header):CSVWriter(csv),
    m_header(header){};
    
    bool writeRow(std::string rowdata) {
        if(!isExist()) {
            CSVWriter::writeRow(m_header);
        }
        return CSVWriter::writeRow(rowdata);
    }
private:
    std::string m_header;
};

class PlutoOrder : public PlutoCSVWriter {
public:
    PlutoOrder(std::string csv):PlutoCSVWriter(csv, header){};
private:
    const std::string header = "1,2";
};

class PlutoCancel : public PlutoCSVWriter {
public:
    PlutoCancel(std::string csv):PlutoCSVWriter(csv, header){};
private:
    const std::string header = "11,12";
    
};

class PlutoOrderResponse : public PlutoCSVReader {
public:
    PlutoOrderResponse(std::string csv):PlutoCSVReader(csv){};
private:
    const std::string header = "21,22";
};

class PlutoCancelResponse : public PlutoCSVReader {
public:
    PlutoCancelResponse(std::string csv):PlutoCSVReader(csv){};
private:
    const std::string header = "31,32";
};

int main()
{
    PlutoOrderResponse *orderResponse = new PlutoOrderResponse("endl.csv");
    RowList rowlist1 = orderResponse->readNewData();

    int a = 8;

    RowList rowlist2 = orderResponse->readNewData();
    return 0;
}