SharedPtr.hpp

#ifndef OPALS_SHARED_PTR_HPP_INCLUDED
#define OPALS_SHARED_PTR_HPP_INCLUDED

#include <opals/config.hpp>
#include <opals/ObjectBase.hpp>
#include <opals/fwd.hpp>

#pragma once

namespace opals
{
  struct SharedPtrImpl;

  OPALS_API void shared_ptr_create(SharedPtrImpl *&, void *obj, void(*deleter)(void *));
  OPALS_API void shared_ptr_create(SharedPtrImpl *&, ObjectBase *obj);
  OPALS_API void shared_ptr_inc(SharedPtrImpl *&);
  OPALS_API void shared_ptr_dec(SharedPtrImpl *&);
  OPALS_API unsigned int shared_ptr_get_count(SharedPtrImpl * const &);
  OPALS_API void* shared_ptr_get(SharedPtrImpl * const &);
  OPALS_API void* shared_ptr_release(SharedPtrImpl *&);

  /** \brief  smart pointer class for opals objects

    Smart pointers uses a reference counting mechanism to control the life time of an object. When the last
    SharePtr instance goes out of scope, the controlled object is deleted. In case an object is shared across
    dll boundaries, it is essential create and delete objects within the same heap. To do so you can either
    provide a corresponding delete function (only non-member functions are supported) or an object is derived
    from ObjectBase and the (overloaded) Delete function is called to delete the object.

    \author JO
    \date   29.01.2019
  */
  template <typename T>
  class SharedPtr
  {
    SharedPtrImpl *pimpl_;

  public:
    SharedPtr() noexcept : pimpl_(0) {}
    /// Put an object that is derived from ObjectBase under the control of the smart pointer class
    SharedPtr(ObjectBase *obj) noexcept : pimpl_(0) { shared_ptr_create(pimpl_, obj); }
    /// Put an object under the control of the smart pointer class with the corresponding deleter function pointer
    SharedPtr(T *obj, void(*deleter)(void *)) noexcept : pimpl_(0) { shared_ptr_create(pimpl_, obj, deleter); }
    SharedPtr(const SharedPtr &ref) noexcept : pimpl_(ref.pimpl_) { shared_ptr_inc(pimpl_); }

    ~SharedPtr() noexcept { shared_ptr_dec(pimpl_); }

    SharedPtr &operator=(const SharedPtr &h) {
      SharedPtr tmp = h;
      swap(tmp);
      return *this;
    }

    /// reset shared pointer and delete controlled object if necessary
    void reset() noexcept {
      SharedPtr tmp;
      swap(tmp);
    }
    /// put a new ObjectBase object under the shared pointer control
    void reset(ObjectBase *obj) noexcept {
      SharedPtr tmp(obj);
      swap(tmp);
    }
    /// put a new object under the shared pointer control (with the corresponding deleter function pointer)
    void reset(T *obj, void(*deleter)(void *)) noexcept {
      SharedPtr tmp(obj, deleter);
      swap(tmp);
    }
    void swap(SharedPtr &h) noexcept {
      std::swap(pimpl_, h.pimpl_);
    }
    /// get pointer to controlled object
    T* get() const noexcept { return (T *)shared_ptr_get(pimpl_); }

    const T& operator*() const { return *get(); }
    T& operator*() { return *get(); }

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

    /// get number of SharedPtr instances that reference the same object
    unsigned int use_count() const noexcept { return shared_ptr_get_count(pimpl_); }
    /// is the controlled object only referenced by this SharedPtr instance
    bool unique() const noexcept { return (shared_ptr_get_count(pimpl_) == 1); }

    operator bool() const noexcept { return (pimpl_ != 0); }

    /// \brief release the controlled object
    /// This is only possible if the controlled object is only referenced by the current SharedPtr instance.
    /// The user has to take care of deleting the object.
    T* release() {
      if (unique() == true)
        return (T*)shared_ptr_release(pimpl_);
      else
        return (T*)0;
    }
  };

}

#endif //OPALS_SHARED_PTR_HPP_INCLUDED