propertymap.hh

Go to the documentation of this file.

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
// SPDX-FileCopyrightInfo: Copyright © 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