/////////////////////////////////////////////////////////////////////////////// 
// Copyright (C) 2002-2016, 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 Teigha(R) software pursuant to a license 
//   agreement with Open Design Alliance.
//   Teigha(R) Copyright (C) 2002-2016 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"

/** \details
    <group Other_Classes>

    This template class provides the typified implementation of smart pointers for instances of classes derived from the OdRxObject class.

    \remarks
    SmartPointers relieve the programmer of having to determine when objects are no longer needed, or having to delete them
    them at that time.

    Each object referenced by a SmartPointer (henceforth 'referenced object') 
    maintains a reference count; i.e., how many SmartPointers are referencing it.
    When the reference count reaches zero, the referenced object is deleted.

    \sa
    TD_Db

    \sa
    <link smart_pointers_example_refexchange.html, Example of Assigning Smart Pointers>

    <link smart_pointers_example_typified.html, Example of a Typified Smart Pointer>

    \sa
    <link smart_pointers_overview.html, Overview of Smart Pointer Classes> 

    The OdRxObjectPtr class
*/
template <class T> class OdSmartPtr : public OdBaseObjectPtr
{
protected:
  /** \details
    Increments the reference counter of the referenced object.
  */
  void internalAddRef()
  {
    if(m_pObject)
      m_pObject->addRef();
  }
  
  /** \details
    Assigns the pointer of specified object to the smart pointer.  
      
    \remarks
    The reference counter of the specified object is incremented.

    If this SmartPointer is currently referencing another object, that object 
    is released prior to the assignment.  

    \param pObject [in]  Pointer to the specified object to be assigned.
  */
  void assign(const T* pObject)
  {
    if (m_pObject != pObject) // Prevent deleting object if nRefs=1
    {
      release();
      m_pObject = const_cast<T*>(pObject);
      internalAddRef();
    }
  }
  
  /** \details
    Performs a "safe" assignment of the specified object to this SmartPointer object. 
      
    \param pObject [in]  Pointer to the object to be assigned.

    Throws:
    eNotThatKindOfClass if not successful. 
  */
  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.

  /** \details
    Declared private to prevent use.
    \note
    Use of SmartPtr<T> as a bool expression produces ambiguous calls with some compilers. Use isNull() instead. 
  */
  bool operator !() const { ODA_FAIL(); return false; }
  
  /** \details
    Declared private to prevent use.
    \note
    Use of SmartPtr<T> as a bool expression produces ambiguous calls with some compilers. Use isNull() instead. 
  */
  operator bool() const { ODA_FAIL(); return false; }

  /** \details
    Declared private to prevent use.
    \note
    Use of SmartPtr<T> as a bool expression produces ambiguous calls with some compilers. Use isNull() instead. 
  */
  operator bool() { ODA_FAIL(); return false; }
  
public:
  /** \details
    Constructors for the typified smart pointer.

    \param pObject [in]  Pointer to the object to be assigned to the new SmartPointer object.

    \remarks
    If pObject is specified, the smart pointer is set to the address of the specified object. If pObject is not specified, the smart pointer is set to a NULL.
    
    \remarks
    If OdRxObjMod or const OdBaseObjectPtr& are specified, the reference counter of the specified object 
    is not incremented. 
  */
  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());
  }

  /** \details
    Assigns the pointer of the specifed object to the smart pointer without incrementing its reference counter.  
      
    \param pObject [in]  Pointer to the specifed object to be assigned.

    \remarks
    The reference counter of the specified object is not incremented.

    If the smart pointer is currently referencing to another object, that object 
    is released prior to the assignment.

    \sa
    <link smart_pointers_example_typified.html, Example of a Typified Smart Pointer>
  */
  void attach(const T* pObject)
  {
    release();
    m_pObject = const_cast<T*>(pObject);
  }
  
  void attach(OdRxObject* pObject)
  {
    release();
    internalQueryX(pObject);
    if(pObject)
      pObject->release();
  }
  
  /** \details
    Destructor for the typified smart pointer.
 
    \remarks
    Decrements the reference counter of the referenced object. When the reference count reaches zero, the referenced object is deleted.
  */
  ~OdSmartPtr()
  {
    release();
  }
  
  /** \details
    Releases the smart pointer reference to the referenced object. 
    
    \remarks
    Decrements the reference counter of the referenced object.  When the reference count reaches zero, 
    the referenced object is deleted. Smart pointer is set to a NULL.

    \sa
    <link smart_pointers_example_typified.html, Example of a Typified Smart Pointer>
  */
  void release()
  {
    if (m_pObject)
    {
      m_pObject->release();
      m_pObject = 0;
    }
  }
  
  /** \details
    Releases the smart pointer reference to the referenced object without decrementing of the reference counter. 
      
    \remarks
    Returns the raw pointer to the referenced object. The reference counter is not modified 
    for the referenced object. Smart pointer is set to a NULL.
 
    \sa
    <link smart_pointers_example_typified.html, Example of a Typified Smart Pointer>
  */
  T* detach()
  {
    T* pRes = static_cast<T*>(m_pObject);
    m_pObject = 0;
    return pRes;
  }
  
  /** \remarks
    The assignment operator increments the reference counter of the referenced object and saves its address in the smart pointer.
     If the smart pointer is currently referencing to another object, that assignment operator releases the referenced object prior 
     to the assignment.  

    \sa
    <link smart_pointers_example_typified.html, Example of a Typified Smart Pointer>
  */
  OdSmartPtr& operator = (const OdSmartPtr& pObject)
  {
    assign(pObject);
    return *this;
  }
    
  OdSmartPtr& operator = (const OdBaseObjectPtr& pObject)
  {
    assign(pObject.get());
    return *this;
  }
  
  OdSmartPtr& operator = (const T* pObject)
  {
    assign(pObject);
    return *this;
  }

  /** \details
    Returns the raw pointer to the referenced object.

    \remarks
    The smart pointer maintains its reference to the referenced object. 
    The reference counter of the referenced object is not changed.
 
    \sa
    <link smart_pointers_example_typified.html, Example of a Typified Smart Pointer>
  */
  const T* get() const
  {
    return static_cast<const T*>(m_pObject);
  }
  
  T* get()
  {
    return static_cast<T*>(m_pObject);
  }
  
  /** \details
    Returns the raw pointer to the referenced object.
      
    \remarks
    The reference counter of the referenced object is not changed.
  */
  T* operator ->()
  {
    return static_cast<T*>(m_pObject);
  }
  
  const T* operator ->() const
  {
    return static_cast<const T*>(m_pObject);
  }
  
#ifdef ODA_GCC_2_95
  /** \details
    Returns the raw pointrer to the referenced object.
    
    \remarks
    The class maintains the reference to the referenced object.
    The reference counter of the referenced object is not changed.
  */
  operator T*() const
  {
    return const_cast<T*>(static_cast<const T*>(m_pObject));
  }
  
#else
  /** \details
    Returns the raw pointer the  referenced object.
    
    \remarks
    This SmartPointer maintains its reference to the referenced object.
    
    The reference counter of the referenced object is not changed.
  */
  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_