hetero-data.hpp

Go to the documentation of this file.

/*
  HETERO-DATA.hpp  -  handle chain of heterogeneous data blocks
 
   Copyright (C)
     2024,            Hermann Vosseler <Ichthyostega@web.de>
 
 **Lumiera** is free software; you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by the
 Free Software Foundation; either version 2 of the License, or (at your
 option) any later version. See the file COPYING for further details.
 
*/
 
 
#ifndef LIB_HETERO_DATA_H
#define LIB_HETERO_DATA_H
 
 
#include "lib/error.hpp"
#include "lib/nocopy.hpp"
#include "lib/meta/typelist.hpp"
#include "lib/meta/typelist-manip.hpp"
#include "lib/meta/typelist-util.hpp"
#include "lib/meta/typeseq-util.hpp"
 
#include <utility>
#include <tuple>
 
 
namespace lib {
  
  template<typename...DATA>
  class HeteroData;
  
  struct StorageLoc
    : util::NonCopyable
    {
      StorageLoc* next{nullptr};
    };
  
  template<size_t seg, typename...DATA>
  struct StorageFrame
    : protected StorageLoc
    , std::tuple<DATA...>
    {
      using Tuple = std::tuple<DATA...>;
      
      using Tuple::tuple;
      
      template<typename SPEC>
      void linkInto (HeteroData<SPEC>&);
      template<typename SPEC>
      void detachFrom (HeteroData<SPEC>&);
      
      template<size_t slot> auto& get() noexcept { return std::get<slot>(*this); }
      template<typename X>  auto& get() noexcept { return std::get<X>(*this);    }
    };
  
  
  template<size_t seg, typename...DATA, class TAIL>
  class HeteroData<meta::Node<StorageFrame<seg, DATA...>,TAIL>>
    : StorageFrame<seg, DATA...>
    {
      using _Self = HeteroData;
      using _Tail = HeteroData<TAIL>;
      using Tuple = std::tuple<DATA...>;
      using Frame = StorageFrame<seg, DATA...>;
      
      static constexpr size_t localSiz = sizeof...(DATA);
      
      template<size_t slot>
      static constexpr bool isLocal = slot < localSiz;
      
      template<size_t slot>
      using PickType = std::conditional_t<isLocal<slot>, std::tuple_element<slot,Tuple>
                                                       , typename _Tail::template PickType<slot-localSiz>>;
                                                      // need to use this helper to prevent eager evaluation on Elm_t<i>
      _Tail&
      accessTail()
        {
          if (Frame::next == nullptr) // Halt system by breaking noexcept
            throw lumiera::error::Fatal{"HeteroData storage logic broken: follow-up extent not(yet) allocated"};
          return * reinterpret_cast<_Tail*> (Frame::next);
        }
      
      template<typename...SPEC>
      static _Self&
      recast (HeteroData<SPEC...>& frontChain)
        {
          return reinterpret_cast<_Self&> (frontChain);
        }
      template<typename...SPEC>
      static _Self const&
      recast (HeteroData<SPEC...> const& frontChain)
        {
          return reinterpret_cast<_Self const&> (frontChain);
        }
      
      
      template<typename...XX>
      friend class HeteroData;  
      
      using Frame::Frame;       
      
      
    public:
      HeteroData() = default;
      
      static constexpr size_t
      size()
        {
          return localSiz + _Tail::size();
        }
      
      template<size_t slot>
      using Elm_t = PickType<slot>::type;
      
      
      template<size_t slot>
      Elm_t<slot>&
      get()  noexcept
        {
          static_assert (slot < size(), "HeteroData access index beyond defined data");
          if constexpr (slot < localSiz)
            return std::get<slot> (*this);
          else
            return accessTail().template get<slot-localSiz>();
        }
      
      template<size_t slot>
      Elm_t<slot> const&
      get()  const noexcept
        {
          return const_cast<HeteroData*>(this)->get<slot>();
        }
      
      
      template<size_t slot>
      struct Accessor
        {
          using Type = Elm_t<slot>;
          
          template<class SPEC>
          static Type&
          retrieveData (HeteroData<SPEC>& frontEnd)
            {
              auto& fullChain = _Self::recast (frontEnd);
              return fullChain.template get<slot>();
            }
          
          template<typename HH>
          Type& operator() (HH& frontEnd) const { return Accessor::retrieveData (frontEnd); }
        };
      
      template<typename...VALS>
      struct Chain
        {
          using Segments = meta::Node<Frame,TAIL>; // ◁———this type describes current chain structure
          using NewFrame = StorageFrame<meta::count<Segments>::value, VALS...>;
          using ChainType = HeteroData<typename meta::Append<Segments,NewFrame>::List>;
                                                // ...and this would be the extended chain structure
          template<typename...INIT>
          static NewFrame
          build (INIT&& ...initArgs)
            {
              return {initArgs ...}; // Note: NewFrame is non-copyable
            }
          template<typename...INIT>
          static NewFrame&
          emplace (void* storage, INIT&& ...initArgs)   
            {
              return * new(storage) NewFrame{initArgs ...};
            }
          
          template<class HET>
          static auto&
          recast (HET& frontChain)
            {
              return ChainType::recast (frontChain);
            }
          
          template<typename...XVALS>
          using ChainExtent = ChainType::template Chain<XVALS...>;
          
          template<size_t slot>
          using Accessor = ChainType::template Accessor<_Self::size()+slot>;
          
          template<typename X>
          using AccessorFor = Accessor<meta::indexOfType<X,VALS...>()>;
        };
    };
  
