COIN-OR::LEMON - Graph Library

Changeset 987:87f7c54892df in lemon-0.x for src/lemon


Ignore:
Timestamp:
11/13/04 18:07:10 (19 years ago)
Author:
Alpar Juttner
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@1377
Message:

Naming changes:

Location:
src/lemon
Files:
16 edited

Legend:

Unmodified
Added
Removed
  • src/lemon/array_map.h

    r980 r987  
    3939   *
    4040   *  The template parameter is the MapRegistry that the maps
    41    *  will belong to and the ValueType.
     41   *  will belong to and the Value.
    4242   */
    4343
     
    5353    typedef _Graph Graph;
    5454    /// The key type of the maps.
    55     typedef _Item KeyType;
     55    typedef _Item Key;
    5656
    5757    typedef AlterationObserverRegistry<_Item> Registry;
     
    6161    typedef _ItemIt KeyIt;
    6262
    63     typedef _Value Value;
    64 
    6563    /// The MapBase of the Map which imlements the core regisitry function.
    6664    typedef typename Registry::ObserverBase Parent;
     
    7068
    7169    /// The value type of the map.
    72     typedef Value ValueType;
     70    typedef _Value Value;
    7371    /// The reference type of the map;
    74     typedef Value& ReferenceType;
     72    typedef Value& Reference;
    7573    /// The pointer type of the map;
    76     typedef Value* PointerType;
     74    typedef Value* Pointer;
    7775
    7876    /// The const value type of the map.
    79     typedef const Value ConstValueType;
     77    typedef const Value ConstValue;
    8078    /// The const reference type of the map;
    81     typedef const Value& ConstReferenceType;
     79    typedef const Value& ConstReference;
    8280    /// The pointer type of the map;
    83     typedef const Value* ConstPointerType;
     81    typedef const Value* ConstPointer;
    8482
    8583
     
    173171     * actual keys of the graph.
    174172     */
    175     ReferenceType operator[](const KeyType& key) {
     173    Reference operator[](const Key& key) {
    176174      int id = graph->id(key);
    177175      return values[id];
     
    182180     * actual keys of the graph.
    183181     */
    184     ConstReferenceType operator[](const KeyType& key) const {
     182    ConstReference operator[](const Key& key) const {
    185183      int id = graph->id(key);
    186184      return values[id];
     
    190188     *  This is a compatibility feature with the not dereferable maps.
    191189     */
    192     void set(const KeyType& key, const ValueType& val) {
     190    void set(const Key& key, const Value& val) {
    193191      (*this)[key] = val;
    194192    }
     
    196194    /** Add a new key to the map. It called by the map registry.
    197195     */
    198     void add(const KeyType& key) {
     196    void add(const Key& key) {
    199197      int id = graph->id(key);
    200198      if (id >= capacity) {
     
    220218    /** Erase a key from the map. It called by the map registry.
    221219     */
    222     void erase(const KeyType& key) {
     220    void erase(const Key& key) {
    223221      int id = graph->id(key);
    224222      allocator.destroy(&(values[id]));
     
    322320//     typedef Iterator iterator;
    323321//     typedef ConstIterator const_iterator;
    324 //     typedef typename Iterator::PairValueType value_type;
    325 //     typedef typename Iterator::KeyType key_type;
    326 //     typedef typename Iterator::ValueType data_type;
    327 //     typedef typename Iterator::PairReferenceType reference;
    328 //     typedef typename Iterator::PairPointerType pointer;
    329 //     typedef typename ConstIterator::PairReferenceType const_reference;
    330 //     typedef typename ConstIterator::PairPointerType const_pointer;
     322//     typedef typename Iterator::PairValue value_type;
     323//     typedef typename Iterator::Key key_type;
     324//     typedef typename Iterator::Value data_type;
     325//     typedef typename Iterator::PairReference reference;
     326//     typedef typename Iterator::PairPointer pointer;
     327//     typedef typename ConstIterator::PairReference const_reference;
     328//     typedef typename ConstIterator::PairPointer const_pointer;
    331329//     typedef int difference_type;             
    332330  };           
  • src/lemon/concept/graph.h

    r986 r987  
    568568//      {
    569569//        //Check the typedef's
    570 //        typename Graph::template NodeMap<int>::ValueType val;
     570//        typename Graph::template NodeMap<int>::Value val;
    571571//        val=1;
    572 //        typename Graph::template NodeMap<int>::KeyType key;
     572//        typename Graph::template NodeMap<int>::Key key;
    573573//        key = typename Graph::NodeIt(G);
    574574//      }
     
    592592//      {
    593593//        //Check the typedef's
    594 //        typename Graph::template NodeMap<bool>::ValueType val;
     594//        typename Graph::template NodeMap<bool>::Value val;
    595595//        val=true;
    596 //        typename Graph::template NodeMap<bool>::KeyType key;
     596//        typename Graph::template NodeMap<bool>::Key key;
    597597//        key= typename Graph::NodeIt(G);
    598598//      }
     
    615615//      {
    616616//        //Check the typedef's
    617 //        typename Graph::template EdgeMap<int>::ValueType val;
     617//        typename Graph::template EdgeMap<int>::Value val;
    618618//        val=1;
    619 //        typename Graph::template EdgeMap<int>::KeyType key;
     619//        typename Graph::template EdgeMap<int>::Key key;
    620620//        key= typename Graph::EdgeIt(G);
    621621//      }
     
    638638//      {
    639639//        //Check the typedef's
    640 //        typename Graph::template EdgeMap<bool>::ValueType val;
     640//        typename Graph::template EdgeMap<bool>::Value val;
    641641//        val=true;
    642 //        typename Graph::template EdgeMap<bool>::KeyType key;
     642//        typename Graph::template EdgeMap<bool>::Key key;
    643643//        key= typename Graph::EdgeIt(G);
    644644//      }
  • src/lemon/concept/graph_component.h

    r986 r987  
    678678      typedef BaseGraphComponent::Edge Edge;
    679679
    680       template <typename Value>
    681       class NodeMap : public ReferenceMap<Node, Value> {
     680      template <typename _Value>
     681      class NodeMap : public ReferenceMap<Node, _Value> {
    682682      public:
    683683        NodeMap(const Graph&) {}
    684         NodeMap(const Graph&, const Value&) {}
     684        NodeMap(const Graph&, const _Value&) {}
    685685        NodeMap(const NodeMap&) {}
    686686
     
    689689      };
    690690
    691       template <typename Value>
    692       class EdgeMap : public ReferenceMap<Edge, Value> {
     691      template <typename _Value>
     692      class EdgeMap : public ReferenceMap<Edge, _Value> {
    693693      public:
    694694        EdgeMap(const Graph&) {}
    695         EdgeMap(const Graph&, const Value&) {}
     695        EdgeMap(const Graph&, const _Value&) {}
    696696        EdgeMap(const EdgeMap&) {}
    697697
  • src/lemon/concept/maps.h

    r959 r987  
    3737    public:
    3838      /// Map's key type.
    39       typedef K KeyType;   
    40       /// Map's value type. (The type of objects associated with the keys).
    41       typedef T ValueType;
     39      typedef K Key;   
     40      /// Map's value type. (The type of objects associated with the keys).
     41      typedef T Value;
    4242
    4343      /// Returns the value associated with a key.
    44       ValueType operator[](const KeyType &k) const {return ValueType();}
     44      Value operator[](const Key &k) const {return Value();}
    4545
    4646      ///Default constructor
     
    5555    public:
    5656      /// Map's key type.
    57       typedef K KeyType;   
    58       /// Map's value type. (The type of objects associated with the keys).
    59       typedef T ValueType;
     57      typedef K Key;   
     58      /// Map's value type. (The type of objects associated with the keys).
     59      typedef T Value;
    6060
    6161      /// Sets the value associated with a key.
    62       void set(const KeyType &k,const ValueType &t) {}
     62      void set(const Key &k,const Value &t) {}
    6363
    6464      ///Default constructor
     
    7373    public:
    7474      /// Map's key type.
    75       typedef K KeyType;   
    76       /// Map's value type. (The type of objects associated with the keys).
    77       typedef T ValueType;
     75      typedef K Key;   
     76      /// Map's value type. (The type of objects associated with the keys).
     77      typedef T Value;
    7878
    7979      /// Returns the value associated with a key.
    80       ValueType operator[](const KeyType &k) const {return ValueType();}
     80      Value operator[](const Key &k) const {return Value();}
    8181      /// Sets the value associated with a key.
    82       void set(const KeyType &k,const ValueType &t) {}
     82      void set(const Key &k,const Value &t) {}
    8383
    8484      ///Default constructor
     
    9393    public:
    9494      /// Map's key type.
    95       typedef K KeyType;   
    96       /// Map's value type. (The type of objects associated with the keys).
    97       typedef T ValueType;
     95      typedef K Key;   
     96      /// Map's value type. (The type of objects associated with the keys).
     97      typedef T Value;
    9898
    9999    protected:
    100       ValueType tmp;
    101     public:
    102       typedef ValueType& ReferenceType;
     100      Value tmp;
     101    public:
     102      typedef Value& Reference;
    103103      /// Map's const reference type.
    104       typedef const ValueType& ConstReferenceType;
     104      typedef const Value& ConstReference;
    105105
    106106      ///Returns a reference to the value associated to a key.
    107       ReferenceType operator[](const KeyType &i) { return tmp; }
     107      Reference operator[](const Key &i) { return tmp; }
    108108      ///Returns a const reference to the value associated to a key.
    109       ConstReferenceType operator[](const KeyType &i) const
     109      ConstReference operator[](const Key &i) const
    110110      { return tmp; }
    111111      /// Sets the value associated with a key.
    112       void set(const KeyType &k,const ValueType &t) { operator[](k)=t; }
     112      void set(const Key &k,const Value &t) { operator[](k)=t; }
    113113
    114114      ///Default constructor
     
    150150    template<typename ReadMap>
    151151    struct ReadMapConcept {
    152       typedef typename ReadMap::KeyType KeyType;
    153       typedef typename ReadMap::ValueType ValueType;
     152      typedef typename ReadMap::Key Key;
     153      typedef typename ReadMap::Value Value;
    154154
    155155      void constraints() {
    156156        // No constraints for constructor.
    157157
    158         // What are the requirement for the ValueType?
     158        // What are the requirement for the Value?
    159159        // CopyConstructible? Assignable? None of these?
    160         ValueType v = m[k];
     160        Value v = m[k];
    161161        v = m[k];
    162162
     
    166166
    167167      ReadMap m;
    168       KeyType k;
     168      Key k;
    169169    };
    170170
    171171    template<typename WriteMap>
    172172    struct WriteMapConcept {
    173       typedef typename WriteMap::KeyType KeyType;
    174       typedef typename WriteMap::ValueType ValueType;
     173      typedef typename WriteMap::Key Key;
     174      typedef typename WriteMap::Value Value;
    175175
    176176      void constraints() {
     
    181181
    182182      WriteMap m;
    183       KeyType k;
    184       ValueType v;
     183      Key k;
     184      Value v;
    185185    };
    186186
     
    195195    template<typename ReferenceMap>
    196196    struct ReferenceMapConcept {
    197       typedef typename ReferenceMap::KeyType KeyType;
    198       typedef typename ReferenceMap::ValueType ValueType;
    199       typedef typename ReferenceMap::ReferenceType ReferenceType;
     197      typedef typename ReferenceMap::Key Key;
     198      typedef typename ReferenceMap::Value Value;
     199      typedef typename ReferenceMap::Reference Reference;
    200200
    201201      // What for is this?
    202       typedef typename ReferenceMap::ConstReferenceType ConstReferenceType;
     202      typedef typename ReferenceMap::ConstReference ConstReference;
    203203
    204204      void constraints() {
     
    208208        // Or should we require real reference?
    209209        // Like this:
    210         // ValueType &vv = m[k];
     210        // Value &vv = m[k];
    211211        // ignore_unused_variable_warning(vv);
    212212      }
    213213
    214214      ReferenceMap m;
    215       KeyType k;
    216       ValueType v;
     215      Key k;
     216      Value v;
    217217    };
    218218
     
    236236      const GraphMap &c;
    237237      const Graph &g;
    238       const typename GraphMap::ValueType &t;
     238      const typename GraphMap::Value &t;
    239239    };
    240240   
  • src/lemon/default_map.h

    r980 r987  
    3434  /** The ArrayMap template class is graph map structure what
    3535   *  automatically updates the map when a key is added to or erased from
    36    *  the map. This map uses the VectorMap if the ValueType is a primitive
     36   *  the map. This map uses the VectorMap if the Value is a primitive
    3737   *  type and the ArrayMap for the other cases.
    3838   *
    3939   *  The template parameter is the MapRegistry that the maps
    40    *  will belong to and the ValueType.
     40   *  will belong to and the Value.
    4141   */
    4242
     
    148148   
    149149    typedef typename Parent::Graph Graph;
    150     typedef typename Parent::ValueType ValueType;
     150    typedef typename Parent::Value Value;
    151151
    152152    DefaultMap(const Graph& _g) : Parent(_g) {}
    153     DefaultMap(const Graph& _g, const ValueType& _v) : Parent(_g, _v) {}
     153    DefaultMap(const Graph& _g, const Value& _v) : Parent(_g, _v) {}
    154154  };
    155155
     
    181181
    182182      //typedef typename Parent::Graph Graph;
    183       typedef typename Parent::ValueType ValueType;
     183      typedef typename Parent::Value Value;
    184184
    185185      NodeMap(const Graph& _g)
    186186        : Parent(_g) {}
    187       NodeMap(const Graph& _g, const ValueType& _v)
     187      NodeMap(const Graph& _g, const Value& _v)
    188188        : Parent(_g, _v) {}
    189189
     
    201201
    202202      //typedef typename Parent::Graph Graph;
    203       typedef typename Parent::ValueType ValueType;
     203      typedef typename Parent::Value Value;
    204204
    205205      EdgeMap(const Graph& _g)
    206206        : Parent(_g) {}
    207       EdgeMap(const Graph& _g, const ValueType& _v)
     207      EdgeMap(const Graph& _g, const Value& _v)
    208208        : Parent(_g, _v) {}
    209209
  • src/lemon/dijkstra.h

    r986 r987  
    3838  ///
    3939  ///The type of the length is determined by the
    40   ///\ref concept::ReadMap::ValueType "ValueType" of the length map.
     40  ///\ref concept::ReadMap::Value "Value" of the length map.
    4141  ///
    4242  ///It is also possible to change the underlying priority heap.
     
    8282   
    8383    ///The type of the length of the edges.
    84     typedef typename LM::ValueType ValueType;
     84    typedef typename LM::Value Value;
    8585    ///The type of the map that stores the edge lengths.
    8686    typedef LM LengthMap;
     
    9292    typedef typename Graph::template NodeMap<Node> PredNodeMap;
    9393    ///The type of the map that stores the dists of the nodes.
    94     typedef typename Graph::template NodeMap<ValueType> DistMap;
     94    typedef typename Graph::template NodeMap<Value> DistMap;
    9595
    9696  private:
     
    238238      typename GR::template NodeMap<int> heap_map(*G,-1);
    239239     
    240       typedef Heap<Node, ValueType, typename GR::template NodeMap<int>,
    241       std::less<ValueType> >
     240      typedef Heap<Node, Value, typename GR::template NodeMap<int>,
     241      std::less<Value> >
    242242      HeapType;
    243243     
     
    249249       
    250250        Node v=heap.top();
    251         ValueType oldvalue=heap[v];
     251        Value oldvalue=heap[v];
    252252        heap.pop();
    253253        distance->set(v, oldvalue);
     
    282282    ///\warning If node \c v in unreachable from the root the return value
    283283    ///of this funcion is undefined.
    284     ValueType dist(Node v) const { return (*distance)[v]; }
     284    Value dist(Node v) const { return (*distance)[v]; }
    285285
    286286    ///Returns the 'previous edge' of the shortest path tree.
  • src/lemon/dimacs.h

    r986 r987  
    5151                  CostMap& cost) {
    5252    g.clear();
    53     typename CapacityMap::ValueType _cap;
    54     typename CostMap::ValueType _cost;
     53    typename CapacityMap::Value _cap;
     54    typename CostMap::Value _cost;
    5555    char d;
    5656    std::string problem;
  • src/lemon/graph_wrapper.h

    r986 r987  
    11221122      typename Graph::template EdgeMap<T> forward_map, backward_map;
    11231123    public:
    1124       typedef T ValueType;
    1125       typedef Edge KeyType;
     1124      typedef T Value;
     1125      typedef Edge Key;
    11261126
    11271127      EdgeMap(const SubBidirGraphWrapper<Graph,
     
    11511151      }
    11521152
    1153       typename Graph::template EdgeMap<T>::ConstReferenceType
     1153      typename Graph::template EdgeMap<T>::ConstReference
    11541154      operator[](Edge e) const {
    11551155        if (!e.backward)
     
    11591159      }
    11601160
    1161       typename Graph::template EdgeMap<T>::ReferenceType
     1161      typename Graph::template EdgeMap<T>::Reference
    11621162      operator[](Edge e) {
    11631163        if (!e.backward)
     
    13461346      const ResGraphWrapper<Graph, Number, CapacityMap, FlowMap>* res_graph;
    13471347    public:
    1348       typedef Number ValueType;
    1349       typedef Edge KeyType;
     1348      typedef Number Value;
     1349      typedef Edge Key;
    13501350      ResCap(const ResGraphWrapper<Graph, Number, CapacityMap, FlowMap>&
    13511351             _res_graph) : res_graph(&_res_graph) { }
  • src/lemon/kruskal.h

    r986 r987  
    113113    const Map &m;
    114114  public:
    115     typedef typename Map::ValueType ValueType;
     115    typedef typename Map::Value Value;
    116116
    117117    NonConstMapWr(const Map &_m) : m(_m) {}
    118118
    119     template<class KeyType>
    120     void set(KeyType const& k, ValueType const &v) const { m.set(k,v); }
     119    template<class Key>
     120    void set(Key const& k, Value const &v) const { m.set(k,v); }
    121121  };
    122122
     
    151151  class KruskalMapInput
    152152    : public std::vector< std::pair<typename GR::Edge,
    153                                     typename Map::ValueType> > {
     153                                    typename Map::Value> > {
    154154   
    155155  public:
    156156    typedef std::vector< std::pair<typename GR::Edge,
    157                                    typename Map::ValueType> > Parent;
     157                                   typename Map::Value> > Parent;
    158158    typedef typename Parent::value_type value_type;
    159159
     
    236236  /// wrapper function exists: \ref kruskalEdgeMap_IteratorOut().
    237237  ///
    238   /// \warning Not a regular property map, as it doesn't know its KeyType
     238  /// \warning Not a regular property map, as it doesn't know its Key
    239239
    240240  template<class Iterator>
     
    243243
    244244  public:
    245     typedef bool ValueType;
     245    typedef bool Value;
    246246
    247247    KruskalSequenceOutput(Iterator const &_it) : it(_it) {}
    248248
    249     template<typename KeyType>
    250     void set(KeyType const& k, bool v) const { if(v) {*it=k; ++it;} }
     249    template<typename Key>
     250    void set(Key const& k, bool v) const { if(v) {*it=k; ++it;} }
    251251  };
    252252
     
    288288  template <class GR, class IN, class RET>
    289289  inline
    290   typename IN::ValueType
     290  typename IN::Value
    291291  kruskalEdgeMap(GR const& G,
    292292                 IN const& in,
     
    333333  template <class GR, class IN, class RET>
    334334  inline
    335   typename IN::ValueType
     335  typename IN::Value
    336336  kruskalEdgeMap_IteratorOut(const GR& G,
    337337                             const IN& in,
  • src/lemon/map_defines.h

    r937 r987  
    5252 */
    5353#define CREATE_NODE_MAP(DynMap) \
    54 template <typename Value> \
    55 class NodeMap : public DynMap<NodeMapRegistry, Value> { \
    56 public: \
    57 typedef DynMap<NodeMapRegistry, Value> Parent; \
     54template <typename _Value> \
     55class NodeMap : public DynMap<NodeMapRegistry, _Value> { \
     56public: \
     57typedef DynMap<NodeMapRegistry, _Value> Parent; \
    5858NodeMap(const typename Parent::Graph& g) \
    5959  : Parent(g, g.node_maps) {} \
    60 NodeMap(const typename Parent::Graph& g, const Value& v) \
     60NodeMap(const typename Parent::Graph& g, const _Value& v) \
    6161  : Parent(g, g.node_maps, v) {} \
    6262NodeMap(const NodeMap& copy) : Parent(static_cast<const Parent&>(copy)) {} \
     
    8282 */
    8383#define CREATE_EDGE_MAP(DynMap) \
    84 template <typename Value> \
    85 class EdgeMap : public DynMap<EdgeMapRegistry, Value> { \
    86 public: \
    87 typedef DynMap<EdgeMapRegistry, Value> Parent; \
     84template <typename _Value> \
     85class EdgeMap : public DynMap<EdgeMapRegistry, _Value> { \
     86public: \
     87typedef DynMap<EdgeMapRegistry, _Value> Parent; \
    8888\
    8989EdgeMap(const typename Parent::Graph& g) \
    9090  : Parent(g, g.edge_maps) {} \
    91 EdgeMap(const typename Parent::Graph& g, const Value& v) \
     91EdgeMap(const typename Parent::Graph& g, const _Value& v) \
    9292  : Parent(g, g.edge_maps, v) {} \
    9393EdgeMap(const EdgeMap& copy) : Parent(static_cast<const Parent&>(copy)) {} \
     
    126126 */
    127127#define CREATE_SYM_EDGE_MAP(DynMap) \
    128 template <typename Value> \
    129 class SymEdgeMap : public DynMap<SymEdgeMapRegistry, Value> { \
    130 public: \
    131 typedef DynMap<SymEdgeMapRegistry, Value> Parent; \
     128template <typename _Value> \
     129class SymEdgeMap : public DynMap<SymEdgeMapRegistry, _Value> { \
     130public: \
     131typedef DynMap<SymEdgeMapRegistry, _Value> Parent; \
    132132\
    133133SymEdgeMap(const typename Parent::Graph& g) \
    134134  : Parent(g, g.sym_edge_maps) {} \
    135 SymEdgeMap(const typename Parent::Graph& g, const Value& v) \
     135SymEdgeMap(const typename Parent::Graph& g, const _Value& v) \
    136136  : Parent(g, g.sym_edge_maps, v) {} \
    137137SymEdgeMap(const SymEdgeMap& copy) \
     
    154154 */
    155155#define IMPORT_NODE_MAP(From, from, To, to) \
    156 template <typename Value> \
    157 class NodeMap : public From::template NodeMap<Value> { \
    158 \
    159 public: \
    160 typedef typename From::template NodeMap<Value> Parent; \
     156template <typename _Value> \
     157class NodeMap : public From::template NodeMap<_Value> { \
     158\
     159public: \
     160typedef typename From::template NodeMap<_Value> Parent; \
    161161\
    162162NodeMap(const To& to) \
    163163  : Parent(static_cast<const From&>(from)) { } \
    164 NodeMap(const To& to, const Value& value) \
     164NodeMap(const To& to, const _Value& value) \
    165165  : Parent(static_cast<const From&>(from), value) { } \
    166166NodeMap(const NodeMap& copy) \
     
    183183 */
    184184#define IMPORT_EDGE_MAP(From, from, To, to) \
    185 template <typename Value> \
    186 class EdgeMap : public From::template EdgeMap<Value> { \
    187 \
    188 public: \
    189 typedef typename From::template EdgeMap<Value> Parent; \
     185template <typename _Value> \
     186class EdgeMap : public From::template EdgeMap<_Value> { \
     187\
     188public: \
     189typedef typename From::template EdgeMap<_Value> Parent; \
    190190\
    191191EdgeMap(const To& to) \
    192192  : Parent(static_cast<const From&>(from)) { } \
    193 EdgeMap(const To& to, const Value& value) \
     193EdgeMap(const To& to, const _Value& value) \
    194194  : Parent(static_cast<const From&>(from), value) { } \
    195195EdgeMap(const EdgeMap& copy) \
  • src/lemon/map_iterator.h

    r921 r987  
    4242
    4343    /// The key type of the iterator.
    44     typedef typename Map::KeyType KeyType;
    45     /// The iterator to iterate on the keys.
    46     typedef typename Map::KeyIt KeyIt;
    47 
    48     /// The value type of the iterator.
    49     typedef typename Map::ValueType ValueType;
    50     /// The reference type of the iterator.
    51     typedef typename Map::ReferenceType ReferenceType;
    52     /// The pointer type of the iterator.
    53     typedef typename Map::PointerType PointerType;
    54 
    55     /// The const value type of the iterator.
    56     typedef typename Map::ConstValueType ConstValueType;
    57     /// The const reference type of the iterator.
    58     typedef typename Map::ConstReferenceType ConstReferenceType;
    59     /// The pointer type of the iterator.
    60     typedef typename Map::ConstPointerType ConstPointerType;
     44    typedef typename Map::Key Key;
     45    /// The iterator to iterate on the keys.
     46    typedef typename Map::KeyIt KeyIt;
     47
     48    /// The value type of the iterator.
     49    typedef typename Map::Value Value;
     50    /// The reference type of the iterator.
     51    typedef typename Map::Reference Reference;
     52    /// The pointer type of the iterator.
     53    typedef typename Map::Pointer Pointer;
     54
     55    /// The const value type of the iterator.
     56    typedef typename Map::ConstValue ConstValue;
     57    /// The const reference type of the iterator.
     58    typedef typename Map::ConstReference ConstReference;
     59    /// The pointer type of the iterator.
     60    typedef typename Map::ConstPointer ConstPointer;
    6161
    6262  protected:
     
    105105
    106106    /// The key type of the iterator.
    107     typedef typename Map::KeyType KeyType;
    108     /// The iterator to iterate on the keys.
    109     typedef typename Map::KeyIt KeyIt;
    110 
    111     /// The value type of the iterator.
    112     typedef typename Map::ValueType ValueType;
    113     /// The reference type of the iterator.
    114     typedef typename Map::ReferenceType ReferenceType;
    115     /// The pointer type of the iterator.
    116     typedef typename Map::PointerType PointerType;
    117 
    118     /// The const value type of the iterator.
    119     typedef typename Map::ConstValueType ConstValueType;
    120     /// The const reference type of the iterator.
    121     typedef typename Map::ConstReferenceType ConstReferenceType;
    122     /// The pointer type of the iterator.
    123     typedef typename Map::ConstPointerType ConstPointerType;
     107    typedef typename Map::Key Key;
     108    /// The iterator to iterate on the keys.
     109    typedef typename Map::KeyIt KeyIt;
     110
     111    /// The value type of the iterator.
     112    typedef typename Map::Value Value;
     113    /// The reference type of the iterator.
     114    typedef typename Map::Reference Reference;
     115    /// The pointer type of the iterator.
     116    typedef typename Map::Pointer Pointer;
     117
     118    /// The const value type of the iterator.
     119    typedef typename Map::ConstValue ConstValue;
     120    /// The const reference type of the iterator.
     121    typedef typename Map::ConstReference ConstReference;
     122    /// The pointer type of the iterator.
     123    typedef typename Map::ConstPointer ConstPointer;
    124124   
    125125  public:
    126126
    127127    /// The value type of the iterator.
    128     typedef extended_pair<KeyType, const KeyType&,
    129       ValueType, const ValueType&> PairValueType;
     128    typedef extended_pair<Key, const Key&,
     129      Value, const Value&> PairValue;
    130130
    131131    /// The reference type of the iterator.
    132     typedef extended_pair<const KeyType&, const KeyType&,
    133       ReferenceType, ReferenceType> PairReferenceType;
     132    typedef extended_pair<const Key&, const Key&,
     133      Reference, Reference> PairReference;
    134134
    135135    /// Default constructor.
     
    141141
    142142    /// Dereference operator for the iterator.
    143     PairReferenceType operator*() {
    144       return PairReferenceType(Base::it, (*map)[Base::it]);
    145     }
    146 
    147     /// The pointer type of the iterator.
    148     class PairPointerType {
     143    PairReference operator*() {
     144      return PairReference(Base::it, (*map)[Base::it]);
     145    }
     146
     147    /// The pointer type of the iterator.
     148    class PairPointer {
    149149      friend class MapIterator;
    150150    private:
    151       PairReferenceType data;
    152       PairPointerType(const KeyType& key, ReferenceType val)
     151      PairReference data;
     152      PairPointer(const Key& key, Reference val)
    153153        : data(key, val) {}
    154154    public:
    155       PairReferenceType* operator->() {return &data;}
     155      PairReference* operator->() {return &data;}
    156156    };
    157157
    158158    /// Arrow operator for the iterator.
    159     PairPointerType operator->() {
    160       return PairPointerType(Base::it, ((*map)[Base::it]));
     159    PairPointer operator->() {
     160      return PairPointer(Base::it, ((*map)[Base::it]));
    161161    }
    162162       
     
    181181    typedef std::forward_iterator_tag iterator_category;
    182182    typedef int difference_type;
    183     typedef PairValueType value_type;
    184     typedef PairReferenceType reference;
    185     typedef PairPointerType pointer;
     183    typedef PairValue value_type;
     184    typedef PairReference reference;
     185    typedef PairPointer pointer;
    186186  };
    187187
     
    198198
    199199    /// The key type of the iterator.
    200     typedef typename Map::KeyType KeyType;
    201     /// The iterator to iterate on the keys.
    202     typedef typename Map::KeyIt KeyIt;
    203 
    204     /// The value type of the iterator.
    205     typedef typename Map::ValueType ValueType;
    206     /// The reference type of the iterator.
    207     typedef typename Map::ReferenceType ReferenceType;
    208     /// The pointer type of the iterator.
    209     typedef typename Map::PointerType PointerType;
    210 
    211     /// The const value type of the iterator.
    212     typedef typename Map::ConstValueType ConstValueType;
    213     /// The const reference type of the iterator.
    214     typedef typename Map::ConstReferenceType ConstReferenceType;
    215     /// The pointer type of the iterator.
    216     typedef typename Map::ConstPointerType ConstPointerType;
     200    typedef typename Map::Key Key;
     201    /// The iterator to iterate on the keys.
     202    typedef typename Map::KeyIt KeyIt;
     203
     204    /// The value type of the iterator.
     205    typedef typename Map::Value Value;
     206    /// The reference type of the iterator.
     207    typedef typename Map::Reference Reference;
     208    /// The pointer type of the iterator.
     209    typedef typename Map::Pointer Pointer;
     210
     211    /// The const value type of the iterator.
     212    typedef typename Map::ConstValue ConstValue;
     213    /// The const reference type of the iterator.
     214    typedef typename Map::ConstReference ConstReference;
     215    /// The pointer type of the iterator.
     216    typedef typename Map::ConstPointer ConstPointer;
    217217
    218218  public:   
     
    233233
    234234    /// The value type of the iterator.
    235     typedef extended_pair<KeyType, const KeyType&,
    236       ValueType, const ValueType&> PairValueType;
     235    typedef extended_pair<Key, const Key&,
     236      Value, const Value&> PairValue;
    237237
    238238    /// The reference type of map.
    239     typedef extended_pair<const KeyType&, const KeyType&,
    240       ConstReferenceType, ConstReferenceType> PairReferenceType;
     239    typedef extended_pair<const Key&, const Key&,
     240      ConstReference, ConstReference> PairReference;
    241241
    242242    /// Dereference operator for the iterator.
    243     PairReferenceType operator*() {
    244       return PairReferenceType(Base::it, (*map)[Base::it]);
    245     }
    246 
    247     /// The pointer type of the iterator.
    248     class PairPointerType {
     243    PairReference operator*() {
     244      return PairReference(Base::it, (*map)[Base::it]);
     245    }
     246
     247    /// The pointer type of the iterator.
     248    class PairPointer {
    249249      friend class MapConstIterator;
    250250    private:
    251       PairReferenceType data;
    252       PairPointerType(const KeyType& key, ConstReferenceType val)
     251      PairReference data;
     252      PairPointer(const Key& key, ConstReference val)
    253253        : data(key, val) {}
    254254    public:
    255       PairReferenceType* operator->() {return &data;}
     255      PairReference* operator->() {return &data;}
    256256    };
    257257
    258258    /// Arrow operator for the iterator.
    259     PairPointerType operator->() {
    260       return PairPointerType(Base::it, (*map)[Base::it]);
     259    PairPointer operator->() {
     260      return PairPointer(Base::it, (*map)[Base::it]);
    261261    }
    262262
     
    281281    typedef std::input_iterator_tag iterator_category;
    282282    typedef int difference_type;
    283     typedef PairValueType value_type;
    284     typedef PairReferenceType reference;
    285     typedef PairPointerType pointer;
     283    typedef PairValue value_type;
     284    typedef PairReference reference;
     285    typedef PairPointer pointer;
    286286  };
    287287
     
    298298 
    299299    /// The key type of the iterator.
    300     typedef typename Map::KeyType KeyType;
     300    typedef typename Map::Key Key;
    301301    /// The iterator to iterate on the keys.
    302302    typedef typename Map::KeyIt KeyIt;
     
    324324
    325325    /// The dereferencing operator of the iterator.
    326     KeyType operator*() const {
    327       return static_cast<KeyType>(Base::it);
     326    Key operator*() const {
     327      return static_cast<Key>(Base::it);
    328328    }
    329329
     
    332332    typedef std::input_iterator_tag iterator_category;
    333333    typedef int difference_type;
    334     typedef KeyType value_type;
    335     typedef const KeyType& reference;
    336     typedef const KeyType* pointer;
     334    typedef Key value_type;
     335    typedef const Key& reference;
     336    typedef const Key* pointer;
    337337  };
    338338
     
    353353
    354354    /// The key type of the iterator.
    355     typedef typename Map::KeyType KeyType;
    356     /// The iterator to iterate on the keys.
    357     typedef typename Map::KeyIt KeyIt;
    358 
    359 
    360     /// The value type of the iterator.
    361     typedef typename Map::ValueType ValueType;
    362     /// The reference type of the iterator.
    363     typedef typename Map::ReferenceType ReferenceType;
    364     /// The pointer type of the iterator.
    365     typedef typename Map::PointerType PointerType;
    366 
    367     /// The const value type of the iterator.
    368     typedef typename Map::ConstValueType ConstValueType;
    369     /// The const reference type of the iterator.
    370     typedef typename Map::ConstReferenceType ConstReferenceType;
    371     /// The pointer type of the iterator.
    372     typedef typename Map::ConstPointerType ConstPointerType;
     355    typedef typename Map::Key Key;
     356    /// The iterator to iterate on the keys.
     357    typedef typename Map::KeyIt KeyIt;
     358
     359
     360    /// The value type of the iterator.
     361    typedef typename Map::Value Value;
     362    /// The reference type of the iterator.
     363    typedef typename Map::Reference Reference;
     364    /// The pointer type of the iterator.
     365    typedef typename Map::Pointer Pointer;
     366
     367    /// The const value type of the iterator.
     368    typedef typename Map::ConstValue ConstValue;
     369    /// The const reference type of the iterator.
     370    typedef typename Map::ConstReference ConstReference;
     371    /// The pointer type of the iterator.
     372    typedef typename Map::ConstPointer ConstPointer;
    373373
    374374  private:
     
    400400
    401401    /// The dereferencing operator of the iterator.
    402     ReferenceType operator*() const {
     402    Reference operator*() const {
    403403      return (*map)[Base::it];
    404404    }
    405405
    406406    /// The arrow operator of the iterator.
    407     PointerType operator->() const {
     407    Pointer operator->() const {
    408408      return &(operator*());
    409409    }
     
    413413    typedef std::forward_iterator_tag iterator_category;
    414414    typedef int difference_type;
    415     typedef ValueType value_type;
    416     typedef ReferenceType reference;
    417     typedef PointerType pointer;
     415    typedef Value value_type;
     416    typedef Reference reference;
     417    typedef Pointer pointer;
    418418  };
    419419
     
    431431
    432432    /// The key type of the iterator.
    433     typedef typename Map::KeyType KeyType;
    434     /// The iterator to iterate on the keys.
    435     typedef typename Map::KeyIt KeyIt;
    436 
    437     /// The value type of the iterator.
    438     typedef typename Map::ValueType ValueType;
    439     /// The reference type of the iterator.
    440     typedef typename Map::ReferenceType ReferenceType;
    441     /// The pointer type of the iterator.
    442     typedef typename Map::PointerType PointerType;
    443 
    444     /// The const value type of the iterator.
    445     typedef typename Map::ConstValueType ConstValueType;
    446     /// The const reference type of the iterator.
    447     typedef typename Map::ConstReferenceType ConstReferenceType;
    448     /// The pointer type of the iterator.
    449     typedef typename Map::ConstPointerType ConstPointerType;
     433    typedef typename Map::Key Key;
     434    /// The iterator to iterate on the keys.
     435    typedef typename Map::KeyIt KeyIt;
     436
     437    /// The value type of the iterator.
     438    typedef typename Map::Value Value;
     439    /// The reference type of the iterator.
     440    typedef typename Map::Reference Reference;
     441    /// The pointer type of the iterator.
     442    typedef typename Map::Pointer Pointer;
     443
     444    /// The const value type of the iterator.
     445    typedef typename Map::ConstValue ConstValue;
     446    /// The const reference type of the iterator.
     447    typedef typename Map::ConstReference ConstReference;
     448    /// The pointer type of the iterator.
     449    typedef typename Map::ConstPointer ConstPointer;
    450450
    451451  private:
     
    482482
    483483    /// The dereferencing operator of the iterator.
    484     ConstReferenceType operator*() const {
     484    ConstReference operator*() const {
    485485      return (*map)[Base::it];
    486486    }
    487487
    488488    /// The arrow operator of the iterator.
    489     ConstPointerType operator->() const {
     489    ConstPointer operator->() const {
    490490      return &(operator*());
    491491    }
     
    495495    typedef std::input_iterator_tag iterator_category;
    496496    typedef int difference_type;
    497     typedef ValueType value_type;
    498     typedef ConstReferenceType reference;
    499     typedef ConstPointerType pointer;
     497    typedef Value value_type;
     498    typedef ConstReference reference;
     499    typedef ConstPointer pointer;
    500500  };
    501501
     
    512512
    513513    /// The key type of the iterator.
    514     typedef typename Map::KeyType KeyType;
    515     /// The iterator to iterate on the keys.
    516     typedef typename Map::KeyIt KeyIt;
    517 
    518 
    519     /// The value type of the iterator.
    520     typedef typename Map::ValueType ValueType;
    521     /// The reference type of the iterator.
    522     typedef typename Map::ReferenceType ReferenceType;
    523     /// The pointer type of the iterator.
    524     typedef typename Map::PointerType PointerType;
    525 
    526     /// The const value type of the iterator.
    527     typedef typename Map::ConstValueType ConstValueType;
    528     /// The const reference type of the iterator.
    529     typedef typename Map::ConstReferenceType ConstReferenceType;
    530     /// The pointer type of the iterator.
    531     typedef typename Map::ConstPointerType ConstPointerType;
     514    typedef typename Map::Key Key;
     515    /// The iterator to iterate on the keys.
     516    typedef typename Map::KeyIt KeyIt;
     517
     518
     519    /// The value type of the iterator.
     520    typedef typename Map::Value Value;
     521    /// The reference type of the iterator.
     522    typedef typename Map::Reference Reference;
     523    /// The pointer type of the iterator.
     524    typedef typename Map::Pointer Pointer;
     525
     526    /// The const value type of the iterator.
     527    typedef typename Map::ConstValue ConstValue;
     528    /// The const reference type of the iterator.
     529    typedef typename Map::ConstReference ConstReference;
     530    /// The pointer type of the iterator.
     531    typedef typename Map::ConstPointer ConstPointer;
    532532
    533533    /// The map initialized const key set.
     
    549549  public:
    550550    // STL  compatibility typedefs.
    551     typedef ValueType value_type;
     551    typedef Value value_type;
    552552    typedef ConstIterator const_iterator;
    553     typedef ConstReferenceType const_reference;
    554     typedef ConstPointerType const_pointer;
     553    typedef ConstReference const_reference;
     554    typedef ConstPointer const_pointer;
    555555    typedef int difference_type;
    556556  };
     
    568568
    569569    /// The key type of the iterator.
    570     typedef typename Map::KeyType KeyType;
    571     /// The iterator to iterate on the keys.
    572     typedef typename Map::KeyIt KeyIt;
    573 
    574 
    575     /// The value type of the iterator.
    576     typedef typename Map::ValueType ValueType;
    577     /// The reference type of the iterator.
    578     typedef typename Map::ReferenceType ReferenceType;
    579     /// The pointer type of the iterator.
    580     typedef typename Map::PointerType PointerType;
    581 
    582     /// The const value type of the iterator.
    583     typedef typename Map::ConstValueType ConstValueType;
    584     /// The const reference type of the iterator.
    585     typedef typename Map::ConstReferenceType ConstReferenceType;
    586     /// The pointer type of the iterator.
    587     typedef typename Map::ConstPointerType ConstPointerType;
     570    typedef typename Map::Key Key;
     571    /// The iterator to iterate on the keys.
     572    typedef typename Map::KeyIt KeyIt;
     573
     574
     575    /// The value type of the iterator.
     576    typedef typename Map::Value Value;
     577    /// The reference type of the iterator.
     578    typedef typename Map::Reference Reference;
     579    /// The pointer type of the iterator.
     580    typedef typename Map::Pointer Pointer;
     581
     582    /// The const value type of the iterator.
     583    typedef typename Map::ConstValue ConstValue;
     584    /// The const reference type of the iterator.
     585    typedef typename Map::ConstReference ConstReference;
     586    /// The pointer type of the iterator.
     587    typedef typename Map::ConstPointer ConstPointer;
    588588
    589589    /// The map initialized const value set.
     
    605605  public:
    606606    // STL  compatibility typedefs.
    607     typedef ValueType value_type;
     607    typedef Value value_type;
    608608    typedef ConstIterator const_iterator;
    609     typedef ConstReferenceType const_reference;
    610     typedef ConstPointerType const_pointer;
     609    typedef ConstReference const_reference;
     610    typedef ConstPointer const_pointer;
    611611    typedef int difference_type;
    612612  };
     
    625625
    626626    /// The key type of the iterator.
    627     typedef typename Map::KeyType KeyType;
    628     /// The iterator to iterate on the keys.
    629     typedef typename Map::KeyIt KeyIt;
    630 
    631 
    632     /// The value type of the iterator.
    633     typedef typename Map::ValueType ValueType;
    634     /// The reference type of the iterator.
    635     typedef typename Map::ReferenceType ReferenceType;
    636     /// The pointer type of the iterator.
    637     typedef typename Map::PointerType PointerType;
    638 
    639     /// The const value type of the iterator.
    640     typedef typename Map::ConstValueType ConstValueType;
    641     /// The const reference type of the iterator.
    642     typedef typename Map::ConstReferenceType ConstReferenceType;
    643     /// The pointer type of the iterator.
    644     typedef typename Map::ConstPointerType ConstPointerType;
     627    typedef typename Map::Key Key;
     628    /// The iterator to iterate on the keys.
     629    typedef typename Map::KeyIt KeyIt;
     630
     631
     632    /// The value type of the iterator.
     633    typedef typename Map::Value Value;
     634    /// The reference type of the iterator.
     635    typedef typename Map::Reference Reference;
     636    /// The pointer type of the iterator.
     637    typedef typename Map::Pointer Pointer;
     638
     639    /// The const value type of the iterator.
     640    typedef typename Map::ConstValue ConstValue;
     641    /// The const reference type of the iterator.
     642    typedef typename Map::ConstReference ConstReference;
     643    /// The pointer type of the iterator.
     644    typedef typename Map::ConstPointer ConstPointer;
    645645
    646646    /// The map initialized value set.
     
    675675  public:
    676676    // STL  compatibility typedefs.
    677     typedef ValueType value_type;
     677    typedef Value value_type;
    678678    typedef Iterator iterator;
    679679    typedef ConstIterator const_iterator;
    680     typedef ReferenceType reference;
    681     typedef ConstReferenceType const_reference;
    682     typedef PointerType pointer;
    683     typedef ConstPointerType const_pointer;
     680    typedef Reference reference;
     681    typedef ConstReference const_reference;
     682    typedef Pointer pointer;
     683    typedef ConstPointer const_pointer;
    684684    typedef int difference_type;
    685685
  • src/lemon/maps.h

    r977 r987  
    3737  public:
    3838    ///\e
    39     typedef K KeyType;
     39    typedef K Key;
    4040    ///\e
    41     typedef T ValueType;
     41    typedef T Value;
    4242  };
    4343
     
    109109
    110110  /// This is essentially a wrapper for \c std::map. With addition that
    111   /// you can specify a default value different from \c ValueType() .
     111  /// you can specify a default value different from \c Value() .
    112112  ///
    113113  /// \todo Provide allocator parameter...
    114   template <typename Key, typename T, typename Compare = std::less<Key> >
    115   class StdMap : public std::map<Key,T,Compare> {
    116     typedef std::map<Key,T,Compare> parent;
     114  template <typename K, typename T, typename Compare = std::less<K> >
     115  class StdMap : public std::map<K,T,Compare> {
     116    typedef std::map<K,T,Compare> parent;
    117117    T v;
    118118    typedef typename parent::value_type PairType;
    119119
    120120  public:
    121     typedef Key KeyType;
    122     typedef T ValueType;
    123     typedef T& ReferenceType;
    124     typedef const T& ConstReferenceType;
     121    typedef K Key;
     122    typedef T Value;
     123    typedef T& Reference;
     124    typedef const T& ConstReference;
    125125
    126126
     
    144144    }
    145145
    146     ReferenceType operator[](const Key &k) {
     146    Reference operator[](const Key &k) {
    147147      return insert(PairType(k,v)).first -> second;
    148148    }
    149     ConstReferenceType operator[](const Key &k) const {
     149    ConstReference operator[](const Key &k) const {
    150150      typename parent::iterator i = lower_bound(k);
    151151      if (i == parent::end() || parent::key_comp()(k, (*i).first))
  • src/lemon/min_cost_flow.h

    r986 r987  
    6060  class MinCostFlow {
    6161
    62     typedef typename LengthMap::ValueType Length;
     62    typedef typename LengthMap::Value Length;
    6363
    6464    //Warning: this should be integer type
    65     typedef typename CapacityMap::ValueType Capacity;
     65    typedef typename CapacityMap::Value Capacity;
    6666   
    6767    typedef typename Graph::Node Node;
     
    9595      const NodeMap &pot;
    9696    public :
    97       typedef typename LengthMap::KeyType KeyType;
    98       typedef typename LengthMap::ValueType ValueType;
     97      typedef typename LengthMap::Key Key;
     98      typedef typename LengthMap::Value Value;
    9999
    100100      ModLengthMap(const ResGW& _g,
     
    102102        g(_g), /*rev(_rev),*/ length(_length), pot(_pot) { }
    103103       
    104       ValueType operator[](typename ResGW::Edge e) const {     
     104      Value operator[](typename ResGW::Edge e) const {     
    105105        if (g.forward(e))
    106106          return  length[e]-(pot[g.target(e)]-pot[g.source(e)]);   
  • src/lemon/suurballe.h

    r986 r987  
    5959
    6060
    61     typedef typename LengthMap::ValueType Length;
     61    typedef typename LengthMap::Value Length;
    6262   
    6363    typedef typename Graph::Node Node;
  • src/lemon/vector_map.h

    r980 r987  
    5454    typedef _Graph Graph;
    5555    /// The key type of the map.
    56     typedef _Item KeyType;
     56    typedef _Item Key;
    5757    /// The id map type of the map.
    5858    typedef AlterationObserverRegistry<_Item> Registry;
     
    7272  public:
    7373
    74     /// The value type of the map.
    75     typedef Value ValueType;
    7674    /// The reference type of the map;
    77     typedef typename Container::reference ReferenceType;
     75    typedef typename Container::reference Reference;
    7876    /// The pointer type of the map;
    79     typedef typename Container::pointer PointerType;
     77    typedef typename Container::pointer Pointer;
    8078
    8179    /// The const value type of the map.
    82     typedef const Value ConstValueType;
     80    typedef const Value ConstValue;
    8381    /// The const reference type of the map;
    84     typedef typename Container::const_reference ConstReferenceType;
     82    typedef typename Container::const_reference ConstReference;
    8583    /// The pointer type of the map;
    86     typedef typename Container::const_pointer ConstPointerType;
     84    typedef typename Container::const_pointer ConstPointer;
    8785
    8886    /// Constructor to attach the new map into the registry.
     
    151149    /// actual items of the graph.
    152150     
    153     ReferenceType operator[](const KeyType& key) {
     151    Reference operator[](const Key& key) {
    154152      return container[graph->id(key)];
    155153    }
     
    160158    /// actual items of the graph.
    161159     
    162     ConstReferenceType operator[](const KeyType& key) const {
     160    ConstReference operator[](const Key& key) const {
    163161      return container[graph->id(key)];
    164162    }
     
    170168    ///
    171169     
    172     void set(const KeyType& key, const ValueType& value) {
     170    void set(const Key& key, const Value& value) {
    173171      (*this)[key] = value;
    174172    }
     
    179177    /// and it overrides the add() member function of the observer base.
    180178     
    181     void add(const KeyType& key) {
     179    void add(const Key& key) {
    182180      int id = graph->id(key);
    183181      if (id >= (int)container.size()) {
     
    190188    /// Erase a key from the map. It called by the observer registry
    191189    /// and it overrides the erase() member function of the observer base.     
    192     void erase(const KeyType&) {}
     190    void erase(const Key&) {}
    193191
    194192    /// Buildes the map.
  • src/lemon/xy.h

    r967 r987  
    5151    public:
    5252
    53       typedef T ValueType;
     53      typedef T Value;
    5454
    5555      T x,y;     
Note: See TracChangeset for help on using the changeset viewer.