SmartPtr.h

Go to the documentation of this file.

 
// Copyright (C) 2002-2022, Open Design Alliance (the "Alliance"). 
// All rights reserved. 
// 
// This software and its documentation and related materials are owned by 
// the Alliance. The software may only be incorporated into application 
// programs owned by members of the Alliance, subject to a signed 
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable  
// trade secrets of the Alliance and its suppliers. The software is also 
// protected by copyright law and international treaty provisions. Application  
// programs incorporating this software must include the following statement 
// with their copyright notices:
//   
//   This application incorporates Open Design Alliance software pursuant to a license 
//   agreement with Open Design Alliance.
//   Open Design Alliance Copyright (C) 2002-2022 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
 
#ifndef _ODASMARTPOINTER_INCLUDED_
#define _ODASMARTPOINTER_INCLUDED_
 
#include "TD_PackPush.h"
#include "Error_NotThatKindOfClass.h"
#include "BaseObjectPtr.h"
 
template <class T> class OdSmartPtr : public OdBaseObjectPtr
{
protected:
  void internalAddRef()
  {
    if(m_pObject)
      m_pObject->addRef();
  }
  
  void assign(const T* pObject)
  {
    if (m_pObject != pObject) // Prevent deleting object if nRefs=1
    {
      release();
      m_pObject = const_cast<T*>(pObject);
      internalAddRef();
    }
  }
  
  void internalQueryX(const OdRxObject* pObject)
  {
    if(pObject)
    {
      OdRxObject* pX = pObject->queryX(T::desc());
      if(pX)
        m_pObject = pX;
      else
        throw OdError_NotThatKindOfClass(pObject->isA(), T::desc());
    }
  }
  
  void assign(const OdRxObject* pObject)
  {
    release();
    internalQueryX(pObject);
  }
  
  // Note: Using of SmartPtr<T> as bool expression produce ambiguous call with some compilers.
  // Use isNull() method instead.
 
  bool operator !() const { ODA_FAIL(); return false; }
  
  operator bool() const { ODA_FAIL(); return false; }
 
  operator bool() { ODA_FAIL(); return false; }
  
public:
  OdSmartPtr()
    : OdBaseObjectPtr()
  {
  }
 
  OdSmartPtr(const T* pObject, OdRxObjMod)
    : OdBaseObjectPtr(pObject)
  {
  }
  
  OdSmartPtr(const T* pObject)
    : OdBaseObjectPtr(pObject)
  {
    internalAddRef();
  }
  
  OdSmartPtr(const OdRxObject* pObject)
    : OdBaseObjectPtr()
  {
    internalQueryX(pObject);
  }
 
  OdSmartPtr(OdRxObject* pObject, OdRxObjMod)
    : OdBaseObjectPtr()
  {
    internalQueryX(pObject);
    if(pObject)
      pObject->release();
  }
  
  OdSmartPtr(const OdSmartPtr& pObject)
    : OdBaseObjectPtr(pObject.get())
  {
    internalAddRef();
  }
 
  OdSmartPtr(const OdRxObjectPtr& pObject)
    : OdBaseObjectPtr()
  {
    internalQueryX(pObject.get());
  }
 
  OdSmartPtr(const OdBaseObjectPtr& pObject)
    : OdBaseObjectPtr()
  {
    internalQueryX(pObject.get());
  }
 
//FELIX_CHANGE_BEGIN
  OdSmartPtr( OdSmartPtr&& pObject ) noexcept : OdBaseObjectPtr( std::move( pObject ) )
  {}
//FELIX_CHANGE_END
 
  void attach(const T* pObject)
  {
    release();
    m_pObject = const_cast<T*>(pObject);
  }
  
  void attach(OdRxObject* pObject)
  {
    release();
    internalQueryX(pObject);
    if(pObject)
      pObject->release();
  }
  
  ~OdSmartPtr()
  {
    release();
  }
  
  void release()
  {
    if (m_pObject)
    {
      m_pObject->release();
      m_pObject = 0;
    }
  }
  
  T* detach()
  {
    T* pRes = static_cast<T*>(m_pObject);
    m_pObject = 0;
    return pRes;
  }
  
  OdSmartPtr& operator = (const OdSmartPtr& pObject)
  {
    assign(pObject);
    return *this;
  }
 
//FELIX_CHANGE_BEGIN
  OdSmartPtr& operator = ( OdSmartPtr&& pObject ) noexcept
  {
    OdBaseObjectPtr::operator=( std::move( pObject ) );
    return *this;
  }
//FELIX_CHANGE_END
 
  OdSmartPtr& operator = (const OdBaseObjectPtr& pObject)
  {
    assign(pObject.get());
    return *this;
  }
  
  OdSmartPtr& operator = (const T* pObject)
  {
    assign(pObject);
    return *this;
  }
 
  const T* get() const
  {
    return static_cast<const T*>(m_pObject);
  }
  
  T* get()
  {
    return static_cast<T*>(m_pObject);
  }
  
  T* operator ->()
  {
    return static_cast<T*>(m_pObject);
  }
  const T* operator ->() const
  {
    return static_cast<const T*>(m_pObject);
  }
  
#ifdef ODA_GCC_2_95
  operator T*() const
  {
    return const_cast<T*>(static_cast<const T*>(m_pObject));
  }
  
#else
  operator T*()
  {
    return static_cast<T*>(m_pObject);
  }
  
  operator const T*() const
  {
    return static_cast<const T*>(m_pObject);
  }
 
#endif
    
  bool operator==(const void* pObject) const
  {
    return (m_pObject==pObject);
  }
 
  bool operator==(const OdSmartPtr& pObject) const
  {
    return operator==((void*)pObject.get());
  }
  
  bool operator!=(const void* pObject) const
  {
    return (m_pObject!=pObject);
  }
 
  bool operator!=(const OdSmartPtr& pObject) const
  {
    return operator!=((void*)pObject.get());
  }
};
 
#include "TD_PackPop.h"
 
#endif // _ODASMARTPOINTER_INCLUDED_