RhodeCode

  class StdMap : public MapBase<K, T> {

    typedef MapBase<K, T> Parent;

    typedef typename Parent::Key Key;

    typedef typename Parent::Value Value;

    typedef True ReferenceMapTag;

  ///Returns a \ref StdMap class

  ///This function just returns a \ref StdMap class with specified 

  ///default value.

  ///\relates StdMap

  template<typename K, typename V, typename Compare = std::less<K> > 

  inline StdMap<K, V, Compare> stdMap(const V& value = V()) {

    return StdMap<K, V, Compare>(value);

  }

  ///Returns a \ref StdMap class created from an appropriate std::map

  ///This function just returns a \ref StdMap class created from an 

  ///appropriate std::map.

  ///\relates StdMap

  template<typename K, typename V, typename Compare = std::less<K> > 

  inline StdMap<K, V, Compare> stdMap( const std::map<K, V, Compare> &map, 

                                       const V& value = V() ) {

    return StdMap<K, V, Compare>(map, value);

  }

  class IntegerMap : public MapBase<int, T> {

    typedef MapBase<int, T> Parent;

    typedef typename Parent::Key Key;

    typedef typename Parent::Value Value;

    typedef True ReferenceMapTag;

  ///Returns an \ref IntegerMap class

  ///This function just returns an \ref IntegerMap class.

  ///\relates IntegerMap

  template<typename T>

  inline IntegerMap<T> integerMap(int size = 0, const T& value = T()) {

    return IntegerMap<T>(size, value);

  }

  ///Returns a \ref SimpleMap class

  ///This function just returns a \ref SimpleMap class.

  ///\relates SimpleMap

  template<typename M>

  inline SimpleMap<M> simpleMap(const M &m) {

    return SimpleMap<M>(m);

  }

  ///Returns a \ref SimpleWriteMap class

  ///This function just returns a \ref SimpleWriteMap class.

  ///\relates SimpleWriteMap

  template<typename M>

  inline SimpleWriteMap<M> simpleWriteMap(M &m) {

    return SimpleWriteMap<M>(m);

  }