/////////////////////////////////////////////////////////////////////////////// 
// Copyright (C) 2002-2025, 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-2025 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 _SharedPtr_h_Included
#define _SharedPtr_h_Included

#include "TD_PackPush.h"

#include "OdaCommon.h"
#include "OdAlloc.h"

/** \details
    This template class implements SharedPointers for instances not derived from OdRxObject.

    \remarks
    SharedPointers 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 SharedPointer (henceforth 'referenced object') 
    has associated with it a reference count; i.e., how many SharedPointers are referencing it.
    When the reference count reaches zero, the referenced object is deleted.

    Corresponding C++ library: TD_Root
    <group Other_Classes> 
*/
template <class T> class OdSharedPtr
{
public:

  OdSharedPtr() : _reference(nullptr), _refCount(nullptr) {}
  
  OdSharedPtr(T* pObject) : _refCount(nullptr)
  { 
    if ((_reference = pObject) != nullptr)
    {
      _refCount = (int*)::odrxAlloc(sizeof(int));
      *_refCount = 1;
    }
  }
  
  /** \remarks
    The another OdSharedPtr object is supplied, its reference count, if present, is incremented.
  */
  OdSharedPtr(const OdSharedPtr& other) 
  {
    _reference = other._reference;
    _refCount = other._refCount;
    if (_refCount)
    {
      ++*_refCount;
    }
  }

  /** \remarks
    Decrements the reference count of the object referenced by this
    SharedPointer object.

    When the reference count reaches zero, the referenced object is deleted.
  */
  ~OdSharedPtr()
  {
    destroy();
  }

  OdSharedPtr& operator=(const OdSharedPtr &other)
  {
    if (_reference != other._reference)
    {
      if (_refCount && !--*_refCount)
      {
        odrxFree(_refCount);
        delete _reference;
      }

      _reference = other._reference;
      _refCount = other._refCount;
      if (_refCount)
      {
        ++*_refCount;
      }
    }
#ifdef _DEBUG
    else if (_reference != nullptr)
    {
      // there can't be independent shared pointers on the same object
      ODA_ASSERT_ONCE(_refCount == other._refCount);
      // if the counters are the same - do nothing (the assignment is no-op)
    }
#endif // _DEBUG
    return *this;
  }

  /** \details
    Returns pointer on the object referenced by this SharedPointer.
      
    \remarks
    The reference count of the referenced object is not modified.
  */
  T* operator->() { return _reference; }

  /** \details
    Returns pointer on the object referenced by this SharedPointer.

    \remarks
    The reference count of the referenced object is not modified.
  */
  const T* operator->() const { return _reference; }

  /** \details
    Returns pointer on the object referenced by this SharedPointer.

    \remarks
    The reference count of the referenced object is not modified.
  */
  operator T* () { return _reference; }

  /** \details
    Returns pointer on the object referenced by this SharedPointer.

    \remarks
    The reference count of the referenced object is not modified.
  */
  operator const T* () const { return _reference; }

  /** \details
    Returns the object referenced by this SharedPointer.

    \remarks
    The reference count of the referenced object is not modified.
  */
  T& operator*() { return *_reference; }

  /** \details
    Returns the object referenced by this SharedPointer.

    \remarks
    The reference count of the referenced object is not modified.
  */
  const T& operator*() const { return *_reference; }

  /** \details
    Returns pointer on the object referenced by this SharedPointer.
      
    \remarks
    The reference count of the referenced object is not modified.
  */
  T* get() { return _reference; }

  /** \details
    Returns pointer on the object referenced by this SharedPointer.

    \remarks
    The reference count of the referenced object is not modified.
  */
  const T* get() const { return _reference; }

  /** \details
    Resets the pointer.
  */
  void reset(T* pObject = nullptr)
  {
    destroy();
    _refCount = nullptr;
    if ((_reference = pObject) != nullptr)
    {
      _refCount = (int*)::odrxAlloc(sizeof(int));
      *_refCount = 1;
    }
  }

  /** \details
    Detaches referenced object from the pointer and returns object.
    Warning: this method may be used only if reference count is 1
      (i.e. when this pointer is the single owner of the referenced object)
  */
  T* detach()
  {
    if (!_refCount)
      return nullptr;
    if (*_refCount > 1)
    {
      ODA_FAIL();
    }
    odrxFree(_refCount);
    T* ret = _reference;
    _refCount = nullptr;
    _reference = nullptr;
    return ret;
  }

  /** \details
    Swaps the managed objects and the reference counts of this shared pointer and another one.
  */
  void swap(OdSharedPtr<T>& other) {
    T* tmpReference = _reference;
    int* tmpRefCount = _refCount;
    _reference = other._reference;
    _refCount = other._refCount;
    other._reference = tmpReference;
    other._refCount = tmpRefCount;
  }

  /** \details
    Returns the number of references to the object.
  */
  int refCount() const
  {
    return _refCount ? *_refCount : 0;
  }

  /** \details
    Returns true if the managed object is managed only by the current shared_ptr.
  */
  bool isUnique() const
  {
    return _refCount ? *_refCount == 1 : false;
  }

  /** \details
    Returns true if and only if this SharedPointer contains a null reference.
  */
  bool isNull() const {return _reference == nullptr;}

private:
  T* _reference;
  int* _refCount;

  void destroy() {
    if (_refCount && !--*_refCount)
    {
      delete _reference;
      odrxFree(_refCount);
    }
  }
};

#include "TD_PackPop.h"

#endif // _SharedPtr_h_Included