refcountptr.h

//
// author Kazys Stepanas
//
// Copyright (c) CSIRO 2015
//
#ifndef REFCOUNTPTR_H_
#define REFCOUNTPTR_H_

#include "plotsconfig.h"

namespace plotutil
{
  template <class T>
  class RefCountPtr
  {
  public:
    RefCountPtr();

    RefCountPtr(T *ptr);

    template <class Q> RefCountPtr(Q *ptr);

    RefCountPtr(const RefCountPtr &other);

    template <class Q> RefCountPtr(const RefCountPtr<Q> &other);

    RefCountPtr(RefCountPtr &&other);

    ~RefCountPtr();

    void release();

    inline T *ptr() { return _ptr; }

    inline const T *ptr() const { return _ptr; }

    inline T &operator * () { return *_ptr; }

    inline const T &operator * () const { return *_ptr; }

    inline T *operator -> () { return _ptr; }

    inline const T *operator -> () const { return _ptr; }

    inline operator bool() const { return _ptr != nullptr; }

    inline bool operator!() const { return _ptr == nullptr; }

    inline bool operator == (const RefCountPtr &other) { return _ptr == other._ptr; }

    inline bool operator != (const RefCountPtr &other) { return _ptr != other._ptr; }

    RefCountPtr &operator = (const RefCountPtr &other);

    RefCountPtr &operator = (T *ptr);

    template <class Q>
    RefCountPtr &operator = (Q *ptr);

  private:
    void reference(T *ptr);

    T *_ptr;  
  };

  template <class T>
  inline RefCountPtr<T>::RefCountPtr()
    : _ptr(nullptr)
  {
  }


  template <class T>
  inline RefCountPtr<T>::RefCountPtr(T *ptr)
  {
    reference(ptr);
  }


  template <class T>
  template <class Q>
  inline RefCountPtr<T>::RefCountPtr(Q *ptr)
  {
    reference(ptr);
  }


  template <class T>
  inline RefCountPtr<T>::RefCountPtr(const RefCountPtr &other)
  {
    reference(other._ptr);
  }

  template <class T>
  inline RefCountPtr<T>::RefCountPtr(RefCountPtr &&other)
  {
    reference(other._ptr);
    other._ptr = nullptr;
  }


  template <class T>
  inline RefCountPtr<T>::~RefCountPtr()
  {
    release();
  }


  template <class T>
  inline void RefCountPtr<T>::release()
  {
    if (_ptr)
    {
      _ptr->decReference();
      _ptr = nullptr;
    }
  }


  template <class T>
  inline RefCountPtr<T> &RefCountPtr<T>::operator = (const RefCountPtr &other)
  {
    release();
    reference(other._ptr);
    return *this;
  }


  template <class T>
  inline RefCountPtr<T> &RefCountPtr<T>::operator = (T *ptr)
  {
    release();
    reference(ptr);
    return *this;
  }


  template <class T>
  template <class Q>
  inline RefCountPtr<T> &RefCountPtr<T>::operator = (Q *ptr)
  {
    release();
    reference(ptr);
    return *this;
  }


  template <class T>
  inline void RefCountPtr<T>::reference(T *ptr)
  {
    _ptr = ptr;
    if (_ptr)
    {
      _ptr->addReference();
    }
  }
}

#endif // REFCOUNTPTR_H_