\hypertarget{classCXXGRAPH_1_1Graph}{}\doxysection{CXXGRAPH\+::Graph$<$ T $>$ Class Template Reference}
\label{classCXXGRAPH_1_1Graph}\index{CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}}


Class that implement the \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{Graph}}. ( This class is not Thread Safe )  




{\ttfamily \#include $<$Graph.\+hpp$>$}



Inheritance diagram for CXXGRAPH\+::Graph$<$ T $>$\+:
\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=228pt]{dc/d80/classCXXGRAPH_1_1Graph__inherit__graph}
\end{center}
\end{figure}
\doxysubsection*{Public Member Functions}
\begin{DoxyCompactItemize}
\item 
\mbox{\Hypertarget{classCXXGRAPH_1_1Graph_a7b66a2077835e57dbbe0429ca3cbde05}\label{classCXXGRAPH_1_1Graph_a7b66a2077835e57dbbe0429ca3cbde05}} 
{\bfseries Graph} (const T\+\_\+\+Edge\+Set$<$ T $>$ \&edge\+Set)
\item 
virtual const T\+\_\+\+Edge\+Set$<$ T $>$ \& \mbox{\hyperlink{classCXXGRAPH_1_1Graph_a8412ba5fbb3bd12ce9c872bd9bbd9824}{get\+Edge\+Set}} () const
\begin{DoxyCompactList}\small\item\em Function that return the \mbox{\hyperlink{classCXXGRAPH_1_1Edge}{Edge}} set of the \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{Graph}} Note\+: No Thread Safe. \end{DoxyCompactList}\item 
virtual void \mbox{\hyperlink{classCXXGRAPH_1_1Graph_a7f4b22c1c3e93bd51600141d9517e36a}{set\+Edge\+Set}} (T\+\_\+\+Edge\+Set$<$ T $>$ \&edge\+Set)
\begin{DoxyCompactList}\small\item\em Function set the \mbox{\hyperlink{classCXXGRAPH_1_1Edge}{Edge}} Set of the \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{Graph}} Note\+: No Thread Safe. \end{DoxyCompactList}\item 
virtual void \mbox{\hyperlink{classCXXGRAPH_1_1Graph_a95fc676b51609323126e1d6f2366c4bb}{add\+Edge}} (const \mbox{\hyperlink{classCXXGRAPH_1_1Edge}{Edge}}$<$ T $>$ $\ast$edge)
\begin{DoxyCompactList}\small\item\em Function add an \mbox{\hyperlink{classCXXGRAPH_1_1Edge}{Edge}} to the \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{Graph}} \mbox{\hyperlink{classCXXGRAPH_1_1Edge}{Edge}} Set Note\+: No Thread Safe. \end{DoxyCompactList}\item 
virtual void \mbox{\hyperlink{classCXXGRAPH_1_1Graph_ac1b14104add48bad5524e31b47411d36}{remove\+Edge}} (unsigned long long edge\+Id)
\begin{DoxyCompactList}\small\item\em Function remove an \mbox{\hyperlink{classCXXGRAPH_1_1Edge}{Edge}} from the \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{Graph}} \mbox{\hyperlink{classCXXGRAPH_1_1Edge}{Edge}} Set Note\+: No Thread Safe. \end{DoxyCompactList}\item 
virtual const std\+::set$<$ const \mbox{\hyperlink{classCXXGRAPH_1_1Node}{Node}}$<$ T $>$ $\ast$ $>$ \mbox{\hyperlink{classCXXGRAPH_1_1Graph_af0544d74b956980e05e2a57a5dc2d2d6}{get\+Node\+Set}} () const
\begin{DoxyCompactList}\small\item\em Function that return the \mbox{\hyperlink{classCXXGRAPH_1_1Node}{Node}} Set of the \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{Graph}} Note\+: No Thread Safe. \end{DoxyCompactList}\item 
virtual const std\+::optional$<$ const \mbox{\hyperlink{classCXXGRAPH_1_1Edge}{Edge}}$<$ T $>$ $\ast$ $>$ \mbox{\hyperlink{classCXXGRAPH_1_1Graph_a5ebab9011fe6155743eaa989c2bf7860}{get\+Edge}} (unsigned long long edge\+Id) const
\begin{DoxyCompactList}\small\item\em Function that return an \mbox{\hyperlink{classCXXGRAPH_1_1Edge}{Edge}} with specific ID if Exist in the \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{Graph}} Note\+: No Thread Safe. \end{DoxyCompactList}\item 
\mbox{\Hypertarget{classCXXGRAPH_1_1Graph_ad000477b7a25ea7bfd1edf589133b042}\label{classCXXGRAPH_1_1Graph_ad000477b7a25ea7bfd1edf589133b042}} 
virtual const Adjacency\+Matrix$<$ T $>$ \mbox{\hyperlink{classCXXGRAPH_1_1Graph_ad000477b7a25ea7bfd1edf589133b042}{get\+Adj\+Matrix}} () const
\begin{DoxyCompactList}\small\item\em This function generate a list of adjacency matrix with every element of the matrix contain the node where is directed the link and the \mbox{\hyperlink{classCXXGRAPH_1_1Edge}{Edge}} corrispondent to the link Note\+: No Thread Safe. \end{DoxyCompactList}\item 
virtual unsigned long long \mbox{\hyperlink{classCXXGRAPH_1_1Graph_a0cc15d4668136f6be44bf18a2e28cc6b}{set\+Find}} (std\+::unordered\+\_\+map$<$ unsigned long long, \mbox{\hyperlink{structCXXGRAPH_1_1Subset__struct}{Subset}} $>$ $\ast$, const unsigned long long elem) const
\begin{DoxyCompactList}\small\item\em This function finds the subset of given a node\+Id Subset is stored in a map where keys are the hash-\/id of the node \& values is the subset. \end{DoxyCompactList}\item 
virtual void \mbox{\hyperlink{classCXXGRAPH_1_1Graph_a60a3f55bd4b195d7225b77b3ae8c9065}{set\+Union}} (std\+::unordered\+\_\+map$<$ unsigned long long, \mbox{\hyperlink{structCXXGRAPH_1_1Subset__struct}{Subset}} $>$ $\ast$, const unsigned long long set1, const unsigned long long elem2) const
\begin{DoxyCompactList}\small\item\em This function modifies the original subset array such that it the union of two sets a and b. \end{DoxyCompactList}\item 
virtual std\+::vector$<$ \mbox{\hyperlink{classCXXGRAPH_1_1Node}{Node}}$<$ T $>$ $>$ \mbox{\hyperlink{classCXXGRAPH_1_1Graph_a31b482ce494f93dcd7125b3aa4eb8f78}{eulerian\+Path}} () const
\begin{DoxyCompactList}\small\item\em This function finds the eulerian path of a directed graph using hierholzers algorithm. \end{DoxyCompactList}\item 
virtual const \mbox{\hyperlink{structCXXGRAPH_1_1DijkstraResult__struct}{Dijkstra\+Result}} \mbox{\hyperlink{classCXXGRAPH_1_1Graph_a8d655cd624cedf47ee366d8c0ab31921}{dijkstra}} (const \mbox{\hyperlink{classCXXGRAPH_1_1Node}{Node}}$<$ T $>$ \&source, const \mbox{\hyperlink{classCXXGRAPH_1_1Node}{Node}}$<$ T $>$ \&target) const
\begin{DoxyCompactList}\small\item\em Function runs the dijkstra algorithm for some source node and target node in the graph and returns the shortest distance of target from the source. Note\+: No Thread Safe. \end{DoxyCompactList}\item 
virtual const \mbox{\hyperlink{structCXXGRAPH_1_1BellmanFordResult__struct}{Bellman\+Ford\+Result}} \mbox{\hyperlink{classCXXGRAPH_1_1Graph_ae88da3d693fb461b53435d94e12e166c}{bellmanford}} (const \mbox{\hyperlink{classCXXGRAPH_1_1Node}{Node}}$<$ T $>$ \&source, const \mbox{\hyperlink{classCXXGRAPH_1_1Node}{Node}}$<$ T $>$ \&target) const
\begin{DoxyCompactList}\small\item\em Function runs the bellman-\/ford algorithm for some source node and target node in the graph and returns the shortest distance of target from the source. It can also detect if a negative cycle exists in the graph. Note\+: No Thread Safe. \end{DoxyCompactList}\item 
virtual const \mbox{\hyperlink{structCXXGRAPH_1_1FWResult__struct}{FWResult}} \mbox{\hyperlink{classCXXGRAPH_1_1Graph_a00b6780a5167547fe05db00e01011223}{floyd\+Warshall}} () const
\begin{DoxyCompactList}\small\item\em Function runs the floyd-\/warshall algorithm and returns the shortest distance of all pair of nodes. It can also detect if a negative cycle exists in the graph. Note\+: No Thread Safe. \end{DoxyCompactList}\item 
virtual const \mbox{\hyperlink{structCXXGRAPH_1_1MstResult__struct}{Mst\+Result}} \mbox{\hyperlink{classCXXGRAPH_1_1Graph_a1dd966cbf26d661a017e36d568fa3223}{prim}} () const
\begin{DoxyCompactList}\small\item\em Function runs the prim algorithm and returns the minimum spanning tree if the graph is undirected. Note\+: No Thread Safe. \end{DoxyCompactList}\item 
virtual const \mbox{\hyperlink{structCXXGRAPH_1_1MstResult__struct}{Mst\+Result}} \mbox{\hyperlink{classCXXGRAPH_1_1Graph_a8ff4c2379cae5b2426788e4bbcd174bc}{boruvka}} () const
\begin{DoxyCompactList}\small\item\em Function runs the boruvka algorithm and returns the minimum spanning tree \& cost if the graph is undirected. Note\+: No Thread Safe. \end{DoxyCompactList}\item 
virtual const \mbox{\hyperlink{structCXXGRAPH_1_1MstResult__struct}{Mst\+Result}} \mbox{\hyperlink{classCXXGRAPH_1_1Graph_acd02bf70592b8f706d441e82bbe6ddc9}{kruskal}} () const
\begin{DoxyCompactList}\small\item\em Function runs the kruskal algorithm and returns the minimum spanning tree if the graph is undirected. Note\+: No Thread Safe. \end{DoxyCompactList}\item 
virtual const std\+::vector$<$ \mbox{\hyperlink{classCXXGRAPH_1_1Node}{Node}}$<$ T $>$ $>$ \mbox{\hyperlink{classCXXGRAPH_1_1Graph_ae94a68dc57331c26070c3aec035264ef}{breadth\+\_\+first\+\_\+search}} (const \mbox{\hyperlink{classCXXGRAPH_1_1Node}{Node}}$<$ T $>$ \&start) const
\begin{DoxyCompactList}\small\item\em Function performs the breadth first search algorithm over the graph Note\+: No Thread Safe. \end{DoxyCompactList}\item 
virtual const std\+::vector$<$ \mbox{\hyperlink{classCXXGRAPH_1_1Node}{Node}}$<$ T $>$ $>$ \mbox{\hyperlink{classCXXGRAPH_1_1Graph_a05d230bd6185b99b624227c4c82b7811}{depth\+\_\+first\+\_\+search}} (const \mbox{\hyperlink{classCXXGRAPH_1_1Node}{Node}}$<$ T $>$ \&start) const
\begin{DoxyCompactList}\small\item\em Function performs the depth first search algorithm over the graph Note\+: No Thread Safe. \end{DoxyCompactList}\item 
virtual bool \mbox{\hyperlink{classCXXGRAPH_1_1Graph_a91a818601c0df0e5abfbaf4da5918afa}{is\+Cyclic\+Directed\+Graph\+DFS}} () const
\begin{DoxyCompactList}\small\item\em This function uses DFS to check for cycle in the graph. Pay Attention, this function work only with directed \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{Graph}} Note\+: No Thread Safe. \end{DoxyCompactList}\item 
virtual bool \mbox{\hyperlink{classCXXGRAPH_1_1Graph_a4f76bb7230c1654dd6b1ec24d0291875}{is\+Cyclic\+Directed\+Graph\+BFS}} () const
\begin{DoxyCompactList}\small\item\em This function uses BFS to check for cycle in the graph. Pay Attention, this function work only with directed \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{Graph}} Note\+: No Thread Safe. \end{DoxyCompactList}\item 
virtual bool \mbox{\hyperlink{classCXXGRAPH_1_1Graph_a54c736ce873d01a0ae290e8a2b448ca2}{contains\+Cycle}} (const T\+\_\+\+Edge\+Set$<$ T $>$ $\ast$) const
\begin{DoxyCompactList}\small\item\em This function checks if the given set of edges forms a cycle or not using union-\/find method. \end{DoxyCompactList}\item 
virtual bool \mbox{\hyperlink{classCXXGRAPH_1_1Graph_afa6c90c1c0e48c74fd486ef87b9626dd}{contains\+Cycle}} (const T\+\_\+\+Edge\+Set$<$ T $>$ $\ast$edge\+Set, std\+::unordered\+\_\+map$<$ unsigned long long, \mbox{\hyperlink{structCXXGRAPH_1_1Subset__struct}{Subset}} $>$ $\ast$) const
\begin{DoxyCompactList}\small\item\em This function checks if the given Subset forms a cycle or not using union-\/find method. \end{DoxyCompactList}\item 
virtual bool \mbox{\hyperlink{classCXXGRAPH_1_1Graph_a5c7ddb5c91f3ab7456c8203a740f52c9}{is\+Directed\+Graph}} () const
\begin{DoxyCompactList}\small\item\em This function checks if a graph is directed Note\+: No Thread Safe. \end{DoxyCompactList}\item 
virtual bool \mbox{\hyperlink{classCXXGRAPH_1_1Graph_a13abdb1d53937f7349cd72f527125edf}{is\+Undirected\+Graph}} () const
\begin{DoxyCompactList}\small\item\em This function checks if a graph is undirected Note\+: No Thread Safe. \end{DoxyCompactList}\item 
virtual bool \mbox{\hyperlink{classCXXGRAPH_1_1Graph_a1c7fc1183438f6f699179a4b02d39b68}{is\+Connected\+Graph}} () const
\begin{DoxyCompactList}\small\item\em This function checks if the graph is connected or not Applicable for Undirected \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{Graph}}, for Directed \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{Graph}} use the \mbox{\hyperlink{classCXXGRAPH_1_1Graph_a2dd3a83617afbd6a27d9f835f0ac7996}{is\+Strongly\+Connected\+Graph()}} function. \end{DoxyCompactList}\item 
virtual bool \mbox{\hyperlink{classCXXGRAPH_1_1Graph_a2dd3a83617afbd6a27d9f835f0ac7996}{is\+Strongly\+Connected\+Graph}} () const
\begin{DoxyCompactList}\small\item\em This function checks if the graph is strongly connected or not Applicable for Directed \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{Graph}}, for Undirected \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{Graph}} use the \mbox{\hyperlink{classCXXGRAPH_1_1Graph_a1c7fc1183438f6f699179a4b02d39b68}{is\+Connected\+Graph()}} function. \end{DoxyCompactList}\item 
virtual std\+::vector$<$ std\+::vector$<$ \mbox{\hyperlink{classCXXGRAPH_1_1Node}{Node}}$<$ T $>$ $>$ $>$ \mbox{\hyperlink{classCXXGRAPH_1_1Graph_a5905a6243d88a7c347c003b9c8789801}{kosaraju}} () const
\begin{DoxyCompactList}\small\item\em This function performs performs the kosaraju algorthm on the graph to find the strongly connected components. \end{DoxyCompactList}\item 
virtual const std\+::vector$<$ \mbox{\hyperlink{classCXXGRAPH_1_1Node}{Node}}$<$ T $>$ $>$ \mbox{\hyperlink{classCXXGRAPH_1_1Graph_a7c6d8a66538ecec3c33c4ff0574cdb2d}{graph\+\_\+slicing}} (const \mbox{\hyperlink{classCXXGRAPH_1_1Node}{Node}}$<$ T $>$ \&start) const
\begin{DoxyCompactList}\small\item\em This function performs \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{Graph}} Slicing based on connectivity. \end{DoxyCompactList}\item 
virtual const \mbox{\hyperlink{structCXXGRAPH_1_1DialResult__struct}{Dial\+Result}} \mbox{\hyperlink{classCXXGRAPH_1_1Graph_a662a0e15cd997252639e7a257b830190}{dial}} (const \mbox{\hyperlink{classCXXGRAPH_1_1Node}{Node}}$<$ T $>$ \&source, int max\+Weight) const
\begin{DoxyCompactList}\small\item\em This function write the graph in an output file Note\+: No Thread Safe. \end{DoxyCompactList}\item 
virtual double \mbox{\hyperlink{classCXXGRAPH_1_1Graph_a47608dbab5286badf6098a54bb2fa364}{ford\+Fulkerson\+Max\+Flow}} (const \mbox{\hyperlink{classCXXGRAPH_1_1Node}{Node}}$<$ T $>$ \&source, const \mbox{\hyperlink{classCXXGRAPH_1_1Node}{Node}}$<$ T $>$ \&target) const
\begin{DoxyCompactList}\small\item\em Function runs the Ford-\/\+Fulkerson algorithm for some source node and target node in the graph and returns the maximum flow of the graph. \end{DoxyCompactList}\item 
virtual int \mbox{\hyperlink{classCXXGRAPH_1_1Graph_a5a1ffeb9ef3b62b38c10bd84b44170a0}{write\+To\+File}} (Input\+Output\+Format format=Input\+Output\+Format\+::\+STANDARD\+\_\+\+CSV, const std\+::string \&working\+Dir=\char`\"{}.\char`\"{}, const std\+::string \&OFile\+Name=\char`\"{}graph\char`\"{}, bool compress=false, bool write\+Node\+Feat=false, bool write\+Edge\+Weight=false) const
\begin{DoxyCompactList}\small\item\em This function write the graph in an output file Note\+: No Thread Safe. \end{DoxyCompactList}\item 
virtual int \mbox{\hyperlink{classCXXGRAPH_1_1Graph_abd5baeb88c2b588c14383155fff4ec3e}{read\+From\+File}} (Input\+Output\+Format format=Input\+Output\+Format\+::\+STANDARD\+\_\+\+CSV, const std\+::string \&working\+Dir=\char`\"{}.\char`\"{}, const std\+::string \&OFile\+Name=\char`\"{}graph\char`\"{}, bool compress=false, bool read\+Node\+Feat=false, bool read\+Edge\+Weight=false)
\begin{DoxyCompactList}\small\item\em This function read the graph from an input file Note\+: No Thread Safe. \end{DoxyCompactList}\item 
virtual Partition\+Map$<$ T $>$ \mbox{\hyperlink{classCXXGRAPH_1_1Graph_a70da23746ecfd20c8b5b226322813af2}{partition\+Graph}} (PARTITIONING\+::\+Partition\+Algorithm algorithm, unsigned int number\+Of\+Partitions, double param1=0.\+0, double param2=0.\+0, double param3=0.\+0, unsigned int number\+Ofthreads=std\+::thread\+::hardware\+\_\+concurrency()) const
\begin{DoxyCompactList}\small\item\em This function partition a graph in a set of partitions Note\+: No Thread Safe. \end{DoxyCompactList}\end{DoxyCompactItemize}
\doxysubsection*{Friends}
\begin{DoxyCompactItemize}
\item 
\mbox{\Hypertarget{classCXXGRAPH_1_1Graph_a8cf06edd83359e8fb9634e9036e0334b}\label{classCXXGRAPH_1_1Graph_a8cf06edd83359e8fb9634e9036e0334b}} 
std\+::ostream \& {\bfseries operator$<$$<$} (std\+::ostream \&os, const \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{Graph}}$<$ T $>$ \&graph)
\item 
\mbox{\Hypertarget{classCXXGRAPH_1_1Graph_a35626ad6a1edaf1309a82bcdd9ab4ee1}\label{classCXXGRAPH_1_1Graph_a35626ad6a1edaf1309a82bcdd9ab4ee1}} 
std\+::ostream \& {\bfseries operator$<$$<$} (std\+::ostream \&os, const Adjacency\+Matrix$<$ T $>$ \&adj)
\end{DoxyCompactItemize}


\doxysubsection{Detailed Description}
\subsubsection*{template$<$typename T$>$\newline
class CXXGRAPH\+::\+Graph$<$ T $>$}

Class that implement the \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{Graph}}. ( This class is not Thread Safe ) 

