/Src/Dependencies/Boost/boost/graph/leda_graph.hpp

http://hadesmem.googlecode.com/ · C++ Header · 952 lines · 790 code · 136 blank · 26 comment · 22 complexity · ef82458f4c475949448dbc754e95dfc4 MD5 · raw file

  1. //=======================================================================
  2. // Copyright 1997, 1998, 1999, 2000 University of Notre Dame.
  3. // Copyright 2004 The Trustees of Indiana University.
  4. // Copyright 2007 University of Karlsruhe
  5. // Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek, Douglas Gregor,
  6. // Jens Mueller
  7. //
  8. // Distributed under the Boost Software License, Version 1.0. (See
  9. // accompanying file LICENSE_1_0.txt or copy at
  10. // http://www.boost.org/LICENSE_1_0.txt)
  11. //=======================================================================
  12. #ifndef BOOST_GRAPH_LEDA_HPP
  13. #define BOOST_GRAPH_LEDA_HPP
  14. #include <boost/config.hpp>
  15. #include <boost/iterator/iterator_facade.hpp>
  16. #include <boost/graph/graph_traits.hpp>
  17. #include <boost/graph/properties.hpp>
  18. #include <LEDA/graph.h>
  19. #include <LEDA/node_array.h>
  20. #include <LEDA/node_map.h>
  21. // The functions and classes in this file allows the user to
  22. // treat a LEDA GRAPH object as a boost graph "as is". No
  23. // wrapper is needed for the GRAPH object.
  24. // Warning: this implementation relies on partial specialization
  25. // for the graph_traits class (so it won't compile with Visual C++)
  26. // Warning: this implementation is in alpha and has not been tested
  27. #if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
  28. namespace boost {
  29. struct leda_graph_traversal_category :
  30. public virtual bidirectional_graph_tag,
  31. public virtual adjacency_graph_tag,
  32. public virtual vertex_list_graph_tag { };
  33. template <class vtype, class etype>
  34. struct graph_traits< leda::GRAPH<vtype,etype> > {
  35. typedef leda::node vertex_descriptor;
  36. typedef leda::edge edge_descriptor;
  37. class adjacency_iterator
  38. : public iterator_facade<adjacency_iterator,
  39. leda::node,
  40. bidirectional_traversal_tag,
  41. leda::node,
  42. const leda::node*>
  43. {
  44. public:
  45. adjacency_iterator(leda::node node = 0,
  46. const leda::GRAPH<vtype, etype>* g = 0)
  47. : base(node), g(g) {}
  48. private:
  49. leda::node dereference() const { return leda::target(base); }
  50. bool equal(const adjacency_iterator& other) const
  51. { return base == other.base; }
  52. void increment() { base = g->adj_succ(base); }
  53. void decrement() { base = g->adj_pred(base); }
  54. leda::edge base;
  55. const leda::GRAPH<vtype, etype>* g;
  56. friend class iterator_core_access;
  57. };
  58. class out_edge_iterator
  59. : public iterator_facade<out_edge_iterator,
  60. leda::edge,
  61. bidirectional_traversal_tag,
  62. const leda::edge&,
  63. const leda::edge*>
  64. {
  65. public:
  66. out_edge_iterator(leda::node node = 0,
  67. const leda::GRAPH<vtype, etype>* g = 0)
  68. : base(node), g(g) {}
  69. private:
  70. const leda::edge& dereference() const { return base; }
  71. bool equal(const out_edge_iterator& other) const
  72. { return base == other.base; }
  73. void increment() { base = g->adj_succ(base); }
  74. void decrement() { base = g->adj_pred(base); }
  75. leda::edge base;
  76. const leda::GRAPH<vtype, etype>* g;
  77. friend class iterator_core_access;
  78. };
  79. class in_edge_iterator
  80. : public iterator_facade<in_edge_iterator,
  81. leda::edge,
  82. bidirectional_traversal_tag,
  83. const leda::edge&,
  84. const leda::edge*>
  85. {
  86. public:
  87. in_edge_iterator(leda::node node = 0,
  88. const leda::GRAPH<vtype, etype>* g = 0)
  89. : base(node), g(g) {}
  90. private:
  91. const leda::edge& dereference() const { return base; }
  92. bool equal(const in_edge_iterator& other) const
  93. { return base == other.base; }
  94. void increment() { base = g->in_succ(base); }
  95. void decrement() { base = g->in_pred(base); }
  96. leda::edge base;
  97. const leda::GRAPH<vtype, etype>* g;
  98. friend class iterator_core_access;
  99. };
  100. class vertex_iterator
  101. : public iterator_facade<vertex_iterator,
  102. leda::node,
  103. bidirectional_traversal_tag,
  104. const leda::node&,
  105. const leda::node*>
  106. {
  107. public:
  108. vertex_iterator(leda::node node = 0,
  109. const leda::GRAPH<vtype, etype>* g = 0)
  110. : base(node), g(g) {}
  111. private:
  112. const leda::node& dereference() const { return base; }
  113. bool equal(const vertex_iterator& other) const
  114. { return base == other.base; }
  115. void increment() { base = g->succ_node(base); }
  116. void decrement() { base = g->pred_node(base); }
  117. leda::node base;
  118. const leda::GRAPH<vtype, etype>* g;
  119. friend class iterator_core_access;
  120. };
  121. class edge_iterator
  122. : public iterator_facade<edge_iterator,
  123. leda::edge,
  124. bidirectional_traversal_tag,
  125. const leda::edge&,
  126. const leda::edge*>
  127. {
  128. public:
  129. edge_iterator(leda::edge edge = 0,
  130. const leda::GRAPH<vtype, etype>* g = 0)
  131. : base(edge), g(g) {}
  132. private:
  133. const leda::edge& dereference() const { return base; }
  134. bool equal(const edge_iterator& other) const
  135. { return base == other.base; }
  136. void increment() { base = g->succ_edge(base); }
  137. void decrement() { base = g->pred_edge(base); }
  138. leda::node base;
  139. const leda::GRAPH<vtype, etype>* g;
  140. friend class iterator_core_access;
  141. };
  142. typedef directed_tag directed_category;
  143. typedef allow_parallel_edge_tag edge_parallel_category; // not sure here
  144. typedef leda_graph_traversal_category traversal_category;
  145. typedef int vertices_size_type;
  146. typedef int edges_size_type;
  147. typedef int degree_size_type;
  148. };
  149. template<>
  150. struct graph_traits<leda::graph> {
  151. typedef leda::node vertex_descriptor;
  152. typedef leda::edge edge_descriptor;
  153. class adjacency_iterator
  154. : public iterator_facade<adjacency_iterator,
  155. leda::node,
  156. bidirectional_traversal_tag,
  157. leda::node,
  158. const leda::node*>
  159. {
  160. public:
  161. adjacency_iterator(leda::edge edge = 0,
  162. const leda::graph* g = 0)
  163. : base(edge), g(g) {}
  164. private:
  165. leda::node dereference() const { return leda::target(base); }
  166. bool equal(const adjacency_iterator& other) const
  167. { return base == other.base; }
  168. void increment() { base = g->adj_succ(base); }
  169. void decrement() { base = g->adj_pred(base); }
  170. leda::edge base;
  171. const leda::graph* g;
  172. friend class iterator_core_access;
  173. };
  174. class out_edge_iterator
  175. : public iterator_facade<out_edge_iterator,
  176. leda::edge,
  177. bidirectional_traversal_tag,
  178. const leda::edge&,
  179. const leda::edge*>
  180. {
  181. public:
  182. out_edge_iterator(leda::edge edge = 0,
  183. const leda::graph* g = 0)
  184. : base(edge), g(g) {}
  185. private:
  186. const leda::edge& dereference() const { return base; }
  187. bool equal(const out_edge_iterator& other) const
  188. { return base == other.base; }
  189. void increment() { base = g->adj_succ(base); }
  190. void decrement() { base = g->adj_pred(base); }
  191. leda::edge base;
  192. const leda::graph* g;
  193. friend class iterator_core_access;
  194. };
  195. class in_edge_iterator
  196. : public iterator_facade<in_edge_iterator,
  197. leda::edge,
  198. bidirectional_traversal_tag,
  199. const leda::edge&,
  200. const leda::edge*>
  201. {
  202. public:
  203. in_edge_iterator(leda::edge edge = 0,
  204. const leda::graph* g = 0)
  205. : base(edge), g(g) {}
  206. private:
  207. const leda::edge& dereference() const { return base; }
  208. bool equal(const in_edge_iterator& other) const
  209. { return base == other.base; }
  210. void increment() { base = g->in_succ(base); }
  211. void decrement() { base = g->in_pred(base); }
  212. leda::edge base;
  213. const leda::graph* g;
  214. friend class iterator_core_access;
  215. };
  216. class vertex_iterator
  217. : public iterator_facade<vertex_iterator,
  218. leda::node,
  219. bidirectional_traversal_tag,
  220. const leda::node&,
  221. const leda::node*>
  222. {
  223. public:
  224. vertex_iterator(leda::node node = 0,
  225. const leda::graph* g = 0)
  226. : base(node), g(g) {}
  227. private:
  228. const leda::node& dereference() const { return base; }
  229. bool equal(const vertex_iterator& other) const
  230. { return base == other.base; }
  231. void increment() { base = g->succ_node(base); }
  232. void decrement() { base = g->pred_node(base); }
  233. leda::node base;
  234. const leda::graph* g;
  235. friend class iterator_core_access;
  236. };
  237. class edge_iterator
  238. : public iterator_facade<edge_iterator,
  239. leda::edge,
  240. bidirectional_traversal_tag,
  241. const leda::edge&,
  242. const leda::edge*>
  243. {
  244. public:
  245. edge_iterator(leda::edge edge = 0,
  246. const leda::graph* g = 0)
  247. : base(edge), g(g) {}
  248. private:
  249. const leda::edge& dereference() const { return base; }
  250. bool equal(const edge_iterator& other) const
  251. { return base == other.base; }
  252. void increment() { base = g->succ_edge(base); }
  253. void decrement() { base = g->pred_edge(base); }
  254. leda::edge base;
  255. const leda::graph* g;
  256. friend class iterator_core_access;
  257. };
  258. typedef directed_tag directed_category;
  259. typedef allow_parallel_edge_tag edge_parallel_category; // not sure here
  260. typedef leda_graph_traversal_category traversal_category;
  261. typedef int vertices_size_type;
  262. typedef int edges_size_type;
  263. typedef int degree_size_type;
  264. };
  265. } // namespace boost
  266. #endif
  267. namespace boost {
  268. //===========================================================================
  269. // functions for GRAPH<vtype,etype>
  270. template <class vtype, class etype>
  271. typename graph_traits< leda::GRAPH<vtype,etype> >::vertex_descriptor
  272. source(typename graph_traits< leda::GRAPH<vtype,etype> >::edge_descriptor e,
  273. const leda::GRAPH<vtype,etype>& g)
  274. {
  275. return source(e);
  276. }
  277. template <class vtype, class etype>
  278. typename graph_traits< leda::GRAPH<vtype,etype> >::vertex_descriptor
  279. target(typename graph_traits< leda::GRAPH<vtype,etype> >::edge_descriptor e,
  280. const leda::GRAPH<vtype,etype>& g)
  281. {
  282. return target(e);
  283. }
  284. template <class vtype, class etype>
  285. inline std::pair<
  286. typename graph_traits< leda::GRAPH<vtype,etype> >::vertex_iterator,
  287. typename graph_traits< leda::GRAPH<vtype,etype> >::vertex_iterator >
  288. vertices(const leda::GRAPH<vtype,etype>& g)
  289. {
  290. typedef typename graph_traits< leda::GRAPH<vtype,etype> >::vertex_iterator
  291. Iter;
  292. return std::make_pair( Iter(g.first_node(),&g), Iter(0,&g) );
  293. }
  294. template <class vtype, class etype>
  295. inline std::pair<
  296. typename graph_traits< leda::GRAPH<vtype,etype> >::edge_iterator,
  297. typename graph_traits< leda::GRAPH<vtype,etype> >::edge_iterator >
  298. edges(const leda::GRAPH<vtype,etype>& g)
  299. {
  300. typedef typename graph_traits< leda::GRAPH<vtype,etype> >::edge_iterator
  301. Iter;
  302. return std::make_pair( Iter(g.first_edge(),&g), Iter(0,&g) );
  303. }
  304. template <class vtype, class etype>
  305. inline std::pair<
  306. typename graph_traits< leda::GRAPH<vtype,etype> >::out_edge_iterator,
  307. typename graph_traits< leda::GRAPH<vtype,etype> >::out_edge_iterator >
  308. out_edges(
  309. typename graph_traits< leda::GRAPH<vtype,etype> >::vertex_descriptor u,
  310. const leda::GRAPH<vtype,etype>& g)
  311. {
  312. typedef typename graph_traits< leda::GRAPH<vtype,etype> >
  313. ::out_edge_iterator Iter;
  314. return std::make_pair( Iter(g.first_adj_edge(u,0),&g), Iter(0,&g) );
  315. }
  316. template <class vtype, class etype>
  317. inline std::pair<
  318. typename graph_traits< leda::GRAPH<vtype,etype> >::in_edge_iterator,
  319. typename graph_traits< leda::GRAPH<vtype,etype> >::in_edge_iterator >
  320. in_edges(
  321. typename graph_traits< leda::GRAPH<vtype,etype> >::vertex_descriptor u,
  322. const leda::GRAPH<vtype,etype>& g)
  323. {
  324. typedef typename graph_traits< leda::GRAPH<vtype,etype> >
  325. ::in_edge_iterator Iter;
  326. return std::make_pair( Iter(g.first_adj_edge(u,1),&g), Iter(0,&g) );
  327. }
  328. template <class vtype, class etype>
  329. inline std::pair<
  330. typename graph_traits< leda::GRAPH<vtype,etype> >::adjacency_iterator,
  331. typename graph_traits< leda::GRAPH<vtype,etype> >::adjacency_iterator >
  332. adjacent_vertices(
  333. typename graph_traits< leda::GRAPH<vtype,etype> >::vertex_descriptor u,
  334. const leda::GRAPH<vtype,etype>& g)
  335. {
  336. typedef typename graph_traits< leda::GRAPH<vtype,etype> >
  337. ::adjacency_iterator Iter;
  338. return std::make_pair( Iter(g.first_adj_edge(u,0),&g), Iter(0,&g) );
  339. }
  340. template <class vtype, class etype>
  341. typename graph_traits< leda::GRAPH<vtype,etype> >::vertices_size_type
  342. num_vertices(const leda::GRAPH<vtype,etype>& g)
  343. {
  344. return g.number_of_nodes();
  345. }
  346. template <class vtype, class etype>
  347. typename graph_traits< leda::GRAPH<vtype,etype> >::edges_size_type
  348. num_edges(const leda::GRAPH<vtype,etype>& g)
  349. {
  350. return g.number_of_edges();
  351. }
  352. template <class vtype, class etype>
  353. typename graph_traits< leda::GRAPH<vtype,etype> >::degree_size_type
  354. out_degree(
  355. typename graph_traits< leda::GRAPH<vtype,etype> >::vertex_descriptor u,
  356. const leda::GRAPH<vtype,etype>& g)
  357. {
  358. return g.outdeg(u);
  359. }
  360. template <class vtype, class etype>
  361. typename graph_traits< leda::GRAPH<vtype,etype> >::degree_size_type
  362. in_degree(
  363. typename graph_traits< leda::GRAPH<vtype,etype> >::vertex_descriptor u,
  364. const leda::GRAPH<vtype,etype>& g)
  365. {
  366. return g.indeg(u);
  367. }
  368. template <class vtype, class etype>
  369. typename graph_traits< leda::GRAPH<vtype,etype> >::degree_size_type
  370. degree(
  371. typename graph_traits< leda::GRAPH<vtype,etype> >::vertex_descriptor u,
  372. const leda::GRAPH<vtype,etype>& g)
  373. {
  374. return g.outdeg(u) + g.indeg(u);
  375. }
  376. template <class vtype, class etype>
  377. typename graph_traits< leda::GRAPH<vtype,etype> >::vertex_descriptor
  378. add_vertex(leda::GRAPH<vtype,etype>& g)
  379. {
  380. return g.new_node();
  381. }
  382. template <class vtype, class etype>
  383. typename graph_traits< leda::GRAPH<vtype,etype> >::vertex_descriptor
  384. add_vertex(const vtype& vp, leda::GRAPH<vtype,etype>& g)
  385. {
  386. return g.new_node(vp);
  387. }
  388. template <class vtype, class etype>
  389. void clear_vertex(
  390. typename graph_traits< leda::GRAPH<vtype,etype> >::vertex_descriptor u,
  391. leda::GRAPH<vtype,etype>& g)
  392. {
  393. typename graph_traits< leda::GRAPH<vtype,etype> >::out_edge_iterator ei, ei_end;
  394. for (boost::tie(ei, ei_end)=out_edges(u,g); ei!=ei_end; ei++)
  395. remove_edge(*ei);
  396. typename graph_traits< leda::GRAPH<vtype,etype> >::in_edge_iterator iei, iei_end;
  397. for (boost::tie(iei, iei_end)=in_edges(u,g); iei!=iei_end; iei++)
  398. remove_edge(*iei);
  399. }
  400. template <class vtype, class etype>
  401. void remove_vertex(
  402. typename graph_traits< leda::GRAPH<vtype,etype> >::vertex_descriptor u,
  403. leda::GRAPH<vtype,etype>& g)
  404. {
  405. g.del_node(u);
  406. }
  407. template <class vtype, class etype>
  408. std::pair<
  409. typename graph_traits< leda::GRAPH<vtype,etype> >::edge_descriptor,
  410. bool>
  411. add_edge(
  412. typename graph_traits< leda::GRAPH<vtype,etype> >::vertex_descriptor u,
  413. typename graph_traits< leda::GRAPH<vtype,etype> >::vertex_descriptor v,
  414. leda::GRAPH<vtype,etype>& g)
  415. {
  416. return std::make_pair(g.new_edge(u, v), true);
  417. }
  418. template <class vtype, class etype>
  419. std::pair<
  420. typename graph_traits< leda::GRAPH<vtype,etype> >::edge_descriptor,
  421. bool>
  422. add_edge(
  423. typename graph_traits< leda::GRAPH<vtype,etype> >::vertex_descriptor u,
  424. typename graph_traits< leda::GRAPH<vtype,etype> >::vertex_descriptor v,
  425. const etype& et,
  426. leda::GRAPH<vtype,etype>& g)
  427. {
  428. return std::make_pair(g.new_edge(u, v, et), true);
  429. }
  430. template <class vtype, class etype>
  431. void
  432. remove_edge(
  433. typename graph_traits< leda::GRAPH<vtype,etype> >::vertex_descriptor u,
  434. typename graph_traits< leda::GRAPH<vtype,etype> >::vertex_descriptor v,
  435. leda::GRAPH<vtype,etype>& g)
  436. {
  437. typename graph_traits< leda::GRAPH<vtype,etype> >::out_edge_iterator
  438. i,iend;
  439. for (boost::tie(i,iend) = out_edges(u,g); i != iend; ++i)
  440. if (target(*i,g) == v)
  441. g.del_edge(*i);
  442. }
  443. template <class vtype, class etype>
  444. void
  445. remove_edge(
  446. typename graph_traits< leda::GRAPH<vtype,etype> >::edge_descriptor e,
  447. leda::GRAPH<vtype,etype>& g)
  448. {
  449. g.del_edge(e);
  450. }
  451. //===========================================================================
  452. // functions for graph (non-templated version)
  453. graph_traits<leda::graph>::vertex_descriptor
  454. source(graph_traits<leda::graph>::edge_descriptor e,
  455. const leda::graph& g)
  456. {
  457. return source(e);
  458. }
  459. graph_traits<leda::graph>::vertex_descriptor
  460. target(graph_traits<leda::graph>::edge_descriptor e,
  461. const leda::graph& g)
  462. {
  463. return target(e);
  464. }
  465. inline std::pair<
  466. graph_traits<leda::graph>::vertex_iterator,
  467. graph_traits<leda::graph>::vertex_iterator >
  468. vertices(const leda::graph& g)
  469. {
  470. typedef graph_traits<leda::graph>::vertex_iterator
  471. Iter;
  472. return std::make_pair( Iter(g.first_node(),&g), Iter(0,&g) );
  473. }
  474. inline std::pair<
  475. graph_traits<leda::graph>::edge_iterator,
  476. graph_traits<leda::graph>::edge_iterator >
  477. edges(const leda::graph& g)
  478. {
  479. typedef graph_traits<leda::graph>::edge_iterator
  480. Iter;
  481. return std::make_pair( Iter(g.first_edge(),&g), Iter(0,&g) );
  482. }
  483. inline std::pair<
  484. graph_traits<leda::graph>::out_edge_iterator,
  485. graph_traits<leda::graph>::out_edge_iterator >
  486. out_edges(
  487. graph_traits<leda::graph>::vertex_descriptor u, const leda::graph& g)
  488. {
  489. typedef graph_traits<leda::graph>::out_edge_iterator Iter;
  490. return std::make_pair( Iter(g.first_adj_edge(u),&g), Iter(0,&g) );
  491. }
  492. inline std::pair<
  493. graph_traits<leda::graph>::in_edge_iterator,
  494. graph_traits<leda::graph>::in_edge_iterator >
  495. in_edges(
  496. graph_traits<leda::graph>::vertex_descriptor u,
  497. const leda::graph& g)
  498. {
  499. typedef graph_traits<leda::graph>
  500. ::in_edge_iterator Iter;
  501. return std::make_pair( Iter(g.first_in_edge(u),&g), Iter(0,&g) );
  502. }
  503. inline std::pair<
  504. graph_traits<leda::graph>::adjacency_iterator,
  505. graph_traits<leda::graph>::adjacency_iterator >
  506. adjacent_vertices(
  507. graph_traits<leda::graph>::vertex_descriptor u,
  508. const leda::graph& g)
  509. {
  510. typedef graph_traits<leda::graph>
  511. ::adjacency_iterator Iter;
  512. return std::make_pair( Iter(g.first_adj_edge(u),&g), Iter(0,&g) );
  513. }
  514. graph_traits<leda::graph>::vertices_size_type
  515. num_vertices(const leda::graph& g)
  516. {
  517. return g.number_of_nodes();
  518. }
  519. graph_traits<leda::graph>::edges_size_type
  520. num_edges(const leda::graph& g)
  521. {
  522. return g.number_of_edges();
  523. }
  524. graph_traits<leda::graph>::degree_size_type
  525. out_degree(
  526. graph_traits<leda::graph>::vertex_descriptor u,
  527. const leda::graph& g)
  528. {
  529. return g.outdeg(u);
  530. }
  531. graph_traits<leda::graph>::degree_size_type
  532. in_degree(
  533. graph_traits<leda::graph>::vertex_descriptor u,
  534. const leda::graph& g)
  535. {
  536. return g.indeg(u);
  537. }
  538. graph_traits<leda::graph>::degree_size_type
  539. degree(
  540. graph_traits<leda::graph>::vertex_descriptor u,
  541. const leda::graph& g)
  542. {
  543. return g.outdeg(u) + g.indeg(u);
  544. }
  545. graph_traits<leda::graph>::vertex_descriptor
  546. add_vertex(leda::graph& g)
  547. {
  548. return g.new_node();
  549. }
  550. void
  551. remove_edge(
  552. graph_traits<leda::graph>::vertex_descriptor u,
  553. graph_traits<leda::graph>::vertex_descriptor v,
  554. leda::graph& g)
  555. {
  556. graph_traits<leda::graph>::out_edge_iterator
  557. i,iend;
  558. for (boost::tie(i,iend) = out_edges(u,g); i != iend; ++i)
  559. if (target(*i,g) == v)
  560. g.del_edge(*i);
  561. }
  562. void
  563. remove_edge(
  564. graph_traits<leda::graph>::edge_descriptor e,
  565. leda::graph& g)
  566. {
  567. g.del_edge(e);
  568. }
  569. void clear_vertex(
  570. graph_traits<leda::graph>::vertex_descriptor u,
  571. leda::graph& g)
  572. {
  573. graph_traits<leda::graph>::out_edge_iterator ei, ei_end;
  574. for (boost::tie(ei, ei_end)=out_edges(u,g); ei!=ei_end; ei++)
  575. remove_edge(*ei, g);
  576. graph_traits<leda::graph>::in_edge_iterator iei, iei_end;
  577. for (boost::tie(iei, iei_end)=in_edges(u,g); iei!=iei_end; iei++)
  578. remove_edge(*iei, g);
  579. }
  580. void remove_vertex(
  581. graph_traits<leda::graph>::vertex_descriptor u,
  582. leda::graph& g)
  583. {
  584. g.del_node(u);
  585. }
  586. std::pair<
  587. graph_traits<leda::graph>::edge_descriptor,
  588. bool>
  589. add_edge(
  590. graph_traits<leda::graph>::vertex_descriptor u,
  591. graph_traits<leda::graph>::vertex_descriptor v,
  592. leda::graph& g)
  593. {
  594. return std::make_pair(g.new_edge(u, v), true);
  595. }
  596. //===========================================================================
  597. // property maps for GRAPH<vtype,etype>
  598. class leda_graph_id_map
  599. : public put_get_helper<int, leda_graph_id_map>
  600. {
  601. public:
  602. typedef readable_property_map_tag category;
  603. typedef int value_type;
  604. typedef int reference;
  605. typedef leda::node key_type;
  606. leda_graph_id_map() { }
  607. template <class T>
  608. long operator[](T x) const { return x->id(); }
  609. };
  610. template <class vtype, class etype>
  611. inline leda_graph_id_map
  612. get(vertex_index_t, const leda::GRAPH<vtype, etype>& g) {
  613. return leda_graph_id_map();
  614. }
  615. template <class vtype, class etype>
  616. inline leda_graph_id_map
  617. get(edge_index_t, const leda::GRAPH<vtype, etype>& g) {
  618. return leda_graph_id_map();
  619. }
  620. template <class Tag>
  621. struct leda_property_map { };
  622. template <>
  623. struct leda_property_map<vertex_index_t> {
  624. template <class vtype, class etype>
  625. struct bind_ {
  626. typedef leda_graph_id_map type;
  627. typedef leda_graph_id_map const_type;
  628. };
  629. };
  630. template <>
  631. struct leda_property_map<edge_index_t> {
  632. template <class vtype, class etype>
  633. struct bind_ {
  634. typedef leda_graph_id_map type;
  635. typedef leda_graph_id_map const_type;
  636. };
  637. };
  638. template <class Data, class DataRef, class GraphPtr>
  639. class leda_graph_data_map
  640. : public put_get_helper<DataRef,
  641. leda_graph_data_map<Data,DataRef,GraphPtr> >
  642. {
  643. public:
  644. typedef Data value_type;
  645. typedef DataRef reference;
  646. typedef void key_type;
  647. typedef lvalue_property_map_tag category;
  648. leda_graph_data_map(GraphPtr g) : m_g(g) { }
  649. template <class NodeOrEdge>
  650. DataRef operator[](NodeOrEdge x) const { return (*m_g)[x]; }
  651. protected:
  652. GraphPtr m_g;
  653. };
  654. template <>
  655. struct leda_property_map<vertex_all_t> {
  656. template <class vtype, class etype>
  657. struct bind_ {
  658. typedef leda_graph_data_map<vtype, vtype&, leda::GRAPH<vtype, etype>*> type;
  659. typedef leda_graph_data_map<vtype, const vtype&,
  660. const leda::GRAPH<vtype, etype>*> const_type;
  661. };
  662. };
  663. template <class vtype, class etype >
  664. inline typename property_map< leda::GRAPH<vtype, etype>, vertex_all_t>::type
  665. get(vertex_all_t, leda::GRAPH<vtype, etype>& g) {
  666. typedef typename property_map< leda::GRAPH<vtype, etype>, vertex_all_t>::type
  667. pmap_type;
  668. return pmap_type(&g);
  669. }
  670. template <class vtype, class etype >
  671. inline typename property_map< leda::GRAPH<vtype, etype>, vertex_all_t>::const_type
  672. get(vertex_all_t, const leda::GRAPH<vtype, etype>& g) {
  673. typedef typename property_map< leda::GRAPH<vtype, etype>,
  674. vertex_all_t>::const_type pmap_type;
  675. return pmap_type(&g);
  676. }
  677. template <>
  678. struct leda_property_map<edge_all_t> {
  679. template <class vtype, class etype>
  680. struct bind_ {
  681. typedef leda_graph_data_map<etype, etype&, leda::GRAPH<vtype, etype>*> type;
  682. typedef leda_graph_data_map<etype, const etype&,
  683. const leda::GRAPH<vtype, etype>*> const_type;
  684. };
  685. };
  686. template <class vtype, class etype >
  687. inline typename property_map< leda::GRAPH<vtype, etype>, edge_all_t>::type
  688. get(edge_all_t, leda::GRAPH<vtype, etype>& g) {
  689. typedef typename property_map< leda::GRAPH<vtype, etype>, edge_all_t>::type
  690. pmap_type;
  691. return pmap_type(&g);
  692. }
  693. template <class vtype, class etype >
  694. inline typename property_map< leda::GRAPH<vtype, etype>, edge_all_t>::const_type
  695. get(edge_all_t, const leda::GRAPH<vtype, etype>& g) {
  696. typedef typename property_map< leda::GRAPH<vtype, etype>,
  697. edge_all_t>::const_type pmap_type;
  698. return pmap_type(&g);
  699. }
  700. // property map interface to the LEDA node_array class
  701. template <class E, class ERef, class NodeMapPtr>
  702. class leda_node_property_map
  703. : public put_get_helper<ERef, leda_node_property_map<E, ERef, NodeMapPtr> >
  704. {
  705. public:
  706. typedef E value_type;
  707. typedef ERef reference;
  708. typedef leda::node key_type;
  709. typedef lvalue_property_map_tag category;
  710. leda_node_property_map(NodeMapPtr a) : m_array(a) { }
  711. ERef operator[](leda::node n) const { return (*m_array)[n]; }
  712. protected:
  713. NodeMapPtr m_array;
  714. };
  715. template <class E>
  716. leda_node_property_map<E, const E&, const leda::node_array<E>*>
  717. make_leda_node_property_map(const leda::node_array<E>& a)
  718. {
  719. typedef leda_node_property_map<E, const E&, const leda::node_array<E>*>
  720. pmap_type;
  721. return pmap_type(&a);
  722. }
  723. template <class E>
  724. leda_node_property_map<E, E&, leda::node_array<E>*>
  725. make_leda_node_property_map(leda::node_array<E>& a)
  726. {
  727. typedef leda_node_property_map<E, E&, leda::node_array<E>*> pmap_type;
  728. return pmap_type(&a);
  729. }
  730. template <class E>
  731. leda_node_property_map<E, const E&, const leda::node_map<E>*>
  732. make_leda_node_property_map(const leda::node_map<E>& a)
  733. {
  734. typedef leda_node_property_map<E,const E&,const leda::node_map<E>*>
  735. pmap_type;
  736. return pmap_type(&a);
  737. }
  738. template <class E>
  739. leda_node_property_map<E, E&, leda::node_map<E>*>
  740. make_leda_node_property_map(leda::node_map<E>& a)
  741. {
  742. typedef leda_node_property_map<E, E&, leda::node_map<E>*> pmap_type;
  743. return pmap_type(&a);
  744. }
  745. // g++ 'enumeral_type' in template unification not implemented workaround
  746. template <class vtype, class etype, class Tag>
  747. struct property_map<leda::GRAPH<vtype, etype>, Tag> {
  748. typedef typename
  749. leda_property_map<Tag>::template bind_<vtype, etype> map_gen;
  750. typedef typename map_gen::type type;
  751. typedef typename map_gen::const_type const_type;
  752. };
  753. template <class vtype, class etype, class PropertyTag, class Key>
  754. inline
  755. typename boost::property_traits<
  756. typename boost::property_map<leda::GRAPH<vtype, etype>,PropertyTag>::const_type
  757. ::value_type
  758. get(PropertyTag p, const leda::GRAPH<vtype, etype>& g, const Key& key) {
  759. return get(get(p, g), key);
  760. }
  761. template <class vtype, class etype, class PropertyTag, class Key,class Value>
  762. inline void
  763. put(PropertyTag p, leda::GRAPH<vtype, etype>& g,
  764. const Key& key, const Value& value)
  765. {
  766. typedef typename property_map<leda::GRAPH<vtype, etype>, PropertyTag>::type Map;
  767. Map pmap = get(p, g);
  768. put(pmap, key, value);
  769. }
  770. // property map interface to the LEDA edge_array class
  771. template <class E, class ERef, class EdgeMapPtr>
  772. class leda_edge_property_map
  773. : public put_get_helper<ERef, leda_edge_property_map<E, ERef, EdgeMapPtr> >
  774. {
  775. public:
  776. typedef E value_type;
  777. typedef ERef reference;
  778. typedef leda::edge key_type;
  779. typedef lvalue_property_map_tag category;
  780. leda_edge_property_map(EdgeMapPtr a) : m_array(a) { }
  781. ERef operator[](leda::edge n) const { return (*m_array)[n]; }
  782. protected:
  783. EdgeMapPtr m_array;
  784. };
  785. template <class E>
  786. leda_edge_property_map<E, const E&, const leda::edge_array<E>*>
  787. make_leda_node_property_map(const leda::node_array<E>& a)
  788. {
  789. typedef leda_edge_property_map<E, const E&, const leda::node_array<E>*>
  790. pmap_type;
  791. return pmap_type(&a);
  792. }
  793. template <class E>
  794. leda_edge_property_map<E, E&, leda::edge_array<E>*>
  795. make_leda_edge_property_map(leda::edge_array<E>& a)
  796. {
  797. typedef leda_edge_property_map<E, E&, leda::edge_array<E>*> pmap_type;
  798. return pmap_type(&a);
  799. }
  800. template <class E>
  801. leda_edge_property_map<E, const E&, const leda::edge_map<E>*>
  802. make_leda_edge_property_map(const leda::edge_map<E>& a)
  803. {
  804. typedef leda_edge_property_map<E,const E&,const leda::edge_map<E>*>
  805. pmap_type;
  806. return pmap_type(&a);
  807. }
  808. template <class E>
  809. leda_edge_property_map<E, E&, leda::edge_map<E>*>
  810. make_leda_edge_property_map(leda::edge_map<E>& a)
  811. {
  812. typedef leda_edge_property_map<E, E&, leda::edge_map<E>*> pmap_type;
  813. return pmap_type(&a);
  814. }
  815. } // namespace boost
  816. #endif // BOOST_GRAPH_LEDA_HPP