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