sharedPointer_std.hh

Go to the documentation of this file.

 
#pragma once
 
 
#include <memory>
 
namespace concepts {
 
  // ********************************************************** null_deleter **
 
  struct null_deleter
  {
    void operator()(void const *) const
    {
    }
  };
 
  // ******************************************************************* RCP **
 
  template<class T>
  class RCP : public std::shared_ptr<T>
  {
  public:
    RCP() : std::shared_ptr<T>() {}
 
    explicit RCP(T* x) : std::shared_ptr<T>(x) {}
    
    RCP(std::shared_ptr<T>& x) : std::shared_ptr<T>(x) {}
 
    template<class F>
    RCP(const std::shared_ptr<F>& x) : std::shared_ptr<T>(x) {}
 
    template<class F, class G>
    RCP(F x, G y) : std::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 std::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>( std::shared_ptr<NewType>(*this) ); 
      }
    #endif
  };
 
  // *************************************************************** makeRCP **
 
  template <class T>
  RCP<T> makeRCP(T* x)
  {
    return RCP<T>(x);
  }
 
  // ********************************************************** makeRCP_weak **
 
  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