tpgGraphDotImporter.h

 
#ifndef TPG_GRAPH_DOT_IMPORTER_H
#define TPG_GRAPH_DOT_IMPORTER_H
 
#include <cstdio>
#include <fstream>
#include <inttypes.h>
#include <map>
#include <memory>
#include <regex>
#include <stdexcept>
#include <string>
 
#include "learn/learningEnvironment.h"
#include "tpg/tpgAction.h"
#include "tpg/tpgEdge.h"
#include "tpg/tpgGraph.h"
#include "tpg/tpgTeam.h"
#include "tpg/tpgVertex.h"
#include "util/counterReset.h"
 
namespace File {
    class TPGGraphDotImporter
    {
      protected:
        std::ifstream pFile;
 
        std::string lastLine;
 
        Environment env;
 
        TPG::TPGGraph& tpg;
 
        std::map<uint64_t, const TPG::TPGVertex*> vertexID;
 
        std::map<const TPG::TPGAction*, std::vector<uint64_t>> actionClasses;
 
        std::map<uint64_t, std::shared_ptr<Program::Program>> programID;
 
        std::map<uint64_t, const TPG::TPGAction*> actionID;
 
        static const std::string lineSeparator;
 
        static const std::string teamRegex;
 
        static const std::string programRegex;
 
        static const std::string instructionRegex;
 
        static const std::string actionRegex;
 
        static const std::string linkProgramInstructionRegex;
 
        static const std::string linkProgramActionRegex;
 
        static const std::string linkProgramTeamRegex;
 
        static const std::string linkActionProgramRegex;
 
        static const std::string addLinkProgramRegex;
 
        void readOperands(std::string& str, Program::Line& line);
 
        void readLine(std::smatch& matches);
 
        void readProgram(std::smatch& matches);
 
        bool getExportedVersion(int& major, int& minor, int& patch);
 
        void dumpTPGGraphHeader();
 
        void readTeam(std::smatch& matches);
 
        void readAction(std::smatch& matches);
 
        void readLinkTeamProgramAction(std::smatch& matches);
 
        void readLinkActionProgram(std::smatch& matches);
 
        void readLinkTeamProgramTeam(std::smatch& matches);
 
        void readLinkTeamProgram(std::smatch& matches);
 
        bool readLineFromFile();
 
      public:
        static const int supportedMajorVersion = 2;
        static const int supportedMinorVersion = 0;
        static const int supportedPatchVersion = 0;
 
        TPGGraphDotImporter(const char* filePath, Environment environment,
                            TPG::TPGGraph& tpgref)
            : env{environment}, tpg{tpgref}
        {
            pFile.open(filePath);
            if (!pFile.is_open()) {
                throw std::runtime_error("Could not open file " +
                                         std::string(filePath));
            }
            importGraph();
        };
 
        static const unsigned int MAX_READ_SIZE = 131072;
 
        ~TPGGraphDotImporter()
        {
            if (pFile.is_open()) {
                pFile.close();
            }
        }
 
        void setNewFilePath(const char* newFilePath);
 
        void importGraph();
    };
}; // namespace File
 
#endif