COIN-OR::LEMON - Graph Library

About

Downloads

Documentation

Development

Issue Tracker

Browse Tickets

Custom Query

Roadmap

Browse Source

Local Info

Mailing Lists

Search

Changes in / [726:3fc2a801c39e:719:ba79e8d64448] in lemon-main


Ignore:
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • lemon/maps.h

    r726 r717  
    5757  /// but data written to it is not required (i.e. it will be sent to
    5858  /// <tt>/dev/null</tt>).
    59   /// It conforms to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     59  /// It conforms the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
    6060  ///
    6161  /// \sa ConstMap
    … …  
    9090  ///
    9191  /// In other aspects it is equivalent to \c NullMap.
    92   /// So it conforms to the \ref concepts::ReadWriteMap "ReadWriteMap"
     92  /// So it conforms the \ref concepts::ReadWriteMap "ReadWriteMap"
    9393  /// concept, but it absorbs the data written to it.
    9494  ///
    … …  
    159159  ///
    160160  /// In other aspects it is equivalent to \c NullMap.
    161   /// So it conforms to the \ref concepts::ReadWriteMap "ReadWriteMap"
     161  /// So it conforms the \ref concepts::ReadWriteMap "ReadWriteMap"
    162162  /// concept, but it absorbs the data written to it.
    163163  ///
    … …  
    233233  /// It can be used with some data structures, for example
    234234  /// \c UnionFind, \c BinHeap, when the used items are small
    235   /// integers. This map conforms to the \ref concepts::ReferenceMap
     235  /// integers. This map conforms the \ref concepts::ReferenceMap
    236236  /// "ReferenceMap" concept.
    237237  ///
    … …  
    341341  /// stored actually. This value can be different from the default
    342342  /// contructed value (i.e. \c %Value()).
    343   /// This type conforms to the \ref concepts::ReferenceMap "ReferenceMap"
     343  /// This type conforms the \ref concepts::ReferenceMap "ReferenceMap"
    344344  /// concept.
    345345  ///
    … …  
    707707  /// The \c Key type of it is inherited from \c M and the \c Value
    708708  /// type is \c V.
    709   /// This type conforms to the \ref concepts::ReadMap "ReadMap" concept.
     709  /// This type conforms the \ref concepts::ReadMap "ReadMap" concept.
    710710  ///
    711711  /// The simplest way of using this map is through the convertMap()
    … …  
    18261826  /// the items stored in the graph, which is returned by the \c id()
    18271827  /// function of the graph. This map can be inverted with its member
    1828   /// class \c InverseMap or with the \c operator()() member.
     1828  /// class \c InverseMap or with the \c operator() member.
    18291829  ///
    18301830  /// \tparam GR The graph type.
    … …  
    18661866  public:
    18671867
    1868     /// \brief The inverse map type of IdMap.
    1869     ///
    1870     /// The inverse map type of IdMap. The subscript operator gives back
    1871     /// an item by its id.
    1872     /// This type conforms to the \ref concepts::ReadMap "ReadMap" concept.
     1868    /// \brief This class represents the inverse of its owner (IdMap).
     1869    ///
     1870    /// This class represents the inverse of its owner (IdMap).
    18731871    /// \see inverse()
    18741872    class InverseMap {
    … …  
    18851883      explicit InverseMap(const IdMap& map) : _graph(map._graph) {}
    18861884
    1887       /// \brief Gives back an item by its id.
     1885      /// \brief Gives back the given item from its id.
    18881886      ///
    1889       /// Gives back an item by its id.
     1887      /// Gives back the given item from its id.
    18901888      Item operator[](int id) const { return _graph->fromId(id, Item());}
    18911889
    … …  
    19001898  };
    19011899
    1902   /// \brief Returns an \c IdMap class.
    1903   ///
    1904   /// This function just returns an \c IdMap class.
    1905   /// \relates IdMap
    1906   template <typename K, typename GR>
    1907   inline IdMap<GR, K> idMap(const GR& graph) {
    1908     return IdMap<GR, K>(graph);
    1909   }
    19101900
    19111901  /// \brief General cross reference graph map type.
    … …  
    19141904  /// It wraps a standard graph map (\c NodeMap, \c ArcMap or \c EdgeMap)
    19151905  /// and if a key is set to a new value, then stores it in the inverse map.
    1916   /// The graph items can be accessed by their values either using
    1917   /// \c InverseMap or \c operator()(), and the values of the map can be
    1918   /// accessed with an STL compatible forward iterator (\c ValueIt).
    1919   ///
    1920   /// This map is intended to be used when all associated values are
    1921   /// different (the map is actually invertable) or there are only a few
    1922   /// items with the same value.
    1923   /// Otherwise consider to use \c IterableValueMap, which is more
    1924   /// suitable and more efficient for such cases. It provides iterators
    1925   /// to traverse the items with the same associated value, however
    1926   /// it does not have \c InverseMap.
     1906  /// The values of the map can be accessed
     1907  /// with stl compatible forward iterator.
    19271908  ///
    19281909  /// This type is not reference map, so it cannot be modified with
    … …  
    19651946    /// \brief Forward iterator for values.
    19661947    ///
    1967     /// This iterator is an STL compatible forward
     1948    /// This iterator is an stl compatible forward
    19681949    /// iterator on the values of the map. The values can
    19691950    /// be accessed in the <tt>[beginValue, endValue)</tt> range.
    19701951    /// They are considered with multiplicity, so each value is
    19711952    /// traversed for each item it is assigned to.
    1972     class ValueIt
     1953    class ValueIterator
    19731954      : public std::iterator<std::forward_iterator_tag, Value> {
    19741955      friend class CrossRefMap;
    19751956    private:
    1976       ValueIt(typename Container::const_iterator _it)
     1957      ValueIterator(typename Container::const_iterator _it)
    19771958        : it(_it) {}
    19781959    public:
    19791960
    1980       /// Constructor
    1981       ValueIt() {}
    1982 
    1983       /// \e
    1984       ValueIt& operator++() { ++it; return *this; }
    1985       /// \e
    1986       ValueIt operator++(int) {
    1987         ValueIt tmp(*this);
     1961      ValueIterator() {}
     1962
     1963      ValueIterator& operator++() { ++it; return *this; }
     1964      ValueIterator operator++(int) {
     1965        ValueIterator tmp(*this);
    19881966        operator++();
    19891967        return tmp;
    19901968      }
    19911969
    1992       /// \e
    19931970      const Value& operator*() const { return it->first; }
    1994       /// \e
    19951971      const Value* operator->() const { return &(it->first); }
    19961972
    1997       /// \e
    1998       bool operator==(ValueIt jt) const { return it == jt.it; }
    1999       /// \e
    2000       bool operator!=(ValueIt jt) const { return it != jt.it; }
     1973      bool operator==(ValueIterator jt) const { return it == jt.it; }
     1974      bool operator!=(ValueIterator jt) const { return it != jt.it; }
    20011975
    20021976    private:
    20031977      typename Container::const_iterator it;
    20041978    };
    2005    
    2006     /// Alias for \c ValueIt
    2007     typedef ValueIt ValueIterator;
    20081979
    20091980    /// \brief Returns an iterator to the first value.
    20101981    ///
    2011     /// Returns an STL compatible iterator to the
     1982    /// Returns an stl compatible iterator to the
    20121983    /// first value of the map. The values of the
    20131984    /// map can be accessed in the <tt>[beginValue, endValue)</tt>
    20141985    /// range.
    2015     ValueIt beginValue() const {
    2016       return ValueIt(_inv_map.begin());
     1986    ValueIterator beginValue() const {
     1987      return ValueIterator(_inv_map.begin());
    20171988    }
    20181989
    20191990    /// \brief Returns an iterator after the last value.
    20201991    ///
    2021     /// Returns an STL compatible iterator after the
     1992    /// Returns an stl compatible iterator after the
    20221993    /// last value of the map. The values of the
    20231994    /// map can be accessed in the <tt>[beginValue, endValue)</tt>
    20241995    /// range.
    2025     ValueIt endValue() const {
    2026       return ValueIt(_inv_map.end());
     1996    ValueIterator endValue() const {
     1997      return ValueIterator(_inv_map.end());
    20271998    }
    20281999
    … …  
    20612032      typename Container::const_iterator it = _inv_map.find(val);
    20622033      return it != _inv_map.end() ? it->second : INVALID;
    2063     }
    2064    
    2065     /// \brief Returns the number of items with the given value.
    2066     ///
    2067     /// This function returns the number of items with the given value
    2068     /// associated with it.
    2069     int count(const Value &val) const {
    2070       return _inv_map.count(val);
    20712034    }
    20722035
    … …  
    21202083  public:
    21212084
    2122     /// \brief The inverse map type of CrossRefMap.
    2123     ///
    2124     /// The inverse map type of CrossRefMap. The subscript operator gives
    2125     /// back an item by its value.
    2126     /// This type conforms to the \ref concepts::ReadMap "ReadMap" concept.
    2127     /// \see inverse()
     2085    /// \brief The inverse map type.
     2086    ///
     2087    /// The inverse of this map. The subscript operator of the map
     2088    /// gives back the item that was last assigned to the value.
    21282089    class InverseMap {
    21292090    public:
    … …  
    21522113    };
    21532114
    2154     /// \brief Gives back the inverse of the map.
    2155     ///
    2156     /// Gives back the inverse of the CrossRefMap.
     2115    /// \brief It gives back the read-only inverse map.
     2116    ///
     2117    /// It gives back the read-only inverse map.
    21572118    InverseMap inverse() const {
    21582119      return InverseMap(*this);
    … …  
    21612122  };
    21622123
    2163   /// \brief Provides continuous and unique id for the
     2124  /// \brief Provides continuous and unique ID for the
    21642125  /// items of a graph.
    21652126  ///
    21662127  /// RangeIdMap provides a unique and continuous
    2167   /// id for each item of a given type (\c Node, \c Arc or
     2128  /// ID for each item of a given type (\c Node, \c Arc or
    21682129  /// \c Edge) in a graph. This id is
    21692130  ///  - \b unique: different items get different ids,
    … …  
    21762137  /// the \c id() function of the graph or \ref IdMap.
    21772138  /// This map can be inverted with its member class \c InverseMap,
    2178   /// or with the \c operator()() member.
     2139  /// or with the \c operator() member.
    21792140  ///
    21802141  /// \tparam GR The graph type.
    … …  
    23042265    }
    23052266
    2306     /// \brief Gives back the \e range \e id of the item
    2307     ///
    2308     /// Gives back the \e range \e id of the item.
     2267    /// \brief Gives back the \e RangeId of the item
     2268    ///
     2269    /// Gives back the \e RangeId of the item.
    23092270    int operator[](const Item& item) const {
    23102271      return Map::operator[](item);
    23112272    }
    23122273
    2313     /// \brief Gives back the item belonging to a \e range \e id
    2314     ///
    2315     /// Gives back the item belonging to the given \e range \e id.
     2274    /// \brief Gives back the item belonging to a \e RangeId
     2275    ///
     2276    /// Gives back the item belonging to a \e RangeId.
    23162277    Item operator()(int id) const {
    23172278      return _inv_map[id];
    … …  
    23272288    /// \brief The inverse map type of RangeIdMap.
    23282289    ///
    2329     /// The inverse map type of RangeIdMap. The subscript operator gives
    2330     /// back an item by its \e range \e id.
    2331     /// This type conforms to the \ref concepts::ReadMap "ReadMap" concept.
     2290    /// The inverse map type of RangeIdMap.
    23322291    class InverseMap {
    23332292    public:
    … …  
    23472306      ///
    23482307      /// Subscript operator. It gives back the item
    2349       /// that the given \e range \e id currently belongs to.
     2308      /// that the descriptor currently belongs to.
    23502309      Value operator[](const Key& key) const {
    23512310        return _inverted(key);
    … …  
    23652324    /// \brief Gives back the inverse of the map.
    23662325    ///
    2367     /// Gives back the inverse of the RangeIdMap.
     2326    /// Gives back the inverse of the map.
    23682327    const InverseMap inverse() const {
    23692328      return InverseMap(*this);
    … …  
    23712330  };
    23722331
    2373   /// \brief Returns a \c RangeIdMap class.
    2374   ///
    2375   /// This function just returns an \c RangeIdMap class.
    2376   /// \relates RangeIdMap
    2377   template <typename K, typename GR>
    2378   inline RangeIdMap<GR, K> rangeIdMap(const GR& graph) {
    2379     return RangeIdMap<GR, K>(graph);
    2380   }
    2381  
    23822332  /// \brief Dynamic iterable \c bool map.
    23832333  ///
    … …  
    23852335  /// \c bool value for graph items (\c Node, \c Arc or \c Edge).
    23862336  /// For both \c true and \c false values it is possible to iterate on
    2387   /// the keys mapped to the value.
     2337  /// the keys.
    23882338  ///
    23892339  /// This type is a reference map, so it can be modified with the
    … …  
    27542704  /// mapped to the value.
    27552705  ///
    2756   /// This map is intended to be used with small integer values, for which
    2757   /// it is efficient, and supports iteration only for non-negative values.
    2758   /// If you need large values and/or iteration for negative integers,
    2759   /// consider to use \ref IterableValueMap instead.
    2760   ///
    27612706  /// This type is a reference map, so it can be modified with the
    27622707  /// subscript operator.
    … …  
    30402985  /// \brief Dynamic iterable map for comparable values.
    30412986  ///
    3042   /// This class provides a special graph map type which can store a
     2987  /// This class provides a special graph map type which can store an
    30432988  /// comparable value for graph items (\c Node, \c Arc or \c Edge).
    30442989  /// For each value it is possible to iterate on the keys mapped to
    3045   /// the value (\c ItemIt), and the values of the map can be accessed
    3046   /// with an STL compatible forward iterator (\c ValueIt).
    3047   /// The map stores a linked list for each value, which contains
    3048   /// the items mapped to the value, and the used values are stored
    3049   /// in balanced binary tree (\c std::map).
    3050   ///
    3051   /// \ref IterableBoolMap and \ref IterableIntMap are similar classes
    3052   /// specialized for \c bool and \c int values, respectively.
     2990  /// the value.
     2991  ///
     2992  /// The map stores for each value a linked list with
     2993  /// the items which mapped to the value, and the values are stored
     2994  /// in balanced binary tree. The values of the map can be accessed
     2995  /// with stl compatible forward iterator.
    30532996  ///
    30542997  /// This type is not reference map, so it cannot be modified with
    … …  
    31293072    /// \brief Forward iterator for values.
    31303073    ///
    3131     /// This iterator is an STL compatible forward
     3074    /// This iterator is an stl compatible forward
    31323075    /// iterator on the values of the map. The values can
    31333076    /// be accessed in the <tt>[beginValue, endValue)</tt> range.
    3134     class ValueIt
     3077    class ValueIterator
    31353078      : public std::iterator<std::forward_iterator_tag, Value> {
    31363079      friend class IterableValueMap;
    31373080    private:
    3138       ValueIt(typename std::map<Value, Key>::const_iterator _it)
     3081      ValueIterator(typename std::map<Value, Key>::const_iterator _it)
    31393082        : it(_it) {}
    31403083    public:
    31413084
    3142       /// Constructor
    3143       ValueIt() {}
    3144 
    3145       /// \e
    3146       ValueIt& operator++() { ++it; return *this; }
    3147       /// \e
    3148       ValueIt operator++(int) {
    3149         ValueIt tmp(*this);
     3085      ValueIterator() {}
     3086
     3087      ValueIterator& operator++() { ++it; return *this; }
     3088      ValueIterator operator++(int) {
     3089        ValueIterator tmp(*this);
    31503090        operator++();
    31513091        return tmp;
    31523092      }
    31533093
    3154       /// \e
    31553094      const Value& operator*() const { return it->first; }
    3156       /// \e
    31573095      const Value* operator->() const { return &(it->first); }
    31583096
    3159       /// \e
    3160       bool operator==(ValueIt jt) const { return it == jt.it; }
    3161       /// \e
    3162       bool operator!=(ValueIt jt) const { return it != jt.it; }
     3097      bool operator==(ValueIterator jt) const { return it == jt.it; }
     3098      bool operator!=(ValueIterator jt) const { return it != jt.it; }
    31633099
    31643100    private:
    … …  
    31683104    /// \brief Returns an iterator to the first value.
    31693105    ///
    3170     /// Returns an STL compatible iterator to the
     3106    /// Returns an stl compatible iterator to the
    31713107    /// first value of the map. The values of the
    31723108    /// map can be accessed in the <tt>[beginValue, endValue)</tt>
    31733109    /// range.
    3174     ValueIt beginValue() const {
    3175       return ValueIt(_first.begin());
     3110    ValueIterator beginValue() const {
     3111      return ValueIterator(_first.begin());
    31763112    }
    31773113
    31783114    /// \brief Returns an iterator after the last value.
    31793115    ///
    3180     /// Returns an STL compatible iterator after the
     3116    /// Returns an stl compatible iterator after the
    31813117    /// last value of the map. The values of the
    31823118    /// map can be accessed in the <tt>[beginValue, endValue)</tt>
    31833119    /// range.
    3184     ValueIt endValue() const {
    3185       return ValueIt(_first.end());
     3120    ValueIterator endValue() const {
     3121      return ValueIterator(_first.end());
    31863122    }
    31873123
    … …  
    33013237  public:
    33023238
    3303     /// The key type (the \c Arc type of the digraph).
     3239    ///\e
    33043240    typedef typename GR::Arc Key;
    3305     /// The value type (the \c Node type of the digraph).
     3241    ///\e
    33063242    typedef typename GR::Node Value;
    33073243
    … …  
    33423278  public:
    33433279
    3344     /// The key type (the \c Arc type of the digraph).
     3280    ///\e
    33453281    typedef typename GR::Arc Key;
    3346     /// The value type (the \c Node type of the digraph).
     3282    ///\e
    33473283    typedef typename GR::Node Value;
    33483284
    … …  
    33843320  public:
    33853321
    3386     /// The key type (the \c Edge type of the digraph).
     3322    typedef typename GR::Arc Value;
    33873323    typedef typename GR::Edge Key;
    3388     /// The value type (the \c Arc type of the digraph).
    3389     typedef typename GR::Arc Value;
    33903324
    33913325    /// \brief Constructor
    … …  
    34263360  public:
    34273361
    3428     /// The key type (the \c Edge type of the digraph).
     3362    typedef typename GR::Arc Value;
    34293363    typedef typename GR::Edge Key;
    3430     /// The value type (the \c Arc type of the digraph).
    3431     typedef typename GR::Arc Value;
    34323364
    34333365    /// \brief Constructor

  • test/maps_test.cc

    r726 r695  
    2323#include <lemon/concepts/maps.h>
    2424#include <lemon/maps.h>
    25 #include <lemon/list_graph.h>
    2625#include <lemon/smart_graph.h>
    27 #include <lemon/adaptors.h>
    28 #include <lemon/dfs.h>
    2926
    3027#include "test_tools.h"
    … …  
    6461typedef ReadWriteMap<A, bool> BoolWriteMap;
    6562typedef ReferenceMap<A, bool, bool&, const bool&> BoolRefMap;
    66 
    67 template<typename Map1, typename Map2, typename ItemIt>
    68 void compareMap(const Map1& map1, const Map2& map2, ItemIt it) {
    69   for (; it != INVALID; ++it)
    70     check(map1[it] == map2[it], "The maps are not equal");
    71 }
    7263
    7364int main()
    … …  
    339330  {
    340331    typedef std::vector<int> vec;
    341     checkConcept<WriteMap<int, bool>, LoggerBoolMap<vec::iterator> >();
    342     checkConcept<WriteMap<int, bool>,
    343                  LoggerBoolMap<std::back_insert_iterator<vec> > >();
    344 
    345332    vec v1;
    346333    vec v2(10);
    … …  
    362349          it != map2.end(); ++it )
    363350      check(v1[i++] == *it, "Something is wrong with LoggerBoolMap");
    364    
    365     typedef ListDigraph Graph;
    366     DIGRAPH_TYPEDEFS(Graph);
    367     Graph gr;
    368 
    369     Node n0 = gr.addNode();
    370     Node n1 = gr.addNode();
    371     Node n2 = gr.addNode();
    372     Node n3 = gr.addNode();
    373    
    374     gr.addArc(n3, n0);
    375     gr.addArc(n3, n2);
    376     gr.addArc(n0, n2);
    377     gr.addArc(n2, n1);
    378     gr.addArc(n0, n1);
    379    
    380     {
    381       std::vector<Node> v;
    382       dfs(gr).processedMap(loggerBoolMap(std::back_inserter(v))).run();
    383 
    384       check(v.size()==4 && v[0]==n1 && v[1]==n2 && v[2]==n0 && v[3]==n3,
    385             "Something is wrong with LoggerBoolMap");
    386     }
    387     {
    388       std::vector<Node> v(countNodes(gr));
    389       dfs(gr).processedMap(loggerBoolMap(v.begin())).run();
    390      
    391       check(v.size()==4 && v[0]==n1 && v[1]==n2 && v[2]==n0 && v[3]==n3,
    392             "Something is wrong with LoggerBoolMap");
    393     }
    394   }
    395  
    396   // IdMap, RangeIdMap
    397   {
    398     typedef ListDigraph Graph;
    399     DIGRAPH_TYPEDEFS(Graph);
    400 
    401     checkConcept<ReadMap<Node, int>, IdMap<Graph, Node> >();
    402     checkConcept<ReadMap<Arc, int>, IdMap<Graph, Arc> >();
    403     checkConcept<ReadMap<Node, int>, RangeIdMap<Graph, Node> >();
    404     checkConcept<ReadMap<Arc, int>, RangeIdMap<Graph, Arc> >();
    405    
    406     Graph gr;
    407     IdMap<Graph, Node> nmap(gr);
    408     IdMap<Graph, Arc> amap(gr);
    409     RangeIdMap<Graph, Node> nrmap(gr);
    410     RangeIdMap<Graph, Arc> armap(gr);
    411    
    412     Node n0 = gr.addNode();
    413     Node n1 = gr.addNode();
    414     Node n2 = gr.addNode();
    415    
    416     Arc a0 = gr.addArc(n0, n1);
    417     Arc a1 = gr.addArc(n0, n2);
    418     Arc a2 = gr.addArc(n2, n1);
    419     Arc a3 = gr.addArc(n2, n0);
    420    
    421     check(nmap[n0] == gr.id(n0) && nmap(gr.id(n0)) == n0, "Wrong IdMap");
    422     check(nmap[n1] == gr.id(n1) && nmap(gr.id(n1)) == n1, "Wrong IdMap");
    423     check(nmap[n2] == gr.id(n2) && nmap(gr.id(n2)) == n2, "Wrong IdMap");
    424 
    425     check(amap[a0] == gr.id(a0) && amap(gr.id(a0)) == a0, "Wrong IdMap");
    426     check(amap[a1] == gr.id(a1) && amap(gr.id(a1)) == a1, "Wrong IdMap");
    427     check(amap[a2] == gr.id(a2) && amap(gr.id(a2)) == a2, "Wrong IdMap");
    428     check(amap[a3] == gr.id(a3) && amap(gr.id(a3)) == a3, "Wrong IdMap");
    429 
    430     check(nmap.inverse()[gr.id(n0)] == n0, "Wrong IdMap::InverseMap");
    431     check(amap.inverse()[gr.id(a0)] == a0, "Wrong IdMap::InverseMap");
    432    
    433     check(nrmap.size() == 3 && armap.size() == 4,
    434           "Wrong RangeIdMap::size()");
    435 
    436     check(nrmap[n0] == 0 && nrmap(0) == n0, "Wrong RangeIdMap");
    437     check(nrmap[n1] == 1 && nrmap(1) == n1, "Wrong RangeIdMap");
    438     check(nrmap[n2] == 2 && nrmap(2) == n2, "Wrong RangeIdMap");
    439    
    440     check(armap[a0] == 0 && armap(0) == a0, "Wrong RangeIdMap");
    441     check(armap[a1] == 1 && armap(1) == a1, "Wrong RangeIdMap");
    442     check(armap[a2] == 2 && armap(2) == a2, "Wrong RangeIdMap");
    443     check(armap[a3] == 3 && armap(3) == a3, "Wrong RangeIdMap");
    444 
    445     check(nrmap.inverse()[0] == n0, "Wrong RangeIdMap::InverseMap");
    446     check(armap.inverse()[0] == a0, "Wrong RangeIdMap::InverseMap");
    447    
    448     gr.erase(n1);
    449    
    450     if (nrmap[n0] == 1) nrmap.swap(n0, n2);
    451     nrmap.swap(n2, n0);
    452     if (armap[a1] == 1) armap.swap(a1, a3);
    453     armap.swap(a3, a1);
    454    
    455     check(nrmap.size() == 2 && armap.size() == 2,
    456           "Wrong RangeIdMap::size()");
    457 
    458     check(nrmap[n0] == 1 && nrmap(1) == n0, "Wrong RangeIdMap");
    459     check(nrmap[n2] == 0 && nrmap(0) == n2, "Wrong RangeIdMap");
    460    
    461     check(armap[a1] == 1 && armap(1) == a1, "Wrong RangeIdMap");
    462     check(armap[a3] == 0 && armap(0) == a3, "Wrong RangeIdMap");
    463 
    464     check(nrmap.inverse()[0] == n2, "Wrong RangeIdMap::InverseMap");
    465     check(armap.inverse()[0] == a3, "Wrong RangeIdMap::InverseMap");
    466   }
    467  
    468   // SourceMap, TargetMap, ForwardMap, BackwardMap, InDegMap, OutDegMap
    469   {
    470     typedef ListGraph Graph;
    471     GRAPH_TYPEDEFS(Graph);
    472    
    473     checkConcept<ReadMap<Arc, Node>, SourceMap<Graph> >();
    474     checkConcept<ReadMap<Arc, Node>, TargetMap<Graph> >();
    475     checkConcept<ReadMap<Edge, Arc>, ForwardMap<Graph> >();
    476     checkConcept<ReadMap<Edge, Arc>, BackwardMap<Graph> >();
    477     checkConcept<ReadMap<Node, int>, InDegMap<Graph> >();
    478     checkConcept<ReadMap<Node, int>, OutDegMap<Graph> >();
    479 
    480     Graph gr;
    481     Node n0 = gr.addNode();
    482     Node n1 = gr.addNode();
    483     Node n2 = gr.addNode();
    484    
    485     gr.addEdge(n0,n1);
    486     gr.addEdge(n1,n2);
    487     gr.addEdge(n0,n2);
    488     gr.addEdge(n2,n1);
    489     gr.addEdge(n1,n2);
    490     gr.addEdge(n0,n1);
    491    
    492     for (EdgeIt e(gr); e != INVALID; ++e) {
    493       check(forwardMap(gr)[e] == gr.direct(e, true), "Wrong ForwardMap");
    494       check(backwardMap(gr)[e] == gr.direct(e, false), "Wrong BackwardMap");
    495     }
    496    
    497     compareMap(sourceMap(orienter(gr, constMap<Edge, bool>(true))),
    498                targetMap(orienter(gr, constMap<Edge, bool>(false))),
    499                EdgeIt(gr));
    500 
    501     typedef Orienter<Graph, const ConstMap<Edge, bool> > Digraph;
    502     Digraph dgr(gr, constMap<Edge, bool>(true));
    503     OutDegMap<Digraph> odm(dgr);
    504     InDegMap<Digraph> idm(dgr);
    505    
    506     check(odm[n0] == 3 && odm[n1] == 2 && odm[n2] == 1, "Wrong OutDegMap");
    507     check(idm[n0] == 0 && idm[n1] == 3 && idm[n2] == 3, "Wrong InDegMap");
    508    
    509     gr.addEdge(n2, n0);
    510 
    511     check(odm[n0] == 3 && odm[n1] == 2 && odm[n2] == 2, "Wrong OutDegMap");
    512     check(idm[n0] == 1 && idm[n1] == 3 && idm[n2] == 3, "Wrong InDegMap");
    513   }
    514  
    515   // CrossRefMap
    516   {
    517     typedef ListDigraph Graph;
    518     DIGRAPH_TYPEDEFS(Graph);
    519 
    520     checkConcept<ReadWriteMap<Node, int>,
    521                  CrossRefMap<Graph, Node, int> >();
    522     checkConcept<ReadWriteMap<Node, bool>,
    523                  CrossRefMap<Graph, Node, bool> >();
    524     checkConcept<ReadWriteMap<Node, double>,
    525                  CrossRefMap<Graph, Node, double> >();
    526    
    527     Graph gr;
    528     typedef CrossRefMap<Graph, Node, char> CRMap;
    529     CRMap map(gr);
    530    
    531     Node n0 = gr.addNode();
    532     Node n1 = gr.addNode();
    533     Node n2 = gr.addNode();
    534    
    535     map.set(n0, 'A');
    536     map.set(n1, 'B');
    537     map.set(n2, 'C');
    538    
    539     check(map[n0] == 'A' && map('A') == n0 && map.inverse()['A'] == n0,
    540           "Wrong CrossRefMap");
    541     check(map[n1] == 'B' && map('B') == n1 && map.inverse()['B'] == n1,
    542           "Wrong CrossRefMap");
    543     check(map[n2] == 'C' && map('C') == n2 && map.inverse()['C'] == n2,
    544           "Wrong CrossRefMap");
    545     check(map.count('A') == 1 && map.count('B') == 1 && map.count('C') == 1,
    546           "Wrong CrossRefMap::count()");
    547    
    548     CRMap::ValueIt it = map.beginValue();
    549     check(*it++ == 'A' && *it++ == 'B' && *it++ == 'C' &&
    550           it == map.endValue(), "Wrong value iterator");
    551    
    552     map.set(n2, 'A');
    553 
    554     check(map[n0] == 'A' && map[n1] == 'B' && map[n2] == 'A',
    555           "Wrong CrossRefMap");
    556     check(map('A') == n0 && map.inverse()['A'] == n0, "Wrong CrossRefMap");
    557     check(map('B') == n1 && map.inverse()['B'] == n1, "Wrong CrossRefMap");
    558     check(map('C') == INVALID && map.inverse()['C'] == INVALID,
    559           "Wrong CrossRefMap");
    560     check(map.count('A') == 2 && map.count('B') == 1 && map.count('C') == 0,
    561           "Wrong CrossRefMap::count()");
    562 
    563     it = map.beginValue();
    564     check(*it++ == 'A' && *it++ == 'A' && *it++ == 'B' &&
    565           it == map.endValue(), "Wrong value iterator");
    566 
    567     map.set(n0, 'C');
    568 
    569     check(map[n0] == 'C' && map[n1] == 'B' && map[n2] == 'A',
    570           "Wrong CrossRefMap");
    571     check(map('A') == n2 && map.inverse()['A'] == n2, "Wrong CrossRefMap");
    572     check(map('B') == n1 && map.inverse()['B'] == n1, "Wrong CrossRefMap");
    573     check(map('C') == n0 && map.inverse()['C'] == n0, "Wrong CrossRefMap");
    574     check(map.count('A') == 1 && map.count('B') == 1 && map.count('C') == 1,
    575           "Wrong CrossRefMap::count()");
    576 
    577     it = map.beginValue();
    578     check(*it++ == 'A' && *it++ == 'B' && *it++ == 'C' &&
    579           it == map.endValue(), "Wrong value iterator");
    580351  }
    581352
    … …  
    776547    }
    777548
    778     for (Ivm::ValueIt vit = map1.beginValue();
     549    for (Ivm::ValueIterator vit = map1.beginValue();
    779550         vit != map1.endValue(); ++vit) {
    780551      check(map1[static_cast<Item>(Ivm::ItemIt(map1, *vit))] == *vit,
    781             "Wrong ValueIt");
     552            "Wrong ValueIterator");
    782553    }
    783554
Note: See TracChangeset for help on using the changeset viewer.