scoped-collection.hpp

Go to the documentation of this file.

/*
  SCOPED-COLLECTION.hpp  -  managing a fixed collection of noncopyable polymorphic objects 

  Copyright (C)         Lumiera.org
    2012,               Hermann Vosseler <Ichthyostega@web.de>

  This program 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.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*/

#ifndef LIB_SCOPED_COLLECTION_H
#define LIB_SCOPED_COLLECTION_H


#include "lib/error.hpp"
#include "lib/nocopy.hpp"
#include "lib/meta/trait.hpp"
#include "lib/iter-adapter.hpp"

#include <cstddef>
#include <type_traits>


namespace lib {
  
  namespace error = lumiera::error;
  using LERR_(INDEX_BOUNDS);
  using LERR_(CAPACITY);
  
  
  
  template
    < class I
    , size_t siz = sizeof(I)
    >
  class ScopedCollection
    : util::NonCopyable
    {
      
    public:
      class ElementHolder
        : util::NonCopyable
        {
          alignas(I) mutable
            std::byte buf_[siz];
          
        public:
         
          I&
          accessObj()  const
            {
              return * std::launder (reinterpret_cast<I*> (&buf_));
            }
          
          void
          destroy()
            {
              accessObj().~I();
            }
          
          
          
          
          template<class TY, typename...ARGS>
          TY&
          create (ARGS&& ...args)
            {
              static_assert ( meta::is_Subclass<TY,I>()
                             && sizeof(TY) <= siz,
                             "ElementHolder buffer too small");
              
              return *new(&buf_) TY (std::forward<ARGS> (args)...);
            }
        };
      
      
      
      
      
      
     ~ScopedCollection ()
        { 
          clear();
        }
      
      explicit
      ScopedCollection (size_t maxElements)
        : level_(0)
        , capacity_(maxElements)
        , elements_(new ElementHolder[maxElements])
        { }
      
      template<class CTOR>
      ScopedCollection (size_t maxElements, CTOR builder)
        : level_(0)
        , capacity_(maxElements)
        , elements_(new ElementHolder[maxElements])
        {
          populate_by (builder);
        }
      
      template<class TY>
      ScopedCollection (size_t maxElements, void (TY::*builder) (ElementHolder&), TY * const instance)
        : level_(0)
        , capacity_(maxElements)
        , elements_(new ElementHolder[maxElements])
        {
          populate_by (builder,instance);
        }
      
      /* == some pre-defined Builders == */
      
      class FillAll;           
      
      template<typename TY>
      class FillWith;          
      
      template<typename IT>
      class PullFrom;          
      
      template<typename IT>
      static PullFrom<IT>
      pull (IT iter)           
        {
          return PullFrom<IT> (iter);
        }
      
      void
      clear()
        {
          REQUIRE (level_ <= capacity_, "Storage corrupted");
          
          while (level_)
            {
              --level_;
              try {
                  elements_[level_].destroy();
                }
              ERROR_LOG_AND_IGNORE (progress, "Clean-up of element in ScopedCollection")
            }
        }
      
      void
      populate()
        try {
            while (level_ < capacity_)
              {
                elements_[level_].template create<I>();
                ++level_;
              }
          }
        catch(...)
          {
            WARN (progress, "Failure while populating ScopedCollection. "
                            "All elements will be discarded");
            clear();
            throw;
          }
      
      template<class CTOR>
      void
      populate_by (CTOR builder)
        try { 
          while (level_ < capacity_)
            {
              ElementHolder& storageFrame (elements_[level_]);
              builder (storageFrame);
              ++level_;
          } }
        catch(...)
          {
            WARN (progress, "Failure while populating ScopedCollection. "
                            "All elements will be discarded");
            clear();
            throw;
          }
      
      template<class TY>
      void
      populate_by (void (TY::*builder) (ElementHolder&), TY * const instance)
        try { 
          while (level_ < capacity_)
            {
              ElementHolder& storageFrame (elements_[level_]);
              (instance->*builder) (storageFrame);
              ++level_;
          } }
        catch(...)
          {
            WARN (progress, "Failure while populating ScopedCollection. "
                            "All elements will be discarded");
            clear();
            throw;
          }
      
      
      
      I&
      emplaceElement()
        {
          return emplace<I>();
        }
      
      
      template<class TY =I, typename...ARGS>
      TY&
      emplace (ARGS&& ...args)
        {
          __ensureSufficientCapacity();
          TY& newElm = elements_[level_].template create<TY>(std::forward<ARGS> (args)...);
          ++level_;
          return newElm;
        }
      
      
      
      /* === Element access and iteration === */
      
      I&
      operator[] (size_t index)  const
        {
          if (index < level_)
            return elements_[index].accessObj();
          
          throw error::Logic ("Attempt to access not (yet) existing object in ScopedCollection"
                             , LERR_(INDEX_BOUNDS));
        }
      
      
      
      using iterator       = IterAdapter<      I *, const ScopedCollection *>;
      using const_iterator = IterAdapter<const I *, const ScopedCollection *>;
      
      
      iterator       begin()       { return iterator       (this, _access_begin()); }
      const_iterator begin() const { return const_iterator (this, _access_begin()); }
      iterator       end ()        { return iterator();       }
      const_iterator end ()  const { return const_iterator(); }
      
      
      size_t  size ()        const { return level_;      }
      size_t  capacity ()    const { return capacity_;   }
      bool    empty ()       const { return 0 == level_; }
      
      
      // use in standard range for loops...
      friend iterator       begin (ScopedCollection& sco)      { return sco.begin(); }
      friend const iterator begin (ScopedCollection const& sco){ return sco.begin(); }
      friend iterator       end   (ScopedCollection& sco)      { return sco.end(); }
      friend const iterator end   (ScopedCollection const& sco){ return sco.end(); }
      
      
    private:
      /* ==== Storage: heap allocated array of element buffers ==== */
      
      typedef std::unique_ptr<ElementHolder[]> ElementStorage;
      
      size_t level_;
      size_t capacity_;
      ElementStorage elements_;
      
      
      
      void
      __ensureSufficientCapacity()
        {
          if (level_ >= capacity_)
            throw error::State ("ScopedCollection exceeding the initially defined capacity"
                               , LERR_(CAPACITY));
        }
      
      
      /* ==== internal callback API for the iterator ==== */
      
      friend void
      iterNext (const ScopedCollection*, I* & pos)
      {
        ElementHolder* & storageLocation = reinterpret_cast<ElementHolder* &> (pos);
        ++storageLocation;
      }
      
      friend void
      iterNext (const ScopedCollection*, const I* & pos)
      {
        const ElementHolder* & storageLocation = reinterpret_cast<const ElementHolder* &> (pos);
        ++storageLocation;
      }
      
      template<typename POS>
      friend bool
      checkPoint (const ScopedCollection* src, POS & pos)
      {
        REQUIRE (src);
        if ((pos) && (pos < src->_access_end()))
          return true;
        else
          {
            pos = 0;
            return false;
      }   }
      
      
      I* _access_begin() const { return & elements_[0].accessObj(); }
      I* _access_end()   const { return & elements_[level_].accessObj(); }
      
    };
  
  
  
  
  /* === Supplement: pre-defined element builders === */
  
  template<class I, size_t siz>
  class ScopedCollection<I,siz>::FillAll
    {
    public:
      void
      operator() (typename ScopedCollection<I,siz>::ElementHolder& storage)
        {
          storage.template create<I>();
        }
    };
  
  template<class I, size_t siz>
  template<typename TY>
  class ScopedCollection<I,siz>::FillWith
    {
    public:
      void
      operator() (typename ScopedCollection<I,siz>::ElementHolder& storage)
        {
          storage.template create<TY>();
        }
    };
  
  template<class I, size_t siz>
  template<typename IT>
  class ScopedCollection<I,siz>::PullFrom
    {
      IT iter_;
      
      using ElementType = typename meta::ValueTypeBinding<IT>::value_type;
      
    public:
      PullFrom (IT source)
        : iter_(source)
        { }
      
      void
      operator() (typename ScopedCollection<I,siz>::ElementHolder& storage)
        {
          storage.template create<ElementType> (*iter_);
          ++iter_;
        }
    };
  
  
  
} // namespace lib
#endif