LEMON/LEMON-official Changeset - r769:b52189c479fb

@@ -58,3 +58,3 @@

58

  /// <tt>/dev/null</tt>).

59

  /// It conforms the \ref concepts::ReadWriteMap "ReadWriteMap" concept.

59

  /// It conforms to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.

60

///

...

@@ -91,3 +91,3 @@

91

  /// In other aspects it is equivalent to \c NullMap.

92

  /// So it conforms the \ref concepts::ReadWriteMap "ReadWriteMap"

92

  /// So it conforms to the \ref concepts::ReadWriteMap "ReadWriteMap"

93

  /// concept, but it absorbs the data written to it.

...

@@ -160,3 +160,3 @@

160

  /// In other aspects it is equivalent to \c NullMap.

161

  /// So it conforms the \ref concepts::ReadWriteMap "ReadWriteMap"

161

  /// So it conforms to the \ref concepts::ReadWriteMap "ReadWriteMap"

162

  /// concept, but it absorbs the data written to it.

...

@@ -234,3 +234,3 @@

234

  /// \c UnionFind, \c BinHeap, when the used items are small

235

  /// integers. This map conforms the \ref concepts::ReferenceMap

235

  /// integers. This map conforms to the \ref concepts::ReferenceMap

236

  /// "ReferenceMap" concept.

...

@@ -342,3 +342,3 @@

342

  /// contructed value (i.e. \c %Value()).

343

  /// This type conforms the \ref concepts::ReferenceMap "ReferenceMap"

343

  /// This type conforms to the \ref concepts::ReferenceMap "ReferenceMap"

344

  /// concept.

...

@@ -708,3 +708,3 @@

708

  /// type is \c V.

709

  /// This type conforms the \ref concepts::ReadMap "ReadMap" concept.

709

  /// This type conforms to the \ref concepts::ReadMap "ReadMap" concept.

710

///

...

@@ -1867,5 +1867,7 @@

1867

1868

    /// \brief This class represents the inverse of its owner (IdMap).

1868

    /// \brief The inverse map type of IdMap.

1869

///

1870

    /// This class represents the inverse of its owner (IdMap).

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.

1871

1873

    /// \see inverse()

...

@@ -1884,5 +1886,5 @@

1884

1886

1885

      /// \brief Gives back the given item from its id.

1887

      /// \brief Gives back an item by its id.

1886

1888

///

1887

      /// Gives back the given item from its id.

1889

      /// Gives back an item by its id.

1888

1890

      Item operator[](int id) const { return _graph->fromId(id, Item());}

...

@@ -1905,4 +1907,13 @@

1905

1907

  /// and if a key is set to a new value, then stores it in the inverse map.

1906

  /// The values of the map can be accessed

1907

  /// with stl compatible forward iterator.

1908

  /// The graph items can be accessed by their values either using

1909

  /// \c InverseMap or \c operator()(), and the values of the map can be

1910

  /// accessed with an STL compatible forward iterator (\c ValueIterator).

1911

///

1912

  /// This map is intended to be used when all associated values are

1913

  /// different (the map is actually invertable) or there are only a few

1914

  /// items with the same value.

1915

  /// Otherwise consider to use \c IterableValueMap, which is more

1916

  /// suitable and more efficient for such cases. It provides iterators

1917

  /// to traverse the items with the same associated value, however

1918

  /// it does not have \c InverseMap.

1908

1919

///

...

@@ -1947,3 +1958,3 @@

1947

1958

///

1948

    /// This iterator is an stl compatible forward

1959

    /// This iterator is an STL compatible forward

1949

1960

    /// iterator on the values of the map. The values can

...

@@ -1960,5 +1971,8 @@

1960

1971

1972

      /// Constructor

1961

1973

      ValueIterator() {}

1962

1974

1975

      /// \e

1963

1976

      ValueIterator& operator++() { ++it; return *this; }

1977

      /// \e

1964

