CoinSmartPtr.hpp

Go to the documentation of this file.

// Copyright (C) 2004, 2006 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Eclipse Public License.
//
// $Id: CoinSmartPtr.hpp 2083 2019-01-06 19:38:09Z unxusr $
//
// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
// Removed lots of debugging stuff and reformatted: Laszlo Ladanyi, IBM
#ifndef CoinSmartPtr_hpp
#define CoinSmartPtr_hpp

#include <list>
#include <cassert>
#include <cstddef>
#include <cstring>

namespace Coin {

//#########################################################################

class ReferencedObject {
public:
  ReferencedObject()
    : reference_count_(0)
  {
  }
  virtual ~ReferencedObject() { assert(reference_count_ == 0); }
  inline int ReferenceCount() const { return reference_count_; }
  inline void AddRef() const { ++reference_count_; }
  inline void ReleaseRef() const { --reference_count_; }

private:
  mutable int reference_count_;
};

//#########################################################################

//#define IP_DEBUG_SMARTPTR
#if COIN_IPOPT_CHECKLEVEL > 2
#define IP_DEBUG_SMARTPTR
#endif
#ifdef IP_DEBUG_SMARTPTR
#include "IpDebug.hpp"
#endif

template < class T >
class SmartPtr {
public:
  T *GetRawPtr() const { return ptr_; }

  bool IsValid() const { return ptr_ != NULL; }

  bool IsNull() const { return ptr_ == NULL; }

private:
  T *ptr_;

  void ReleasePointer_()
  {
    if (ptr_) {
      ptr_->ReleaseRef();
      if (ptr_->ReferenceCount() == 0) {
        delete ptr_;
      }
      ptr_ = NULL;
    }
  }

  SmartPtr< T > &SetFromRawPtr_(T *rhs)
  {
    ReleasePointer_(); // Release any old pointer
    if (rhs != NULL) {
      rhs->AddRef();
      ptr_ = rhs;
    }
    return *this;
  }

  inline SmartPtr< T > &SetFromSmartPtr_(const SmartPtr< T > &rhs)
  {
    SetFromRawPtr_(rhs.GetRawPtr());
    return (*this);
  }


public:
#define dbg_smartptr_verbosity 0

  SmartPtr()
    : ptr_(NULL)
  {
  }

  SmartPtr(const SmartPtr< T > &copy)
    : ptr_(NULL)
  {
    (void)SetFromSmartPtr_(copy);
  }

  SmartPtr(T *ptr)
    : ptr_(NULL)
  {
    (void)SetFromRawPtr_(ptr);
  }

  ~SmartPtr()
  {
    ReleasePointer_();
  }

  T *operator->() const
  {
#if COIN_COINUTILS_CHECKLEVEL > 0
    assert(ptr_);
#endif
    return ptr_;
  }

  T &operator*() const
  {
#if COIN_IPOPT_CHECKLEVEL > 0
    assert(ptr_);
#endif
    return *ptr_;
  }

  SmartPtr< T > &operator=(T *rhs)
  {
    return SetFromRawPtr_(rhs);
  }

  SmartPtr< T > &operator=(const SmartPtr< T > &rhs)
  {
    return SetFromSmartPtr_(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 U1, class U2 >
bool ComparePointers(const U1 *lhs, const U2 *rhs)
{
  if (lhs == rhs) {
    return true;
  }
  // 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 void*.
  return static_cast< const void * >(lhs) == static_cast< const void * >(rhs);
}

} // namespace Coin

//#############################################################################

template < class U1, class U2 >
bool operator==(const Coin::SmartPtr< U1 > &lhs, const Coin::SmartPtr< U2 > &rhs)
{
  return Coin::ComparePointers(lhs.GetRawPtr(), rhs.GetRawPtr());
}

template < class U1, class U2 >
bool operator==(const Coin::SmartPtr< U1 > &lhs, U2 *raw_rhs)
{
  return Coin::ComparePointers(lhs.GetRawPtr(), raw_rhs);
}

template < class U1, class U2 >
bool operator==(U1 *raw_lhs, const Coin::SmartPtr< U2 > &rhs)
{
  return Coin::ComparePointers(raw_lhs, rhs.GetRawPtr());
}

template < class U1, class U2 >
bool operator!=(const Coin::SmartPtr< U1 > &lhs, const Coin::SmartPtr< U2 > &rhs)
{
  return !operator==(lhs, rhs);
}

template < class U1, class U2 >
bool operator!=(const Coin::SmartPtr< U1 > &lhs, U2 *raw_rhs)
{
  return !operator==(lhs, raw_rhs);
}

template < class U1, class U2 >
bool operator!=(U1 *raw_lhs, const Coin::SmartPtr< U2 > &rhs)
{
  return !operator==(raw_lhs, rhs);
}

#define CoinReferencedObject Coin::ReferencedObject
#define CoinSmartPtr Coin::SmartPtr
#define CoinComparePointers Coin::ComparePointers

#endif

/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/