Changeset - r865:e9c203fb003d
« 551:c6acc3
901:f58e01 »
867:994c7d »
866:2e9655 »
gravatar
kpeter (Peter Kovacs)
kpeter@inf.elte.hu
Bug fix in map_extender.h (#330)
0 1 0
default
1 file changed with 48 insertions and 48 deletions:
lemon/bits/map_extender.h
48
48
↑ Collapse diff ↑
lemon/bits/map_extender.h
Ignore white space 6 line context
... ... 
@@ -80,36 +80,36 @@
80 80 
      typedef Item Parent;
81 81 
      typedef typename Map::Value Value;
82 82 

			




	83
	
	
		
      MapIt() {}


			




	
	83
	
		
      MapIt() : map(NULL) {}


			




	84
	84
	
		

			




	85
	
	
		
      MapIt(Invalid i) : Parent(i) { }


			




	
	85
	
		
      MapIt(Invalid i) : Parent(i), map(NULL) {}


			




	86
	86
	
		

			




	87
	
	
		
      explicit MapIt(Map& _map) : map(_map) {


			




	88
	
	
		
        map.notifier()->first(*this);


			




	
	87
	
		
      explicit MapIt(Map& _map) : map(&_map) {


			




	
	88
	
		
        map->notifier()->first(*this);


			




	89
	89
	
		
      }


			




	90
	90
	
		

			




	91
	91
	
		
      MapIt(const Map& _map, const Item& item)


			




	92
	
	
		
        : Parent(item), map(_map) {}


			




	
	92
	
		
        : Parent(item), map(&_map) {}


			




	93
	93
	
		

			




	94
	94
	
		
      MapIt& operator++() {


			




	95
	
	
		
        map.notifier()->next(*this);


			




	
	95
	
		
        map->notifier()->next(*this);


			




	96
	96
	
		
        return *this;


			




	97
	97
	
		
      }


			




	98
	98
	
		

			




	99
	99
	
		
      typename MapTraits<Map>::ConstReturnValue operator*() const {


			




	100
	
	
		
        return map[*this];


			




	
	100
	
		
        return (*map)[*this];


			




	101
	101
	
		
      }


			




	102
	102
	
		

			




	103
	103
	
		
      typename MapTraits<Map>::ReturnValue operator*() {


			




	104
	
	
		
        return map[*this];


			




	
	104
	
		
        return (*map)[*this];


			




	105
	105
	
		
      }


			




	106
	106
	
		

			




	107
	107
	
		
      void set(const Value& value) {


			




	108
	
	
		
        map.set(*this, value);


			




	
	108
	
		
        map->set(*this, value);


			




	109
	109
	
		
      }


			




	110
	110
	
		

			




	111
	111
	
		
    protected:


			




	112
	
	
		
      Map& map;


			




	
	112
	
		
      Map* map;


			




	113
	113
	
		

			




	114
	114
	
		
    };


			




	115
	115
	
		

			




	...
	...
	
		
@@ -120,19 +120,19 @@


			




	120
	120
	
		

			




	121
	121
	
		
      typedef typename Map::Value Value;


			




	122
	122
	
		

			




	123
	
	
		
      ConstMapIt() {}


			




	
	123
	
		
      ConstMapIt() : map(NULL) {}


			




	124
	124
	
		

			




	125
	
	
		
      ConstMapIt(Invalid i) : Parent(i) { }


			




	
	125
	
		
      ConstMapIt(Invalid i) : Parent(i), map(NULL) {}


			




	126
	126
	
		

			




	127
	
	
		
      explicit ConstMapIt(Map& _map) : map(_map) {


			




	128
	
	
		
        map.notifier()->first(*this);


			




	
	127
	
		
      explicit ConstMapIt(Map& _map) : map(&_map) {


			




	
	128
	
		
        map->notifier()->first(*this);


			




	129
	129
	
		
      }


			




	130
	130
	
		

			




	131
	131
	
		
      ConstMapIt(const Map& _map, const Item& item)


			




	132
	132
	
		
        : Parent(item), map(_map) {}


			




	133
	133
	
		

			




	134
	134
	
		
      ConstMapIt& operator++() {


			




	135
	
	
		
        map.notifier()->next(*this);


			




	
	135
	
		
        map->notifier()->next(*this);


			




	136
	136
	
		
        return *this;


			




	137
	137
	
		
      }


			




	138
	138
	
		

			




	...
	...
	
		
@@ -141,7 +141,7 @@


			




	141
	141
	
		
      }


			




	142
	142
	
		

			




	143
	143
	
		
    protected:


			




	144
	
	
		
      const Map& map;


			




	
	144
	
		
      const Map* map;


			




	145
	145
	
		
    };


			




	146
	146
	
		

			




	147
	147
	
		
    class ItemIt : public Item {


			




	...
	...
	
		
@@ -149,24 +149,24 @@


			




	149
	149
	
		

			




	150
	150
	
		
      typedef Item Parent;


			




	151
	151
	
		

			




	152
	
	
		
      ItemIt() {}


			




	
	152
	
		
      ItemIt() : map(NULL) {}


			




	153
	153
	
		

			




	154
	
	
		
      ItemIt(Invalid i) : Parent(i) { }


			




	
	154
	
		
      ItemIt(Invalid i) : Parent(i), map(NULL) {}


			




	155
	155
	
		

			




	156
	
	
		
      explicit ItemIt(Map& _map) : map(_map) {


			




	157
	
	
		
        map.notifier()->first(*this);


			




	
	156
	
		
      explicit ItemIt(Map& _map) : map(&_map) {


			




	
	157
	
		
        map->notifier()->first(*this);


			




	158
	158
	
		
      }


			




	159
	159
	
		

			




	160
	160
	
		
      ItemIt(const Map& _map, const Item& item)


			




	161
	
	
		
        : Parent(item), map(_map) {}


			




	
	161
	
		
        : Parent(item), map(&_map) {}


			




	162
	162
	
		

			




	163
	163
	
		
      ItemIt& operator++() {


			




	164
	
	
		
        map.notifier()->next(*this);


			




	
	164
	
		
        map->notifier()->next(*this);


			




	165
	165
	
		
        return *this;


			




	166
	166
	
		
      }


			




	167
	167
	
		

			




	168
	168
	
		
    protected:


			




	169
	
	
		
      const Map& map;


			




	
	169
	
		
      const Map* map;


			




	170
	170
	
		

			




	171
	171
	
		
    };


			




	172
	172
	
		
  };


			




	...
	...
	
		
