source: lemon-0.x/src/include/skeletons/maps.h @ 283:91e78d9b78f4

// -*- c++ -*-
#ifndef HUGO_MAPSKELETON_H
#define HUGO_MAPSKELETON_H

///\file
///\brief Map concepts checking classes for testing and documenting.

namespace hugo {

  /// The namespace of HUGOlib concepts and concept checking classes
  namespace skeleton {
  
    /// Null map concept
    template<typename K, typename T>
    class NullMap
    {
    public:
      /// Map's key type.
      typedef K KeyType;    
      /// Map's value type. (The type of objects associated with the keys).
      typedef T ValueType;

      /// Facility to define a map with an other value type
      template<typename T1>
      struct rebind {
        /// The type of a map with the given value type
        typedef NullMap<K,T1> other;
      };

      NullMap() {}
    };
    
    /// Readable map concept
    template<typename K, typename T>
    class ReadableMap : public NullMap<K,T>
    {
    public:
      /// Map's key type.
      typedef K KeyType;    
      /// Map's value type. (The type of objects associated with the keys).
      typedef T ValueType;

      /// Returns the value associated with a key.
      ValueType operator[](const KeyType &k) const {return ValueType();}

      /// Copy contsructor. (optional)
      ReadableMap(const ReadableMap&) {}
      /// Assignment operator. (optional)
      ReadableMap& operator=(const ReadableMap&) {return *this;}

      /// Facility to define a map with an other value type (optional)
      template<typename T1>
      struct rebind {
        /// The type of a map with the given value type
        typedef ReadableMap<K,T1> other;
      };
      /// @brief Constructor that copies all keys from the other map and
      /// assigns to them a default value (optional)
      template<typename T1>
      ReadableMap(const ReadableMap<K,T1> &map, const T1 &v) {}

      ReadableMap() {}
    };


    /// Writable map concept
    template<typename K, typename T>
    class WritableMap : public NullMap<K,T>
    {
    public:
      /// Map's key type.
      typedef K KeyType;    
      /// Map's value type. (The type of objects associated with the keys).
      typedef T ValueType;

      /// Sets the value associated with a key.
      void set(const KeyType &k,const ValueType &t) {}

      /// Copy contsructor. (optional)
      WritableMap(const WritableMap&) {}
      /// Assignment operator. (optional)
      WritableMap& operator=(const WritableMap&) {return *this;}

      /// Facility to define a map with an other value type (optional)
      template<typename T1>
      struct rebind {
        /// The type of a map with the given value type
        typedef WritableMap<K,T1> other;
      };
      /// @brief Constructor that copies all keys from the other map and
      /// assigns to them a default value (optional)
      template<typename T1>
      WritableMap(const WritableMap<K,T1> &map, const T1 &v) {}

      WritableMap() {}
    };

    ///Read/Writeable map concept
    template<typename K, typename T>
    class ReadWritableMap : public ReadableMap<K,T>,
                            public WritableMap<K,T>
    {
    public:
      /// Map's key type.
      typedef K KeyType;    
      /// Map's value type. (The type of objects associated with the keys).
      typedef T ValueType;

      /// Returns the value associated with a key.
      ValueType operator[](const KeyType &k) const {return ValueType();}
      /// Sets the value associated with a key.
      void set(const KeyType &k,const ValueType &t) {}

      /// Copy contsructor. (optional)
      ReadWritableMap(const ReadWritableMap&) {}
      /// Assignment operator. (optional)
      ReadWritableMap& operator=(const ReadWritableMap&) {return *this;}

      /// Facility to define a map with an other value type (optional)
      template<typename T1>
      struct rebind {
        /// The type of a map with the given value type
        typedef ReadWritableMap<K,T1> other;
      };
      /// @brief Constructor that copies all keys from the other map and
      /// assigns to them a default value (optional)
      template<typename T1>
      ReadWritableMap(const ReadWritableMap<K,T1> &map, const T1 &v) {}

      ReadWritableMap() {}
    };
  
  
    ///Dereferable map concept
    template<typename K, typename T>
    class DereferableMap : public ReadWritableMap<K,T>
    {
    public:
      /// Map's key type.
      typedef K KeyType;    
      /// Map's value type. (The type of objects associated with the keys).
      typedef T ValueType;
      /// Map's reference type. (Reference to an object associated with a key)
      typedef ValueType& ReferenceType;
      /// Map's const reference type.
      typedef const ValueType& ConstReferenceType;

      ///Returns a reference to the value associated to a key.
      ReferenceType operator[](const KeyType &i);
      ///Returns a const reference to the value associated to a key.
      ConstReferenceType operator[](const KeyType &i) const;
      /// Sets the value associated with a key.
      void set(const KeyType &k,const ValueType &t) { operator[](k)=t; }

      /// Copy contsructor. (optional)
      DereferableMap(const DereferableMap&) {}
      /// Assignment operator. (optional)
      DereferableMap& operator=(const DereferableMap&) {return *this;}

      /// Facility to define a map with an other value type (optional)
      template<typename T1>
      struct rebind {
        /// The type of a map with the given value type
        typedef DereferableMap<K,T1> other;
      };
      /// @brief Constructor that copies all keys from the other map and
      /// assigns to them a default value (optional)
      template<typename T1>
      DereferableMap(const DereferableMap<K,T1> &map, const T1 &v) {}

      DereferableMap() {}
    };


  }
}
#endif // HUGO_MAPSKELETON_H