toolbox/sharedPointer.hh

Go to the documentation of this file.

#pragma once
#include "boost/shared_ptr.hpp"
#include "boost/weak_ptr.hpp"

namespace concepts {

  struct null_deleter
  {
    void operator()(void const *) const
    {
    }
  };

  template<class T>
  class RCP : public boost::shared_ptr<T>
  {
  public:
    RCP() : boost::shared_ptr<T>() {}

    explicit RCP(T* x) : boost::shared_ptr<T>(x) {}
    
    RCP(boost::shared_ptr<T>& x) : boost::shared_ptr<T>(x) {}

    template<class F>
    RCP(const boost::shared_ptr<F>& x) : boost::shared_ptr<T>(x) {}

    template<class F, class G>
    RCP(F x, G y) : boost::shared_ptr<T>(x, y) {}

    RCP<T>& operator=(const RCP<T> x)
    {
      RCP<T>(x).swap(*this);
      return *this;
    }

    template<class F>
    RCP<T>& operator=(const boost::shared_ptr<F> x)
    {
      RCP<T>(x).swap(*this);
      return *this;
    }

    // this conversion operator is already implemented for shared_ptr
    #if 0 
    // template function for implicit conversion ops.
    template<class NewType>
      operator RCP<NewType>() 
      {
        return RCP<NewType>( boost::shared_ptr<NewType>(*this) ); 
      }
    #endif
  };

  template <class T>
  RCP<T> makeRCP(T* x)
  {
    return RCP<T>(x);
  }

  template<class T>
  RCP<T> makeRCP_weak(T* x)
  {
    return RCP<T>(x, null_deleter());
  }
  
    #if 1
  template<class T>
  RCP<const T> makecRCP_weak(T* x) // create a const pointer
  {
    return RCP<const T>(x, null_deleter());
  }
  #endif


} // namespace concepts