/* -*- C++ -*-

 * src/lemon/concept/maps.h - Part of LEMON, a generic C++ optimization library

 *

 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

 * (Egervary Combinatorial Optimization Research Group, EGRES).

 *

 * Permission to use, modify and distribute this software is granted

 * provided that this copyright notice appears in all copies. For

 * precise terms see the accompanying LICENSE file.

 *

 * This software is provided "AS IS" with no warranty of any kind,

 * express or implied, and with no claim as to its suitability for any

 * purpose.

 *

 */

#ifndef LEMON_CONCEPT_MAPS_H

#define LEMON_CONCEPT_MAPS_H

#include <lemon/concept_check.h>

///\ingroup concept

///\file

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

namespace lemon {

  namespace concept {

    /// \addtogroup concept

    /// @{

    /// Readable map concept

    template<typename K, typename T>

    class ReadMap

    {

    public:

      /// Map's key type.

      typedef K Key;    

      /// Map's value type. (The type of objects associated with the keys).

      typedef T Value;

      // \bug Value don't need to be default constructible.

      /// Returns the value associated with a key.

      Value operator[](const Key &) const {return Value();}

      template<typename _ReadMap>

      struct Constraints {

	void constraints() {

	  Value val = m[key];

	  val = m[key];

	  typename _ReadMap::Value own_val = m[own_key]; 

	  own_val = m[own_key]; 

	  ignore_unused_variable_warning(val);

	  ignore_unused_variable_warning(own_val);

	  ignore_unused_variable_warning(key);

	}

	Key& key;

	typename _ReadMap::Key& own_key;

	_ReadMap& m;

      };

    };

    /// Writable map concept

    template<typename K, typename T>

    class WriteMap

    {

    public:

      /// Map's key type.

      typedef K Key;    

      /// Map's value type. (The type of objects associated with the keys).

      typedef T Value;

      /// Sets the value associated with a key.

      void set(const Key &k,const Value &t) {}

      ///Default constructor

      WriteMap() {}

      template <typename _WriteMap>

      struct Constraints {

	void constraints() {

	  // No constraints for constructor.

	  m.set(key, val);

	  m.set(own_key, own_val);

	  ignore_unused_variable(key);

	  ignore_unused_variable(val);

	  ignore_unused_variable(own_key);

	  ignore_unused_variable(own_val);

	}

	Value& val;

	typename _WriteMap::Value own_val;

	Key& key;

	typename _WriteMap::Key& own_key;

	WriteMap& m;

      };

    };

    ///Read/Writable map concept

    template<typename K, typename T>

    class ReadWriteMap : public ReadMap<K,T>,

			    public WriteMap<K,T>

    {

    public:

      /// Map's key type.

      typedef K Key;    

      /// Map's value type. (The type of objects associated with the keys).

      typedef T Value;

      /// Returns the value associated with a key.

      Value operator[](const Key &k) const {return Value();}

      /// Sets the value associated with a key.

      void set(const Key &k,const Value &t) {}

      template<typename _ReadWriteMap>

      struct Constraints {

	void constraints() {

	  checkConcept<ReadMap<K, T>, _ReadWriteMap >();

	  checkConcept<ReadMap<K, T>, _ReadWriteMap >();

	}

      };

    };

    ///Dereferable map concept

    template<typename K, typename T, typename R, typename CR>

    class ReferenceMap : public ReadWriteMap<K,T>

    {

    public:

      /// Map's key type.

      typedef K Key;    

      /// Map's value type. (The type of objects associated with the keys).

      typedef T Value;

      /// Map's reference type.

      typedef R Reference;

      /// Map's const reference type.

      typedef CR ConstReference;

    protected:

      Value tmp;

    public:

      ///Returns a reference to the value associated to a key.

      Reference operator[](const Key &i) { return tmp; }

      ///Returns a const reference to the value associated to a key.

      ConstReference operator[](const Key &i) const

      { return tmp; }

      /// Sets the value associated with a key.

      void set(const Key &k,const Value &t) { operator[](k)=t; }

      // \todo rethink this concept

      template<typename _ReferenceMap>

      struct ReferenceMapConcept {

	void constraints() {

	  checkConcept<ReadWriteMap, _ReferenceMap >();

	  m[key] = val;

	  val  = m[key];

	  m[key] = ref;

	  ref = m[key];

	  m[own_key] = own_val;

	  own_val  = m[own_key];

	  m[own_key] = own_ref;

	  own_ref = m[own_key];	  	  

	}

	typename _ReferenceMap::Key& own_key;

	typename _ReferenceMap::Value& own_val;

	typename _ReferenceMap::Reference& own_ref;

	Key& key;

	Value& val;

	Reference& ref;

	ReferenceMap& m;

      };

    };

    // @}

  } //namespace concept

} //namespace lemon

#endif // LEMON_CONCEPT_MAPS_H