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);
      }
    };
  }
  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;
  };
}