uninitialised-storage.hpp

Go to the documentation of this file.

/*
  UNINITIALISED-STORAGE.hpp  -  array-like container with raw storage
 
   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_UNINITIALISED_STORAGE_H
#define LIB_UNINITIALISED_STORAGE_H
 
 
#include <cstddef>
#include <utility>
#include <array>
#include <new>
 
 
namespace lib {
  
  template<typename T, size_t cnt =1>
  class UninitialisedStorage
    {
      using _Arr = std::array<T,cnt>;
      alignas(T) std::byte buffer_[sizeof(_Arr)];
      
    public:
      _Arr&
      array()
        {
          return * std::launder (reinterpret_cast<_Arr* > (&buffer_));
        }
      
      _Arr const&
      array()  const
        {
          return * std::launder (reinterpret_cast<_Arr const*> (&buffer_));
        }
      
      
      operator _Arr&()                        { return array(); }
      operator _Arr const&()            const { return array(); }
      
      T &      operator[] (size_t idx)        { return array()[idx]; }
      T const& operator[] (size_t idx)  const { return array()[idx]; }
      
      
      template<typename...Args>
      T&
      createAt (size_t idx, Args&& ...args)
        {
          return *new(&operator[](idx)) T{std::forward<Args>(args)...};
        }
      
      void
      destroyAt (size_t idx)
        {
          operator[](idx).~T();
        }
      
      static constexpr size_t size() { return cnt; }
    };
  
  
  
  
  template<typename T>
  class UninitialisedDynBlock
    {
      using _Arr = T[];
      
      void*  buff_{nullptr};
      size_t size_{0};
      
    public:
      T*
      allocate(size_t cnt)
        {
          if (buff_) discard();
          size_ = cnt;
          buff_ = cnt? std::aligned_alloc (std::alignment_of<T>(), cnt * sizeof(T))
                     : nullptr;
          return front();
        }
      
      void
      discard()
        {
          std::free (buff_);
          buff_ = nullptr;
          size_ = 0;
        }
      
      
      UninitialisedDynBlock()  =default;
     ~UninitialisedDynBlock()
        {
          if (buff_)
            discard();
        }
      explicit
      UninitialisedDynBlock (size_t cnt)
        {
          if (cnt)
            allocate(cnt);
        }
      
      UninitialisedDynBlock (UninitialisedDynBlock && rr)
        {
          if (this != &rr)
            swap (*this, rr);
        }
      
      UninitialisedDynBlock (UninitialisedDynBlock const&)            =delete;
      UninitialisedDynBlock& operator= (UninitialisedDynBlock &&)     =delete;
      UninitialisedDynBlock& operator= (UninitialisedDynBlock const&) =delete;
      
      friend void
      swap (UninitialisedDynBlock& u1, UninitialisedDynBlock& u2)
      {
        using std::swap;
        swap (u1.size_, u2.size_);
        swap (u1.buff_, u2.buff_);
      }
      
      explicit
      operator bool()  const
        {
          return bool(buff_);
        }
      
      size_t
      size()  const
        {
          return size_;
        }
      
      
      _Arr&
      array()
        {
          return * std::launder (reinterpret_cast<_Arr* > (buff_));
        }
      
      _Arr const&
      array()  const
        {
          return * std::launder (reinterpret_cast<_Arr const*> (buff_));
        }
      
      
      T *      front()       { return &array()[0]; }
      T const* front() const { return &array()[0]; }
      T *      after()       { return &array()[size_];}
      T const* after() const { return &array()[size_];}
      T *      back ()       { return after() - 1; }
      T const* back () const { return after() - 1; }
      
      T &      operator[] (size_t idx)        { return array()[idx]; }
      T const& operator[] (size_t idx)  const { return array()[idx]; }
      
      
      template<typename...Args>
      T&
      createAt (size_t idx, Args&& ...args)
        {
          return *new(&operator[](idx)) T{std::forward<Args>(args)...};
        }
      
      void
      destroyAt (size_t idx)
        {
          operator[](idx).~T();
        }
    };
  
  
} // namespace lib
#endif /*LIB_UNINITIALISED_STORAGE_H*/