///////////////////////////////////////////////////////////////////////////////
|
// 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 _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.
|
|
Library: TD_Root
|
<group Other_Classes>
|
*/
|
template <class T> class OdSharedPtr
|
{
|
public:
|
|
OdSharedPtr() : _reference(0), _refCount(0) {}
|
|
OdSharedPtr(T* pObject) : _refCount(0)
|
{
|
if ((_reference = pObject) != 0)
|
{
|
_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()
|
{
|
if (_refCount && !--*_refCount)
|
{
|
delete _reference;
|
odrxFree(_refCount);
|
}
|
}
|
|
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 != 0)
|
{
|
// 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;
|
}
|
|
T* operator->() { return _reference; }
|
|
/** \details
|
Returns the object referenced by this SharedPointer.
|
|
\remarks
|
This SharedPointer object maintains its reference to the object, and the object's
|
reference count is not modified.
|
*/
|
T* get() { return _reference; }
|
const T* get() const { return _reference; }
|
|
operator T*() { return _reference; }
|
operator const T*() const { return _reference; }
|
|
/** \details
|
Returns the object referenced by this SharedPointer.
|
|
\remarks
|
The reference count of the referenced object is unchanged.
|
*/
|
const T* operator->() const { return _reference; }
|
|
T& operator*(){ return *_reference; }
|
|
const T& operator*() const { return *_reference; }
|
|
/** \details
|
Returns true if and only if this SharedPointer contains a null reference.
|
*/
|
bool isNull() const {return _reference == 0;}
|
|
/** \details
|
Detaches referenced object from the pointer.
|
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 0;
|
if (*_refCount > 1)
|
{
|
ODA_FAIL();
|
}
|
odrxFree(_refCount);
|
_refCount = 0;
|
T* ret = _reference;
|
_reference = 0;
|
return ret;
|
}
|
/** \details
|
Returns the number of references to the object.
|
*/
|
int refCount() const
|
{
|
return _refCount ? *_refCount : 0;
|
}
|
private:
|
T* _reference;
|
int* _refCount;
|
};
|
|
#include "TD_PackPop.h"
|
|
#endif // _SharedPtr_h_Included
|
