Graph_TS.hpp

/***********************************************************/
/***      ______  ____  ______                 _         ***/
/***     / ___\ \/ /\ \/ / ___|_ __ __ _ _ __ | |__      ***/
/***    | |    \  /  \  / |  _| '__/ _` | '_ \| '_ \     ***/
/***    | |___ /  \  /  \ |_| | | | (_| | |_) | | | |    ***/
/***     \____/_/\_\/_/\_\____|_|  \__,_| .__/|_| |_|    ***/
/***                                    |_|              ***/
/***********************************************************/
/***     Header-Only C++ Library for Graph               ***/
/***     Representation and Algorithms                   ***/
/***********************************************************/
/***     Author: ZigRazor                                ***/
/***     E-Mail: zigrazor@gmail.com                      ***/
/***********************************************************/
/***     Collaboration: -----------                      ***/
/***********************************************************/
/***     License: AGPL v3.0                              ***/
/***********************************************************/
 
#ifndef __CXXGRAPH_GRAPH_TS_H__
#define __CXXGRAPH_GRAPH_TS_H__
 
#pragma once
 
#include "Graph/Graph.hpp"
 
namespace CXXGRAPH
{
 
    template <typename T>
    class Graph_TS : public Graph<T>, public ThreadSafe
    {
    public:
        Graph_TS() = default;
        Graph_TS(const std::list<const Edge<T> *> &edgeSet);
        Graph_TS(const Graph<T> &graph);
        ~Graph_TS() = default;
        const std::list<const Edge<T> *> &getEdgeSet() const override;
        void setEdgeSet(std::list<const Edge<T> *> &edgeSet) override;
        void addEdge(const Edge<T> *edge) override;
        void removeEdge(unsigned long long edgeId) override;
        const std::list<const Node<T> *> getNodeSet() const override;
        const std::optional<const Edge<T> *> getEdge(unsigned long long edgeId) const override;
        const AdjacencyMatrix<T> getAdjMatrix() const override;
        const DijkstraResult dijkstra(const Node<T> &source, const Node<T> &target) const override;
    const BellmanFordResult bellmanford(const Node<T> &source, const Node<T> &target) const override;
    const FWResult floydWarshall() const override;
        const std::vector<Node<T>> breadth_first_search(const Node<T> &start) const override;
        const std::vector<Node<T>> depth_first_search(const Node<T> &start) const override;
 
        bool isCyclicDirectedGraphDFS() const override;
 
        bool isCyclicDirectedGraphBFS() const override;
 
        bool isDirectedGraph() const override;
 
        const DialResult dial(const Node<T> &source, int maxWeight) const override;
 
        int writeToFile(InputOutputFormat format = InputOutputFormat::STANDARD_CSV, const std::string &workingDir = ".", const std::string &OFileName = "graph", bool compress = false, bool writeNodeFeat = false, bool writeEdgeWeight = false) const override;
 
        int readFromFile(InputOutputFormat format = InputOutputFormat::STANDARD_CSV, const std::string &workingDir = ".", const std::string &OFileName = "graph", bool compress = false, bool readNodeFeat = false, bool readEdgeWeight = false) override;
 
        PartitionMap<T> partitionGraph(PARTITIONING::PartitionAlgorithm algorithm, unsigned int numberOfPartitions,double param1 = 0.0,double param2 = 0.0,double param3 = 0.0,unsigned int numberOfthreads = std::thread::hardware_concurrency()) const override;
    };
 
    template <typename T>
    Graph_TS<T>::Graph_TS(const std::list<const Edge<T> *> &edgeSet) : Graph<T>(edgeSet), ThreadSafe() {}
 
    template <typename T>
    Graph_TS<T>::Graph_TS(const Graph<T> &graph) : Graph<T>(graph), ThreadSafe() {}
 
    template <typename T>
    const std::list<const Edge<T> *> &Graph_TS<T>::getEdgeSet() const
    {
        std::lock_guard<std::mutex> lock(mutex);
        return Graph<T>::getEdgeSet();
    }
 
    template <typename T>
    void Graph_TS<T>::setEdgeSet(std::list<const Edge<T> *> &edgeSet)
    {
        getLock();
        Graph<T>::setEdgeSet(edgeSet);
        releaseLock();
    }
 
    template <typename T>
    void Graph_TS<T>::addEdge(const Edge<T> *edge)
    {
        getLock();
        Graph<T>::addEdge(edge);
        releaseLock();
    }
 
