scoped-holder.hpp

Go to the documentation of this file.

/*
  SCOPED-HOLDER.hpp  -  general purpose wrapper for dealing with ownership problems 

  Copyright (C)         Lumiera.org
    2008,               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_HOLDER_H
#define LIB_SCOPED_HOLDER_H

#include "lib/error.hpp"

#include <memory>


namespace lib {
  
  
  
  
  template<class B>
  class ScopedPtrHolder
    : public std::unique_ptr<B>
    {
      typedef std::unique_ptr<B> _Parent;
      
      static B* must_be_null (_Parent const& ptr)
      {
        if (ptr)
          throw lumiera::error::Logic("ScopedPtrHolder protocol violation: "
                                      "attempt to copy from non-null.");
        return 0;
      }
      
    public:
      ScopedPtrHolder()
        : _Parent{}
        { }
      
      template<class SU>
      explicit ScopedPtrHolder (SU * p)  // never throws
        : _Parent(p)
        { }
      
      template<class SU>
      explicit ScopedPtrHolder (std::unique_ptr<SU> pu)  // never throws
        : _Parent(pu.release())
        { }
      
      ScopedPtrHolder (ScopedPtrHolder const& ref)
        : _Parent(must_be_null (ref))
        { }
      
      ScopedPtrHolder&
      operator= (ScopedPtrHolder const& ref)
        {
          must_be_null (*this);
          must_be_null (ref);
          return *this;
        }
      
      friend void
      transfer_control (ScopedPtrHolder& from, ScopedPtrHolder& to)
      {
        if (!from) return;
        TRACE (test, "transfer_control<ScopedPtrHolder>... from=%p to=%p",&from, &to);
        must_be_null (to);
        to.swap(from);
      }
    };
  
  
  
  
  template<class TY>
  class ScopedHolder
    {
      char content_[sizeof(TY)];
      char created_;
      
      
      static char
      must_be_empty (ScopedHolder<TY> const& ref)
      {
        if (ref)
          throw lumiera::error::Logic("ScopedHolder protocol violation: "
                                      "copy operation after having invoked create().");
        return 0;
      }
      
    public:
      ScopedHolder()
        : created_(0)
        { }
      
      ~ScopedHolder() { clear(); }
      
      
      TY& 
      create ()
        {
          ASSERT (!created_);
          TY * obj = new(content_) TY();
          ++created_;
          return *obj;
        }
      
      TY& 
      create (TY const& o)    
        {
          ASSERT (!created_);
          TY * obj = new(content_) TY(o);
          ++created_;
          return *obj;
        }
      
      void
      clear ()
        {
          if (created_)
            get()->~TY();
          created_ = false;
        }
      
      
      ScopedHolder (ScopedHolder const& ref)
        : created_(must_be_empty (ref))
        { }
      
      ScopedHolder&
      operator= (ScopedHolder const& ref)
        {
          must_be_empty (*this);
          must_be_empty (ref);
          return *this;
        }
        
      
      TY&
      operator* ()  const
        {
          ASSERT (created_);
          return (TY&) content_;
        }
      
      TY* 
      operator-> ()  const
        {
          ASSERT (created_);
          return (TY*) &content_;
        }
      
      TY* get() const     // never throws
        { 
          return (TY*) &content_; 
        }
      
      
      
      explicit operator bool() const { return created_; }
      bool operator! ()        const { return not created_; }
      
      
      friend void
      transfer_control (ScopedHolder& from, ScopedHolder& to)
      {
        if (!from) return;
        TRACE (test, "transfer_control<ScopedHolder>... from=%p to=%p",&from, &to);
        must_be_empty (to);
        to.create();
        try
          {
            transfer_control(*from,*to);  // note: assumed to have no side-effect in case it throws
            from.clear();
            return;
          }
        catch(...)
          {
            to.clear();
            WARN (test, "transfer_control operation aborted.");
            throw;
          }
      }
    };
  
  
  
  
} // namespace lib
#endif