gravatar
kpeter (Peter Kovacs)
kpeter@inf.elte.hu
Fixes in adaptors.h to compile on AIX
0 1 0
default
1 file changed with 6 insertions and 6 deletions:
↑ Collapse diff ↑
Ignore white space 96 line context
... ...
@@ -3150,115 +3150,115 @@
3150 3150

	
3151 3151
      NodeMapBase(const SplitNodesBase<DGR>& adaptor)
3152 3152
        : _in_map(*adaptor._digraph), _out_map(*adaptor._digraph) {}
3153 3153
      NodeMapBase(const SplitNodesBase<DGR>& adaptor, const V& value)
3154 3154
        : _in_map(*adaptor._digraph, value),
3155 3155
          _out_map(*adaptor._digraph, value) {}
3156 3156

	
3157 3157
      void set(const Node& key, const V& val) {
3158 3158
        if (SplitNodesBase<DGR>::inNode(key)) { _in_map.set(key, val); }
3159 3159
        else {_out_map.set(key, val); }
3160 3160
      }
3161 3161

	
3162 3162
      ReturnValue operator[](const Node& key) {
3163 3163
        if (SplitNodesBase<DGR>::inNode(key)) { return _in_map[key]; }
3164 3164
        else { return _out_map[key]; }
3165 3165
      }
3166 3166

	
3167 3167
      ConstReturnValue operator[](const Node& key) const {
3168 3168
        if (Adaptor::inNode(key)) { return _in_map[key]; }
3169 3169
        else { return _out_map[key]; }
3170 3170
      }
3171 3171

	
3172 3172
    private:
3173 3173
      NodeImpl _in_map, _out_map;
3174 3174
    };
3175 3175

	
3176 3176
    template <typename V>
3177 3177
    class ArcMapBase
3178 3178
      : public MapTraits<typename Parent::template ArcMap<V> > {
3179 3179
      typedef typename Parent::template ArcMap<V> ArcImpl;
3180 3180
      typedef typename Parent::template NodeMap<V> NodeImpl;
3181 3181
    public:
3182 3182
      typedef Arc Key;
3183 3183
      typedef V Value;
3184 3184
      typedef typename MapTraits<ArcImpl>::ReferenceMapTag ReferenceMapTag;
3185 3185
      typedef typename MapTraits<ArcImpl>::ReturnValue ReturnValue;
3186 3186
      typedef typename MapTraits<ArcImpl>::ConstReturnValue ConstReturnValue;
3187 3187
      typedef typename MapTraits<ArcImpl>::ReturnValue Reference;
3188 3188
      typedef typename MapTraits<ArcImpl>::ConstReturnValue ConstReference;
3189 3189

	
3190 3190
      ArcMapBase(const SplitNodesBase<DGR>& adaptor)
3191 3191
        : _arc_map(*adaptor._digraph), _node_map(*adaptor._digraph) {}
3192 3192
      ArcMapBase(const SplitNodesBase<DGR>& adaptor, const V& value)
3193 3193
        : _arc_map(*adaptor._digraph, value),
3194 3194
          _node_map(*adaptor._digraph, value) {}
3195 3195

	
3196 3196
      void set(const Arc& key, const V& val) {
3197 3197
        if (SplitNodesBase<DGR>::origArc(key)) {
3198
          _arc_map.set(key._item.first(), val);
3198
          _arc_map.set(static_cast<const DigraphArc&>(key), val);
3199 3199
        } else {
3200
          _node_map.set(key._item.second(), val);
3200
          _node_map.set(static_cast<const DigraphNode&>(key), val);
3201 3201
        }
3202 3202
      }
3203 3203

	
3204 3204
      ReturnValue operator[](const Arc& key) {
3205 3205
        if (SplitNodesBase<DGR>::origArc(key)) {
3206
          return _arc_map[key._item.first()];
3206
          return _arc_map[static_cast<const DigraphArc&>(key)];
3207 3207
        } else {
3208
          return _node_map[key._item.second()];
3208
          return _node_map[static_cast<const DigraphNode&>(key)];
3209 3209
        }
3210 3210
      }
3211 3211

	
3212 3212
      ConstReturnValue operator[](const Arc& key) const {
3213 3213
        if (SplitNodesBase<DGR>::origArc(key)) {
3214
          return _arc_map[key._item.first()];
3214
          return _arc_map[static_cast<const DigraphArc&>(key)];
3215 3215
        } else {
3216
          return _node_map[key._item.second()];
3216
          return _node_map[static_cast<const DigraphNode&>(key)];
3217 3217
        }
3218 3218
      }
3219 3219

	
3220 3220
    private:
3221 3221
      ArcImpl _arc_map;
3222 3222
      NodeImpl _node_map;
3223 3223
    };
3224 3224

	
3225 3225
  public:
3226 3226

	
3227 3227
    template <typename V>
3228 3228
    class NodeMap
3229 3229
      : public SubMapExtender<SplitNodesBase<DGR>, NodeMapBase<V> >
3230 3230
    {
3231 3231
    public:
3232 3232
      typedef V Value;
3233 3233
      typedef SubMapExtender<SplitNodesBase<DGR>, NodeMapBase<Value> > Parent;
3234 3234

	
3235 3235
      NodeMap(const SplitNodesBase<DGR>& adaptor)
3236 3236
        : Parent(adaptor) {}
3237 3237

	
3238 3238
      NodeMap(const SplitNodesBase<DGR>& adaptor, const V& value)
3239 3239
        : Parent(adaptor, value) {}
3240 3240

	
3241 3241
    private:
3242 3242
      NodeMap& operator=(const NodeMap& cmap) {
3243 3243
        return operator=<NodeMap>(cmap);
3244 3244
      }
3245 3245

	
3246 3246
      template <typename CMap>
3247 3247
      NodeMap& operator=(const CMap& cmap) {
3248 3248
        Parent::operator=(cmap);
3249 3249
        return *this;
3250 3250
      }
3251 3251
    };
3252 3252

	
3253 3253
    template <typename V>
3254 3254
    class ArcMap
3255 3255
      : public SubMapExtender<SplitNodesBase<DGR>, ArcMapBase<V> >
3256 3256
    {
3257 3257
    public:
3258 3258
      typedef V Value;
3259 3259
      typedef SubMapExtender<SplitNodesBase<DGR>, ArcMapBase<Value> > Parent;
3260 3260

	
3261 3261
      ArcMap(const SplitNodesBase<DGR>& adaptor)
3262 3262
        : Parent(adaptor) {}
3263 3263

	
3264 3264
      ArcMap(const SplitNodesBase<DGR>& adaptor, const V& value)
0 comments (0 inline)