#include <lemon/concept_check.h>

     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;

     };