@@ -224,36 +224,36 @@


			




	224
	224
	
		
      typedef Item Parent;


			




	225
	225
	
		
      typedef typename Map::Value Value;


			




	226
	226
	
		

			




	227
	
	
		
      MapIt() {}


			




	
	227
	
		
      MapIt() : map(NULL) {}


			




	228
	228
	
		

			




	229
	
	
		
      MapIt(Invalid i) : Parent(i) { }


			




	
	229
	
		
      MapIt(Invalid i) : Parent(i), map(NULL) { }


			




	230
	230
	
		

			




	231
	
	
		
      explicit MapIt(Map& _map) : map(_map) {


			




	232
	
	
		
        map.graph.first(*this);


			




	
	231
	
		
      explicit MapIt(Map& _map) : map(&_map) {


			




	
	232
	
		
        map->graph.first(*this);


			




	233
	233
	
		
      }


			




	234
	234
	
		

			




	235
	235
	
		
      MapIt(const Map& _map, const Item& item)


			




	236
	
	
		
        : Parent(item), map(_map) {}


			




	
	236
	
		
        : Parent(item), map(&_map) {}


			




	237
	237
	
		

			




	238
	238
	
		
      MapIt& operator++() {


			




	239
	
	
		
        map.graph.next(*this);


			




	
	239
	
		
        map->graph.next(*this);


			




	240
	240
	
		
        return *this;


			




	241
	241
	
		
      }


			




	242
	242
	
		

			




	243
	243
	
		
      typename MapTraits<Map>::ConstReturnValue operator*() const {


			




	244
	
	
		
        return map[*this];


			




	
	244
	
		
        return (*map)[*this];


			




	245
	245
	
		
      }


			




	246
	246
	
		

			




	247
	247
	
		
      typename MapTraits<Map>::ReturnValue operator*() {


			




	248
	
	
		
        return map[*this];


			




	
	248
	
		
        return (*map)[*this];


			




	249
	249
	
		
      }


			




	250
	250
	
		

			




	251
	251
	
		
      void set(const Value& value) {


			




	252
	
	
		
        map.set(*this, value);


			




	
	252
	
		
        map->set(*this, value);


			




	253
	253
	
		
      }


			




	254
	254
	
		

			




	255
	255
	
		
    protected:


			




	256
	
	
		
      Map& map;


			




	
	256
	
		
      Map* map;


			




	257
	257
	
		

			




	258
	258
	
		
    };


			




	259
	259
	
		

			




	...
	...
	
		
