PHAL_TypeKeyMap.hpp

Go to the documentation of this file.

//*****************************************************************//
//    Albany 2.0:  Copyright 2012 Sandia Corporation               //
//    This Software is released under the BSD license detailed     //
//    in the file "license.txt" in the top-level Albany directory  //
//*****************************************************************//
#ifndef PHAL_TYPE_KEY_MAP_HPP
#define PHAL_TYPE_KEY_MAP_HPP

#include "Teuchos_Array.hpp"
#include "Teuchos_any.hpp"

#include "boost/mpl/vector.hpp"
#include "boost/mpl/pair.hpp"
#include "boost/mpl/find_if.hpp"
#include "boost/mpl/size.hpp"
#include "boost/mpl/transform.hpp"
#include "boost/mpl/back_inserter.hpp"
#include "boost/mpl/placeholders.hpp"
#include "boost/type_traits.hpp"

namespace PHAL {


  template <typename TypeMap>
  class TypeKeyMap {

    public:

    template <typename T>
    struct GetObjectTypeAndPos {
      typedef typename boost::mpl::find_if<
  TypeMap, 
  boost::is_same<boost::mpl::first<boost::mpl::placeholders::_1>, T >
  >::type Iter;
      typedef typename boost::mpl::deref<Iter>::type Pair;
      typedef typename boost::mpl::second<Pair>::type type;
      typedef typename Iter::pos pos;
      static const int value = pos::value;
    };

    template <typename T>
    struct GetObjectRefType {
      typedef typename GetObjectTypeAndPos<T>::type object_type;
      typedef typename boost::add_reference<object_type>::type type;
    };

    template <typename T>
    struct GetObjectConstRefType {
      typedef typename GetObjectTypeAndPos<T>::type object_type;
      typedef typename boost::add_const<object_type>::type const_type;
      typedef typename boost::add_reference<const_type>::type type;
    };

    typedef Teuchos::Array<Teuchos::any> container;

    typedef typename container::iterator iterator;

    typedef typename container::const_iterator const_iterator;

    TypeKeyMap() : objects(boost::mpl::size<TypeMap>::value) {}

    ~TypeKeyMap() {}

    template<typename T> typename GetObjectRefType<T>::type 
    getValue() {
      typedef typename GetObjectTypeAndPos<T>::type type;
      const int pos = GetObjectTypeAndPos<T>::value;
      return Teuchos::any_cast<type>(objects[pos]);
    }

    template<typename T> typename GetObjectConstRefType<T>::type 
    getValue() const {
      typedef typename GetObjectTypeAndPos<T>::type type;
      const int pos = GetObjectTypeAndPos<T>::value;
      return Teuchos::any_cast<type>(objects[pos]);
    }

    template <typename T> 
    void setValue(typename GetObjectConstRefType<T>::type x) {
      const int pos = GetObjectTypeAndPos<T>::value;
      objects[pos] = x;
    }

    iterator begin() { return iterator(objects.begin()); }

    const_iterator begin() const { return iterator(objects.begin()); }

    iterator end() { return iterator(objects.end()); }

    const_iterator end() const { return iterator(objects.end()); }

  private:

    container objects;

  };

  template <typename KeySeq, typename ElemSeq> 
  struct ZipMap {
    
    // Create pair<T1,T2>
    struct CreatePair {
      template <typename T1, typename T2> struct apply {
  typedef boost::mpl::pair<T1,T2> type;
      };
    };

    typedef typename 
    boost::mpl::transform< 
      KeySeq, 
      ElemSeq, 
      CreatePair,
      boost::mpl::back_inserter< boost::mpl::vector<> > >::type type;
  };

  template <typename KeySeq, typename F> 
  struct CreateLambdaKeyMap {
    typedef typename boost::mpl::transform<KeySeq, F>::type ElemSeq;
    typedef typename ZipMap<KeySeq,ElemSeq>::type type;
  };

}

#endif