IpSmartPtr.hpp

Go to the documentation of this file.

// Copyright (C) 2004, 2011 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Eclipse Public License.
//
// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
 
#ifndef __IPSMARTPTR_HPP__
#define __IPSMARTPTR_HPP__
 
#include "IpReferenced.hpp"
 
#include "IpDebug.hpp"
#if IPOPT_CHECKLEVEL > 2
# define IP_DEBUG_SMARTPTR
#endif
#ifndef IPOPT_UNUSED
# if defined(__GNUC__)
#   define IPOPT_UNUSED __attribute__((unused))
# else
#   define IPOPT_UNUSED
# endif
#endif
 
namespace Ipopt
{
 
template<class T>
class SmartPtr: public Referencer
{
public:
#define ipopt_dbg_smartptr_verbosity 0
 
 
   SmartPtr();
 
   SmartPtr(
      const SmartPtr<T>& copy
   );
 
   template<class U>
   SmartPtr(
      const SmartPtr<U>& copy
   );
 
   SmartPtr(
      T* ptr
   );
 
   ~SmartPtr();
 
 
   T* operator->() const;
 
   T& operator*() const;
 
   SmartPtr<T>& operator=(
      T* rhs
   );
 
   SmartPtr<T>& operator=(
      const SmartPtr<T>& rhs
   );
 
   template<class U>
   SmartPtr<T>& operator=(
      const SmartPtr<U>& rhs);
 
   template<class U1, class U2>
   friend
   bool operator==(
      const SmartPtr<U1>& lhs,
      const SmartPtr<U2>& rhs
   );
 
   template<class U1, class U2>
   friend
   bool operator==(
      const SmartPtr<U1>& lhs,
      U2*                 raw_rhs
   );
 
   template<class U1, class U2>
   friend
   bool operator==(
      U1*                 lhs,
      const SmartPtr<U2>& raw_rhs
   );
 
   template<class U1, class U2>
   friend
   bool operator!=(
      const SmartPtr<U1>& lhs,
      const SmartPtr<U2>& rhs
   );
 
   template<class U1, class U2>
   friend
   bool operator!=(
      const SmartPtr<U1>& lhs,
      U2*                 raw_rhs
   );
 
   template<class U1, class U2>
   friend
   bool operator!=(
      U1*                 lhs,
      const SmartPtr<U2>& raw_rhs
   );
 
   template<class U>
   friend
   bool operator<(
      const SmartPtr<U>& lhs,
      const SmartPtr<U>& rhs
   );
 
 
   template<class U>
   friend U* GetRawPtr(
      const SmartPtr<U>& smart_ptr
   );
 
   template<class U>
   friend SmartPtr<const U> ConstPtr(
      const SmartPtr<U>& smart_ptr
   );
 
   template<class U>
   friend
   bool IsValid(
      const SmartPtr<U>& smart_ptr
   );
 
   template<class U>
   friend
   bool IsNull(
      const SmartPtr<U>& smart_ptr
   );
 
private:
 
   T* ptr_;
 
   SmartPtr<T>& SetFromRawPtr_(
      T* rhs
   );
 
   SmartPtr<T>& SetFromSmartPtr_(
      const SmartPtr<T>& rhs
   );
 
