DotParser.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/Graph.h>
#include <ogdf/basic/GraphAttributes.h>
#include <ogdf/cluster/ClusterGraph.h>
#include <ogdf/cluster/ClusterGraphAttributes.h>
#include <ogdf/basic/HashArray.h>
 
#include <ogdf/fileformats/DOT.h>
#include <ogdf/fileformats/DotLexer.h>
 
#include <cstdio>
#include <vector>
#include <set>
#include <string>
 
 
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;
};
 
}
}