\doxysubsection{Member Function Documentation}
\mbox{\Hypertarget{classCXXGRAPH_1_1Graph_a95fc676b51609323126e1d6f2366c4bb}\label{classCXXGRAPH_1_1Graph_a95fc676b51609323126e1d6f2366c4bb}} 
\index{CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}!addEdge@{addEdge}}
\index{addEdge@{addEdge}!CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}}
\doxysubsubsection{\texorpdfstring{addEdge()}{addEdge()}}
{\footnotesize\ttfamily template$<$typename T $>$ \\
void \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{CXXGRAPH\+::\+Graph}}$<$ T $>$\+::add\+Edge (\begin{DoxyParamCaption}\item[{const \mbox{\hyperlink{classCXXGRAPH_1_1Edge}{Edge}}$<$ T $>$ $\ast$}]{edge }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [virtual]}}



Function add an \mbox{\hyperlink{classCXXGRAPH_1_1Edge}{Edge}} to the \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{Graph}} \mbox{\hyperlink{classCXXGRAPH_1_1Edge}{Edge}} Set Note\+: No Thread Safe. 


\begin{DoxyParams}{Parameters}
{\em edge} & The \mbox{\hyperlink{classCXXGRAPH_1_1Edge}{Edge}} to insert \\
\hline
\end{DoxyParams}
\mbox{\Hypertarget{classCXXGRAPH_1_1Graph_ae88da3d693fb461b53435d94e12e166c}\label{classCXXGRAPH_1_1Graph_ae88da3d693fb461b53435d94e12e166c}} 
\index{CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}!bellmanford@{bellmanford}}
\index{bellmanford@{bellmanford}!CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}}
\doxysubsubsection{\texorpdfstring{bellmanford()}{bellmanford()}}
{\footnotesize\ttfamily template$<$typename T $>$ \\
const \mbox{\hyperlink{structCXXGRAPH_1_1BellmanFordResult__struct}{Bellman\+Ford\+Result}} \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{CXXGRAPH\+::\+Graph}}$<$ T $>$\+::bellmanford (\begin{DoxyParamCaption}\item[{const \mbox{\hyperlink{classCXXGRAPH_1_1Node}{Node}}$<$ T $>$ \&}]{source,  }\item[{const \mbox{\hyperlink{classCXXGRAPH_1_1Node}{Node}}$<$ T $>$ \&}]{target }\end{DoxyParamCaption}) const\hspace{0.3cm}{\ttfamily [virtual]}}



