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
    : std::vector<T*>,
      util::NonCopyable
    {
      typedef std::vector<T*> _Vec;
      typedef typename _Vec::iterator VIter;
      
      typedef RangeIter<VIter> RIter;
      typedef PtrDerefIter<RIter> IterType;
      
      typedef typename IterType::ConstIterType ConstIterType;
      typedef typename IterType::WrappedConstIterType RcIter;
      
      
    public:
      typedef size_t   size_type;
      typedef T        value_type;
      typedef T &      reference;
      typedef T const& const_reference;
      
      
      
      ScopedPtrVect ()
        : _Vec()
        { }
      
      explicit
      ScopedPtrVect (size_type capacity)
        : _Vec()
        {
          _Vec::reserve (capacity);
        }
      
     ~ScopedPtrVect ()
        { 
          clear();
        }
      
      
      T&
      manage (T* obj)
        {
          REQUIRE (obj);
          try 
            {
              this->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() && bool(*pos))
            {
              extracted = *pos;
              _Vec::erase(pos);  // EX_STRONG
              return extracted;
            }
          return NULL;
        }
      
      
      void
      clear()
        { 
          VIter e = _Vec::end();
          for (VIter i = _Vec::begin(); i!=e; ++i)
            if (*i)
              try {
                  delete *i;
                  *i = 0;
                }
              ERROR_LOG_AND_IGNORE (library, "Clean-up of ScopedPtrVect");
          _Vec::clear();
        }
      
      
      /* === Element access and iteration === */
      
      T&
      operator[] (size_type i)
        {
          return *get(i);
        }
      
      typedef IterType      iterator;
      typedef ConstIterType const_iterator;
      
      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);
          return RIter (elements.begin(), elements.end());
        }
    };
  
  
  
  
} // namespace lib
#endif