scoped-holder-transfer.hpp

Go to the documentation of this file.

/*
  SCOPED-HOLDER-TRANSFER.hpp  -  using ScopedHolder within a STL vector 

   Copyright (C)
     2008,            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_SCOPEDHOLDER_TRANSFER_H
#define LIB_SCOPEDHOLDER_TRANSFER_H

#include "lib/error.hpp"
#include <memory>


namespace lib {
  
  
  
  
  template<class TY, class PAR = std::allocator<TY>>
  class Allocator_TransferNoncopyable
    {
      typedef Allocator_TransferNoncopyable<TY,PAR> _ThisType;
      
      PAR par_;
      
      
    public:
      typedef typename PAR::size_type       size_type;
      typedef typename PAR::difference_type difference_type; 
      typedef typename PAR::pointer         pointer;
      typedef typename PAR::const_pointer   const_pointer;
      typedef typename PAR::reference       reference;
      typedef typename PAR::const_reference const_reference;
      typedef typename PAR::value_type      value_type;

      template<typename XX>
        struct rebind
        { typedef Allocator_TransferNoncopyable<XX, PAR> other; };

      Allocator_TransferNoncopyable()  { }

      Allocator_TransferNoncopyable(const _ThisType& allo)
        : par_(allo.par_) { }
      Allocator_TransferNoncopyable(const PAR& allo)
        : par_(allo) { }

      template<typename X>
      Allocator_TransferNoncopyable(const std::allocator<X>&) { }

      ~Allocator_TransferNoncopyable() { }

      
      //------------proxying-the-parent-allocator------------------------------------
      
      size_type     max_size()                      const { return par_.max_size(); }
      pointer       address(reference r)            const { return par_.address(r); }
      const_pointer address(const_reference cr)     const { return par_.address(cr); }
      pointer       allocate(size_type n, const void *p=0){ return par_.allocate(n,p); }
      void          deallocate(pointer p, size_type n)    {        par_.deallocate(p,n); }
      void          destroy(pointer p)                    {        par_.destroy(p); }
      
      
      void 
      construct (pointer p, const TY& ref)
        {
          new(p) TY();   
          ASSERT (p);
          ASSERT (!(*p), "protocol violation: target already manages another object.");
          if (ref)
            transfer_control (const_cast<TY&>(ref), *p);
        }
    };
  
  template<typename TY1, typename TY2, class ALO>
  inline bool
  operator== (Allocator_TransferNoncopyable<TY1,ALO> const&, Allocator_TransferNoncopyable<TY2, ALO> const&)
  { return true; }

  template<typename TY1, typename TY2, class ALO>
  inline bool
  operator!= (Allocator_TransferNoncopyable<TY1,ALO> const&, Allocator_TransferNoncopyable<TY2,ALO> const&)
  { return false; }

  
  
  
} // namespace lib
#endif