Function runs the bellman-\/ford algorithm for some source node and target node in the graph and returns the shortest distance of target from the source. It can also detect if a negative cycle exists in the graph. Note\+: No Thread Safe. 


\begin{DoxyParams}{Parameters}
{\em source} & source vertex \\
\hline
{\em target} & target vertex\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
shortest distance if target is reachable from source else ERROR in case if target is not reachable from source. If there is no error then also returns if the graph contains a negative cycle. 
\end{DoxyReturn}
\mbox{\Hypertarget{classCXXGRAPH_1_1Graph_a8ff4c2379cae5b2426788e4bbcd174bc}\label{classCXXGRAPH_1_1Graph_a8ff4c2379cae5b2426788e4bbcd174bc}} 
\index{CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}!boruvka@{boruvka}}
\index{boruvka@{boruvka}!CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}}
\doxysubsubsection{\texorpdfstring{boruvka()}{boruvka()}}
{\footnotesize\ttfamily template$<$typename T $>$ \\
const \mbox{\hyperlink{structCXXGRAPH_1_1MstResult__struct}{Mst\+Result}} \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{CXXGRAPH\+::\+Graph}}$<$ T $>$\+::boruvka\hspace{0.3cm}{\ttfamily [virtual]}}



Function runs the boruvka algorithm and returns the minimum spanning tree \& cost if the graph is undirected. Note\+: No Thread Safe. 

