scoped-ptrvect.hpp

Go to the documentation of this file.

/*
  SCOPED-PTRVECT.hpp  -  simple noncopyable lifecycle managing collection of pointers
 
   Copyright (C)
     2009,            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_SCOPED_PTRVECT_H
#define LIB_SCOPED_PTRVECT_H
 
 
#include "include/logging.h"
#include "lib/iter-adapter-ptr-deref.hpp"
#include "lib/nocopy.hpp"
#include "lib/error.hpp"
#include "lib/util.hpp"
 
#include <vector>
#include <algorithm>
 
 
namespace lib {
  
  
  
  template<class T>
  class ScopedPtrVect
    : util::MoveAssign
    {
      using _Vec  = std::vector<T*>;
      using VIter = _Vec::iterator;
      
      using RIter    = RangeIter<VIter>;
      using IterType = PtrDerefIter<RIter>;
      
      using ConstIterType = IterType::ConstIterType;
      using RcIter        = IterType::WrappedConstIterType;
      
      _Vec vec_;
      
    public:
      typedef size_t   size_type;
      typedef T        value_type;
      typedef T &      reference;
      typedef T const& const_reference;
      
      
      
     ~ScopedPtrVect()
        {
          clear();
        }
      
      ScopedPtrVect()
        : vec_{}
        { }
      
      explicit
      ScopedPtrVect (size_type capacity)
        : vec_{}
        {
          vec_.reserve (capacity);
        }
      
      ScopedPtrVect (ScopedPtrVect && src)
        : vec_{std::move (src.vec_)}
        { }
      
      friend void
      swap (ScopedPtrVect& left, ScopedPtrVect& right)
        {
          swap (left.vec_, right.vec_);
        }
      
      ScopedPtrVect&
      operator= (ScopedPtrVect && other)
        {
          swap (*this, other);
          return *this;
        }
      
      
      T&
      manage (T* obj)
        {
          REQUIRE (obj);
          try
            {
              vec_.push_back (obj);
              return *obj;
            }
          catch(...)
            {
              delete obj;
              throw;
        }   }
      
      
      T*
      detach (void* objAddress)
        {
          T* extracted = static_cast<T*> (objAddress);
          VIter pos = std::find (vec_.begin(),vec_.end(), extracted);
          if (pos != vec_.end() and *pos != nullptr)
            {
              extracted = *pos;
              vec_.erase(pos);  // EX_STRONG
              return extracted;
            }
          return nullptr;
        }
      
      
      void
      clear()
        {
          for (T*& p : vec_)
            if (p)
              try {
                  delete p;
                  p = nullptr;
                }
              ERROR_LOG_AND_IGNORE (library, "Clean-up of ScopedPtrVect");
          vec_.clear();
        }
      
      
      /* === Element access and iteration === */
      
      T&
      operator[] (size_type i)
        {
          return * get(i);
        }
      
      using iterator       = IterType;
      using const_iterator = ConstIterType;
      
      iterator       begin()       { return       iterator (allPtrs()); }
      iterator       end()         { return       iterator ( RIter() ); }
      const_iterator begin() const { return const_iterator::build_by_cast (allPtrs()); }
      const_iterator end()   const { return const_iterator::nil();      }
      
      
      
      
      /* ====== proxied vector functions ==================== */
      
      size_type  size()      const { return vec_.size();     }
      size_type  max_size()  const { return vec_.max_size(); }
      size_type  capacity()  const { return vec_.capacity(); }
      bool       empty()     const { return vec_.empty();    }
      
      
    private:
      T*
      get (size_type i)
        {
          T* p (vec_.at (i));
          if (!p)
            throw lumiera::error::Invalid("no valid object at this index");
          else
            return p;
        }
      
      RIter
      allPtrs()
        {
          return RIter{vec_.begin(), vec_.end()};
        }
      RIter
      allPtrs()  const
        {
          _Vec& elements = util::unConst(this)->vec_;
          return RIter{elements.begin(), elements.end()};
        }
    };
  
  
  
  
} // namespace lib
#endif