allocator-handle.hpp

Go to the documentation of this file.

/*
  ALLOCATOR-HANDLE.hpp  -  front-end handle for custom allocation schemes
 
   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_ALLOCATOR_HANDLE_H
#define LIB_ALLOCATOR_HANDLE_H
 
#include "lib/error.hpp"
 
#include <cstddef>
#include <utility>
#include <list>
 
 
 
namespace lib {
  namespace allo {
    
    
    
    template<class ALO>
    class StdFactory
      : private ALO
      {
        using Allo  = ALO;
        using AlloT = std::allocator_traits<Allo>;
        using BaseType = Allo::value_type;
        
        Allo& baseAllocator() { return *this; }
        
        template<typename X>
        auto
        adaptAllocator()
          {
            using XAllo = AlloT::template rebind_alloc<X>;
            if constexpr (std::is_constructible_v<XAllo, Allo>)
              return XAllo{baseAllocator()};
            else
              return XAllo{};
          }
        
        template<class ALOT, typename...ARGS>
        ALOT::pointer
        construct (ALOT::allocator_type& allo, ARGS&& ...args)
          {
            auto loc = ALOT::allocate (allo, 1);
            try { ALOT::construct (allo, loc, std::forward<ARGS>(args)...); }
            catch(...)
              {
                ALOT::deallocate (allo, loc, 1);
                throw;
              }
            return loc;
          }
        
        template<class ALOT>
        void
        destroy (ALOT::allocator_type& allo, ALOT::pointer elm)
          {
            ALOT::destroy (allo, elm);
            ALOT::deallocate (allo, elm, 1);
          }
        
        
      public:
        StdFactory (Allo allo = Allo{})
          : Allo{std::move (allo)}
          { }
        
        template<class XALO>
        bool constexpr operator== (StdFactory<XALO> const& o)  const
          {
            return baseAllocator() == o.baseAllocator();
          }
        template<class XALO>
        bool constexpr operator!= (StdFactory<XALO> const& o)  const
          {
            return not (*this == o);
          }
        
        
        
        template<class TY, typename...ARGS>
        TY*
        create (ARGS&& ...args)
          {
            if constexpr (std::is_same_v<TY, BaseType>)
              {
                return construct<AlloT> (baseAllocator(), std::forward<ARGS>(args)...);
              }
            else
              {
                using XAlloT = AlloT::template rebind_traits<TY>;
                auto xAllo = adaptAllocator<TY>();
                return construct<XAlloT> (xAllo, std::forward<ARGS>(args)...);
              }
          }
        
        template<class TY>
        void
        dispose (TY* elm)
          {
            if constexpr (std::is_same_v<TY, BaseType>)
              {
                destroy<AlloT> (baseAllocator(), elm);
              }
            else
              {
                using XAlloT = AlloT::template rebind_traits<TY>;
                auto xAllo = adaptAllocator<TY>();
                destroy<XAlloT> (xAllo, elm);
              }
          }
      };
    
    
    
    
    template<class FAC>
    struct is_Stateless
      : std::__and_< std::is_empty<FAC>
                   , std::is_default_constructible<FAC>
                   >
      { };
    template<class FAC>
    auto is_Stateless_v = is_Stateless<FAC>{};
    
    
    
    
    
    template<class FAC>
    class OwnUniqueAdapter
      : protected FAC
      {
        template<typename TY>
        static void
        dispose (TY* elm)            
          {
            FAC factory;
            factory.dispose (elm);
          };
        
        template<typename TY>
        struct StatefulDeleter       
          : protected FAC
          {
            void
            operator() (TY* elm)
              {
                FAC::dispose (elm);
              }
            
            StatefulDeleter (FAC const& anchor)
              : FAC{anchor}
              { }
          };
        
        
      public:
        OwnUniqueAdapter (FAC const& factory)
          : FAC{factory}
          { }
        using FAC::FAC;
        
        template<class TY, typename...ARGS>
        auto
        make_unique (ARGS&& ...args)
          {
            if constexpr (is_Stateless_v<FAC>)
              {
                using Handle = std::unique_ptr<TY, void(TY*)>;
                return Handle{FAC::template create<TY> (std::forward<ARGS> (args)...)
                             , &OwnUniqueAdapter::dispose
                             };
              }
            else
              {
                using Handle = std::unique_ptr<TY, StatefulDeleter<TY>>;
                return Handle{FAC::template create<TY> (std::forward<ARGS> (args)...)
                             , StatefulDeleter<TY>{*this}
                             };
              }
          }
      };
  }
  
  
  
  template<typename TY>
  class AllocatorHandle
    {
      struct Allocation
        {
          alignas(TY)
            std::byte buf_[sizeof(TY)];
          
          template<typename...ARGS>
          TY&
          create (ARGS&& ...args)
            {
              return *new(&buf_) TY {std::forward<ARGS> (args)...};
            }
          
          TY&
          access()
            {
              return * std::launder (reinterpret_cast<TY*> (&buf_));
            }
          void
          discard() 
            {
              access().~TY();
            }
        };
      
      std::list<Allocation> storage_;
      
    public:
      template<typename...ARGS>
      TY&
      operator() (ARGS&& ...args)
        {                  // EX_STRONG
          auto pos = storage_.emplace (storage_.end());  
          try {
              return pos->create (std::forward<ARGS> (args)...);
            }
          catch(...)
            {
              storage_.erase (pos); // EX_FREE
              
              CStr errID = lumiera_error();
              ERROR (memory, "Allocation failed with unknown exception. "
                             "Lumiera errorID=%s", errID?errID:"??");
              throw;
            }
        }
      
     ~AllocatorHandle()
        try {
            for (auto& alloc : storage_)
              alloc.discard();
          }
        ERROR_LOG_AND_IGNORE (memory, "clean-up of custom AllocatorHandle")
    };
  
  
  
} // namespace lib
#endif /*LIB_ALLOCATOR_HANDLE_H*/