\begin{DoxyReturn}{Returns}
struct of type Mst\+Result with following fields success\+: true if algorithm completed successfully ELSE false mst\+: vector containing id of nodes in minimum spanning tree \& cost of MST mst\+Cost\+: Cost of MST error\+Message\+: \char`\"{}\char`\"{} if no error ELSE report the encountered error 
\end{DoxyReturn}
\mbox{\Hypertarget{classCXXGRAPH_1_1Graph_ae94a68dc57331c26070c3aec035264ef}\label{classCXXGRAPH_1_1Graph_ae94a68dc57331c26070c3aec035264ef}} 
\index{CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}!breadth\_first\_search@{breadth\_first\_search}}
\index{breadth\_first\_search@{breadth\_first\_search}!CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}}
\doxysubsubsection{\texorpdfstring{breadth\_first\_search()}{breadth\_first\_search()}}
{\footnotesize\ttfamily template$<$typename T $>$ \\
const std\+::vector$<$ \mbox{\hyperlink{classCXXGRAPH_1_1Node}{Node}}$<$ T $>$ $>$ \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{CXXGRAPH\+::\+Graph}}$<$ T $>$\+::breadth\+\_\+first\+\_\+search (\begin{DoxyParamCaption}\item[{const \mbox{\hyperlink{classCXXGRAPH_1_1Node}{Node}}$<$ T $>$ \&}]{start }\end{DoxyParamCaption}) const\hspace{0.3cm}{\ttfamily [virtual]}}



Function performs the breadth first search algorithm over the graph Note\+: No Thread Safe. 


\begin{DoxyParams}{Parameters}
{\em start} & \mbox{\hyperlink{classCXXGRAPH_1_1Node}{Node}} from where traversing starts \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
a vector of \mbox{\hyperlink{classCXXGRAPH_1_1Node}{Node}} indicating which \mbox{\hyperlink{classCXXGRAPH_1_1Node}{Node}} were visited during the search. 
\end{DoxyReturn}
\mbox{\Hypertarget{classCXXGRAPH_1_1Graph_a54c736ce873d01a0ae290e8a2b448ca2}\label{classCXXGRAPH_1_1Graph_a54c736ce873d01a0ae290e8a2b448ca2}} 
\index{CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}!containsCycle@{containsCycle}}
\index{containsCycle@{containsCycle}!CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}}
\doxysubsubsection{\texorpdfstring{containsCycle()}{containsCycle()}\hspace{0.1cm}{\footnotesize\ttfamily [1/2]}}
{\footnotesize\ttfamily template$<$typename T $>$ \\
bool \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{CXXGRAPH\+::\+Graph}}$<$ T $>$\+::contains\+Cycle (\begin{DoxyParamCaption}\item[{const T\+\_\+\+Edge\+Set$<$ T $>$ $\ast$}]{edge\+Set }\end{DoxyParamCaption}) const\hspace{0.3cm}{\ttfamily [virtual]}}



This function checks if the given set of edges forms a cycle or not using union-\/find method. 

\begin{DoxyReturn}{Returns}
true if a cycle is detected, else false 
\end{DoxyReturn}
\mbox{\Hypertarget{classCXXGRAPH_1_1Graph_afa6c90c1c0e48c74fd486ef87b9626dd}\label{classCXXGRAPH_1_1Graph_afa6c90c1c0e48c74fd486ef87b9626dd}} 
\index{CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}!containsCycle@{containsCycle}}
\index{containsCycle@{containsCycle}!CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}}
\doxysubsubsection{\texorpdfstring{containsCycle()}{containsCycle()}\hspace{0.1cm}{\footnotesize\ttfamily [2/2]}}
{\footnotesize\ttfamily template$<$typename T $>$ \\
bool \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{CXXGRAPH\+::\+Graph}}$<$ T $>$\+::contains\+Cycle (\begin{DoxyParamCaption}\item[{const T\+\_\+\+Edge\+Set$<$ T $>$ $\ast$}]{edge\+Set,  }\item[{std\+::unordered\+\_\+map$<$ unsigned long long, \mbox{\hyperlink{structCXXGRAPH_1_1Subset__struct}{Subset}} $>$ $\ast$}]{subset }\end{DoxyParamCaption}) const\hspace{0.3cm}{\ttfamily [virtual]}}



This function checks if the given Subset forms a cycle or not using union-\/find method. 

\begin{DoxyReturn}{Returns}
true if a cycle is detected, else false 
\end{DoxyReturn}
\mbox{\Hypertarget{classCXXGRAPH_1_1Graph_a05d230bd6185b99b624227c4c82b7811}\label{classCXXGRAPH_1_1Graph_a05d230bd6185b99b624227c4c82b7811}} 
\index{CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}!depth\_first\_search@{depth\_first\_search}}
\index{depth\_first\_search@{depth\_first\_search}!CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}}
\doxysubsubsection{\texorpdfstring{depth\_first\_search()}{depth\_first\_search()}}
{\footnotesize\ttfamily template$<$typename T $>$ \\
const std\+::vector$<$ \mbox{\hyperlink{classCXXGRAPH_1_1Node}{Node}}$<$ T $>$ $>$ \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{CXXGRAPH\+::\+Graph}}$<$ T $>$\+::depth\+\_\+first\+\_\+search (\begin{DoxyParamCaption}\item[{const \mbox{\hyperlink{classCXXGRAPH_1_1Node}{Node}}$<$ T $>$ \&}]{start }\end{DoxyParamCaption}) const\hspace{0.3cm}{\ttfamily [virtual]}}



Function performs the depth first search algorithm over the graph Note\+: No Thread Safe. 


\begin{DoxyParams}{Parameters}
{\em start} & \mbox{\hyperlink{classCXXGRAPH_1_1Node}{Node}} from where traversing starts \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
a vector of \mbox{\hyperlink{classCXXGRAPH_1_1Node}{Node}} indicating which \mbox{\hyperlink{classCXXGRAPH_1_1Node}{Node}} were visited during the search. 
\end{DoxyReturn}
\mbox{\Hypertarget{classCXXGRAPH_1_1Graph_a662a0e15cd997252639e7a257b830190}\label{classCXXGRAPH_1_1Graph_a662a0e15cd997252639e7a257b830190}} 
\index{CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}!dial@{dial}}
\index{dial@{dial}!CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}}
\doxysubsubsection{\texorpdfstring{dial()}{dial()}}
{\footnotesize\ttfamily template$<$typename T $>$ \\
const \mbox{\hyperlink{structCXXGRAPH_1_1DialResult__struct}{Dial\+Result}} \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{CXXGRAPH\+::\+Graph}}$<$ T $>$\+::dial (\begin{DoxyParamCaption}\item[{const \mbox{\hyperlink{classCXXGRAPH_1_1Node}{Node}}$<$ T $>$ \&}]{source,  }\item[{int}]{max\+Weight }\end{DoxyParamCaption}) const\hspace{0.3cm}{\ttfamily [virtual]}}



This function write the graph in an output file Note\+: No Thread Safe. 


\begin{DoxyParams}{Parameters}
{\em format} & The Output format of the file \\
\hline
{\em working\+Dir} & The path to the directory in which will be placed the output file \\
\hline
{\em OFile\+Name} & The Output File Name ( ) \\
\hline
{\em compress} & Indicates if the output will be compressed \\
\hline
{\em write\+Node\+Feat} & Indicates if export also \mbox{\hyperlink{classCXXGRAPH_1_1Node}{Node}} Features \\
\hline
{\em write\+Edge\+Weight} & Indicates if export also \mbox{\hyperlink{classCXXGRAPH_1_1Edge}{Edge}} Weights \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
0 if all OK, else return a negative value
\end{DoxyReturn}
Function runs the Dial algorithm (Optimized Dijkstra for small range weights) for some source node and target node in the graph and returns the shortest distance of target from the source. Note\+: No Thread Safe


