DotParser.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/Graph.h>
#include <ogdf/basic/GraphAttributes.h>
#include <ogdf/basic/HashArray.h>
#include <ogdf/cluster/ClusterGraph.h>
#include <ogdf/cluster/ClusterGraphAttributes.h>
#include <ogdf/fileformats/DOT.h>
#include <ogdf/fileformats/DotLexer.h>
 
#include <cstdio>
#include <set>
#include <string>
#include <vector>
 
namespace ogdf {
 
namespace dot {
 
class Parser;
struct SubgraphData;
 
 
class Ast {
public:
    struct Graph;
    struct StmtList;
    struct NodeStmt;
    struct EdgeStmt;
    struct AttrStmt;
    struct AsgnStmt;
    struct Subgraph;
    struct NodeId;
    struct EdgeRhs;
    struct AttrList;
    struct AList;
    struct Port;
    struct CompassPt;
 
    struct Stmt;
    struct EdgeLhs;
 
private:
    using Tokens = std::vector<Token>;
    using Iterator = Tokens::const_iterator;
 
    const Tokens m_tokens;
    const Iterator m_tend;
 
    Graph* m_graph;
 
    Graph* parseGraph(Iterator current, Iterator& rest);
    Subgraph* parseSubgraph(Iterator current, Iterator& rest);
    NodeStmt* parseNodeStmt(Iterator current, Iterator& rest);
    EdgeStmt* parseEdgeStmt(Iterator current, Iterator& rest);
    AttrStmt* parseAttrStmt(Iterator current, Iterator& rest);
    AsgnStmt* parseAsgnStmt(Iterator current, Iterator& rest);
    EdgeRhs* parseEdgeRhs(Iterator current, Iterator& rest);
    NodeId* parseNodeId(Iterator current, Iterator& rest);
    Stmt* parseStmt(Iterator current, Iterator& rest);
    StmtList* parseStmtList(Iterator current, Iterator& rest);
    AttrList* parseAttrList(Iterator current, Iterator& rest);
    AList* parseAList(Iterator current, Iterator& rest);
    Port* parsePort(Iterator current, Iterator& rest);
    CompassPt* parseCompassPt(Iterator current, Iterator& rest);
 
public:
 
    explicit Ast(const Tokens& tokens);
    ~Ast();
 
 
    bool build();
 
    Graph* root() const;
 
    struct Graph {
        const bool strict;
        const bool directed;
        std::string* id;
 
        StmtList* statements;
 
        Graph(const bool& paramStrict, const bool& dir, std::string* idString,
                StmtList* statementList);
        ~Graph();
 
        bool read(Parser& P, ogdf::Graph& G, GraphAttributes* GA, ClusterGraph* C,
                ClusterGraphAttributes* CA);
    };
 
    struct StmtList {
        Stmt* head;
        StmtList* tail;
 
        StmtList(Stmt* headSTMT, StmtList* tailStatementList);
        ~StmtList();
    };
 
    struct Stmt {
        virtual ~Stmt() = 0;
 
        virtual bool read(Parser& P, ogdf::Graph& G, GraphAttributes* GA, ClusterGraph* C,
                ClusterGraphAttributes* CA, const SubgraphData& data) = 0;
    };
 
    struct NodeStmt : public Stmt {
        NodeId* nodeId;
        AttrList* attrs;
 
        NodeStmt(NodeId* nodeID, AttrList* attrList);
        ~NodeStmt();
 
        virtual bool read(Parser& P, ogdf::Graph& G, GraphAttributes* GA, ClusterGraph* C,
                ClusterGraphAttributes* CA, const SubgraphData& data) override;
    };
 
    struct EdgeStmt : public Stmt {
        EdgeLhs* lhs;
        EdgeRhs* rhs;
        AttrList* attrs;
 
        EdgeStmt(EdgeLhs* edgeLHS, EdgeRhs* edgeRHS, AttrList* attrList);
        ~EdgeStmt();
 
        virtual bool read(Parser& P, ogdf::Graph& G, GraphAttributes* GA, ClusterGraph* C,
                ClusterGraphAttributes* CA, const SubgraphData& data) override;
    };
 
    struct AsgnStmt : public Stmt {
        const std::string lhs;
        const std::string rhs;
 
