// -*- 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