\begin{DoxyParams}{Parameters}
{\em source} & source vertex \\
\hline
{\em max\+Weight} & maximum weight of the edge\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
shortest distance for all nodes reachable from source else ERROR in case there is error in the computation. 
\end{DoxyReturn}
\mbox{\Hypertarget{classCXXGRAPH_1_1Graph_a8d655cd624cedf47ee366d8c0ab31921}\label{classCXXGRAPH_1_1Graph_a8d655cd624cedf47ee366d8c0ab31921}} 
\index{CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}!dijkstra@{dijkstra}}
\index{dijkstra@{dijkstra}!CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}}
\doxysubsubsection{\texorpdfstring{dijkstra()}{dijkstra()}}
{\footnotesize\ttfamily template$<$typename T $>$ \\
const \mbox{\hyperlink{structCXXGRAPH_1_1DijkstraResult__struct}{Dijkstra\+Result}} \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{CXXGRAPH\+::\+Graph}}$<$ T $>$\+::dijkstra (\begin{DoxyParamCaption}\item[{const \mbox{\hyperlink{classCXXGRAPH_1_1Node}{Node}}$<$ T $>$ \&}]{source,  }\item[{const \mbox{\hyperlink{classCXXGRAPH_1_1Node}{Node}}$<$ T $>$ \&}]{target }\end{DoxyParamCaption}) const\hspace{0.3cm}{\ttfamily [virtual]}}



Function runs the dijkstra algorithm for some source node and target node in the graph and returns the shortest distance of target from the source. Note\+: No Thread Safe. 


\begin{DoxyParams}{Parameters}
{\em source} & source vertex \\
\hline
{\em target} & target vertex\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
shortest distance if target is reachable from source else ERROR in case if target is not reachable from source or there is error in the computation. 
\end{DoxyReturn}
\mbox{\Hypertarget{classCXXGRAPH_1_1Graph_a31b482ce494f93dcd7125b3aa4eb8f78}\label{classCXXGRAPH_1_1Graph_a31b482ce494f93dcd7125b3aa4eb8f78}} 
\index{CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}!eulerianPath@{eulerianPath}}
\index{eulerianPath@{eulerianPath}!CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}}
\doxysubsubsection{\texorpdfstring{eulerianPath()}{eulerianPath()}}
{\footnotesize\ttfamily template$<$typename T $>$ \\
std\+::vector$<$ \mbox{\hyperlink{classCXXGRAPH_1_1Node}{Node}}$<$ T $>$ $>$ \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{CXXGRAPH\+::\+Graph}}$<$ T $>$\+::eulerian\+Path\hspace{0.3cm}{\ttfamily [virtual]}}



This function finds the eulerian path of a directed graph using hierholzers algorithm. 

\begin{DoxyReturn}{Returns}
a vector containing nodes in eulerian path Note\+: No Thread Safe 
\end{DoxyReturn}
\mbox{\Hypertarget{classCXXGRAPH_1_1Graph_a00b6780a5167547fe05db00e01011223}\label{classCXXGRAPH_1_1Graph_a00b6780a5167547fe05db00e01011223}} 
\index{CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}!floydWarshall@{floydWarshall}}
\index{floydWarshall@{floydWarshall}!CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}}
\doxysubsubsection{\texorpdfstring{floydWarshall()}{floydWarshall()}}
{\footnotesize\ttfamily template$<$typename T $>$ \\
const \mbox{\hyperlink{structCXXGRAPH_1_1FWResult__struct}{FWResult}} \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{CXXGRAPH\+::\+Graph}}$<$ T $>$\+::floyd\+Warshall\hspace{0.3cm}{\ttfamily [virtual]}}



Function runs the floyd-\/warshall algorithm and returns the shortest distance of all pair of nodes. It can also detect if a negative cycle exists in the graph. Note\+: No Thread Safe. 

\begin{DoxyReturn}{Returns}
a map whose keys are node ids and values are the shortest distance. If there is no error then also returns if the graph contains a negative cycle. 
\end{DoxyReturn}
\mbox{\Hypertarget{classCXXGRAPH_1_1Graph_a47608dbab5286badf6098a54bb2fa364}\label{classCXXGRAPH_1_1Graph_a47608dbab5286badf6098a54bb2fa364}} 
\index{CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}!fordFulkersonMaxFlow@{fordFulkersonMaxFlow}}
\index{fordFulkersonMaxFlow@{fordFulkersonMaxFlow}!CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}}
\doxysubsubsection{\texorpdfstring{fordFulkersonMaxFlow()}{fordFulkersonMaxFlow()}}
{\footnotesize\ttfamily template$<$typename T $>$ \\
double \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{CXXGRAPH\+::\+Graph}}$<$ T $>$\+::ford\+Fulkerson\+Max\+Flow (\begin{DoxyParamCaption}\item[{const \mbox{\hyperlink{classCXXGRAPH_1_1Node}{Node}}$<$ T $>$ \&}]{source,  }\item[{const \mbox{\hyperlink{classCXXGRAPH_1_1Node}{Node}}$<$ T $>$ \&}]{target }\end{DoxyParamCaption}) const\hspace{0.3cm}{\ttfamily [virtual]}}



Function runs the Ford-\/\+Fulkerson algorithm for some source node and target node in the graph and returns the maximum flow of the graph. 


\begin{DoxyParams}{Parameters}
{\em source} & source vertex \\
\hline
{\em target} & target vertex \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
double Max-\/\+Flow value or -\/1 in case of error 
\end{DoxyReturn}
\mbox{\Hypertarget{classCXXGRAPH_1_1Graph_a5ebab9011fe6155743eaa989c2bf7860}\label{classCXXGRAPH_1_1Graph_a5ebab9011fe6155743eaa989c2bf7860}} 
\index{CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}!getEdge@{getEdge}}
\index{getEdge@{getEdge}!CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}}
\doxysubsubsection{\texorpdfstring{getEdge()}{getEdge()}}
{\footnotesize\ttfamily template$<$typename T $>$ \\
const std\+::optional$<$ const \mbox{\hyperlink{classCXXGRAPH_1_1Edge}{Edge}}$<$ T $>$ $\ast$ $>$ \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{CXXGRAPH\+::\+Graph}}$<$ T $>$\+::get\+Edge (\begin{DoxyParamCaption}\item[{unsigned long long}]{edge\+Id }\end{DoxyParamCaption}) const\hspace{0.3cm}{\ttfamily [virtual]}}



Function that return an \mbox{\hyperlink{classCXXGRAPH_1_1Edge}{Edge}} with specific ID if Exist in the \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{Graph}} Note\+: No Thread Safe. 


\begin{DoxyParams}{Parameters}
{\em edge\+Id} & The \mbox{\hyperlink{classCXXGRAPH_1_1Edge}{Edge}} Id to return \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
the \mbox{\hyperlink{classCXXGRAPH_1_1Edge}{Edge}} if exist 
\end{DoxyReturn}
\mbox{\Hypertarget{classCXXGRAPH_1_1Graph_a8412ba5fbb3bd12ce9c872bd9bbd9824}\label{classCXXGRAPH_1_1Graph_a8412ba5fbb3bd12ce9c872bd9bbd9824}} 
\index{CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}!getEdgeSet@{getEdgeSet}}
\index{getEdgeSet@{getEdgeSet}!CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}}
\doxysubsubsection{\texorpdfstring{getEdgeSet()}{getEdgeSet()}}
{\footnotesize\ttfamily template$<$typename T $>$ \\
const T\+\_\+\+Edge\+Set$<$ T $>$ \& \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{CXXGRAPH\+::\+Graph}}$<$ T $>$\+::get\+Edge\+Set\hspace{0.3cm}{\ttfamily [virtual]}}



Function that return the \mbox{\hyperlink{classCXXGRAPH_1_1Edge}{Edge}} set of the \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{Graph}} Note\+: No Thread Safe. 