    template <typename T>
    void Graph_TS<T>::removeEdge(unsigned long long edgeId)
    {
        getLock();
        Graph<T>::removeEdge(edgeId);
        releaseLock();
    }
 
    template <typename T>
    const std::list<const Node<T> *> Graph_TS<T>::getNodeSet() const
    {
        getLock();
        auto ns = Graph<T>::getNodeSet();
        releaseLock();
        return ns;
    }
 
    template <typename T>
    const std::optional<const Edge<T> *> Graph_TS<T>::getEdge(unsigned long long edgeId) const
    {
        getLock();
        auto e = Graph<T>::getEdge(edgeId);
        releaseLock();
        return e;
    }
 
    template <typename T>
    const AdjacencyMatrix<T> Graph_TS<T>::getAdjMatrix() const
    {
        getLock();
        auto adjm = Graph<T>::getAdjMatrix();
        releaseLock();
        return adjm;
    }
 
    template <typename T>
    const DijkstraResult Graph_TS<T>::dijkstra(const Node<T> &source, const Node<T> &target) const
    {
        getLock();
        auto dij = Graph<T>::dijkstra(source, target);
        releaseLock();
        return dij;
    }
    
    template <typename T>
    const BellmanFordResult Graph_TS<T>::bellmanford(const Node<T> &source, const Node<T> &target) const
    {
        getLock();
        auto bellford = Graph<T>::bellmanford(source, target);
        releaseLock();
        return bellford;
    }
    
    template <typename T>
    const FWResult Graph_TS<T>::floydWarshall() const
    {
        getLock();
        auto fw = Graph<T>::floydWarshall();
        releaseLock();
        return fw;
    }
    
    template <typename T>
    const std::vector<Node<T>> Graph_TS<T>::breadth_first_search(const Node<T> &start) const
    {
        getLock();
        auto bfs = Graph<T>::breadth_first_search(start);
        releaseLock();
        return bfs;
    }
 
    template <typename T>
    const std::vector<Node<T>> Graph_TS<T>::depth_first_search(const Node<T> &start) const
    {
        getLock();
        auto dfs = Graph<T>::depth_first_search(start);
        releaseLock();
        return dfs;
    }
 
    template <typename T>
    bool Graph_TS<T>::isCyclicDirectedGraphDFS() const
    {
        getLock();
        auto result = Graph<T>::isCyclicDirectedGraphDFS();
        releaseLock();
        return result;
    }
 
    template <typename T>
    bool Graph_TS<T>::isCyclicDirectedGraphBFS() const
    {
        getLock();
        auto result = Graph<T>::isCyclicDirectedGraphBFS();
        releaseLock();
        return result;
    }
 
    template <typename T>
    bool Graph_TS<T>::isDirectedGraph() const
    {
        getLock();
        auto result = Graph<T>::isDirectedGraph();
        releaseLock();
        return result;
    }
 
    template <typename T>
    const DialResult Graph_TS<T>::dial(const Node<T> &source, int maxWeight) const
    {
        getLock();
        auto dial = Graph<T>::dial(source, maxWeight);
        releaseLock();
        return dial;
    }
 
    template <typename T>
    int Graph_TS<T>::writeToFile(InputOutputFormat format, const std::string &workingDir, const std::string &OFileName, bool compress, bool writeNodeFeat, bool writeEdgeWeight) const
    {
        getLock();
        auto result = Graph<T>::writeToFile(format, workingDir, OFileName, compress, writeNodeFeat, writeEdgeWeight);
        releaseLock();
        return result;
    }
 
    template <typename T>
    int Graph_TS<T>::readFromFile(InputOutputFormat format, const std::string &workingDir, const std::string &OFileName, bool compress, bool readNodeFeat, bool readEdgeWeight)
    {
        getLock();
        auto result = Graph<T>::readFromFile(format, workingDir, OFileName, compress, readNodeFeat, readEdgeWeight);
        releaseLock();
        return result;
    }
 
    template <typename T>
    PartitionMap<T> Graph_TS<T>::partitionGraph(PARTITIONING::PartitionAlgorithm algorithm, unsigned int numberOfPartitions,double param1,double param2,double param3,unsigned int numberOfthreads) const
    {
        getLock();
        auto partitions = Graph<T>::partitionGraph(algorithm, numberOfPartitions, param1, param2, param3, numberOfthreads);
        releaseLock();
        return partitions;
    }
}
#endif // __CXXGRAPH_GRAPH_TS_H__