propertymap.hh

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
// SPDX-FileCopyrightInfo: Copyright (C) DUNE Project contributors, see file LICENSE.md in module root
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
#ifndef DUNE_PROPERTYMAP_HH
#define DUNE_PROPERTYMAP_HH
 
#include <cstddef>
#include <iterator>
#include <type_traits>
 
namespace Dune
{
 
  template<class PM>
  struct PropertyMapTraits
  {
    typedef typename PM::KeyType KeyType;
    typedef typename PM::ValueType ValueType;
    typedef typename PM::Reference Reference;
    typedef typename PM::Category Category;
  };
 
  struct ReadablePropertyMapTag
  {};
 
  struct WritablePropertyMapTag
  {};
 
  struct ReadWritePropertyMapTag
    : public ReadablePropertyMapTag, public WritablePropertyMapTag
  {};
 
  struct LvaluePropertyMapTag
    : public ReadWritePropertyMapTag
  {};
 
  template<class T>
  struct PropertyMapTraits<T*>
  {
    typedef T ValueType;
    typedef ValueType& Reference;
    typedef std::ptrdiff_t KeyType;
    typedef LvaluePropertyMapTag Category;
  };
 
 
  template<class T>
  struct PropertyMapTraits<const T*>
  {
    typedef T ValueType;
    typedef const ValueType& Reference;
    typedef std::ptrdiff_t KeyType;
    typedef LvaluePropertyMapTag Category;
  };
 
  template<class Reference, class PropertyMap>
  struct RAPropertyMapHelper
  {};
 
  template<class Reference, class PropertyMap, class Key>
  inline Reference
  get(const RAPropertyMapHelper<Reference,PropertyMap>& pmap,
      const Key& key)
  {
    return static_cast<const PropertyMap&>(pmap)[key];
  }
 
  template<class Reference, class PropertyMap, class Key, class Value>
  inline void
  put(const RAPropertyMapHelper<Reference,PropertyMap>& pmap,
      const Key& key, const Value& value)
  {
    static_assert(std::is_convertible<typename PropertyMap::Category,WritablePropertyMapTag>::value,
                  "WritablePropertyMapTag required!");
    static_cast<const PropertyMap&>(pmap)[key] = value;
  }
 
  template<class RAI, class IM,
      class T = typename std::iterator_traits<RAI>::value_type,
      class R = typename std::iterator_traits<RAI>::reference>
  class IteratorPropertyMap
    : public RAPropertyMapHelper<R,IteratorPropertyMap<RAI,IM,T,R> >
  {
  public:
    typedef RAI RandomAccessIterator;
 
    typedef IM IndexMap;
 
    typedef typename IndexMap::KeyType KeyType;
 
    typedef T ValueType;
 
    typedef R Reference;
 
    typedef LvaluePropertyMapTag Category;
 
    inline IteratorPropertyMap(RandomAccessIterator iter,
                               const IndexMap& im=IndexMap())
      : iter_(iter), indexMap_(im)
    {}
 
    inline IteratorPropertyMap()
      : iter_(), indexMap_()
    {}
 
    inline Reference operator[](KeyType key) const
    {
      return *(iter_ + get(indexMap_, key));
    }
 
  private:
    RandomAccessIterator iter_;
    IndexMap indexMap_;
  };
 
  template<typename T>
  class AssociativePropertyMap
    : RAPropertyMapHelper<typename T::value_type::second_type&,
          AssociativePropertyMap<T> >
  {
    typedef T UniqueAssociativeContainer;
 
    typedef typename UniqueAssociativeContainer::value_type::first_type
    KeyType;
 
    typedef typename UniqueAssociativeContainer::value_type::second_type
    ValueType;
 
    typedef ValueType& Reference;
 
    typedef LvaluePropertyMapTag Category;
 
    inline AssociativePropertyMap()
      : map_(0)
    {}
 
    inline AssociativePropertyMap(UniqueAssociativeContainer& map)
      : map_(&map)
    {}
 
    inline Reference operator[](KeyType key) const
    {
      return map_->find(key)->second;
    }
  private:
    UniqueAssociativeContainer* map_;
  };
 
  template<typename T>
  class ConstAssociativePropertyMap
    : RAPropertyMapHelper<const typename T::value_type::second_type&,
          ConstAssociativePropertyMap<T> >
  {
    typedef T UniqueAssociativeContainer;
 
    typedef typename UniqueAssociativeContainer::value_type::first_type
    KeyType;
 
    typedef typename UniqueAssociativeContainer::value_type::second_type
    ValueType;
 
    typedef const ValueType& Reference;
 
    typedef LvaluePropertyMapTag Category;
 
    inline ConstAssociativePropertyMap()
      : map_(0)
    {}
 
    inline ConstAssociativePropertyMap(const UniqueAssociativeContainer& map)
      : map_(&map)
    {}
 
    inline Reference operator[](KeyType key) const
    {
      return map_->find(key)->second;
    }
  private:
    const UniqueAssociativeContainer* map_;
  };
 
  struct IdentityMap
    : public RAPropertyMapHelper<std::size_t, IdentityMap>
  {
    typedef std::size_t KeyType;
 
    typedef std::size_t ValueType;
 
    typedef std::size_t Reference;
 
    typedef ReadablePropertyMapTag Category;
 
    inline ValueType operator[](const KeyType& key) const
    {
      return key;
    }
  };
 
 
  template<typename T, typename C>
  struct PropertyMapTypeSelector
  {
    typedef T Tag;
    typedef C Container;
  };
 
}
 
#endif