1 #ifndef NODE_MAP_BASE_H |
1 #ifndef NODE_MAP_BASE_H |
2 #define NODE_MAP_BASE_H |
2 #define NODE_MAP_BASE_H |
3 |
3 |
4 template <class G, class K> |
4 /** |
|
5 Template base class for implementing mapping on nodes. |
|
6 \param The first template parameter is the Graph class. The Graph |
|
7 must have an \emp node_maps member with \emp NodeMapRegistry class. |
|
8 \param The second template parameter is the Node type of the class. |
|
9 |
|
10 */ |
|
11 |
|
12 template <typename G, typename K> |
5 class NodeMapBase { |
13 class NodeMapBase { |
6 public: |
14 public: |
7 typedef G Graph; |
15 typedef G Graph; |
8 |
16 |
9 typedef K KeyType; |
17 typedef K KeyType; |
10 |
18 |
|
19 /** |
|
20 Default constructor. |
|
21 */ |
|
22 |
11 NodeMapBase() : graph(0) {} |
23 NodeMapBase() : graph(0) {} |
|
24 |
|
25 /** |
|
26 Simple constructor to register into a graph. |
|
27 */ |
|
28 |
12 NodeMapBase(Graph& g) : graph(&g) { |
29 NodeMapBase(Graph& g) : graph(&g) { |
13 graph->node_maps.add(*this); |
30 graph->node_maps.add(*this); |
14 } |
31 } |
|
32 |
|
33 /** |
|
34 Copy constructor with registering into the map. |
|
35 */ |
|
36 |
|
37 NodeMapBase(const NodeMapBase& copy) : graph(copy.graph) { |
|
38 if (graph) { |
|
39 graph->node_maps.add(*this); |
|
40 } |
|
41 } |
|
42 |
|
43 /** |
|
44 Assign operator. |
|
45 */ |
|
46 |
|
47 const NodeMapBase& operator=(const NodeMapBase& copy) { |
|
48 if (graph) { |
|
49 graph.node_maps.erase(*this); |
|
50 } |
|
51 graph = copy.graph; |
|
52 if (graph) { |
|
53 graph->node_maps.add(*this); |
|
54 } |
|
55 |
|
56 } |
|
57 |
|
58 |
|
59 /** |
|
60 Destructor. |
|
61 */ |
15 |
62 |
16 virtual ~NodeMapBase() { |
63 virtual ~NodeMapBase() { |
17 if (graph) { |
64 if (graph) { |
18 graph.node_maps.erase(*this); |
65 graph.node_maps.erase(*this); |
19 } |
66 } |
23 |
70 |
24 Graph* graph; |
71 Graph* graph; |
25 |
72 |
26 int graph_index; |
73 int graph_index; |
27 |
74 |
|
75 /** |
|
76 Helper function to implement the default constructor in the subclasses. |
|
77 */ |
|
78 |
28 void init() { |
79 void init() { |
29 for (Graph::NodeIt it(g); g.valid(it); g.next(it)) { |
80 for (Graph::NodeIt it(g); g.valid(it); g.next(it)) { |
30 add(it); |
81 add(it); |
31 } |
82 } |
32 } |
83 } |
|
84 |
|
85 /** |
|
86 Helper function to implement the destructor in the subclasses. |
|
87 */ |
33 |
88 |
34 void destroy() { |
89 void destroy() { |
35 for (Graph::NodeIt it(g); g.valid(it); g.next(it)) { |
90 for (Graph::NodeIt it(g); g.valid(it); g.next(it)) { |
36 erase(it); |
91 erase(it); |
37 } |
92 } |
38 } |
93 } |
39 |
94 |
|
95 /** |
|
96 The add member function should be overloaded in the subclasses. |
|
97 \e Add extends the map with the new node. |
|
98 */ |
|
99 |
40 virtual void add(const KeyType&) = 0; |
100 virtual void add(const KeyType&) = 0; |
|
101 |
|
102 /** |
|
103 The erase member function should be overloaded in the subclasses. |
|
104 \e Erase removes the node from the map. |
|
105 */ |
|
106 |
41 virtual void erase(const KeyType&) = 0; |
107 virtual void erase(const KeyType&) = 0; |
|
108 |
|
109 /** |
|
110 Exception class to throw at unsupported operation. |
|
111 */ |
|
112 |
|
113 class NotSupportedOperationException {}; |
42 |
114 |
43 friend class Graph; |
115 friend class Graph; |
44 }; |
116 }; |
45 |
117 |
46 #endif |
118 #endif |