AnnotatedPointer.h

#pragma once
 
#include <tuple>
 
namespace knowCore
{
  namespace details
  {
    template<typename _T_, typename... _TOther_>
    struct make_default
    {
      static std::tuple<typename _T_::Type, typename _TOther_::Type...> create()
      {
        return std::tuple_cat(std::tuple<typename _T_::Type>(_T_::Default),
                              make_default<_TOther_...>::create());
      }
    };
    template<typename _T_>
    struct make_default<_T_>
    {
      static std::tuple<typename _T_::Type> create()
      {
        return std::tuple<typename _T_::Type>(_T_::Default);
      }
    };
  } // namespace details
  template<typename _T_, _T_ _default_>
  struct PointerAnnotation
  {
    typedef _T_ Type;
    static constexpr _T_ Default = _default_;
  };
  template<typename _T_, typename... _Annotation_>
  class AnnotatedPointer
  {
    typedef std::tuple<typename _Annotation_::Type...> AnnotationsT;
  public:
    AnnotatedPointer(_T_* _t, typename _Annotation_::Type... _annotations)
        : t(_t), m_annotations(_annotations...)
    {
    }
    AnnotatedPointer(_T_* _t)
        : t(_t), m_annotations(details::make_default<_Annotation_...>::create())
    {
    }
    _T_* pointer() { return t; }
    _T_* operator*() { return t; }
    const _T_* operator*() const { return t; }
    std::tuple<typename _Annotation_::Type...> annotations() const { return m_annotations; }
    template<int _index_>
    std::tuple_element_t<_index_, AnnotationsT> get() const
    {
      return std::get<_index_>(m_annotations);
    }
  public:
  private:
    _T_* t;
    AnnotationsT m_annotations;
  };
} // namespace knowCore