///////////////////////////////////////////////////////////////////////////////
|
// 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 _ODRXMULTICAST_H_
|
#define _ODRXMULTICAST_H_
|
|
#include "RxObject.h"
|
|
#include "TD_PackPush.h"
|
|
/** details
|
Provides ability to cast RxObject into set of classes as one step.
|
|
- Basic (investigate entire classes structure and set all pointers)
|
odrxMultiCast - Check all classes include protocol extensions
|
odrxMultiCastObject - Check all classes without protocol extensions check
|
odrxMultiCastX - Check all protocol extensions only
|
- Single shot (investigate classes structure until any first doesn't found and stop check)
|
odrxMultiCastFwd - scan forward (from OdRxObject class) with protocol extensions with second priority
|
odrxMultiCastFwdXPrior - scan forward (from OdRxObject class) with protocol extensions with first priority
|
odrxMultiCastFwdObject - scan forward (from OdRxObject class) without protocol extensions check
|
odrxMultiCastFwdX - scan forward (from OdRxObject class) protocol extensions only
|
odrxMultiCastBk - scan backward (from last inherited class) with protocol extensions with second priority
|
odrxMultiCastBkXPrior - scan backward (from last inherited class) with protocol extensions with first priority
|
odrxMultiCastBkObject - scan backward (from last inherited class) without protocol extensions check
|
odrxMultiCastBkX - scan backward (from last inherited class) protocol extensions only
|
|
\param pObject [in] - object for which check will be processed
|
\param pPointers [out] - array of pointers which will be set to found classes (use static_cast or c-style cast to convert pointers)
|
\param pClasses [in] - array of classes into which object cast must be processed
|
\param nClasses [in] - count of classes in pClasses and pointer in pPointers arrays
|
*/
|
|
inline // Returns count of available casts, pPointers must be non-zero
|
OdUInt32 odrxMultiCast(const OdRxObject *pObject, OdRxObjectPtr *pPointers, const OdRxClass **pClasses, OdUInt32 nClasses)
|
{
|
OdUInt32 nCasts = 0;
|
if (!pObject || !pPointers || !pClasses || !nClasses)
|
return nCasts;
|
OdRxClass *pClass = pObject->isA();
|
while (pClass)
|
{
|
for (OdUInt32 nClass = 0; nClass < nClasses; nClass++)
|
{
|
if (pPointers[nClass].isNull())
|
{
|
if (pClass == pClasses[nClass])
|
{
|
pPointers[nClass] = pObject;
|
nCasts++;
|
if (nCasts == nClasses)
|
return nCasts;
|
}
|
else
|
{
|
pPointers[nClass] = pClass->getX(pClasses[nClass]);
|
if (!pPointers[nClass].isNull())
|
{
|
nCasts++;
|
if (nCasts == nClasses)
|
return nCasts;
|
}
|
}
|
}
|
}
|
pClass = pClass->myParent();
|
}
|
return nCasts;
|
}
|
|
inline // If pCasts null returns bit mask, elsewhere count of casts
|
OdUInt32 odrxMultiCastObject(const OdRxObject *pObject, bool *pCasts, const OdRxClass **pClasses, OdUInt32 nClasses)
|
{
|
OdUInt32 nCasts = 0, nBits = 0;
|
if (!pObject || !pClasses || !nClasses)
|
return nCasts;
|
OdRxClass *pClass = pObject->isA();
|
while (pClass)
|
{
|
for (OdUInt32 nClass = 0; nClass < nClasses; nClass++)
|
{
|
if ((pCasts) ? !pCasts[nClass] : ((nBits & (1 << nClass)) == 0))
|
{
|
if (pClass == pClasses[nClass])
|
{
|
if (pCasts)
|
pCasts[nClass] = true;
|
else
|
nBits |= 1 << nClass;
|
nCasts++;
|
if (nCasts == nClasses)
|
return nCasts;
|
}
|
}
|
}
|
pClass = pClass->myParent();
|
}
|
return (pCasts) ? nCasts : nBits;
|
}
|
|
inline // Returns count of available casts, pPointers must be non-zero
|
OdUInt32 odrxMultiCastX(const OdRxObject *pObject, OdRxObjectPtr *pPointers, const OdRxClass **pClasses, OdUInt32 nClasses)
|
{
|
OdUInt32 nCasts = 0;
|
if (!pObject || !pPointers || !pClasses || !nClasses)
|
return nCasts;
|
OdRxClass *pClass = pObject->isA();
|
while (pClass)
|
{
|
for (OdUInt32 nClass = 0; nClass < nClasses; nClass++)
|
{
|
if (pPointers[nClass].isNull())
|
{
|
pPointers[nClass] = pClass->getX(pClasses[nClass]);
|
if (!pPointers[nClass].isNull())
|
{
|
nCasts++;
|
if (nCasts == nClasses)
|
return nCasts;
|
}
|
}
|
}
|
pClass = pClass->myParent();
|
}
|
return nCasts;
|
}
|
|
inline
|
OdUInt32 odrxMultiCastFwd_(OdRxClass *pClass, const OdRxObject *pObject, OdRxObjectPtr &pPointer, const OdRxClass **pClasses, OdUInt32 nClasses)
|
{
|
OdRxClass *pParent = pClass->myParent();
|
if (pParent)
|
{
|
OdUInt32 nIndex = odrxMultiCastFwd_(pParent, pObject, pPointer, pClasses, nClasses);
|
if (nIndex < nClasses)
|
return nIndex;
|
}
|
for (OdUInt32 nClass = 0; nClass < nClasses; nClass++)
|
{
|
if (pClass == pClasses[nClass])
|
{
|
pPointer = pObject;
|
return nClass;
|
}
|
else
|
{
|
pPointer = pClass->getX(pClasses[nClass]);
|
if (!pPointer.isNull())
|
return nClass;
|
}
|
}
|
return nClasses;
|
}
|
inline
|
OdUInt32 odrxMultiCastFwd(const OdRxObject *pObject, OdRxObjectPtr &pPointer, const OdRxClass **pClasses, OdUInt32 nClasses)
|
{
|
if (!pObject || !pClasses || !nClasses)
|
return nClasses;
|
OdRxClass *pClass = pObject->isA();
|
return odrxMultiCastFwd_(pClass, pObject, pPointer, pClasses, nClasses);
|
}
|
|
inline
|
OdUInt32 odrxMultiCastFwdXPrior_(OdRxClass *pClass, const OdRxObject *pObject, OdRxObjectPtr &pPointer, const OdRxClass **pClasses, OdUInt32 nClasses)
|
{
|
OdRxClass *pParent = pClass->myParent();
|
if (pParent)
|
{
|
OdUInt32 nIndex = odrxMultiCastFwdXPrior_(pParent, pObject, pPointer, pClasses, nClasses);
|
if (nIndex < nClasses)
|
return nIndex;
|
}
|
for (OdUInt32 nClass = 0; nClass < nClasses; nClass++)
|
{
|
pPointer = pClass->getX(pClasses[nClass]);
|
if (!pPointer.isNull())
|
return nClass;
|
if (pClass == pClasses[nClass])
|
{
|
pPointer = pObject;
|
return nClass;
|
}
|
}
|
return nClasses;
|
}
|
inline
|
OdUInt32 odrxMultiCastFwdXPrior(const OdRxObject *pObject, OdRxObjectPtr &pPointer, const OdRxClass **pClasses, OdUInt32 nClasses)
|
{
|
if (!pObject || !pClasses || !nClasses)
|
return nClasses;
|
OdRxClass *pClass = pObject->isA();
|
return odrxMultiCastFwdXPrior_(pClass, pObject, pPointer, pClasses, nClasses);
|
}
|
|
inline
|
OdUInt32 odrxMultiCastFwdObject_(OdRxClass *pClass, const OdRxObject *pObject, const OdRxClass **pClasses, OdUInt32 nClasses)
|
{
|
OdRxClass *pParent = pClass->myParent();
|
if (pParent)
|
{
|
OdUInt32 nIndex = odrxMultiCastFwdObject_(pParent, pObject, pClasses, nClasses);
|
if (nIndex < nClasses)
|
return nIndex;
|
}
|
for (OdUInt32 nClass = 0; nClass < nClasses; nClass++)
|
{
|
if (pClass == pClasses[nClass])
|
return nClass;
|
}
|
return nClasses;
|
}
|
inline
|
OdUInt32 odrxMultiCastFwdObject(const OdRxObject *pObject, const OdRxClass **pClasses, OdUInt32 nClasses)
|
{
|
if (!pObject || !pClasses || !nClasses)
|
return nClasses;
|
OdRxClass *pClass = pObject->isA();
|
return odrxMultiCastFwdObject_(pClass, pObject, pClasses, nClasses);
|
}
|
|
inline
|
OdUInt32 odrxMultiCastFwdX_(OdRxClass *pClass, const OdRxObject *pObject, OdRxObjectPtr &pPointer, const OdRxClass **pClasses, OdUInt32 nClasses)
|
{
|
OdRxClass *pParent = pClass->myParent();
|
if (pParent)
|
{
|
OdUInt32 nIndex = odrxMultiCastFwdX_(pParent, pObject, pPointer, pClasses, nClasses);
|
if (nIndex < nClasses)
|
return nIndex;
|
}
|
for (OdUInt32 nClass = 0; nClass < nClasses; nClass++)
|
{
|
pPointer = pClass->getX(pClasses[nClass]);
|
if (!pPointer.isNull())
|
return nClass;
|
}
|
return nClasses;
|
}
|
inline
|
OdUInt32 odrxMultiCastFwdX(const OdRxObject *pObject, OdRxObjectPtr &pPointer, const OdRxClass **pClasses, OdUInt32 nClasses)
|
{
|
if (!pObject || !pClasses || !nClasses)
|
return nClasses;
|
OdRxClass *pClass = pObject->isA();
|
return odrxMultiCastFwdX_(pClass, pObject, pPointer, pClasses, nClasses);
|
}
|
|
inline
|
OdUInt32 odrxMultiCastBk(const OdRxObject *pObject, OdRxObjectPtr &pPointer, const OdRxClass **pClasses, OdUInt32 nClasses)
|
{
|
if (!pObject || !pClasses || !nClasses)
|
return nClasses;
|
OdRxClass *pClass = pObject->isA();
|
while (pClass)
|
{
|
for (OdUInt32 nClass = 0; nClass < nClasses; nClass++)
|
{
|
if (pClass == pClasses[nClass])
|
{
|
pPointer = pObject;
|
return nClass;
|
}
|
else
|
{
|
pPointer = pClass->getX(pClasses[nClass]);
|
if (!pPointer.isNull())
|
return nClass;
|
}
|
}
|
pClass = pClass->myParent();
|
}
|
return nClasses;
|
}
|
|
inline
|
OdUInt32 odrxMultiCastBkXPrior(const OdRxObject *pObject, OdRxObjectPtr &pPointer, const OdRxClass **pClasses, OdUInt32 nClasses)
|
{
|
if (!pObject || !pClasses || !nClasses)
|
return nClasses;
|
OdRxClass *pClass = pObject->isA();
|
while (pClass)
|
{
|
for (OdUInt32 nClass = 0; nClass < nClasses; nClass++)
|
{
|
pPointer = pClass->getX(pClasses[nClass]);
|
if (!pPointer.isNull())
|
return nClass;
|
if (pClass == pClasses[nClass])
|
{
|
pPointer = pObject;
|
return nClass;
|
}
|
}
|
pClass = pClass->myParent();
|
}
|
return nClasses;
|
}
|
|
inline
|
OdUInt32 odrxMultiCastBkObject(const OdRxObject *pObject, const OdRxClass **pClasses, OdUInt32 nClasses)
|
{
|
if (!pObject || !pClasses || !nClasses)
|
return nClasses;
|
OdRxClass *pClass = pObject->isA();
|
while (pClass)
|
{
|
for (OdUInt32 nClass = 0; nClass < nClasses; nClass++)
|
{
|
if (pClass == pClasses[nClass])
|
return nClass;
|
}
|
pClass = pClass->myParent();
|
}
|
return nClasses;
|
}
|
|
inline
|
OdUInt32 odrxMultiCastBkX(const OdRxObject *pObject, OdRxObjectPtr &pPointer, const OdRxClass **pClasses, OdUInt32 nClasses)
|
{
|
if (!pObject || !pClasses || !nClasses)
|
return nClasses;
|
OdRxClass *pClass = pObject->isA();
|
while (pClass)
|
{
|
for (OdUInt32 nClass = 0; nClass < nClasses; nClass++)
|
{
|
pPointer = pClass->getX(pClasses[nClass]);
|
if (!pPointer.isNull())
|
return nClass;
|
}
|
pClass = pClass->myParent();
|
}
|
return nClasses;
|
}
|
|
#include "TD_PackPop.h"
|
|
#endif // _ODRXMULTICAST_H_
|