1978

      ValueIterator operator++(int) {

...

@@ -1969,6 +1983,10 @@

1969

1983

1984

      /// \e

1970

1985

      const Value& operator*() const { return it->first; }

1986

      /// \e

1971

1987

      const Value* operator->() const { return &(it->first); }

1972

1988

1989

      /// \e

1973

1990

      bool operator==(ValueIterator jt) const { return it == jt.it; }

1991

      /// \e

1974

1992

      bool operator!=(ValueIterator jt) const { return it != jt.it; }

...

@@ -1981,3 +1999,3 @@

1981

1999

///

1982

    /// Returns an stl compatible iterator to the

2000

    /// Returns an STL compatible iterator to the

1983

2001

    /// first value of the map. The values of the

...

@@ -1991,3 +2009,3 @@

1991

2009

///

1992

    /// Returns an stl compatible iterator after the

2010

    /// Returns an STL compatible iterator after the

1993

2011

    /// last value of the map. The values of the

...

@@ -2092,6 +2110,8 @@

2092

2110

2093

    /// \brief The inverse map type.

2111

    /// \brief The inverse map type of CrossRefMap.

2094

2112

///

2095

    /// The inverse of this map. The subscript operator of the map

2096

    /// gives back the item that was last assigned to the value.

2113

    /// The inverse map type of CrossRefMap. The subscript operator gives

2114

    /// back an item by its value.

2115

    /// This type conforms to the \ref concepts::ReadMap "ReadMap" concept.

2116

    /// \see inverse()

2097

2117

    class InverseMap {

...

@@ -2122,5 +2142,5 @@

2122

2142

2123

    /// \brief It gives back the read-only inverse map.

2143

    /// \brief Gives back the inverse of the map.

2124

2144

///

2125

    /// It gives back the read-only inverse map.

2145

    /// Gives back the inverse of the CrossRefMap.

2126

2146

    InverseMap inverse() const {

...

@@ -2274,5 +2294,5 @@

2274

2294

2275

    /// \brief Gives back the \e RangeId of the item

2295

    /// \brief Gives back the \e range \e id of the item

2276

2296

///

2277

    /// Gives back the \e RangeId of the item.

2297

    /// Gives back the \e range \e id of the item.

2278

2298

    int operator[](const Item& item) const {

...

@@ -2281,5 +2301,5 @@

2281

2301

2282

    /// \brief Gives back the item belonging to a \e RangeId

2302

    /// \brief Gives back the item belonging to a \e range \e id

2283

2303

///

2284

    /// Gives back the item belonging to a \e RangeId.

2304

    /// Gives back the item belonging to the given \e range \e id.

2285

2305

    Item operator()(int id) const {

...

@@ -2297,3 +2317,5 @@

2297

2317

///

2298

    /// The inverse map type of RangeIdMap.

2318

    /// The inverse map type of RangeIdMap. The subscript operator gives

2319

    /// back an item by its \e range \e id.

2320

    /// This type conforms to the \ref concepts::ReadMap "ReadMap" concept.

2299

2321

    class InverseMap {

...

@@ -2315,3 +2337,3 @@

2315

2337

      /// Subscript operator. It gives back the item

2316

      /// that the descriptor currently belongs to.

2338

      /// that the given \e range \e id currently belongs to.

2317

2339

      Value operator[](const Key& key) const {

...

@@ -2333,3 +2355,3 @@

2333

2355

///

2334

    /// Gives back the inverse of the map.

2356

    /// Gives back the inverse of the RangeIdMap.

2335

2357

    const InverseMap inverse() const {

...

@@ -2344,6 +2366,6 @@

2344

2366

  /// For both \c true and \c false values it is possible to iterate on

2345

  /// the keys.

2367

  /// the keys mapped to the value.

2346

2368

///

2347

2369

  /// This type is a reference map, so it can be modified with the

2348

  /// subscription operator.

2370

  /// subscript operator.

2349

2371

///

...

@@ -2713,4 +2735,9 @@

2713

2735

///

2736

  /// This map is intended to be used with small integer values, for which

2737

  /// it is efficient, and supports iteration only for non-negative values.

2738

  /// If you need large values and/or iteration for negative integers,

2739

  /// consider to use \ref IterableValueMap instead.

2740

///

2714

2741

  /// This type is a reference map, so it can be modified with the

2715

  /// subscription operator.

2742

  /// subscript operator.

2716

2743

///

...

@@ -2994,14 +3021,16 @@

2994

3021

///

2995

  /// This class provides a special graph map type which can store an

3022

  /// This class provides a special graph map type which can store a

2996

3023

  /// comparable value for graph items (\c Node, \c Arc or \c Edge).

2997

3024

  /// For each value it is possible to iterate on the keys mapped to

2998

  /// the value.

3025

  /// the value (\c ItemIt), and the values of the map can be accessed

3026

  /// with an STL compatible forward iterator (\c ValueIterator).

3027

  /// The map stores a linked list for each value, which contains

3028

  /// the items mapped to the value, and the used values are stored

3029

  /// in balanced binary tree (\c std::map).

2999

3030

///

3000

  /// The map stores for each value a linked list with

3001

  /// the items which mapped to the value, and the values are stored

3002

  /// in balanced binary tree. The values of the map can be accessed

3003

  /// with stl compatible forward iterator.

3031

  /// \ref IterableBoolMap and \ref IterableIntMap are similar classes

3032

  /// specialized for \c bool and \c int values, respectively.

3004

3033

///

3005

3034

  /// This type is not reference map, so it cannot be modified with

3006

  /// the subscription operator.

3035

  /// the subscript operator.

3007

3036

///

...

@@ -3081,3 +3110,3 @@

3081

3110

///

3082

    /// This iterator is an stl compatible forward

3111

    /// This iterator is an STL compatible forward

3083

3112

    /// iterator on the values of the map. The values can

...

@@ -3092,5 +3121,8 @@

3092

3121

3122

      /// Constructor

3093

3123

      ValueIterator() {}

3094

3124

3125

      /// \e

3095

3126

      ValueIterator& operator++() { ++it; return *this; }

3127

      /// \e

3096

3128

      ValueIterator operator++(int) {

...

@@ -3101,6 +3133,10 @@

3101

3133

3134

      /// \e

3102

3135

      const Value& operator*() const { return it->first; }

3136

      /// \e

3103

3137

      const Value* operator->() const { return &(it->first); }

3104

3138

3139

      /// \e

3105

3140

      bool operator==(ValueIterator jt) const { return it == jt.it; }

3141

      /// \e

3106

3142

      bool operator!=(ValueIterator jt) const { return it != jt.it; }

...

@@ -3113,3 +3149,3 @@

3113

3149

///

3114

    /// Returns an stl compatible iterator to the

3150

    /// Returns an STL compatible iterator to the

3115

3151

    /// first value of the map. The values of the

...

@@ -3123,3 +3159,3 @@

3123

3159

///

3124

    /// Returns an stl compatible iterator after the

3160

    /// Returns an STL compatible iterator after the

3125

3161

    /// last value of the map. The values of the

RhodeCode

Login to your account