3 #ifndef GRAPH_TYPEDEFS_HPP
4 #define GRAPH_TYPEDEFS_HPP
6 #include <boost/graph/graph_traits.hpp>
7 #include <boost/graph/adjacency_list.hpp>
15 #define translate_edge(e,g,h,t) (boost::edge(t.at(boost::source(e, g)), t.at(boost::target(e, g)), h).first)
18 typedef enum {dir_rev, dir_fwd, dir_fwdrev} Direction;
20 using VertexName = std::string;
21 using EdgeName = std::pair<VertexName, VertexName>;
31 PathsAndCycles(
const unsigned _p = 0,
const unsigned _c = 0): p(_p), c(_c) {}
33 operator size_t()
const
36 boost::hash_combine(hash, c);
42 return {p + pc.p, c + pc.c};
52 return {p - pc.p, c - pc.c};
63 return (p <= pc.p) && (c <= pc.c);
67 return (p < pc.p) && (c < pc.c);
71 return (p == pc.p) && (c == pc.c);
75 return !operator==(pc);
78 friend std::ostream& operator<<(std::ostream& os,
const PathsAndCycles& pc)
80 return os <<
"("<<pc.p<<
","<<pc.c<<
")";
91 using Vertex =
typename boost::graph_traits<Graph>::vertex_descriptor;
93 using VertexProperty =
typename Graph::vertex_bundled;
95 using VertexPair =
typename std::pair<Vertex<Graph>, Vertex<Graph> >;
97 using VertexPairSet =
typename boost::unordered_set<VertexPair<Graph> >;
99 using VertexIter =
typename boost::graph_traits<Graph>::vertex_iterator;
100 template<
class Graph>
101 using VertexIterRange =
typename std::pair<VertexIter<Graph>, VertexIter<Graph> >;
102 template<
class Graph>
103 using AdjIter =
typename boost::graph_traits<Graph>::adjacency_iterator;
104 template<
class Graph>
105 using AdjIterRange =
typename std::pair<AdjIter<Graph>, AdjIter<Graph> >;
106 template<
class Graph>
107 using cVertexIndexMap =
typename boost::property_map<Graph, unsigned VertexProperty<Graph>::*>::const_type;
108 template<
class Graph>
109 using VertexIndexMap =
typename boost::property_map<Graph, unsigned VertexProperty<Graph>::*>::type;
111 template<
class Graph>
112 using VPairDependencyMap =
typename boost::unordered_map<VertexPair<Graph>, std::list<VertexPair<Graph> > >;
114 template<
class Graph>
115 using Edge =
typename boost::graph_traits<Graph>::edge_descriptor;
116 template<
class Graph>
117 using EdgeProperty =
typename Graph::edge_bundled;
118 template<
class Graph>
119 using EdgeIter =
typename boost::graph_traits<Graph>::edge_iterator;
120 template<
class Graph>
121 using EdgeIterRange =
typename std::pair<EdgeIter<Graph>, EdgeIter<Graph> >;
122 template<
class Graph>
123 using OEdgeIter =
typename boost::graph_traits<Graph>::out_edge_iterator;
124 template<
class Graph>
125 using OEdgeIterRange =
typename std::pair<OEdgeIter<Graph>, OEdgeIter<Graph> >;
126 template<
class Graph>
127 using VertexAndOEIterRange = std::pair<Vertex<Graph>, OEdgeIterRange<Graph> >;
128 template<
class Graph>
129 using OEIterList = std::list<VertexAndOEIterRange<Graph> >;
130 template<
class Graph>
131 using IEdgeIter =
typename boost::graph_traits<Graph>::in_edge_iterator;
132 template<
class Graph>
133 using IEdgeIterRange =
typename std::pair<IEdgeIter<Graph>, IEdgeIter<Graph> >;
136 template<
class Graph1,
class Graph2>
137 using VTranslateMap =
typename boost::unordered_map<Vertex<Graph1>, Vertex<Graph2> >;
140 template<
class Graph>
141 using Matching = VTranslateMap<Graph, Graph>;
143 template<
class Graph>
144 using EWeightMap =
typename boost::property_map<Graph, boost::edge_weight_t>::type;
145 template<
class Graph>
146 using cEWeightMap =
typename boost::property_map<Graph, boost::edge_weight_t>::const_type;
149 template<
class Graph>
150 using VertexAndNum =
typename std::pair<Vertex<Graph>,
unsigned>;
151 template<
class Graph>
152 using VertexAndDegree = VertexAndNum<Graph>;
157 template <
class Graph,
class Pair = std::unordered_pair<VertexName, VertexName> >
164 size_t operator()(
const Edge<Graph>& e)
const {
165 const Vertex<Graph>& u = boost::source(e, g);
166 const Vertex<Graph>& v = boost::target(e, g);
173 template <
class Graph>
179 template <
class Graph>
184 bool operator()(
const Vertex<Graph>& u,
const Vertex<Graph>& v){
185 return degree(u, g) < degree(v, g);
190 template<
class Graph>
192 template<
class Graph>
194 template<
class Graph>
195 using EdgeList = std::list<Edge<Graph> >;
196 template<
class Graph>
198 template<
class Graph>
201 template<
class Graph>
202 using VertexToInt = boost::unordered_map<Vertex<Graph>,
unsigned>;
203 template<
class Graph>
204 using VertexSet = boost::unordered_set<Vertex<Graph> >;
205 template<
class Graph>
206 using VertexList = std::list<Vertex<Graph> >;
207 template<
class Graph>
208 using VertexPairList = std::list<VertexPair<Graph> >;
209 template<
class Graph>
210 using VertexQueue = std::queue<Vertex<Graph> >;
212 template<
class Graph>
213 using VertexPairToInt = boost::unordered_map<VertexPair<Graph>,
unsigned>;
214 #warning TODO: use unordered_pair_hash for BridgeMaps, so the bridge (u,v) can be found by looking for (v,u)!!!
215 template<
class Graph>
216 using ComponentMap = VertexToInt<Graph>;
217 template<
class Graph>
218 using BiConnComponentMap = EdgeToInt<Graph>;
219 template<
class Graph>
220 using WeightedBridge = std::pair<VertexPair<Graph>,
unsigned>;
221 template<
class Graph>
222 using BridgeMap = VertexPairToInt<Graph>;
223 template<
class Graph>
224 using BridgeIter =
typename BridgeMap<Graph>::iterator;
225 template<
class Graph>
226 using cBridgeIter =
typename BridgeMap<Graph>::const_iterator;
231 template<
class Graph>
232 using VertexAndGraph = std::pair<const Vertex<Graph>&,
const Graph&>;
233 template<
class Graph>
234 std::ostream& operator<<(std::ostream& os, const VertexAndGraph<Graph>& vg){
235 const Vertex<Graph>& v = vg.first;
236 const Graph& g = vg.second;
237 return os << g[v].name;
242 template<
typename Graph>
243 using VertexPairAndGraph = std::pair<const VertexPair<Graph>&,
const Graph&>;
244 template<
typename Graph>
245 std::ostream& operator<<(std::ostream& os, const VertexPairAndGraph<Graph>& uvg){
246 const Graph& g = uvg.second;
247 return os << VertexAndGraph<Graph>(uvg.first.first, g) <<
"->" << VertexAndGraph<Graph>(uvg.first.second, g);
251 template<
typename Graph>
252 using EdgeAndGraph = std::pair<const Edge<Graph>&,
const Graph&>;
253 template<
typename Graph>
254 std::ostream& operator<<(std::ostream& os, const EdgeAndGraph<Graph>& eg){
255 const Edge<Graph>& e = eg.first;
256 const Graph& g = eg.second;
257 return os << VertexAndGraph<Graph>(boost::source(e, g), g) <<
"->" << VertexAndGraph<Graph>(boost::target(e, g), g);
261 template<
typename Graph>
262 using VertexListAndGraph = std::pair<const VertexList<Graph>&,
const Graph&>;
263 template<
typename Graph>
264 std::ostream& operator<<(std::ostream& os, const VertexListAndGraph<Graph>& lg){
265 const Graph& g = lg.second;
266 for(
const auto& u: lg.first) os << VertexAndGraph<Graph>(u, g) <<
" ";
270 template<
typename Graph>
271 using VertexPairListAndGraph = std::pair<const std::list<VertexPair<Graph> >&,
const Graph&>;
272 template<
typename Graph>
273 std::ostream& operator<<(std::ostream& os, const VertexPairListAndGraph<Graph>& lg){
274 const Graph& g = lg.second;
275 for(
const auto& u: lg.first) os << VertexPairAndGraph<Graph>(u, g) <<
" ";
280 template<
typename Graph>
281 using VertexSetAndGraph = std::pair<const VertexSet<Graph>&,
const Graph&>;
282 template<
typename Graph>
283 std::ostream& operator<<(std::ostream& os, const VertexSetAndGraph<Graph>& lg){
284 const Graph& g = lg.second;
285 for(
const auto& u: lg.first) os << VertexPairAndGraph<Graph>(u, g) <<
" ";
290 template<
class Graph>
291 const EdgeName get_edge_name(
const Edge<Graph>& e,
const Graph& g)
293 const Vertex<Graph> u = boost::source(e, g);
294 const Vertex<Graph> v = boost::target(e, g);
295 return EdgeName(g[u].name, g[v].name);
298 std::ostream& operator<<(std::ostream& os,
const EdgeName& en){
299 return os <<
"("<<en.first <<
","<<en.second<<
")";
Definition: graph_typedefs.hpp:158
Definition: read_adj_list.hpp:22
an unordered pair
Definition: unordered_pair.hpp:17
size_t hash_value(const boost::unordered_set< T > &S)
a hash computation for an unordered set, XORing its members
Definition: utils.hpp:178
Definition: graph_typedefs.hpp:180
Definition: graph_typedefs.hpp:26