sharedPointer.hh

Go to the documentation of this file.

 
#pragma once
 
// The contens of original sharedPointer.hh is in sharedPointer_boost.hh
// Due to C++11 standard there is no need to use boost::shared_ptr.
// We take std::shared_ptr, if the compiler supports C++11.
 
#if __cplusplus>=201103L
#include "sharedPointer_std.hh"
 
#else
#include "sharedPointer_boost.hh"
 
#endif
 
 
 
// namespace concepts {
 
//   // ********************************************************** null_deleter **
 
//   struct null_deleter
//   {
//     void operator()(void const *) const
//     {
//     }
//   };
 
//   // ******************************************************************* RCP **
 
//   /** Reference-counting pointer
 
//       @author Kersten Schmidt, 2010
//               Holger Brandsmeier, 2010
//   */
//   template<class T>
//   class RCP : public std::shared_ptr<T>
//   {
//   public:
//     /// Default constructor
//     RCP() : std::shared_ptr<T>() {}
 
//     /** Constructor for a simple pointer, which will be deleted by the RCP
 
//         It should be only called with pointer to dynamic variables, e.g.
//         <pre>RCP p(new int(4));</pre>
 
//         Do NOT use it with pointers to variables in the stack. Do not
//         <pre>int i = 4; RCP p(&i); // <-- DO NOT -- </pre>
 
//         Use instead the function \c makeRCP_weak for weak RCPs, where
//         the pointer is not deleted.
//         <pre>int i = 4; RCP p = makeRCP_weak(&i);</pre>
//      */
//     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) {}
 
//     /// Constructor which includes the deleter G 
//     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 **
 
//   /** Function to create a RCP which deletes the object when no RCP
//       points on it anymore.
 
//       The function has to be used, if the object is created with new.
 
//       For example:
//       <pre>
//       RCP<int>::Type iP = makeRCP(new int(2));
//       iP.reset();   // deletes the integer 2
//       </pre>
 
//       Second example:
//       <pre>
//       RCP<int>::Type iP = makeRCP(new int(3)), jP = iP;
//       jP.reset();   // does not delete the integer 3, as jP points still on it
//       iP.reset();   // deletes the integer 3, no RCP points on it
//       </pre>
//   */
//   template <class T>
//   RCP<T> makeRCP(T* x)
//   {
//     return RCP<T>(x);
//   }
 
//   // ********************************************************** makeRCP_weak **
 
//   /** Function to create a RCP without deleting the object in the destructor
 
//   The function has to be used, if the object remains externally,
//   e.g., in the heap.
 
//   For example:
//   <pre>
//   int i = 1;
//   RCP<int>::Type iP = makeRCP_weak(&i);
//   iP.reset();   // will not delete the integer 1
//   </pre>
//   */
//   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