  template<>
  class HeteroData<meta::Nil>
    {
    public:
      static size_t constexpr size() { return 0; }
      
      template<size_t>
      using Elm_t = void;
      template<size_t>
      using PickType = void;
    };
  
  /*************************************************************************/
  template<typename...DATA>
  class HeteroData
    : public HeteroData<meta::Node<StorageFrame<0, DATA...>, meta::Nil>>
    {
      using _FrontBlock = HeteroData<meta::Node<StorageFrame<0, DATA...>, meta::Nil>>;
      
    public:
      using NewFrame = _FrontBlock::Frame;
      using ChainType = _FrontBlock;
      using _FrontBlock::_FrontBlock;
      
      template<typename...INIT>
      static HeteroData
      build (INIT&& ...initArgs)
        {
          return {initArgs ...};
        }
    };
  
  
  namespace {
    inline StorageLoc*&
    checkedTraversal (size_t segments, StorageLoc* last)
    {
      REQUIRE(last);
      while (segments and last->next)
        {
          last = last->next;
          --segments;
        }
      ASSERT (last->next == nullptr and segments == 1
             ,"Failure to attach new data segment to HeteroData: "
              "assumed type structure does not match real connectivity, "
              "end-of-chain encountered with %d type segment(s) remaining"
             , segments);
      return last->next;
    }
    
    inline void
    checkedDetach (size_t segments, StorageLoc* seg, void* chainBlock)
    {
      REQUIRE(seg);
      while (segments and seg->next)
        if (segments == 1 and seg->next == chainBlock)
          {
            seg->next = nullptr;
            return;
          }
        else
          {
            seg = seg->next;
            --segments;
          }
      NOTREACHED ("Failure to detach a data segment from HeteroData: "
                  "assumed type structure does not match real connectivity");
    }
  }//(End)helper
  
  
  template<size_t seg, typename...DATA>
  template<typename SPEC>
  inline void
  StorageFrame<seg,DATA...>::linkInto (HeteroData<SPEC>& prefixChain)
  {
    StorageLoc*  firstSeg = reinterpret_cast<StorageLoc*> (&prefixChain);
    StorageLoc*& lastLink = checkedTraversal (seg, firstSeg);
    ENSURE (lastLink == nullptr);
    lastLink = this;
  }
  
  template<size_t seg, typename...DATA>
  template<typename SPEC>
  inline void
  StorageFrame<seg,DATA...>::detachFrom (HeteroData<SPEC>& prefixChain)
  {
    StorageLoc*  firstSeg = reinterpret_cast<StorageLoc*> (&prefixChain);
    checkedDetach (seg, firstSeg, this);
  }
}// namespace lib
 
 
 
 
namespace std { // Specialisation to support C++ »Tuple Protocol« and structured bindings.
  
  template<typename...DATA>
  struct tuple_size<lib::HeteroData<DATA...> >
    : integral_constant<size_t, lib::HeteroData<DATA...>::size()>
    { };
  
  template<size_t I, typename...DATA>
  struct tuple_element<I, lib::HeteroData<DATA...> >
    {
      using type = lib::HeteroData<DATA...>::template Elm_t<I>;
    };
  template<size_t I>
  struct tuple_element<I, lib::HeteroData<lib::meta::Nil> >
    {
      static_assert ("accessing element-type of an empty HeteroData block");
    };
  
  // Note: deliberately NOT providing a free get<i> function.
  //       Overload resolution would fail, since it attempts to instantiate std::get<i>(tuple) as a candidate,
  //       which triggers an assertion failure when using an index valid only for the full chain, not the base tuple
  
  
  template<size_t seg, typename...DATA>
  struct tuple_size<lib::StorageFrame<seg,DATA...> >
    : tuple_size<typename lib::StorageFrame<seg,DATA...>::Tuple>
    { };
 
  template<size_t I, size_t seg, typename...DATA>
  struct tuple_element<I, lib::StorageFrame<seg,DATA...> >
    : tuple_element<I, typename lib::StorageFrame<seg,DATA...>::Tuple>
    { };
  
  // no need to define an overload for std::get<i>
  // (other than a template specialisation, it will use base-type conversion to std::tuple on its argument;
  
}// namespace std
#endif /*LIB_HETERO_DATA_H*/