\begin{DoxyReturn}{Returns}
a list of Edges of the graph 
\end{DoxyReturn}
\mbox{\Hypertarget{classCXXGRAPH_1_1Graph_af0544d74b956980e05e2a57a5dc2d2d6}\label{classCXXGRAPH_1_1Graph_af0544d74b956980e05e2a57a5dc2d2d6}} 
\index{CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}!getNodeSet@{getNodeSet}}
\index{getNodeSet@{getNodeSet}!CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}}
\doxysubsubsection{\texorpdfstring{getNodeSet()}{getNodeSet()}}
{\footnotesize\ttfamily template$<$typename T $>$ \\
const std\+::set$<$ const \mbox{\hyperlink{classCXXGRAPH_1_1Node}{Node}}$<$ T $>$ $\ast$ $>$ \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{CXXGRAPH\+::\+Graph}}$<$ T $>$\+::get\+Node\+Set\hspace{0.3cm}{\ttfamily [virtual]}}



Function that return the \mbox{\hyperlink{classCXXGRAPH_1_1Node}{Node}} Set of the \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{Graph}} Note\+: No Thread Safe. 

\begin{DoxyReturn}{Returns}
a list of Nodes of the graph 
\end{DoxyReturn}
\mbox{\Hypertarget{classCXXGRAPH_1_1Graph_a7c6d8a66538ecec3c33c4ff0574cdb2d}\label{classCXXGRAPH_1_1Graph_a7c6d8a66538ecec3c33c4ff0574cdb2d}} 
\index{CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}!graph\_slicing@{graph\_slicing}}
\index{graph\_slicing@{graph\_slicing}!CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}}
\doxysubsubsection{\texorpdfstring{graph\_slicing()}{graph\_slicing()}}
{\footnotesize\ttfamily template$<$typename T $>$ \\
const std\+::vector$<$ \mbox{\hyperlink{classCXXGRAPH_1_1Node}{Node}}$<$ T $>$ $>$ \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{CXXGRAPH\+::\+Graph}}$<$ T $>$\+::graph\+\_\+slicing (\begin{DoxyParamCaption}\item[{const \mbox{\hyperlink{classCXXGRAPH_1_1Node}{Node}}$<$ T $>$ \&}]{start }\end{DoxyParamCaption}) const\hspace{0.3cm}{\ttfamily [virtual]}}



This function performs \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{Graph}} Slicing based on connectivity. 

Mathematical definition of the problem\+:

Let G be the set of nodes in a graph and n be a given node in that set. Let C be the non-\/strict subset of G containing both n and all nodes reachable from n, and let C\textquotesingle{} be its complement. There\textquotesingle{}s a third set M, which is the non-\/strict subset of C containing all nodes that are reachable from any node in C\textquotesingle{}. The problem consists of finding all nodes that belong to C but not to M.

Note\+: No Thread Safe 
\begin{DoxyParams}{Parameters}
{\em start} & \mbox{\hyperlink{classCXXGRAPH_1_1Node}{Node}} from where traversing starts \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
a vector of nodes that belong to C but not to M. 
\end{DoxyReturn}
\mbox{\Hypertarget{classCXXGRAPH_1_1Graph_a1c7fc1183438f6f699179a4b02d39b68}\label{classCXXGRAPH_1_1Graph_a1c7fc1183438f6f699179a4b02d39b68}} 
\index{CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}!isConnectedGraph@{isConnectedGraph}}
\index{isConnectedGraph@{isConnectedGraph}!CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}}
\doxysubsubsection{\texorpdfstring{isConnectedGraph()}{isConnectedGraph()}}
{\footnotesize\ttfamily template$<$typename T $>$ \\
bool \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{CXXGRAPH\+::\+Graph}}$<$ T $>$\+::is\+Connected\+Graph\hspace{0.3cm}{\ttfamily [virtual]}}



This function checks if the graph is connected or not Applicable for Undirected \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{Graph}}, for Directed \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{Graph}} use the \mbox{\hyperlink{classCXXGRAPH_1_1Graph_a2dd3a83617afbd6a27d9f835f0ac7996}{is\+Strongly\+Connected\+Graph()}} function. 

\begin{DoxyReturn}{Returns}
true if the graph is connected 

false otherwise 
\end{DoxyReturn}
\mbox{\Hypertarget{classCXXGRAPH_1_1Graph_a4f76bb7230c1654dd6b1ec24d0291875}\label{classCXXGRAPH_1_1Graph_a4f76bb7230c1654dd6b1ec24d0291875}} 
\index{CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}!isCyclicDirectedGraphBFS@{isCyclicDirectedGraphBFS}}
\index{isCyclicDirectedGraphBFS@{isCyclicDirectedGraphBFS}!CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}}
\doxysubsubsection{\texorpdfstring{isCyclicDirectedGraphBFS()}{isCyclicDirectedGraphBFS()}}
{\footnotesize\ttfamily template$<$typename T $>$ \\
bool \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{CXXGRAPH\+::\+Graph}}$<$ T $>$\+::is\+Cyclic\+Directed\+Graph\+BFS\hspace{0.3cm}{\ttfamily [virtual]}}



This function uses BFS to check for cycle in the graph. Pay Attention, this function work only with directed \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{Graph}} Note\+: No Thread Safe. 

\begin{DoxyReturn}{Returns}
true if a cycle is detected, else false. ( false is returned also if the graph in indirected) 
\end{DoxyReturn}
\mbox{\Hypertarget{classCXXGRAPH_1_1Graph_a91a818601c0df0e5abfbaf4da5918afa}\label{classCXXGRAPH_1_1Graph_a91a818601c0df0e5abfbaf4da5918afa}} 
\index{CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}!isCyclicDirectedGraphDFS@{isCyclicDirectedGraphDFS}}
\index{isCyclicDirectedGraphDFS@{isCyclicDirectedGraphDFS}!CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}}
\doxysubsubsection{\texorpdfstring{isCyclicDirectedGraphDFS()}{isCyclicDirectedGraphDFS()}}
{\footnotesize\ttfamily template$<$typename T $>$ \\
bool \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{CXXGRAPH\+::\+Graph}}$<$ T $>$\+::is\+Cyclic\+Directed\+Graph\+DFS\hspace{0.3cm}{\ttfamily [virtual]}}



This function uses DFS to check for cycle in the graph. Pay Attention, this function work only with directed \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{Graph}} Note\+: No Thread Safe. 

\begin{DoxyReturn}{Returns}
true if a cycle is detected, else false. ( false is returned also if the graph in indirected) 
\end{DoxyReturn}
\mbox{\Hypertarget{classCXXGRAPH_1_1Graph_a5c7ddb5c91f3ab7456c8203a740f52c9}\label{classCXXGRAPH_1_1Graph_a5c7ddb5c91f3ab7456c8203a740f52c9}} 
\index{CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}!isDirectedGraph@{isDirectedGraph}}
\index{isDirectedGraph@{isDirectedGraph}!CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}}
\doxysubsubsection{\texorpdfstring{isDirectedGraph()}{isDirectedGraph()}}
{\footnotesize\ttfamily template$<$typename T $>$ \\
bool \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{CXXGRAPH\+::\+Graph}}$<$ T $>$\+::is\+Directed\+Graph\hspace{0.3cm}{\ttfamily [virtual]}}



This function checks if a graph is directed Note\+: No Thread Safe. 

\begin{DoxyReturn}{Returns}
true if the graph is directed, else false. 
\end{DoxyReturn}
\mbox{\Hypertarget{classCXXGRAPH_1_1Graph_a2dd3a83617afbd6a27d9f835f0ac7996}\label{classCXXGRAPH_1_1Graph_a2dd3a83617afbd6a27d9f835f0ac7996}} 
\index{CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}!isStronglyConnectedGraph@{isStronglyConnectedGraph}}
\index{isStronglyConnectedGraph@{isStronglyConnectedGraph}!CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}}
\doxysubsubsection{\texorpdfstring{isStronglyConnectedGraph()}{isStronglyConnectedGraph()}}
{\footnotesize\ttfamily template$<$typename T $>$ \\
bool \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{CXXGRAPH\+::\+Graph}}$<$ T $>$\+::is\+Strongly\+Connected\+Graph\hspace{0.3cm}{\ttfamily [virtual]}}



