TEnvelope.h

Go to the documentation of this file.

#pragma once
 
namespace sf
{
 
template<typename T>
class TEnvelope
{
  public:
    TEnvelope(T* letter);
 
    TEnvelope(const TEnvelope& src);
 
    TEnvelope(const TEnvelope&& src) noexcept;
 
    ~TEnvelope();
 
    TEnvelope& operator=(const TEnvelope& src);
 
    TEnvelope& operator=(T* object);
 
    operator bool();
 
    T* operator->();
 
    T& operator*();
 
    T* operator()();
 
    T* get();
 
    const T* get() const;
 
    explicit operator T*();
 
    explicit operator const T*() const;
 
    int referencedCount() const;
 
  private:
    struct Letter
    {
        explicit Letter(T* object);
 
        ~Letter();
 
        void addRef();
 
        void release();
 
        T* _object;
        int _refCount;
    };
 
    Letter* _letter;
};
 
template<typename T>
TEnvelope<T>::TEnvelope(T* letter)
  : _letter(new Letter(letter))
{}
 
template<typename T>
TEnvelope<T>::TEnvelope(const TEnvelope& src)
  : _letter(src._letter)
{
  _letter->addRef();
}
 
template<typename T>
TEnvelope<T>::TEnvelope(const TEnvelope&& src) noexcept
  : _letter(src._letter)
{}
 
template<typename T>
TEnvelope<T>::~TEnvelope()
{
  _letter->release();
}
 
template<typename T>
TEnvelope<T>& TEnvelope<T>::operator=(const TEnvelope& src)
{
  if (this != &src)
  {
    _letter->release();
    _letter = src._letter;
    _letter->addRef();
  }
  return *this;
}
 
template<typename T>
TEnvelope<T>& TEnvelope<T>::operator=(T* object)
{
  _letter->release();
  _letter = new Letter(object);
  return *this;
}
 
template<typename T>
TEnvelope<T>::operator bool()
{
  return _letter->_object != nullptr;
}
 
template<typename T>
T* TEnvelope<T>::operator->()
{
  return _letter->_object;
}
 
template<typename T>
T& TEnvelope<T>::operator*()
{
  return *_letter->_object;
}
 
template<typename T>
T* TEnvelope<T>::operator()()
{
  return _letter->_object;
}
 
template<typename T>
T* TEnvelope<T>::get()
{
  return _letter->_object;
}
 
template<typename T>
const T* TEnvelope<T>::get() const
{
  return _letter->_object;
}
 
template<typename T>
TEnvelope<T>::operator T*()
{
  return _letter->_object;
}
 
template<typename T>
TEnvelope<T>::operator const T*() const
{
  return _letter->_object;
}
 
template<typename T>
int TEnvelope<T>::referencedCount() const
{
  return _letter ? _letter->_refCount : 0;
}
 
template<typename T>
TEnvelope<T>::Letter::Letter(T* object)
  : _object(object)
  , _refCount(1)
{}
 
template<typename T>
TEnvelope<T>::Letter::~Letter()
{
  delete _object;
}
 
template<typename T>
void TEnvelope<T>::Letter::addRef()
{
  _refCount++;
}
 
template<typename T>
void TEnvelope<T>::Letter::release()
{
  if (--_refCount == 0)
  {
    delete this;
  }
}
 
}// namespace sf