@@ -264,28 +264,28 @@


			




	264
	264
	
		

			




	265
	265
	
		
      typedef typename Map::Value Value;


			




	266
	266
	
		

			




	267
	
	
		
      ConstMapIt() {}


			




	
	267
	
		
      ConstMapIt() : map(NULL) {}


			




	268
	268
	
		

			




	269
	
	
		
      ConstMapIt(Invalid i) : Parent(i) { }


			




	
	269
	
		
      ConstMapIt(Invalid i) : Parent(i), map(NULL) { }


			




	270
	270
	
		

			




	271
	
	
		
      explicit ConstMapIt(Map& _map) : map(_map) {


			




	272
	
	
		
        map.graph.first(*this);


			




	
	271
	
		
      explicit ConstMapIt(Map& _map) : map(&_map) {


			




	
	272
	
		
        map->graph.first(*this);


			




	273
	273
	
		
      }


			




	274
	274
	
		

			




	275
	275
	
		
      ConstMapIt(const Map& _map, const Item& item)


			




	276
	
	
		
        : Parent(item), map(_map) {}


			




	
	276
	
		
        : Parent(item), map(&_map) {}


			




	277
	277
	
		

			




	278
	278
	
		
      ConstMapIt& operator++() {


			




	279
	
	
		
        map.graph.next(*this);


			




	
	279
	
		
        map->graph.next(*this);


			




	280
	280
	
		
        return *this;


			




	281
	281
	
		
      }


			




	282
	282
	
		

			




	283
	283
	
		
      typename MapTraits<Map>::ConstReturnValue operator*() const {


			




	284
	
	
		
        return map[*this];


			




	
	284
	
		
        return (*map)[*this];


			




	285
	285
	
		
      }


			




	286
	286
	
		

			




	287
	287
	
		
    protected:


			




	288
	
	
		
      const Map& map;


			




	
	288
	
		
      const Map* map;


			




	289
	289
	
		
    };


			




	290
	290
	
		

			




	291
	291
	
		
    class ItemIt : public Item {


			




	...
	...
	
		
@@ -293,24 +293,24 @@


			




	293
	293
	
		

			




	294
	294
	
		
      typedef Item Parent;


			




	295
	295
	
		

			




	296
	
	
		
      ItemIt() {}


			




	
	296
	
		
      ItemIt() : map(NULL) {}


			




	297
	297
	
		

			




	298
	
	
		
      ItemIt(Invalid i) : Parent(i) { }


			




	
	298
	
		
      ItemIt(Invalid i) : Parent(i), map(NULL) { }


			




	299
	299
	
		

			




	300
	
	
		
      explicit ItemIt(Map& _map) : map(_map) {


			




	301
	
	
		
        map.graph.first(*this);


			




	
	300
	
		
      explicit ItemIt(Map& _map) : map(&_map) {


			




	
	301
	
		
        map->graph.first(*this);


			




	302
	302
	
		
      }


			




	303
	303
	
		

			




	304
	304
	
		
      ItemIt(const Map& _map, const Item& item)


			




	305
	
	
		
        : Parent(item), map(_map) {}


			




	
	305
	
		
        : Parent(item), map(&_map) {}


			




	306
	306
	
		

			




	307
	307
	
		
      ItemIt& operator++() {


			




	308
	
	
		
        map.graph.next(*this);


			




	
	308
	
		
        map->graph.next(*this);


			




	309
	309
	
		
        return *this;


			




	310
	310
	
		
      }


			




	311
	311
	
		

			




	312
	312
	
		
    protected:


			




	313
	
	
		
      const Map& map;


			




	
	313
	
		
      const Map* map;


			




	314
	314
	
		

			




	315
	315
	
		
    };


			




	316
	316
	
		

			




        

    






    
    



    


    

     
    
0 comments (0 inline)