This function checks if the graph is strongly connected or not Applicable for Directed \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{Graph}}, for Undirected \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{Graph}} use the \mbox{\hyperlink{classCXXGRAPH_1_1Graph_a1c7fc1183438f6f699179a4b02d39b68}{is\+Connected\+Graph()}} function. 

\begin{DoxyReturn}{Returns}
true if the graph is connected 

false otherwise 
\end{DoxyReturn}
\mbox{\Hypertarget{classCXXGRAPH_1_1Graph_a13abdb1d53937f7349cd72f527125edf}\label{classCXXGRAPH_1_1Graph_a13abdb1d53937f7349cd72f527125edf}} 
\index{CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}!isUndirectedGraph@{isUndirectedGraph}}
\index{isUndirectedGraph@{isUndirectedGraph}!CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}}
\doxysubsubsection{\texorpdfstring{isUndirectedGraph()}{isUndirectedGraph()}}
{\footnotesize\ttfamily template$<$typename T $>$ \\
bool \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{CXXGRAPH\+::\+Graph}}$<$ T $>$\+::is\+Undirected\+Graph\hspace{0.3cm}{\ttfamily [virtual]}}



This function checks if a graph is undirected Note\+: No Thread Safe. 

\begin{DoxyReturn}{Returns}
true if the graph is undirected, else false. 
\end{DoxyReturn}
\mbox{\Hypertarget{classCXXGRAPH_1_1Graph_a5905a6243d88a7c347c003b9c8789801}\label{classCXXGRAPH_1_1Graph_a5905a6243d88a7c347c003b9c8789801}} 
\index{CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}!kosaraju@{kosaraju}}
\index{kosaraju@{kosaraju}!CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}}
\doxysubsubsection{\texorpdfstring{kosaraju()}{kosaraju()}}
{\footnotesize\ttfamily template$<$typename T $>$ \\
std\+::vector$<$ std\+::vector$<$ \mbox{\hyperlink{classCXXGRAPH_1_1Node}{Node}}$<$ T $>$ $>$ $>$ \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{CXXGRAPH\+::\+Graph}}$<$ T $>$\+::kosaraju\hspace{0.3cm}{\ttfamily [virtual]}}



This function performs performs the kosaraju algorthm on the graph to find the strongly connected components. 

Mathematical definition of the problem\+: A strongly connected component (SCC) of a directed graph is a maximal strongly connected subgraph.

Note\+: No Thread Safe \begin{DoxyReturn}{Returns}
a vector of vector of strongly connected components. 
\end{DoxyReturn}
\mbox{\Hypertarget{classCXXGRAPH_1_1Graph_acd02bf70592b8f706d441e82bbe6ddc9}\label{classCXXGRAPH_1_1Graph_acd02bf70592b8f706d441e82bbe6ddc9}} 
\index{CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}!kruskal@{kruskal}}
\index{kruskal@{kruskal}!CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}}
\doxysubsubsection{\texorpdfstring{kruskal()}{kruskal()}}
{\footnotesize\ttfamily template$<$typename T $>$ \\
const \mbox{\hyperlink{structCXXGRAPH_1_1MstResult__struct}{Mst\+Result}} \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{CXXGRAPH\+::\+Graph}}$<$ T $>$\+::kruskal\hspace{0.3cm}{\ttfamily [virtual]}}



Function runs the kruskal algorithm and returns the minimum spanning tree if the graph is undirected. Note\+: No Thread Safe. 

\begin{DoxyReturn}{Returns}
struct of type Mst\+Result with following fields success\+: true if algorithm completed successfully ELSE false mst\+: vector containing id of nodes in minimum spanning tree \& cost of MST mst\+Cost\+: Cost of MST error\+Message\+: \char`\"{}\char`\"{} if no error ELSE report the encountered error 
\end{DoxyReturn}
\mbox{\Hypertarget{classCXXGRAPH_1_1Graph_a70da23746ecfd20c8b5b226322813af2}\label{classCXXGRAPH_1_1Graph_a70da23746ecfd20c8b5b226322813af2}} 
\index{CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}!partitionGraph@{partitionGraph}}
\index{partitionGraph@{partitionGraph}!CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}}
\doxysubsubsection{\texorpdfstring{partitionGraph()}{partitionGraph()}}
{\footnotesize\ttfamily template$<$typename T $>$ \\
Partition\+Map$<$ T $>$ \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{CXXGRAPH\+::\+Graph}}$<$ T $>$\+::partition\+Graph (\begin{DoxyParamCaption}\item[{PARTITIONING\+::\+Partition\+Algorithm}]{algorithm,  }\item[{unsigned int}]{number\+Of\+Partitions,  }\item[{double}]{param1 = {\ttfamily 0.0},  }\item[{double}]{param2 = {\ttfamily 0.0},  }\item[{double}]{param3 = {\ttfamily 0.0},  }\item[{unsigned int}]{number\+Ofthreads = {\ttfamily std\+:\+:thread\+:\+:hardware\+\_\+concurrency()} }\end{DoxyParamCaption}) const\hspace{0.3cm}{\ttfamily [virtual]}}



This function partition a graph in a set of partitions Note\+: No Thread Safe. 


\begin{DoxyParams}{Parameters}
{\em algorithm} & The partition algorithm \\
\hline
{\em number\+Of\+Partition} & The number of partitions \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
The partiton Map of the partitioned graph 
\end{DoxyReturn}
\mbox{\Hypertarget{classCXXGRAPH_1_1Graph_a1dd966cbf26d661a017e36d568fa3223}\label{classCXXGRAPH_1_1Graph_a1dd966cbf26d661a017e36d568fa3223}} 
\index{CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}!prim@{prim}}
\index{prim@{prim}!CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}}
\doxysubsubsection{\texorpdfstring{prim()}{prim()}}
{\footnotesize\ttfamily template$<$typename T $>$ \\
const \mbox{\hyperlink{structCXXGRAPH_1_1MstResult__struct}{Mst\+Result}} \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{CXXGRAPH\+::\+Graph}}$<$ T $>$\+::prim\hspace{0.3cm}{\ttfamily [virtual]}}



Function runs the prim algorithm and returns the minimum spanning tree if the graph is undirected. Note\+: No Thread Safe. 

\begin{DoxyReturn}{Returns}
a vector containing id of nodes in minimum spanning tree \& cost of MST 
\end{DoxyReturn}
\mbox{\Hypertarget{classCXXGRAPH_1_1Graph_abd5baeb88c2b588c14383155fff4ec3e}\label{classCXXGRAPH_1_1Graph_abd5baeb88c2b588c14383155fff4ec3e}} 
\index{CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}!readFromFile@{readFromFile}}
\index{readFromFile@{readFromFile}!CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}}
\doxysubsubsection{\texorpdfstring{readFromFile()}{readFromFile()}}
{\footnotesize\ttfamily template$<$typename T $>$ \\
int \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{CXXGRAPH\+::\+Graph}}$<$ T $>$\+::read\+From\+File (\begin{DoxyParamCaption}\item[{Input\+Output\+Format}]{format = {\ttfamily InputOutputFormat\+:\+:STANDARD\+\_\+CSV},  }\item[{const std\+::string \&}]{working\+Dir = {\ttfamily \char`\"{}.\char`\"{}},  }\item[{const std\+::string \&}]{OFile\+Name = {\ttfamily \char`\"{}graph\char`\"{}},  }\item[{bool}]{compress = {\ttfamily false},  }\item[{bool}]{read\+Node\+Feat = {\ttfamily false},  }\item[{bool}]{read\+Edge\+Weight = {\ttfamily false} }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [virtual]}}



This function read the graph from an input file Note\+: No Thread Safe. 


\begin{DoxyParams}{Parameters}
{\em format} & The Input format of the file \\
\hline
{\em working\+Dir} & The path to the directory in which is placed the Input file \\
\hline
{\em OFile\+Name} & The Input File Name ( ) \\
\hline
{\em compress} & Indicates if the Input is compressed \\
\hline
{\em read\+Node\+Feat} & Indicates if import also \mbox{\hyperlink{classCXXGRAPH_1_1Node}{Node}} Features \\
\hline
{\em read\+Edge\+Weight} & Indicates if import also \mbox{\hyperlink{classCXXGRAPH_1_1Edge}{Edge}} Weights \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
0 if all OK, else return a negative value 
\end{DoxyReturn}
\mbox{\Hypertarget{classCXXGRAPH_1_1Graph_ac1b14104add48bad5524e31b47411d36}\label{classCXXGRAPH_1_1Graph_ac1b14104add48bad5524e31b47411d36}} 
\index{CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}!removeEdge@{removeEdge}}
\index{removeEdge@{removeEdge}!CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}}
\doxysubsubsection{\texorpdfstring{removeEdge()}{removeEdge()}}
{\footnotesize\ttfamily template$<$typename T $>$ \\
void \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{CXXGRAPH\+::\+Graph}}$<$ T $>$\+::remove\+Edge (\begin{DoxyParamCaption}\item[{unsigned long long}]{edge\+Id }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [virtual]}}



