GraphBuilder.h

Go to the documentation of this file.

#pragma once

#include <Core/ExecObject.h>
#include <time.h>

#include <algorithm>
#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/depth_first_search.hpp>
#include <boost/graph/dijkstra_shortest_paths.hpp>
#include <boost/graph/graph_utility.hpp>
#include <boost/graph/graphviz.hpp>
#include <boost/graph/labeled_graph.hpp>
#include <boost/graph/isomorphism.hpp>
#include <boost/graph/properties.hpp>
#include <boost/graph/topological_sort.hpp>
#include <boost/graph/visitors.hpp>
#include <boost/utility.hpp>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <set>
#include <vector>
#include <string>
#include <optional>
#include <tbb/mutex.h>


typedef boost::adjacency_list<boost::setS, boost::vecS, boost::bidirectionalS, boost::property<boost::vertex_name_t, std::string> > ObjectGraph_Type;



//typedef boost::adjacency_list<boost::vecS, boost::listS, boost::bidirectionalS, boost::property<boost::vertex_index_t, size_t>> ObjectGraph_Type;

/*
typedef boost::adjacency_list<
    boost::listS,
    boost::listS,
    boost::bidirectionalS,
    boost::property<boost::vertex_index_t, long,
    boost::property<boost::vertex_name_t, std::string   >>
    > ObjectGraph_Type;
*/


typedef ObjectGraph_Type::vertex_descriptor Object_Vertex;



namespace Core
{
class LX_CORE_EXPORT ObjectGraph
{
public:
    ObjectGraph();
    // Copy constructor
    ObjectGraph(const ObjectGraph& rhs);

    ObjectGraph(std::vector<Core::DocObject*> objs, bool ignoreLinksToTemporaryObjects = false);
    ~ObjectGraph();

    void clear();
    bool hasObject(const Core::DocObject* o) const;
    bool addObject(const Core::DocObject* o);
    bool removeObject(const Core::DocObject* o);
    bool updateObject(const Core::DocObject* o);
    


    bool recreate(std::vector<const Core::DocObject*> toDelete);
    
    std::vector<Core::DocObject*> build_SubGraph(const std::vector<Core::DocObject*>& featureSet);

    std::vector<const Core::DocObject*> getInner(const Core::DocObject* o, std::function<bool(const Core::DocObject*)>* allowToAddObject = 0);
    std::vector<const Core::DocObject*> getOuter(const Core::DocObject* o);

    bool checkForCycle();
    std::vector<const Core::DocObject*> getTopologicalSorted();

    std::vector<const Core::DocObject*> getLinksToMe(const Core::DocObject* o);
    std::vector<const Core::DocObject*> getLinksFromMe(const Core::DocObject* o);

    std::vector<const Core::DocObject*> getBackLinksToMe(const Core::DocObject* o);
    std::vector<const Core::DocObject*> getBackLinksFromMe(const Core::DocObject* o);

    
    std::string dump();
    std::vector< std::string > getErrors();

private:
    
    bool allLinksConnected();
    bool updateObject_BackLink(const Core::DocObject* o);
    bool addObjectLinks(const Core::DocObject* o);
    std::string dumpSort(ObjectGraph_Type g);
    ObjectGraph_Type build(const std::vector<Core::DocObject*>& featureSet, std::map<Object_Vertex, Core::DocObject*>& myFeaturemap);

    void getOuter(Object_Vertex& vertex, std::vector<const Core::DocObject*>& behindobjects);
    void getInner(Object_Vertex& vertex,
                  std::set<const Core::DocObject*>& beforeobjects,
                  std::function<bool(const Core::DocObject*)>* allowToAddObject);
    void getInner(Object_Vertex& vertex,
                  std::vector<const Core::DocObject*>& beforeobjects,
                  std::function<bool(const Core::DocObject*)>* allowToAddObject);
    std::unordered_map<Object_Vertex, const Core::DocObject*> _vertex_to_object;
    std::unordered_map<const Core::DocObject*, Object_Vertex> _object_to_vertex;

    std::unordered_map<Object_Vertex, const Core::DocObject*> _vertex_to_object_BackLink;
    std::unordered_map<const Core::DocObject*, Object_Vertex> _object_to_vertex_BackLink;

    ObjectGraph_Type* _objectGraph;
    ObjectGraph_Type* _objectGraphBackLinks;
    bool _ignoreLinksToTemporaryObjects = false;

    std::vector< std::string > mErrors;
    
};


struct NodeInfo{size_t id;};
struct EdgeInfo{size_t pos;};


/*
typedef boost::labeled_graph< boost::adjacency_list<
    boost::vecS, boost::vecS, boost::undirectedS, NodeInfo, EdgeInfo>,
    std::string> RelGraph_Type;
    */


//typedef boost::property<boost::vertex_name_t, std::string> VertexProperty;
//typedef boost::property<boost::edge_name_t, long> EdgeProperty;
using   RelGraph_Type = boost::adjacency_list<boost::listS, boost::setS, boost::bidirectionalS,NodeInfo,EdgeInfo >;
using   RelGraph_Vertex = RelGraph_Type::vertex_descriptor;
using   RelGraph_Edge = RelGraph_Type::edge_descriptor;
using   RelGraph_Link = std::pair<Core::PropertyLinkBaseBase*,Core::DocObject*>;

class LX_CORE_EXPORT RelGraph
{
public:
    RelGraph( Core::CoreDocument* doc );
    Core::PropertyLinkBaseBase* getProperty(Core::DocObject* docObj, size_t pos);
    
    bool hasRelationShip(PropertyLinkBaseBase* p, Core::DocObject* from, Core::DocObject* to);
    

    void addObject( Core::DocObject* from );
    void removeObject( Core::DocObject* obj );
    void addRelationShip(PropertyLinkBaseBase* p, Core::DocObject* from,Core::DocObject* to);
    void addRelationShips(PropertyLinkBaseBase* p, Core::DocObject* from,const std::list<Core::DocObject*>& linkList);
    void addRelationShips(PropertyLinkBaseBase* p, Core::DocObject* from,const std::unordered_set<Core::DocObject*>& linkSet);
    void removeRelationShip(PropertyLinkBaseBase* p, Core::DocObject* from,Core::DocObject* to);
    void removeRelationShips(PropertyLinkBaseBase* p, Core::DocObject* from,const std::list<Core::DocObject*>& linkList);
    void removeRelationShips(PropertyLinkBaseBase* p, Core::DocObject* from,const std::unordered_set<Core::DocObject*>& linkSet);
    void test_graph2();
    std::string dump();
    void test_graph();
    std::vector<RelGraph_Link> getOutEdges(Core::DocObject* docObj);

    std::vector<RelGraph_Link> RelGraph::getInEdges(Core::DocObject* docObj);
    void breakLinks( Core::DocObject* from );

    

private:
    RelGraph_Vertex RelGraph::getOrAddVertex( Core::DocObject* docObj );
    std::optional<RelGraph_Vertex> getVertex(Core::DocObject* docObj); 
    RelGraph_Type _relGraph;
    std::unordered_map<size_t,RelGraph_Vertex> _object_to_vertex;    
    RelGraph() = default;
    Core::CoreDocument* _cDoc = nullptr;
    tbb::mutex m_mutex;

};


}  // namespace Core