source: lemon-0.x/src/lemon/concept/maps.h @ 959:c80ef5912903

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