Dereference.h

Go to the documentation of this file.

#ifndef LARDATA_UTILITIES_DEREFERENCE_H
#define LARDATA_UTILITIES_DEREFERENCE_H 1

// C/C++ standard libraries
#include <type_traits>

namespace lar {
  namespace util {
    namespace details {
      
      
      template <typename T>
      struct is_type: public std::true_type {};
      
      

      template <typename T, typename Enable = void>
      struct has_dereference_class: public std::false_type {};
      
      template <typename T>
      struct has_dereference_class<
        T,
        typename std::enable_if<is_type<decltype(*(T()))>::value, void>::type
        >:
        public std::true_type
      {};
      
      

      template <typename T, bool CanDereference>
      struct dereferenced_type {
      //  using type = typename std::add_lvalue_reference<T>::type;
        using type = T;
      }; // dereferenced_type <>
      
      template <typename T>
      struct dereferenced_type<T, true> {
        using type = decltype(*T());
      }; // dereferenced_type<T, true>
      
      
      

      template <typename T, bool CanDereference>
      struct dereference_class {
        using argument_type = T;
        using reference_type = typename std::add_lvalue_reference
          <typename dereferenced_type<T, CanDereference>::type>::type;
        
        reference_type operator() (argument_type& ref) const { return ref; }
      }; // dereference_class<T, bool>
      
      
      template <typename T>
      struct dereference_class<T, true> {
        using argument_type = T;
        using reference_type = typename std::add_lvalue_reference
          <typename dereferenced_type<T, true>::type>::type;
        
        reference_type operator() (argument_type& ref) const { return *ref; }
      }; // dereference_class<T, true>
      
      

      template <typename T, bool CanDereference>
      struct make_pointer_class {
        using argument_type = T;
        using pointer_type = typename std::add_pointer
          <typename dereferenced_type<T, CanDereference>::type>::type;
        
        pointer_type operator() (argument_type& ref) const { return &ref; }
      }; // make_pointer_class<T, bool>
      
      
      template <typename T>
      struct make_pointer_class<T, true> {
        using argument_type = T;
        using pointer_type = typename std::add_pointer
          <typename dereferenced_type<T, true>::type>::type;
        
        pointer_type operator() (argument_type& ref) const { return &*ref; }
      }; // make_pointer_class<T, true>
      
    } // namespace details
    
    
    template <typename T>
    struct dereferenced_type: public 
      details::dereferenced_type<T, details::has_dereference_class<T>::value>
    {};
    
    
    template <typename T>
    inline 
    typename details::dereference_class
      <T, details::has_dereference_class<T>::value>::reference_type
    dereference(T& v)
      {
        return details::dereference_class
          <T, details::has_dereference_class<T>::value>()(v);
      }
    
    template <typename T>
    inline 
    typename details::make_pointer_class
      <T, details::has_dereference_class<T>::value>::pointer_type
    make_pointer(T& v)
      {
        return details::make_pointer_class
          <T, details::has_dereference_class<T>::value>()(v);
      }
    
  } // namespace util

} // namespace lar

#endif // LARDATA_UTILITIES_DEREFERENCE_H