OSSmartPtr.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.
//
// $Id: IpSmartPtr.hpp 2005 2011-06-06 12:55:16Z stefan $
//
// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13

// copied from IpReferenced.hpp so as to allow OS to be compiled
// stand-alone (without the Fortran implications inherent in Ipopt)

#ifndef OSSMARTPTR_HPP
#define OSSMARTPTR_HPP

#include "OSReferenced.hpp"

  template<class T>
  class OSSmartPtr : public OSReferencer
  {
  public:

    OSSmartPtr();

    OSSmartPtr(const OSSmartPtr<T>& copy);

    OSSmartPtr(T* ptr);

    ~OSSmartPtr();

    T* operator->() const;

    T& operator*() const;

    OSSmartPtr<T>& operator=(T* rhs);

    OSSmartPtr<T>& operator=(const OSSmartPtr<T>& rhs);

    template <class U1, class U2>
    friend
    bool operator==(const OSSmartPtr<U1>& lhs, const OSSmartPtr<U2>& rhs);

    template <class U1, class U2>
    friend
    bool operator==(const OSSmartPtr<U1>& lhs, U2* raw_rhs);

    template <class U1, class U2>
    friend
    bool operator==(U1* lhs, const OSSmartPtr<U2>& raw_rhs);

    template <class U1, class U2>
    friend
    bool operator!=(const OSSmartPtr<U1>& lhs, const OSSmartPtr<U2>& rhs);

    template <class U1, class U2>
    friend
    bool operator!=(const OSSmartPtr<U1>& lhs, U2* raw_rhs);

    template <class U1, class U2>
    friend
    bool operator!=(U1* lhs, const OSSmartPtr<U2>& raw_rhs);

    template <class U>
    friend
    U* GetRawPtr(const OSSmartPtr<U>& smart_ptr);

    template <class U>
    friend
    OSSmartPtr<const U> ConstPtr(const OSSmartPtr<U>& smart_ptr);

    template <class U>
    friend
    bool IsValid(const OSSmartPtr<U>& smart_ptr);

    template <class U>
    friend
    bool IsNull(const OSSmartPtr<U>& smart_ptr);

  private:
    T* ptr_;

    OSSmartPtr<T>& SetFromRawPtr_(T* rhs);

    OSSmartPtr<T>& SetFromSmartPtr_(const OSSmartPtr<T>& rhs);

    void ReleasePointer_();
  };

  template <class U>
  U* GetRawPtr(const OSSmartPtr<U>& smart_ptr);

  template <class U>
  OSSmartPtr<const U> ConstPtr(const OSSmartPtr<U>& smart_ptr);

  template <class U>
  bool IsNull(const OSSmartPtr<U>& smart_ptr);

  template <class U>
  bool IsValid(const OSSmartPtr<U>& smart_ptr);

  template <class U1, class U2>
  bool operator==(const OSSmartPtr<U1>& lhs, const OSSmartPtr<U2>& rhs);

  template <class U1, class U2>
  bool operator==(const OSSmartPtr<U1>& lhs, U2* raw_rhs);

  template <class U1, class U2>
  bool operator==(U1* lhs, const OSSmartPtr<U2>& raw_rhs);

  template <class U1, class U2>
  bool operator!=(const OSSmartPtr<U1>& lhs, const OSSmartPtr<U2>& rhs);

  template <class U1, class U2>
  bool operator!=(const OSSmartPtr<U1>& lhs, U2* raw_rhs);

  template <class U1, class U2>
  bool operator!=(U1* lhs, const OSSmartPtr<U2>& raw_rhs);



  template <class T>
  OSSmartPtr<T>::OSSmartPtr()
      :
      ptr_(0)
  {

#ifdef CHECK_SMARTPTR

    const OSReferencedObject* trying_to_use_SmartPtr_with_an_object_that_does_not_inherit_from_ReferencedObject_
    = ptr_;
    trying_to_use_SmartPtr_with_an_object_that_does_not_inherit_from_ReferencedObject_ = 0;
#endif

  }


  template <class T>
  OSSmartPtr<T>::OSSmartPtr(const OSSmartPtr<T>& copy)
      :
      ptr_(0)
  {

#ifdef CHECK_SMARTPTR

    const ReferencedObject* trying_to_use_SmartPtr_with_an_object_that_does_not_inherit_from_ReferencedObject_
    = ptr_;
    trying_to_use_SmartPtr_with_an_object_that_does_not_inherit_from_ReferencedObject_ = 0;
#endif

    (void) SetFromSmartPtr_(copy);
  }


  template <class T>
  OSSmartPtr<T>::OSSmartPtr(T* ptr)
      :
      ptr_(0)
  {
#ifdef CHECK_SMARTPTR

    const ReferencedObject* trying_to_use_SmartPtr_with_an_object_that_does_not_inherit_from_ReferencedObject_
    = ptr_;
    trying_to_use_SmartPtr_with_an_object_that_does_not_inherit_from_ReferencedObject_ = 0;
#endif

    (void) SetFromRawPtr_(ptr);
  }

  template <class T>
  OSSmartPtr<T>::~OSSmartPtr()
  {
    ReleasePointer_();
  }

  template <class T>
  T* OSSmartPtr<T>::operator->() const
  {
    return ptr_;
  }


  template <class T>
  T& OSSmartPtr<T>::operator*() const
  {
    return *ptr_;
  }


  template <class T>
  OSSmartPtr<T>& OSSmartPtr<T>::operator=(T* rhs)
  {
    return SetFromRawPtr_(rhs);
  }


  template <class T>
  OSSmartPtr<T>& OSSmartPtr<T>::operator=(const OSSmartPtr<T>& rhs)
  {
    return SetFromSmartPtr_(rhs);
  }


  template <class T>
  OSSmartPtr<T>& OSSmartPtr<T>::SetFromRawPtr_(T* rhs)
  {
    // Release any old pointer
    ReleasePointer_();

    if (rhs != 0) {
      rhs->AddRef(this);
      ptr_ = rhs;
    }

    return *this;
  }

  template <class T>
  OSSmartPtr<T>& OSSmartPtr<T>::SetFromSmartPtr_(const OSSmartPtr<T>& rhs)
  {
    T* ptr = GetRawPtr(rhs);
    /* AW: I changed this so that NULL is correctly copied from the
       right hand side */
    //     if (ptr != NULL) {
    //       SetFromRawPtr_(ptr);
    //     }
    SetFromRawPtr_(ptr);

    return (*this);
  }


  template <class T>
  void OSSmartPtr<T>::ReleasePointer_()
  {
    if (ptr_) {
      ptr_->ReleaseRef(this);
      if (ptr_->ReferenceCount() == 0) {
        delete ptr_;
      }
      ptr_ = 0;
    }
  }


  template <class U>
  U* GetRawPtr(const OSSmartPtr<U>& smart_ptr)
  {
    return smart_ptr.ptr_;
  }

  template <class U>
  OSSmartPtr<const U> ConstPtr(const OSSmartPtr<U>& smart_ptr)
  {
    // compiler should implicitly cast
    return GetRawPtr(smart_ptr);
  }

  template <class U>
  bool IsValid(const OSSmartPtr<U>& smart_ptr)
  {
    return !IsNull(smart_ptr);
  }

  template <class U>
  bool IsNull(const OSSmartPtr<U>& smart_ptr)
  {
    return (smart_ptr.ptr_ == 0);
  }


  template <class U1, class U2>
  bool ComparePointers(const U1* lhs, const U2* rhs)
  {
    if (lhs == rhs) {
      return true;
    }

    // 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 void*
    const void* v_lhs = static_cast<const void*>(lhs);
    const void* v_rhs = static_cast<const void*>(rhs);
    if (v_lhs == v_rhs) {
      return true;
    }

    // They must not be the same
    return false;
  }

  template <class U1, class U2>
  bool operator==(const OSSmartPtr<U1>& lhs, const OSSmartPtr<U2>& rhs)
  {
    U1* raw_lhs = GetRawPtr(lhs);
    U2* raw_rhs = GetRawPtr(rhs);
    return ComparePointers(raw_lhs, raw_rhs);
  }

  template <class U1, class U2>
  bool operator==(const OSSmartPtr<U1>& lhs, U2* raw_rhs)
  {
    U1* raw_lhs = GetRawPtr(lhs);
    return ComparePointers(raw_lhs, raw_rhs);
  }

  template <class U1, class U2>
  bool operator==(U1* raw_lhs, const OSSmartPtr<U2>& rhs)
  {
    const U2* raw_rhs = GetRawPtr(rhs);
    return ComparePointers(raw_lhs, raw_rhs);
  }

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

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

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

#endif