gravatar
alpar (Alpar Juttner)
alpar@cs.elte.hu
Merge bugfix #364 to branch 1.1
0 2 0
merge 1.1
1 file changed with 4 insertions and 0 deletions:
↑ Collapse diff ↑
Ignore white space 6 line context
... ...
@@ -251,64 +251,66 @@
251 251
    void clear() {
252 252
      notifier(Arc()).clear();
253 253
      Parent::clear();
254 254
    }
255 255

	
256 256
    void erase(const Arc& arc) {
257 257
      notifier(Arc()).erase(arc);
258 258
      Parent::erase(arc);
259 259
    }
260 260

	
261 261
    ArcSetExtender() {
262 262
      arc_notifier.setContainer(*this);
263 263
    }
264 264

	
265 265
    ~ArcSetExtender() {
266 266
      arc_notifier.clear();
267 267
    }
268 268

	
269 269
  };
270 270

	
271 271

	
272 272
  // \ingroup digraphbits
273 273
  //
274 274
  // \brief Extender for the EdgeSets
275 275
  template <typename Base>
276 276
  class EdgeSetExtender : public Base {
277 277
    typedef Base Parent;
278 278

	
279 279
  public:
280 280

	
281 281
    typedef EdgeSetExtender Graph;
282 282

	
283
    typedef True UndirectedTag;
284

	
283 285
    typedef typename Parent::Node Node;
284 286
    typedef typename Parent::Arc Arc;
285 287
    typedef typename Parent::Edge Edge;
286 288

	
287 289
    int maxId(Node) const {
288 290
      return Parent::maxNodeId();
289 291
    }
290 292

	
291 293
    int maxId(Arc) const {
292 294
      return Parent::maxArcId();
293 295
    }
294 296

	
295 297
    int maxId(Edge) const {
296 298
      return Parent::maxEdgeId();
297 299
    }
298 300

	
299 301
    Node fromId(int id, Node) const {
300 302
      return Parent::nodeFromId(id);
301 303
    }
302 304

	
303 305
    Arc fromId(int id, Arc) const {
304 306
      return Parent::arcFromId(id);
305 307
    }
306 308

	
307 309
    Edge fromId(int id, Edge) const {
308 310
      return Parent::edgeFromId(id);
309 311
    }
310 312

	
311 313
    Node oppositeNode(const Node &n, const Edge &e) const {
312 314
      if( n == Parent::u(e))
313 315
	return Parent::v(e);
314 316
      else if( n == Parent::v(e))
... ...
@@ -152,64 +152,66 @@
152 152
      InArcIt& operator++() {
153 153
        _adaptor->nextIn(*this);
154 154
        return *this;
155 155
      }
156 156

	
157 157
    };
158 158

	
159 159
    Node baseNode(const OutArcIt &e) const {
160 160
      return Parent::source(e);
161 161
    }
162 162
    Node runningNode(const OutArcIt &e) const {
163 163
      return Parent::target(e);
164 164
    }
165 165

	
166 166
    Node baseNode(const InArcIt &e) const {
167 167
      return Parent::target(e);
168 168
    }
169 169
    Node runningNode(const InArcIt &e) const {
170 170
      return Parent::source(e);
171 171
    }
172 172

	
173 173
  };
174 174

	
175 175
  template <typename _Graph>
176 176
  class GraphAdaptorExtender : public _Graph {
177 177
    typedef _Graph Parent;
178 178

	
179 179
  public:
180 180

	
181 181
    typedef _Graph Graph;
182 182
    typedef GraphAdaptorExtender Adaptor;
183 183

	
184
    typedef True UndirectedTag;
185

	
184 186
    typedef typename Parent::Node Node;
185 187
    typedef typename Parent::Arc Arc;
186 188
    typedef typename Parent::Edge Edge;
187 189

	
188 190
    // Graph extension
189 191

	
190 192
    int maxId(Node) const {
191 193
      return Parent::maxNodeId();
192 194
    }
193 195

	
194 196
    int maxId(Arc) const {
195 197
      return Parent::maxArcId();
196 198
    }
197 199

	
198 200
    int maxId(Edge) const {
199 201
      return Parent::maxEdgeId();
200 202
    }
201 203

	
202 204
    Node fromId(int id, Node) const {
203 205
      return Parent::nodeFromId(id);
204 206
    }
205 207

	
206 208
    Arc fromId(int id, Arc) const {
207 209
      return Parent::arcFromId(id);
208 210
    }
209 211

	
210 212
    Edge fromId(int id, Edge) const {
211 213
      return Parent::edgeFromId(id);
212 214
    }
213 215

	
214 216
    Node oppositeNode(const Node &n, const Edge &e) const {
215 217
      if( n == Parent::u(e))
0 comments (0 inline)