        AsgnStmt(const std::string& lhsString, const std::string& rhsString);
        ~AsgnStmt();
 
        virtual bool read(Parser& P, ogdf::Graph& G, GraphAttributes* GA, ClusterGraph* C,
                ClusterGraphAttributes* CA, const SubgraphData& data) override;
    };
 
    struct AttrStmt : public Stmt {
        enum class Type { graph, edge, node };
 
        Type type;
        AttrList* attrs;
 
        AttrStmt(const Type& paramType, AttrList* attrList);
        ~AttrStmt();
 
        virtual bool read(Parser& P, ogdf::Graph& G, GraphAttributes* GA, ClusterGraph* C,
                ClusterGraphAttributes* CA, const SubgraphData& data) override;
    };
 
    struct EdgeLhs {
        virtual ~EdgeLhs() = 0;
 
        virtual bool read(Parser& P, ogdf::Graph& G, GraphAttributes* GA, ClusterGraph* C,
                ClusterGraphAttributes* CA, const SubgraphData& data) = 0;
    };
 
    struct Subgraph : public Stmt, EdgeLhs {
        std::string* id;
        StmtList* statements;
 
        Subgraph(std::string* idString, StmtList* statementList);
        ~Subgraph();
 
        virtual bool read(Parser& P, ogdf::Graph& G, GraphAttributes* GA, ClusterGraph* C,
                ClusterGraphAttributes* CA, const SubgraphData& data) override;
    };
 
    struct NodeId : public EdgeLhs {
        const std::string id;
        Port* port;
 
        NodeId(const std::string& idString, Port* paramPort);
        ~NodeId();
 
        virtual bool read(Parser& P, ogdf::Graph& G, GraphAttributes* GA, ClusterGraph* C,
                ClusterGraphAttributes* CA, const SubgraphData& data) override;
    };
 
    struct CompassPt {
        enum class Type { n, ne, e, se, s, sw, w, nw, c, wildcard };
        Type type;
 
        CompassPt(const Type& paramType);
        ~CompassPt();
    };
 
    struct Port {
        std::string* id;
        CompassPt* compassPt;
 
        Port(std::string* idString, CompassPt* compassPT);
        ~Port();
    };
 
    struct EdgeRhs {
        EdgeLhs* head;
        EdgeRhs* tail;
 
        EdgeRhs(EdgeLhs* headEdgeLHS, EdgeRhs* tailEdgeRHS);
        ~EdgeRhs();
    };
 
    struct AttrList {
        AList* head;
        AttrList* tail;
 
        AttrList(AList* headAList, AttrList* tailAttrList);
        ~AttrList();
    };
 
    struct AList {
        AsgnStmt* head;
        AList* tail;
 
        AList(AsgnStmt* headAsgnStmt, AList* tailAList);
        ~AList();
    };
};
 
 
class Parser {
private:
    std::istream& m_in;
 
    // Maps node id to Graph node.
    HashArray<std::string, node> m_nodeId;
 
    bool readGraph(Graph& G, GraphAttributes* GA, ClusterGraph* C, ClusterGraphAttributes* CA);
 
public:
    explicit Parser(std::istream& in);
 
    bool read(Graph& G);
    bool read(Graph& G, GraphAttributes& GA);
    bool read(Graph& G, ClusterGraph& C);
    bool read(Graph& G, ClusterGraph& C, ClusterGraphAttributes& CA);
 
 
    node requestNode(Graph& G, GraphAttributes* GA, ClusterGraph* C, const SubgraphData& data,
            const std::string& id);
};
 
struct SubgraphData {
    cluster rootCluster;
    std::vector<Ast::AttrList*>& nodeDefaults;
    std::vector<Ast::AttrList*>& edgeDefaults;
    std::set<node>& nodes;
 
 
    SubgraphData(cluster root, std::vector<Ast::AttrList*>& nodeDefaultsVector,
            std::vector<Ast::AttrList*>& edgeDefaultsVector, std::set<node>& nodeSet);
 
 
    SubgraphData withCluster(cluster newRootCluster) const;
 
    SubgraphData withDefaults(std::vector<Ast::AttrList*>& newNodeDefaults,
            std::vector<Ast::AttrList*>& newEdgeDefaults) const;
    SubgraphData withNodes(std::set<node>& newNodes) const;
};
 
}
}