graph.h

#ifndef __GRAPH_H__
#define __GRAPH_H__

#include "anymap.h"
#include "predicate.h"
#include "edge.h"

#include <vector>
#include <set>
#include <map>
#include <memory>
#include <functional>

#include "libtools.h"

namespace com {
    namespace graph {
        namespace detail {
            struct EdgeHelper {
                std::string name;
                std::map< std::string, std::string > props;
            };

            struct NodeHelper {
                NodeHelper(const std::string& name, int id) : name(name), id(id) {}//, owner(nullptr) {}
                std::string name;
                int id;
                //NodeHelper* owner;
                std::vector<NodeHelper*> children;
                std::vector<EdgeHelper> edges;
                std::map< std::string, std::string > props;
            };

            void parseDotLine(const std::string& line, std::map<std::string, detail::NodeHelper*>& nodesLookup,
                              std::map<std::string, std::map<std::string, std::string> >& funcLookup, detail::NodeHelper*& entryNode);

            std::shared_ptr< Node > buildNodeFromNodeHelper(NodeHelper* nodeHelper,
                                                    std::map<std::string, std::shared_ptr<Node> >& nodes,
                                                    std::map<std::string, std::shared_ptr<sys::ActionItemExecutor> >& edgeExecs,
                                                    std::map<std::string, std::shared_ptr<sys::ActionItemExecutor> >& predExecs,
                                                    const std::map<std::string, NodeHelper*>& nodesLookup,
                                                    const std::map<std::string, std::map<std::string, std::string> >& funcLookup);

            std::shared_ptr<Edge> buildEdgeWithSubsequentNodes(EdgeHelper& edgeHelper,
                                                               NodeHelper* endNodeHelper,
                                                               std::map<std::string, std::shared_ptr<Node> >& nodes,
                                                               std::map<std::string, std::shared_ptr<sys::ActionItemExecutor> >& edgeExecs,
                                                               std::map<std::string, std::shared_ptr<sys::ActionItemExecutor> >& predExecs,
                                                               const std::map<std::string, NodeHelper*>& nodesLookup,
                                                               const std::map<std::string, std::map<std::string, std::string> >& funcLookup);

            std::shared_ptr<sys::ActionItemExecutor> buildActionItemExecutorFromHelperProps(const std::map<std::string, std::string>& props);
        }

        class MAC_DLLEXPORT Node : public std::enable_shared_from_this< Node > {
        public:
            Node(int id, std::shared_ptr< Predicate > pred = nullptr);
            Node(const Node&) = delete;
            ~Node(){}

            int getId() const;

            std::shared_ptr< Predicate > getPredicate();

            void setPredicate(std::shared_ptr< Predicate > pred);

            Anymap& run(Anymap& input);

            bool verify();

        private:
            // возвращает <isInfiniteLoopInside, doesItCreateLoop>
            std::pair< bool, bool > tryToFindInfiniteLoop(std::shared_ptr< Node > node, std::set< std::shared_ptr<Node> > nodesPath,
                                                          std::set< std::shared_ptr<Node> > nodesDirectPath);

            bool hasTerminateNode(std::shared_ptr< Node > node,
                                                    std::map< std::shared_ptr<Node>, std::set< std::shared_ptr<Node> > > nodesBranches,
                                                    std::set< std::shared_ptr<Node> > directNodesPath);

        private:
            int m_id;
            std::shared_ptr< Predicate > m_predicate;
        };

        MAC_DLLEXPORT std::shared_ptr< Node > loadFromADot(const std::string& adotFile);
    }
}

#endif