   void ReleasePointer_();
};
 
template<class U>
U* GetRawPtr(
   const SmartPtr<U>& smart_ptr
);
 
template<class U>
SmartPtr<const U> ConstPtr(
   const SmartPtr<U>& smart_ptr
);
 
template<class U>
bool IsNull(
   const SmartPtr<U>& smart_ptr
);
 
template<class U>
bool IsValid(
   const SmartPtr<U>& smart_ptr
);
 
template<class U1, class U2>
bool operator==(
   const SmartPtr<U1>& lhs,
   const SmartPtr<U2>& rhs
);
 
template<class U1, class U2>
bool operator==(
   const SmartPtr<U1>& lhs,
   U2*                 raw_rhs
);
 
template<class U1, class U2>
bool operator==(
   U1*                 lhs,
   const SmartPtr<U2>& raw_rhs
);
 
template<class U1, class U2>
bool operator!=(
   const SmartPtr<U1>& lhs,
   const SmartPtr<U2>& rhs);
 
template<class U1, class U2>
bool operator!=(
   const SmartPtr<U1>& lhs,
   U2*                 raw_rhs
);
 
template<class U1, class U2>
bool operator!=(
   U1*                 lhs,
   const SmartPtr<U2>& raw_rhs
);
 
 
template<class T>
SmartPtr<T>::SmartPtr()
   : ptr_(0)
{
#ifdef IP_DEBUG_SMARTPTR
   DBG_START_METH("SmartPtr<T>::SmartPtr()", ipopt_dbg_smartptr_verbosity);
#endif
 
#ifndef NDEBUG
   const ReferencedObject* IPOPT_UNUSED trying_to_use_SmartPtr_with_an_object_that_does_not_inherit_from_ReferencedObject_ = ptr_;
#endif
}
 
template<class T>
SmartPtr<T>::SmartPtr(
   const SmartPtr<T>& copy
)
   : ptr_(0)
{
#ifdef IP_DEBUG_SMARTPTR
   DBG_START_METH("SmartPtr<T>::SmartPtr(const SmartPtr<T>& copy)", ipopt_dbg_smartptr_verbosity);
#endif
 
#ifndef NDEBUG
   const ReferencedObject* IPOPT_UNUSED trying_to_use_SmartPtr_with_an_object_that_does_not_inherit_from_ReferencedObject_ =
      ptr_;
#endif
 
   (void) SetFromSmartPtr_(copy);
}
 
template<class T>
template<class U>
SmartPtr<T>::SmartPtr(
   const SmartPtr<U>& copy
)
   : ptr_(0)
{
#ifdef IP_DEBUG_SMARTPTR
   DBG_START_METH("SmartPtr<T>::SmartPtr(const SmartPtr<U>& copy)", ipopt_dbg_smartptr_verbosity);
#endif
 
#ifndef NDEBUG
   const ReferencedObject* IPOPT_UNUSED trying_to_use_SmartPtr_with_an_object_that_does_not_inherit_from_ReferencedObject_ =
      ptr_;
#endif
 
   (void) SetFromSmartPtr_(GetRawPtr(copy));
}
 
template<class T>
SmartPtr<T>::SmartPtr(
   T* ptr
)
   : ptr_(0)
{
#ifdef IP_DEBUG_SMARTPTR
   DBG_START_METH("SmartPtr<T>::SmartPtr(T* ptr)", ipopt_dbg_smartptr_verbosity);
#endif
 
#ifndef NDEBUG
   const ReferencedObject* IPOPT_UNUSED trying_to_use_SmartPtr_with_an_object_that_does_not_inherit_from_ReferencedObject_ =
      ptr_;
#endif
 
   (void) SetFromRawPtr_(ptr);
}
 
template<class T>
SmartPtr<T>::~SmartPtr()
{
#ifdef IP_DEBUG_SMARTPTR
   DBG_START_METH("SmartPtr<T>::~SmartPtr(T* ptr)", ipopt_dbg_smartptr_verbosity);
#endif
 
   ReleasePointer_();
}
 
template<class T>
T* SmartPtr<T>::operator->() const
{
#ifdef IP_DEBUG_SMARTPTR
   DBG_START_METH("T* SmartPtr<T>::operator->()", ipopt_dbg_smartptr_verbosity);
#endif
 
   // cannot deref a null pointer
#if IPOPT_CHECKLEVEL > 0
   assert(ptr_);
#endif
 
   return ptr_;
}
 
template<class T>
T& SmartPtr<T>::operator*() const
{
#ifdef IP_DEBUG_SMARTPTR
   DBG_START_METH("T& SmartPtr<T>::operator*()", ipopt_dbg_smartptr_verbosity);
#endif
 
   // cannot dereference a null pointer
#if IPOPT_CHECKLEVEL > 0
   assert(ptr_);
#endif
 
   return *ptr_;
}
 
template<class T>
SmartPtr<T>& SmartPtr<T>::operator=(
   T* rhs
)
{
#ifdef IP_DEBUG_SMARTPTR
   DBG_START_METH("SmartPtr<T>& SmartPtr<T>::operator=(T* rhs)", ipopt_dbg_smartptr_verbosity);
#endif
 
   return SetFromRawPtr_(rhs);
}
 
template<class T>
SmartPtr<T>& SmartPtr<T>::operator=(
   const SmartPtr<T>& rhs
)
{
#ifdef IP_DEBUG_SMARTPTR
   DBG_START_METH(
      "SmartPtr<T>& SmartPtr<T>::operator=(const SmartPtr<T>& rhs)",
      ipopt_dbg_smartptr_verbosity);
#endif
 
   return SetFromSmartPtr_(rhs);
}
 
template<class T>
template<class U>
SmartPtr<T>& SmartPtr<T>::operator=(
   const SmartPtr<U>& rhs
)
{
#ifdef IP_DEBUG_SMARTPTR
   DBG_START_METH(
      "SmartPtr<T>& SmartPtr<T>::operator=(const SmartPtr<U>& rhs)",
      ipopt_dbg_smartptr_verbosity);
#endif
 
   return SetFromSmartPtr_(GetRawPtr(rhs));
}
 
template<class T>
SmartPtr<T>& SmartPtr<T>::SetFromRawPtr_(
   T* rhs
)
{
#ifdef IP_DEBUG_SMARTPTR
   DBG_START_METH(
      "SmartPtr<T>& SmartPtr<T>::SetFromRawPtr_(T* rhs)", ipopt_dbg_smartptr_verbosity);
#endif
 
   if( rhs != 0 )
   {
      rhs->AddRef(this);
   }
 
   // Release any old pointer
   ReleasePointer_();
 
   ptr_ = rhs;
 
   return *this;
}
 
template<class T>
SmartPtr<T>& SmartPtr<T>::SetFromSmartPtr_(
   const SmartPtr<T>& rhs
)
{
#ifdef IP_DEBUG_SMARTPTR
   DBG_START_METH(
      "SmartPtr<T>& SmartPtr<T>::SetFromSmartPtr_(const SmartPtr<T>& rhs)",
      ipopt_dbg_smartptr_verbosity);
#endif
 
   SetFromRawPtr_(GetRawPtr(rhs));
 
   return (*this);
}
 
template<class T>
void SmartPtr<T>::ReleasePointer_()
{
#ifdef IP_DEBUG_SMARTPTR
   DBG_START_METH(
      "void SmartPtr<T>::ReleasePointer()",
      ipopt_dbg_smartptr_verbosity);
#endif
 
   if( ptr_ )
   {
      ptr_->ReleaseRef(this);
      if( ptr_->ReferenceCount() == 0 )
      {
         delete ptr_;
      }
   }
}
 
template<class U>
U* GetRawPtr(
   const SmartPtr<U>& smart_ptr
)
{
#ifdef IP_DEBUG_SMARTPTR
   DBG_START_FUN(
      "T* GetRawPtr(const SmartPtr<T>& smart_ptr)",
      0);
#endif
 
   return smart_ptr.ptr_;
}
 
template<class U>
SmartPtr<const U> ConstPtr(
   const SmartPtr<U>& smart_ptr
)
{
   // compiler should implicitly cast
   return GetRawPtr(smart_ptr);
}
 
template<class U>
bool IsValid(
   const SmartPtr<U>& smart_ptr
)
{
   return !IsNull(smart_ptr);
}
 
template<class U>
bool IsNull(
   const SmartPtr<U>& smart_ptr
)
{
#ifdef IP_DEBUG_SMARTPTR
   DBG_START_FUN(
      "bool IsNull(const SmartPtr<T>& smart_ptr)",
      0);
#endif
 
   return (smart_ptr.ptr_ == 0);
}
 
template<class U1, class U2>
bool ComparePointers(
   const U1* lhs,
   const U2* rhs
)
{
#ifdef IP_DEBUG_SMARTPTR
   DBG_START_FUN(
      "bool ComparePtrs(const U1* lhs, const U2* rhs)",
      ipopt_dbg_smartptr_verbosity);
#endif
 
   // Even if lhs and rhs point to the same object
   // with different interfaces U1 and U2, we cannot guarantee that
   // the value of the pointers will be equivalent. We can
   // guarantee this if we convert to ReferencedObject* (see also #162)
   const ReferencedObject* v_lhs = lhs;
   const ReferencedObject* v_rhs = rhs;
 
   return v_lhs == v_rhs;
}
 
template<class U1, class U2>
bool operator==(
   const SmartPtr<U1>& lhs,
   const SmartPtr<U2>& rhs
)
{
#ifdef IP_DEBUG_SMARTPTR
   DBG_START_FUN(
      "bool operator==(const SmartPtr<U1>& lhs, const SmartPtr<U2>& rhs)",
      ipopt_dbg_smartptr_verbosity);
#endif
 
   U1* raw_lhs = GetRawPtr(lhs);
   U2* raw_rhs = GetRawPtr(rhs);
   return ComparePointers(raw_lhs, raw_rhs);
}
 
template<class U1, class U2>
bool operator==(
   const SmartPtr<U1>& lhs,
   U2*                 raw_rhs
)
{
#ifdef IP_DEBUG_SMARTPTR
   DBG_START_FUN(
      "bool operator==(SmartPtr<U1>& lhs, U2* rhs)",
      ipopt_dbg_smartptr_verbosity);
#endif
 
   U1* raw_lhs = GetRawPtr(lhs);
   return ComparePointers(raw_lhs, raw_rhs);
}
 
template<class U1, class U2>
bool operator==(
   U1*                 raw_lhs,
   const SmartPtr<U2>& rhs
)
{
#ifdef IP_DEBUG_SMARTPTR
   DBG_START_FUN(
      "bool operator==(U1* raw_lhs, SmartPtr<U2>& rhs)",
      ipopt_dbg_smartptr_verbosity);
#endif
 
   const U2* raw_rhs = GetRawPtr(rhs);
   return ComparePointers(raw_lhs, raw_rhs);
}
 
template<class U1, class U2>
bool operator!=(
   const SmartPtr<U1>& lhs,
   const SmartPtr<U2>& rhs
)
{
#ifdef IP_DEBUG_SMARTPTR
   DBG_START_FUN(
      "bool operator!=(const SmartPtr<U1>& lhs, const SmartPtr<U2>& rhs)",
      ipopt_dbg_smartptr_verbosity);
#endif
 
   bool retValue = operator==(lhs, rhs);
   return !retValue;
}
 
template<class U1, class U2>
bool operator!=(
   const SmartPtr<U1>& lhs,
   U2*                 raw_rhs
)
{
#ifdef IP_DEBUG_SMARTPTR
   DBG_START_FUN(
      "bool operator!=(SmartPtr<U1>& lhs, U2* rhs)",
      ipopt_dbg_smartptr_verbosity);
#endif
 
   bool retValue = operator==(lhs, raw_rhs);
   return !retValue;
}
 
template<class U1, class U2>
bool operator!=(
   U1*                 raw_lhs,
   const SmartPtr<U2>& rhs
)
{
#ifdef IP_DEBUG_SMARTPTR
   DBG_START_FUN(
      "bool operator!=(U1* raw_lhs, SmartPtr<U2>& rhs)",
      ipopt_dbg_smartptr_verbosity);
#endif
 
   bool retValue = operator==(raw_lhs, rhs);
   return !retValue;
}
 
template<class T>
void swap(
   SmartPtr<T>& a,
   SmartPtr<T>& b
)
{
#ifdef IP_DEBUG_REFERENCED
   SmartPtr<T> tmp(a);
   a = b;
   b = tmp;
#else
   std::swap(a.prt_, b.ptr_);
#endif
}
 
template<class T>
bool operator<(
   const SmartPtr<T>& lhs,
   const SmartPtr<T>& rhs
)
{
   return lhs.ptr_ < rhs.ptr_;
}
 
template<class T>
bool operator>(
   const SmartPtr<T>& lhs,
   const SmartPtr<T>& rhs
)
{
   return rhs < lhs;
}
 
template<class T> bool operator<=(
   const SmartPtr<T>& lhs,
   const SmartPtr<T>& rhs
)
{
   return !(rhs < lhs);
}
 
template<class T> bool operator>=(
   const SmartPtr<T>& lhs,
   const SmartPtr<T>& rhs
)
{
   return !(lhs < rhs);
}
 
} // namespace Ipopt
 
#undef ipopt_dbg_smartptr_verbosity
 
#endif