IAutoReleasePool.h

 
#ifndef COSMO_AUTO_RELEASE_POOL_INTERFACE_H
#define COSMO_AUTO_RELEASE_POOL_INTERFACE_H
 
#include <Pt/Cosmo/Api.h>
 
namespace Pt {
 
namespace Cosmo {
 
class AutoReleasable;
 
class IAutoReleasePool
{
  friend class AutoReleasable;
 
  public:
    virtual ~IAutoReleasePool()
    { }
 
  protected:
    virtual void onAttachReleasable(AutoReleasable& r) = 0;
 
    virtual void onDetachReleasable(AutoReleasable& r) = 0;
};
 
class AutoReleasable
{
  friend class AutoReleasePool;
 
  public:
    AutoReleasable()
    : _pool(0)
    , _next(0)
    { }
 
    explicit AutoReleasable(IAutoReleasePool& pool)
    : _pool(&pool)
    , _next(0)
    { 
      _pool->onAttachReleasable(*this);
    }
 
    AutoReleasable(AutoReleasable&& other) noexcept
    : _pool(0)
    , _next(0)
    { 
      movePool(other);
    }
 
    virtual ~AutoReleasable()
    {
      detachPool();
    }
 
    AutoReleasable& operator=(AutoReleasable&& other) noexcept
    {
      if(this == &other)
        return *this;
 
      detachPool();
      movePool(other);
      return *this;
    }
 
    void reset()
    {
      detachPool();
      onRelease();
    }
 
  protected:
    virtual void onRelease() = 0;
 
  private:
    void detachPool()
    {
      if(_pool)
      {        
        _pool->onDetachReleasable(*this);
        _pool = 0;
      }
    }
 
    void movePool(AutoReleasable& other)
    {
      IAutoReleasePool* otherPool = other._pool;
      if(otherPool)
      {
        otherPool->onDetachReleasable(other);
        other._pool = 0;
 
        _pool = otherPool;
        _pool->onAttachReleasable(*this);
      }
    }
 
    AutoReleasable(const AutoReleasable& other) = delete;
 
    AutoReleasable& operator=(const AutoReleasable& other) = delete;
 
  private:
    IAutoReleasePool* _pool;
    AutoReleasable*   _next;
};
 
} // namespace Cosmo
 
} // namespace Pt
 
#endif // include guard