Function remove an \mbox{\hyperlink{classCXXGRAPH_1_1Edge}{Edge}} from the \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{Graph}} \mbox{\hyperlink{classCXXGRAPH_1_1Edge}{Edge}} Set Note\+: No Thread Safe. 


\begin{DoxyParams}{Parameters}
{\em edge\+Id} & The \mbox{\hyperlink{classCXXGRAPH_1_1Edge}{Edge}} Id to remove \\
\hline
\end{DoxyParams}
\mbox{\Hypertarget{classCXXGRAPH_1_1Graph_a7f4b22c1c3e93bd51600141d9517e36a}\label{classCXXGRAPH_1_1Graph_a7f4b22c1c3e93bd51600141d9517e36a}} 
\index{CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}!setEdgeSet@{setEdgeSet}}
\index{setEdgeSet@{setEdgeSet}!CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}}
\doxysubsubsection{\texorpdfstring{setEdgeSet()}{setEdgeSet()}}
{\footnotesize\ttfamily template$<$typename T $>$ \\
void \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{CXXGRAPH\+::\+Graph}}$<$ T $>$\+::set\+Edge\+Set (\begin{DoxyParamCaption}\item[{T\+\_\+\+Edge\+Set$<$ T $>$ \&}]{edge\+Set }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [virtual]}}



Function set the \mbox{\hyperlink{classCXXGRAPH_1_1Edge}{Edge}} Set of the \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{Graph}} Note\+: No Thread Safe. 


\begin{DoxyParams}{Parameters}
{\em edge\+Set} & The \mbox{\hyperlink{classCXXGRAPH_1_1Edge}{Edge}} Set \\
\hline
\end{DoxyParams}
\mbox{\Hypertarget{classCXXGRAPH_1_1Graph_a0cc15d4668136f6be44bf18a2e28cc6b}\label{classCXXGRAPH_1_1Graph_a0cc15d4668136f6be44bf18a2e28cc6b}} 
\index{CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}!setFind@{setFind}}
\index{setFind@{setFind}!CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}}
\doxysubsubsection{\texorpdfstring{setFind()}{setFind()}}
{\footnotesize\ttfamily template$<$typename T $>$ \\
unsigned long long \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{CXXGRAPH\+::\+Graph}}$<$ T $>$\+::set\+Find (\begin{DoxyParamCaption}\item[{std\+::unordered\+\_\+map$<$ unsigned long long, \mbox{\hyperlink{structCXXGRAPH_1_1Subset__struct}{Subset}} $>$ $\ast$}]{subsets,  }\item[{const unsigned long long}]{elem }\end{DoxyParamCaption}) const\hspace{0.3cm}{\ttfamily [virtual]}}



This function finds the subset of given a node\+Id Subset is stored in a map where keys are the hash-\/id of the node \& values is the subset. 


\begin{DoxyParams}{Parameters}
{\em subset} & query subset, we want to find target in this subset \\
\hline
{\em elem} & elem that we wish to find in the subset\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
parent node of elem Note\+: No Thread Safe 
\end{DoxyReturn}
\mbox{\Hypertarget{classCXXGRAPH_1_1Graph_a60a3f55bd4b195d7225b77b3ae8c9065}\label{classCXXGRAPH_1_1Graph_a60a3f55bd4b195d7225b77b3ae8c9065}} 
\index{CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}!setUnion@{setUnion}}
\index{setUnion@{setUnion}!CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}}
\doxysubsubsection{\texorpdfstring{setUnion()}{setUnion()}}
{\footnotesize\ttfamily template$<$typename T $>$ \\
void \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{CXXGRAPH\+::\+Graph}}$<$ T $>$\+::set\+Union (\begin{DoxyParamCaption}\item[{std\+::unordered\+\_\+map$<$ unsigned long long, \mbox{\hyperlink{structCXXGRAPH_1_1Subset__struct}{Subset}} $>$ $\ast$}]{subsets,  }\item[{const unsigned long long}]{set1,  }\item[{const unsigned long long}]{elem2 }\end{DoxyParamCaption}) const\hspace{0.3cm}{\ttfamily [virtual]}}



This function modifies the original subset array such that it the union of two sets a and b. 


\begin{DoxyParams}{Parameters}
{\em subset} & original subset is modified to obtain union of a \& b \\
\hline
{\em a} & parent id of set1 \\
\hline
{\em b} & parent id of set2 NOTE\+: Original subset is no longer available after union. Note\+: No Thread Safe \\
\hline
\end{DoxyParams}
\mbox{\Hypertarget{classCXXGRAPH_1_1Graph_a5a1ffeb9ef3b62b38c10bd84b44170a0}\label{classCXXGRAPH_1_1Graph_a5a1ffeb9ef3b62b38c10bd84b44170a0}} 
\index{CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}!writeToFile@{writeToFile}}
\index{writeToFile@{writeToFile}!CXXGRAPH::Graph$<$ T $>$@{CXXGRAPH::Graph$<$ T $>$}}
\doxysubsubsection{\texorpdfstring{writeToFile()}{writeToFile()}}
{\footnotesize\ttfamily template$<$typename T $>$ \\
int \mbox{\hyperlink{classCXXGRAPH_1_1Graph}{CXXGRAPH\+::\+Graph}}$<$ T $>$\+::write\+To\+File (\begin{DoxyParamCaption}\item[{Input\+Output\+Format}]{format = {\ttfamily InputOutputFormat\+:\+:STANDARD\+\_\+CSV},  }\item[{const std\+::string \&}]{working\+Dir = {\ttfamily \char`\"{}.\char`\"{}},  }\item[{const std\+::string \&}]{OFile\+Name = {\ttfamily \char`\"{}graph\char`\"{}},  }\item[{bool}]{compress = {\ttfamily false},  }\item[{bool}]{write\+Node\+Feat = {\ttfamily false},  }\item[{bool}]{write\+Edge\+Weight = {\ttfamily false} }\end{DoxyParamCaption}) const\hspace{0.3cm}{\ttfamily [virtual]}}



This function write the graph in an output file Note\+: No Thread Safe. 


\begin{DoxyParams}{Parameters}
{\em format} & The Output format of the file \\
\hline
{\em working\+Dir} & The path to the directory in which is placed the Output file \\
\hline
{\em OFile\+Name} & The Output File Name ( ) \\
\hline
{\em compress} & Indicates if the Output will be compressed ( Pay Attention if compress flag is true, not compressed files will be deleted \mbox{[} \#48 \mbox{]} ) \\
\hline
{\em write\+Node\+Feat} & Indicates if export also \mbox{\hyperlink{classCXXGRAPH_1_1Node}{Node}} Features \\
\hline
{\em write\+Edge\+Weight} & Indicates if export also \mbox{\hyperlink{classCXXGRAPH_1_1Edge}{Edge}} Weights \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
0 if all OK, else return a negative value 
\end{DoxyReturn}


The documentation for this class was generated from the following file\+:\begin{DoxyCompactItemize}
\item 
/github/workspace/include/\+Graph/Graph.\+hpp\end{DoxyCompactItemize}
