lazy-init.hpp

Go to the documentation of this file.

/*
  LAZY-INIT.hpp  -  a self-initialising functor
 
   Copyright (C)
     2023,            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_LAZY_INIT_H
#define LIB_LAZY_INIT_H
 
 
#include "lib/error.h"
#include "lib/meta/function.hpp"
#include "lib/opaque-holder.hpp"
#include "lib/util.hpp"
 
#include <functional>
#include <utility>
#include <memory>
 
 
namespace lib {
  namespace err = lumiera::error;
  
  using lib::meta::_Fun;
  using lib::meta::_FunArg;
  using lib::meta::has_Sig;
  using util::unConst;
  using std::function;
  using std::forward;
  using std::move;
  
  using RawAddr = void const*;
  
  
  namespace {// the anonymous namespace of horrors...
    
    inline ptrdiff_t
    captureRawAddrOffset (RawAddr anchor, RawAddr subject)
    {
      // Dear Mr.Compiler, please get out of my way.
      // I just genuinely want to shoot myself into my foot...
      char* anchorAddr  = reinterpret_cast<char*> (unConst(anchor));
      char* subjectAddr = reinterpret_cast<char*> (unConst(subject));
      return subjectAddr - anchorAddr;
    }
    
    template<class TAR>
    inline static TAR*
    relocate (RawAddr anchor, ptrdiff_t offset)
    {
      char* anchorAddr = reinterpret_cast<char*> (unConst(anchor));
      char* adjusted   = anchorAddr + offset;
      void* rawTarget  = reinterpret_cast<void*> (adjusted);
      return static_cast<TAR*> (rawTarget);
    }
    
    
    const ptrdiff_t FUNCTOR_PAYLOAD_OFFSET =
      []{
          size_t slot{42};
          std::function<RawAddr(void)> probe = [slot]{ return RawAddr(&slot); };
          RawAddr functor = &probe;
          RawAddr payload = probe();
          if (not util::isCloseBy(functor, payload))
            throw err::Fatal{"Unable to use lib::LazyInit because std::function does not "
                             "apply small-object optimisation with inline storage."};
          return captureRawAddrOffset (functor,payload);
        }();
    //
  }//(End)low-level manipulations
  
  
  
  
  template<class SIG>
  class TrojanFun
    {
      template<class DEL, typename RET, typename... ARGS>
      static auto
      buildTrapActivator (DEL* delegate, _Fun<RET(ARGS...)>)
        {
          return [delegate]
                 (ARGS ...args) -> RET
                    {
                      auto currLocation = &delegate;
                      auto& functor = (*delegate) (currLocation);
                      //
                      return functor (forward<ARGS> (args)...);
                    };
        }
    public:
      
      template<class DEL>
      static auto
      generateTrap (DEL* delegate)
        {
          static_assert (_Fun<DEL>(), "Delegate must be function-like");
          using Ret =    _Fun<DEL>::Ret;
          static_assert (_Fun<Ret>(), "Result from invoking delegate must also be function-like");
          static_assert (has_Sig<Ret, SIG>(), "Result from delegate must expose target signature");
          
          REQUIRE (delegate);
          
          return buildTrapActivator (delegate, _Fun<SIG>());
        }
    };
  
  
  
  
  
  struct EmptyBase { };
  
  /**************************************************************/
  template<class PAR =EmptyBase>
  class LazyInit
    : public PAR
    {
      template<class SIG>
      using DelegateType = std::function<std::function<SIG>&(RawAddr)>;
      
      using PlaceholderType = DelegateType<void(void)>;
      using HeapStorage = InPlaceBuffer<PlaceholderType>;
      using PendingInit = std::shared_ptr<HeapStorage>;
      
      PendingInit pendingInit_;
      
      
      PendingInit const&
      __trapLocked (PendingInit const& init)
        {
          if (not init)
            throw err::State{"Component was already configured with a processing function, "
                             "which binds into a fixed object location. It can not be moved anymore."
                            , err::LUMIERA_ERROR_LIFECYCLE};
          return init;
        }
      
      PendingInit&&
      __trapLocked (PendingInit && init)
        {
          if (not init)
            throw err::State{"Component was already configured with a processing function, "
                             "which binds into a fixed object location. It can not be moved anymore."
                            , err::LUMIERA_ERROR_LIFECYCLE};
          return move (init);
        }
      
      
      
    protected:
      struct MarkDisabled{};
      
      template<typename...ARGS>
      LazyInit (MarkDisabled, ARGS&& ...parentCtorArgs)
        : PAR(forward<ARGS> (parentCtorArgs)...)
        , pendingInit_{}
        { }
      
      
    public:
      template<class SIG, class INI, typename...ARGS>
      LazyInit (std::function<SIG>& targetFunctor, INI&& initialiser, ARGS&& ...parentCtorArgs)
        : PAR(forward<ARGS> (parentCtorArgs)...)
        , pendingInit_{}
        {
          installInitialiser (targetFunctor, forward<INI> (initialiser));
        }
      
      
      LazyInit (LazyInit const& ref)
        : PAR{ref}
        , pendingInit_{__trapLocked (ref.pendingInit_)}
        { }
      
      LazyInit (LazyInit && rref)
        : PAR{move (rref)}
        , pendingInit_{__trapLocked (move(rref.pendingInit_))}
        { }
      
      LazyInit&
      operator= (LazyInit const& ref)
        {
          if (not util::isSameObject (ref, *this))
            {
              PAR::operator= (ref);
              pendingInit_ = __trapLocked (ref.pendingInit_);
            }
          return *this;
        }
      
      LazyInit&
      operator= (LazyInit && rref)
        {
          if (not util::isSameObject (rref, *this))
            {
              PAR::operator= (move (rref));
              pendingInit_ = __trapLocked (move (rref.pendingInit_));
            }
          return *this;
        }
      
      
      bool
      isInit()  const
        {
          return not pendingInit_;
        }
      
      template<class SIG>
      void
      installEmptyInitialiser()
        {
          pendingInit_.reset (new HeapStorage{emptyInitialiser<SIG>()});
        }
      
      template<class SIG, class INI>
      void
      installInitialiser (std::function<SIG>& targetFunctor, INI&& initialiser)
        {
          pendingInit_ = prepareInitialiser (targetFunctor, forward<INI> (initialiser));
        }
      
      
    private: /* ========== setup of the initialisation mechanism ========== */
      template<class SIG>
      DelegateType<SIG>
      emptyInitialiser()
        {
          using TargetFun = std::function<SIG>;
          return DelegateType<SIG>([disabledFunctor = TargetFun()]
                                   (RawAddr) -> TargetFun&
                                     {
                                       return disabledFunctor;
                                     });
        }
      
      template<class SIG, class INI>
      PendingInit
      prepareInitialiser (std::function<SIG>& targetFunctor, INI&& initialiser)
        {
          if (isInit() and targetFunctor)
            {// object is already »engaged« — no need to delay init
              using ExpectedArg = _FunArg<INI>;
              initialiser (static_cast<ExpectedArg> (this));
              return PendingInit(); // keep engaged; no pending init
            }
          // else: prepare delayed init...
          PendingInit storageHandle{
            new HeapStorage{
              buildInitialiserDelegate (targetFunctor, forward<INI> (initialiser))}};
           // place a »Trojan« into the target functor to trigger initialisation on invocation...
          targetFunctor = TrojanFun<SIG>::generateTrap (getPointerToDelegate<SIG> (*storageHandle));
          return storageHandle;
        }
      
      template<class SIG>
      static DelegateType<SIG>*
      getPointerToDelegate (HeapStorage& buffer)
        {
          return reinterpret_cast<DelegateType<SIG>*> (&buffer);
        }
      
      template<class SIG>
      static std::function<SIG>
      maybeInvoke (PendingInit const& pendingInit, RawAddr location)
        {
          if (not pendingInit) // no pending init -> empty TargetFun
            return std::function<SIG>();
          auto* pendingDelegate = getPointerToDelegate<SIG>(*pendingInit);
          return (*pendingDelegate) (location); // invoke to create new TargetFun
        }
      
      template<class SIG, class INI>
      DelegateType<SIG>
      buildInitialiserDelegate (std::function<SIG>& targetFunctor, INI&& initialiser)
        {
          using TargetFun = std::function<SIG>;
          using ExpectedArg = _FunArg<INI>;
          return DelegateType<SIG>{
                     [performInit = forward<INI> (initialiser)
                     ,previousInit = move (pendingInit_)
                     ,targetOffset = captureRawAddrOffset (this, &targetFunctor)]
                     (RawAddr location) -> TargetFun&
                        {// apply known offset backwards to find current location of the host object
                          TargetFun* target = relocate<TargetFun> (location, -FUNCTOR_PAYLOAD_OFFSET);
                          LazyInit* self = relocate<LazyInit> (target, -targetOffset);
                          REQUIRE (self);
                              // tie storage to this (possibly recursive) call
                          auto storageHandle = move(self->pendingInit_);
                            // setup  target as it would be with eager init
                          (*target) = maybeInvoke<SIG> (previousInit, location);
                          // invoke init, possibly downcast to derived *self
                          performInit (static_cast<ExpectedArg> (self));
                          return *target; // back to the »Trojan« to yield first result
                        }};
        }
    };
  
  
  
} // namespace lib
#endif /*LIB_LAZY_INIT_H*/