/* -*- 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 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();}

       ///Default constructor

       ReadMap() {}

     };

     /// Writable map concept

     template<typename K, typename T>

     class WriteMap

     {

     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) {}

       ///Default constructor

       WriteMap() {}

     };

     ///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 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) {}

       ///Default constructor

       ReadWriteMap() {}

     };

     ///Dereferable map concept

     template<typename K, typename T>

     class ReferenceMap : public ReadWriteMap<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;

     protected:

       ValueType tmp;

     public:

       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) { return tmp; }

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

       ConstReferenceType operator[](const KeyType &i) const

       { return tmp; }

       /// Sets the value associated with a key.

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

       ///Default constructor

       ReferenceMap() {}

     };

     template<typename Item, typename T, typename Graph>

     class GraphMap : public ReadWriteMap<Item, T> {

       // I really, really don't like the idea that every graph should have

       // reference maps! --klao

     private:

       // We state explicitly that graph maps have no default constructor?

       GraphMap();

     public:

       explicit GraphMap(Graph const&) {}

       // value for initializing

       GraphMap(Graph const&, T) {}

       // this probably should be required:

       GraphMap(GraphMap const&) {}

       GraphMap& operator=(GraphMap const&) { return *this; }

       // but this is a absolute no-op! We should provide a more generic

       // graph-map-copy operation.

       //

       // template<typename TT>

       // GraphMap(GraphMap<TT> const&);

       //

       // template<typename TT>

       // GraphMap& operator=(const GraphMap<TT>&);

     };

     /****************  Concept-checking classes  ****************/

     template<typename ReadMap>

     struct ReadMapConcept {

       typedef typename ReadMap::KeyType KeyType;

       typedef typename ReadMap::ValueType ValueType;

       void constraints() {

 	// No constraints for constructor.

 	// What are the requirement for the ValueType?

 	// CopyConstructible? Assignable? None of these?

 	ValueType v = m[k];

 	v = m[k];

 	// FIXME:

 	ignore_unused_variable_warning(v);

       }

       ReadMap m;

       KeyType k;

     };

     template<typename WriteMap>

     struct WriteMapConcept {

       typedef typename WriteMap::KeyType KeyType;

       typedef typename WriteMap::ValueType ValueType;

       void constraints() {

 	// No constraints for constructor.

 	m.set(k, v);

       }

       WriteMap m;

       KeyType k;

       ValueType v;

     };

     template<typename ReadWriteMap>

     struct ReadWriteMapConcept {

       void constraints() {

 	function_requires< ReadMapConcept<ReadWriteMap> >();

 	function_requires< WriteMapConcept<ReadWriteMap> >();

       }

     };

     template<typename ReferenceMap>

     struct ReferenceMapConcept {

       typedef typename ReferenceMap::KeyType KeyType;

       typedef typename ReferenceMap::ValueType ValueType;

       typedef typename ReferenceMap::ReferenceType ReferenceType;

       // What for is this?

       typedef typename ReferenceMap::ConstReferenceType ConstReferenceType;

       void constraints() {

 	function_requires< ReadWriteMapConcept<ReferenceMap> >();

 	m[k] = v;

 	// Or should we require real reference?

 	// Like this:

 	// ValueType &vv = m[k];

 	// ignore_unused_variable_warning(vv);

       }

       ReferenceMap m;

       KeyType k;

       ValueType v;

     };

     /// \todo GraphMapConceptCheck

     template<typename GraphMap, typename Graph>

     struct GraphMapConcept {

       void constraints() {

 	function_requires< ReadWriteMapConcept<GraphMap> >();

 	// Construction with a graph parameter

 	GraphMap a(g);

 	// Ctor with a graph and a default value parameter

 	GraphMap a2(g,t);

 	// Copy ctor. Do we need it?

 	GraphMap b=c;

 	// Copy operator. Do we need it?

 	a=b;

 	ignore_unused_variable_warning(a2);

       }

       const GraphMap &c;

       const Graph &g;

       const typename GraphMap::ValueType &t;

     };

     // @}

   } //namespace concept

 } //namespace lemon

 #endif // LEMON_CONCEPT_MAPS_H