#include "CDSRefMap.h"
#include <stdlib.h>
#include <string.h>
#include <libkern/OSAtomic.h>
CDSRefMap::CDSRefMap ( void ) : fMapMutex( "CDSRefMap::fMapMutex" )
{
fTableCount = 0;
memset( fRefMapTables, 0, sizeof( fRefMapTables ) );
}
CDSRefMap::~CDSRefMap ( void )
{
ClearAllMaps();
}
void CDSRefMap::ClearAllMaps( void )
{
UInt32 i = 1;
UInt32 j = 1;
fMapMutex.WaitLock();
for ( i = 1; i <= kMaxFWTables; i++ ) {
if ( fRefMapTables[ i ] != nil )
{
for (j=0; j< kMaxFWTableItems; j++)
{
if (fRefMapTables[ i ]->fTableData[j] != nil)
{
free(fRefMapTables[ i ]->fTableData[j]);
fRefMapTables[ i ]->fTableData[j] = nil;
}
}
free( fRefMapTables[ i ] ); fRefMapTables[ i ] = nil;
fTableCount--;
}
}
fMapMutex.SignalLock();
}
tDirStatus CDSRefMap::VerifyReference ( tDirReference inDirRef, UInt32 inType,
SInt32 inPID )
{
tDirStatus siResult = eDSInvalidReference;
sFWRefMapEntry *refData = nil;
sPIDFWInfo *pPIDInfo = nil;
if ((inDirRef & 0x00C00000) != 0)
{
siResult = GetReference( inDirRef, &refData );
if ( siResult == eDSNoErr )
{
if ( refData->fType != inType )
{
siResult = eDSInvalidRefType;
}
else
{
siResult = eDSInvalidRefType;
if (refData->fPID == inPID)
{
siResult = eDSNoErr;
}
else
{
pPIDInfo = refData->fChildPID;
while ( (pPIDInfo != nil) && (siResult != eDSNoErr) )
{
if (pPIDInfo->fPID == inPID)
{
siResult = eDSNoErr;
}
pPIDInfo = pPIDInfo->fNext;
}
}
}
}
}
return( siResult );
}
tDirStatus CDSRefMap::VerifyDirRef ( tDirReference inDirRef,
SInt32 inPID )
{
tDirStatus siResult = eDSDirSrvcNotOpened;
siResult = VerifyReference( inDirRef, eDirectoryRefType, inPID );
return( siResult );
}
tDirStatus CDSRefMap::VerifyNodeRef ( tDirNodeReference inDirNodeRef,
SInt32 inPID )
{
tDirStatus siResult = eDSDirSrvcNotOpened;
siResult = VerifyReference( inDirNodeRef, eNodeRefType, inPID );
return( siResult );
}
tDirStatus CDSRefMap::VerifyRecordRef ( tRecordReference inRecordRef,
SInt32 inPID )
{
tDirStatus siResult = eDSDirSrvcNotOpened;
siResult = VerifyReference( inRecordRef, eRecordRefType, inPID );
return( siResult );
}
tDirStatus CDSRefMap::VerifyAttrListRef ( tAttributeListRef inAttributeListRef,
SInt32 inPID )
{
tDirStatus siResult = eDSDirSrvcNotOpened;
siResult = VerifyReference( inAttributeListRef, eAttrListRefType, inPID );
return( siResult );
}
tDirStatus CDSRefMap::VerifyAttrValueRef ( tAttributeValueListRef inAttributeValueListRef,
SInt32 inPID )
{
tDirStatus siResult = eDSDirSrvcNotOpened;
siResult = VerifyReference( inAttributeValueListRef, eAttrValueListRefType, inPID );
return( siResult );
}
tDirStatus CDSRefMap::NewDirRefMap ( UInt32 *outNewRef, SInt32 inPID,
UInt32 serverRef,
UInt32 messageIndex )
{
tDirStatus siResult = eDSDirSrvcNotOpened;
siResult = GetNewRef( outNewRef, 0, eDirectoryRefType, inPID, serverRef, messageIndex );
return( siResult );
}
tDirStatus CDSRefMap::NewNodeRefMap ( UInt32 *outNewRef,
UInt32 inParentID,
SInt32 inPID,
UInt32 serverRef,
UInt32 messageIndex,
char *inPluginName)
{
tDirStatus siResult = eDSDirSrvcNotOpened;
siResult = GetNewRef( outNewRef, inParentID, eNodeRefType, inPID, serverRef, messageIndex );
if (siResult == eDSNoErr)
{
siResult = SetPluginName( *outNewRef, eNodeRefType, inPluginName, inPID );
}
return( siResult );
}
tDirStatus CDSRefMap::NewRecordRefMap ( UInt32 *outNewRef,
UInt32 inParentID,
SInt32 inPID,
UInt32 serverRef,
UInt32 messageIndex )
{
tDirStatus siResult = eDSDirSrvcNotOpened;
siResult = GetNewRef( outNewRef, inParentID, eRecordRefType, inPID, serverRef, messageIndex );
return( siResult );
}
tDirStatus CDSRefMap::NewAttrListRefMap ( UInt32 *outNewRef,
UInt32 inParentID,
SInt32 inPID,
UInt32 serverRef,
UInt32 messageIndex )
{
tDirStatus siResult = eDSDirSrvcNotOpened;
siResult = GetNewRef( outNewRef, inParentID, eAttrListRefType, inPID, serverRef, messageIndex );
return( siResult );
}
tDirStatus CDSRefMap::NewAttrValueRefMap ( UInt32 *outNewRef,
UInt32 inParentID,
SInt32 inPID,
UInt32 serverRef,
UInt32 messageIndex )
{
tDirStatus siResult = eDSDirSrvcNotOpened;
siResult = GetNewRef( outNewRef, inParentID, eAttrValueListRefType, inPID, serverRef, messageIndex );
return( siResult );
}
tDirStatus CDSRefMap::RemoveDirRef ( UInt32 inDirRef, SInt32 inPID )
{
tDirStatus siResult = eDSDirSrvcNotOpened;
siResult = RemoveRef( inDirRef, eDirectoryRefType, inPID );
return( siResult );
}
tDirStatus CDSRefMap::RemoveNodeRef ( UInt32 inNodeRef, SInt32 inPID )
{
tDirStatus siResult = eDSDirSrvcNotOpened;
siResult = RemoveRef( inNodeRef, eNodeRefType, inPID );
return( siResult );
}
tDirStatus CDSRefMap::RemoveRecordRef ( UInt32 inRecRef, SInt32 inPID )
{
tDirStatus siResult = eDSDirSrvcNotOpened;
siResult = RemoveRef( inRecRef, eRecordRefType, inPID );
return( siResult );
}
tDirStatus CDSRefMap::RemoveAttrListRef ( UInt32 inAttrListRef, SInt32 inPID )
{
tDirStatus siResult = eDSDirSrvcNotOpened;
siResult = RemoveRef( inAttrListRef, eAttrListRefType, inPID );
return( siResult );
}
tDirStatus CDSRefMap::RemoveAttrValueRef ( UInt32 inAttrValueRef, SInt32 inPID )
{
tDirStatus siResult = eDSDirSrvcNotOpened;
siResult = RemoveRef( inAttrValueRef, eAttrValueListRefType, inPID );
return( siResult );
}
sFWRefMapEntry* CDSRefMap::GetTableRef ( UInt32 inRefNum )
{
UInt32 uiSlot = 0;
UInt32 uiRefNum = (inRefNum & 0x00FFFFFF);
UInt32 uiTableNum = (inRefNum & 0xFF000000) >> 24;
sRefMapTable *pTable = nil;
sFWRefMapEntry *pOutEntry = nil;
fMapMutex.WaitLock();
try
{
pTable = GetThisTable( uiTableNum );
if ( pTable == nil ) throw( (SInt32)eDSInvalidReference );
uiSlot = uiRefNum % kMaxFWTableItems;
if ( pTable->fTableData != nil)
{
if ( pTable->fTableData[ uiSlot ] != nil )
{
if ( uiRefNum == pTable->fTableData[ uiSlot ]->fRefNum )
{
pOutEntry = pTable->fTableData[ uiSlot ];
}
}
}
}
catch( SInt32 err )
{
}
fMapMutex.SignalLock();
return( pOutEntry );
}
sRefMapTable* CDSRefMap::GetNextTable ( sRefMapTable *inTable )
{
UInt32 uiTblNum = 0;
sRefMapTable *pOutTable = nil;
fMapMutex.WaitLock();
try
{
if ( inTable == nil )
{
if ( fRefMapTables[ 1 ] == nil )
{
fRefMapTables[ 1 ] = (sRefMapTable *)calloc( sizeof( sRefMapTable ), sizeof( char ) );
if ( fRefMapTables[ 1 ] == nil ) throw((SInt32)eMemoryAllocError);
fRefMapTables[ 1 ]->fTableNum = 1;
fTableCount = 1;
}
pOutTable = fRefMapTables[ 1 ];
}
else
{
uiTblNum = inTable->fTableNum + 1;
if (uiTblNum > kMaxFWTables) throw( (SInt32)eDSInvalidReference );
if ( fRefMapTables[ uiTblNum ] == nil )
{
fTableCount = uiTblNum;
fRefMapTables[ uiTblNum ] = (sRefMapTable *)calloc( sizeof( sRefMapTable ), sizeof( char ) );
if( fRefMapTables[ uiTblNum ] == nil ) throw((SInt32)eMemoryAllocError);
if (uiTblNum == 0) throw( (SInt32)eDSInvalidReference );
fRefMapTables[ uiTblNum ]->fTableNum = uiTblNum;
}
pOutTable = fRefMapTables[ uiTblNum ];
}
}
catch( SInt32 err )
{
}
fMapMutex.SignalLock();
return( pOutTable );
}
sRefMapTable* CDSRefMap::GetThisTable ( UInt32 inTableNum )
{
sRefMapTable *pOutTable = nil;
fMapMutex.WaitLock();
pOutTable = fRefMapTables[ inTableNum ];
fMapMutex.SignalLock();
return( pOutTable );
}
tDirStatus CDSRefMap::GetNewRef ( UInt32 *outRef,
UInt32 inParentID,
eRefTypes inType,
SInt32 inPID,
UInt32 serverRef,
UInt32 messageIndex )
{
bool done = false;
tDirStatus outResult = eDSNoErr;
sRefMapTable *pCurTable = nil;
UInt32 uiRefNum = 0;
UInt32 uiCntr = 0;
UInt32 uiSlot = 0;
UInt32 uiTableNum = 0;
fMapMutex.WaitLock();
try
{
*outRef = 0;
while ( !done )
{
pCurTable = GetNextTable( pCurTable );
if ( pCurTable == nil ) throw( (SInt32)eDSRefTableFWAllocError );
if ( pCurTable->fItemCnt < kMaxFWTableItems )
{
uiCntr = 0;
uiTableNum = pCurTable->fTableNum;
while ( (uiCntr < kMaxFWTableItems) && !done ) {
if ( (pCurTable->fCurRefNum == 0) ||
(pCurTable->fCurRefNum > 0x000FFFFF) )
{
pCurTable->fCurRefNum = 1;
}
uiRefNum = pCurTable->fCurRefNum++;
uiRefNum += 0x00C00000;
uiSlot = uiRefNum % kMaxFWTableItems;
if ( pCurTable->fTableData[ uiSlot ] == nil )
{
pCurTable->fTableData[ uiSlot ] = (sFWRefMapEntry *)calloc( sizeof( sFWRefMapEntry ), sizeof( char ) );
if ( pCurTable->fTableData[ uiSlot ] == nil ) throw( (SInt32)eDSRefTableFWAllocError );
pCurTable->fTableData[ uiSlot ]->fRefNum = uiRefNum;
pCurTable->fTableData[ uiSlot ]->fType = inType;
pCurTable->fTableData[ uiSlot ]->fParentID = inParentID;
pCurTable->fTableData[ uiSlot ]->fPID = inPID;
pCurTable->fTableData[ uiSlot ]->fRemoteRefNum = serverRef;
pCurTable->fTableData[ uiSlot ]->fChildren = nil;
pCurTable->fTableData[ uiSlot ]->fChildPID = nil;
pCurTable->fTableData[ uiSlot ]->fMessageTableIndex = messageIndex;
uiTableNum = (uiTableNum << 24);
uiRefNum = uiRefNum | uiTableNum;
*outRef = uiRefNum;
pCurTable->fItemCnt++;
outResult = eDSNoErr;
done = true;
}
uiCntr++; }
}
}
if ( inParentID != 0 )
{
outResult = LinkToParent( *outRef, inType, inParentID, inPID );
}
}
catch( SInt32 err )
{
outResult = (tDirStatus)err;
}
fMapMutex.SignalLock();
return( outResult );
}
tDirStatus CDSRefMap::LinkToParent ( UInt32 inRefNum, UInt32 inType, UInt32 inParentID, SInt32 inPID )
{
tDirStatus dsResult = eDSNoErr;
sFWRefMapEntry *pCurrRef = nil;
sListFWInfo *pChildInfo = nil;
fMapMutex.WaitLock();
try
{
pCurrRef = GetTableRef( inParentID );
if ( pCurrRef == nil ) throw( (SInt32)eDSInvalidReference );
pChildInfo = (sListFWInfo *)calloc( sizeof( sListFWInfo ), sizeof( char ) );
if ( pChildInfo == nil ) throw( (SInt32)eDSRefTableFWAllocError );
pChildInfo->fRefNum = inRefNum;
pChildInfo->fType = inType;
pChildInfo->fPID = inPID;
pChildInfo->fNext = pCurrRef->fChildren;
pCurrRef->fChildren = pChildInfo;
}
catch( SInt32 err )
{
dsResult = (tDirStatus)err;
}
fMapMutex.SignalLock();
return( dsResult );
}
tDirStatus CDSRefMap::UnlinkFromParent ( UInt32 inRefNum )
{
tDirStatus dsResult = eDSNoErr;
UInt32 i = 1;
UInt32 parentID = 0;
sFWRefMapEntry *pCurrRef = nil;
sFWRefMapEntry *pParentRef = nil;
sListFWInfo *pCurrChild = nil;
sListFWInfo *pPrevChild = nil;
fMapMutex.WaitLock();
try
{
pCurrRef = GetTableRef( inRefNum );
if ( pCurrRef == nil ) throw( (SInt32)eDSInvalidReference );
parentID = pCurrRef->fParentID;
if ( parentID != 0 )
{
pParentRef = GetTableRef( parentID );
if ( pParentRef == nil ) throw( (SInt32)eDSInvalidReference );
pCurrChild = pParentRef->fChildren;
pPrevChild = pParentRef->fChildren;
while ( pCurrChild != nil )
{
if ( pCurrChild->fRefNum == inRefNum )
{
if ( i == 1 )
{
pParentRef->fChildren = pCurrChild->fNext;
}
else
{
pPrevChild->fNext = pCurrChild->fNext;
}
free( pCurrChild );
pCurrChild = nil;
break;
}
pPrevChild = pCurrChild;
pCurrChild = pCurrChild->fNext;
i++;
}
}
}
catch( SInt32 err )
{
dsResult = (tDirStatus)err;
}
fMapMutex.SignalLock();
return( dsResult );
}
tDirStatus CDSRefMap::GetReference ( UInt32 inRefNum, sFWRefMapEntry **outRefData )
{
tDirStatus dsResult = eDSNoErr;
sFWRefMapEntry *pCurrRef = nil;
fMapMutex.WaitLock();
try
{
pCurrRef = GetTableRef( inRefNum );
if ( pCurrRef == nil ) throw( (SInt32)eDSInvalidReference );
*outRefData = pCurrRef;
}
catch( SInt32 err )
{
dsResult = (tDirStatus)err;
}
fMapMutex.SignalLock();
return( dsResult );
}
tDirStatus CDSRefMap::RemoveRef ( UInt32 inRefNum, UInt32 inType, SInt32 inPID )
{
tDirStatus dsResult = eDSNoErr;
sFWRefMapEntry *pCurrRef = nil;
sRefMapTable *pTable = nil;
UInt32 uiSlot = 0;
UInt32 uiTableNum = (inRefNum & 0xFF000000) >> 24;
UInt32 uiRefNum = (inRefNum & 0x00FFFFFF);
bool doFree = false;
sPIDFWInfo *pPIDInfo = nil;
sPIDFWInfo *pPrevPIDInfo = nil;
fMapMutex.WaitLock();
try
{
dsResult = VerifyReference( inRefNum, inType, inPID );
if ( dsResult == eDSNoErr )
{
pTable = GetThisTable( uiTableNum );
if ( pTable == nil ) throw( (SInt32)eDSInvalidReference );
uiSlot = uiRefNum % kMaxFWTableItems;
if ( inType != eDirectoryRefType ) {
dsResult = UnlinkFromParent( inRefNum );
if ( dsResult != eDSNoErr ) throw( (SInt32)dsResult );
}
pCurrRef = GetTableRef( inRefNum ); if ( pCurrRef == nil ) throw( (SInt32)eDSInvalidReference );
if (inType != pCurrRef->fType) throw( (SInt32)eDSInvalidReference );
if ( pCurrRef->fChildren != nil )
{
fMapMutex.SignalLock();
RemoveChildren( pCurrRef->fChildren, inPID );
fMapMutex.WaitLock();
}
if (pCurrRef->fPID == inPID)
{
pCurrRef->fPID = -1;
if (pCurrRef->fChildPID == nil)
{
doFree = true;
}
}
else
{
pPIDInfo = pCurrRef->fChildPID;
pPrevPIDInfo = pCurrRef->fChildPID;
while (pPIDInfo != nil)
{
if (pPIDInfo->fPID == inPID)
{
if (pPIDInfo == pCurrRef->fChildPID)
{
pCurrRef->fChildPID = pCurrRef->fChildPID->fNext;
free(pPIDInfo);
pPIDInfo = pCurrRef->fChildPID;
pPrevPIDInfo = pCurrRef->fChildPID;
}
else
{
pPrevPIDInfo->fNext = pPIDInfo->fNext;
free(pPIDInfo);
pPIDInfo = pPrevPIDInfo->fNext;
}
}
else
{
pPrevPIDInfo = pPIDInfo;
pPIDInfo = pPIDInfo->fNext;
}
}
if ( (pCurrRef->fPID == -1) && (pCurrRef->fChildPID == nil) )
{
doFree = true;
}
}
if (doFree)
{
if ( pTable->fTableData[ uiSlot ] != nil )
{
if ( uiRefNum == pTable->fTableData[ uiSlot ]->fRefNum )
{
pCurrRef = pTable->fTableData[ uiSlot ];
pTable->fTableData[ uiSlot ] = nil;
pTable->fItemCnt--;
#ifdef __LITTLE_ENDIAN__
RemoveServerToLocalRefMap(pCurrRef->fRemoteRefNum);
#endif
free(pCurrRef);
pCurrRef = nil;
}
}
}
}
}
catch( SInt32 err )
{
dsResult = (tDirStatus)err;
}
fMapMutex.SignalLock();
return( dsResult );
}
void CDSRefMap::RemoveChildren ( sListFWInfo *inChildList, SInt32 inPID )
{
sListFWInfo *pCurrChild = nil;
sListFWInfo *pNextChild = nil;
fMapMutex.WaitLock();
try
{
pCurrChild = inChildList;
while ( pCurrChild != nil )
{
pNextChild = pCurrChild->fNext;
if ( pCurrChild->fPID == inPID )
{
fMapMutex.SignalLock();
RemoveRef( pCurrChild->fRefNum, pCurrChild->fType, inPID );
fMapMutex.WaitLock();
}
pCurrChild = pNextChild;
}
}
catch( SInt32 err )
{
}
fMapMutex.SignalLock();
}
tDirStatus CDSRefMap::SetMessageTableIndex ( UInt32 inRefNum, UInt32 inType, UInt32 inMsgTableIndex, SInt32 inPID )
{
tDirStatus siResult = eDSDirSrvcNotOpened;
sFWRefMapEntry *pCurrRef = nil;
siResult = VerifyReference( inRefNum, inType, inPID );
if (siResult == eDSNoErr)
{
pCurrRef = GetTableRef( inRefNum );
siResult = eDSInvalidReference;
if ( pCurrRef != nil )
{
pCurrRef->fMessageTableIndex = inMsgTableIndex;
siResult = eDSNoErr;
}
}
return( siResult );
}
tDirStatus CDSRefMap::SetPluginName ( UInt32 inRefNum, UInt32 inType, char* inPluginName, SInt32 inPID )
{
tDirStatus siResult = eDSDirSrvcNotOpened;
sFWRefMapEntry *pCurrRef = nil;
siResult = VerifyReference( inRefNum, inType, inPID );
if (siResult == eDSNoErr)
{
pCurrRef = GetTableRef( inRefNum );
siResult = eDSInvalidReference;
if ( pCurrRef != nil )
{
pCurrRef->fPluginName = inPluginName;
siResult = eDSNoErr;
}
}
return( siResult );
}
UInt32 CDSRefMap::GetRefNum ( UInt32 inRefNum, UInt32 inType, SInt32 inPID )
{
SInt32 siResult = eDSNoErr;
UInt32 theRefNum = inRefNum; sFWRefMapEntry *pCurrRef = nil;
if ((inRefNum & 0x00C00000) != 0)
{
siResult = VerifyReference( inRefNum, inType, inPID );
if (siResult == eDSNoErr)
{
pCurrRef = GetTableRef( inRefNum );
if ( pCurrRef != nil )
{
theRefNum = pCurrRef->fRemoteRefNum;
}
}
}
return( theRefNum );
}
UInt32 CDSRefMap::GetMessageTableIndex ( UInt32 inRefNum, UInt32 inType, SInt32 inPID )
{
SInt32 siResult = eDSNoErr;
UInt32 theMsgTableIndex = 0; sFWRefMapEntry *pCurrRef = nil;
if ((inRefNum & 0x00C00000) != 0)
{
siResult = VerifyReference( inRefNum, inType, inPID );
if (siResult == eDSNoErr)
{
pCurrRef = GetTableRef( inRefNum );
if ( pCurrRef != nil )
{
theMsgTableIndex = pCurrRef->fMessageTableIndex;
}
}
}
return( theMsgTableIndex );
}
char* CDSRefMap::GetPluginName( UInt32 inRefNum, SInt32 inPID )
{
SInt32 siResult = eDSNoErr;
sFWRefMapEntry *pCurrRef = nil;
char *outPluginName = nil;
if ((inRefNum & 0x00C00000) != 0)
{
siResult = VerifyReference( inRefNum, eNodeRefType, inPID );
if (siResult == eDSNoErr)
{
pCurrRef = GetTableRef( inRefNum );
if ( pCurrRef != nil )
{
outPluginName = pCurrRef->fPluginName;
}
}
}
return( outPluginName );
}
UInt32 CDSRefMap::GetRefNumMap ( UInt32 inRefNum, UInt32 inType, SInt32 inPID )
{
SInt32 siResult = eDSNoErr;
UInt32 theRefNum = inRefNum; sFWRefMapEntry *pCurrRef = nil;
if ((inRefNum & 0x00C00000) != 0)
{
siResult = VerifyReference( inRefNum, inType, inPID );
if (siResult == eDSNoErr)
{
pCurrRef = GetTableRef( inRefNum );
if ( pCurrRef != nil )
{
theRefNum = pCurrRef->fRemoteRefNum;
}
}
}
return( theRefNum );
}
#ifdef __LITTLE_ENDIAN__
#include <map> //STL map class
typedef std::map<UInt32, UInt32> tRefMap;
typedef tRefMap::iterator tRefMapI;
struct sEndianMaps
{
tRefMap fServerToLocalRefMap;
tRefMap fMsgIDToServerRefMap;
tRefMap fMsgIDToCustomCodeMap;
};
static sEndianMaps *gEndianMaps = NULL;
static pthread_once_t _gGlobalsInitialized = PTHREAD_ONCE_INIT;
static void __ForkChild( void )
{
gEndianMaps->fServerToLocalRefMap.clear();
gEndianMaps->fMsgIDToServerRefMap.clear();
gEndianMaps->fMsgIDToCustomCodeMap.clear();
}
static void __InitGlobals( void )
{
gEndianMaps = new sEndianMaps;
pthread_atfork( NULL, NULL, __ForkChild );
}
void CDSRefMap::MapServerRefToLocalRef( UInt32 inServerRef, UInt32 inLocalRef )
{
pthread_once( &_gGlobalsInitialized, __InitGlobals );
if (inServerRef != 0 && inLocalRef != 0)
{
gEndianMaps->fServerToLocalRefMap[inServerRef] = inLocalRef;
}
}
void CDSRefMap::RemoveServerToLocalRefMap( UInt32 inServerRef )
{
pthread_once( &_gGlobalsInitialized, __InitGlobals );
if (inServerRef != 0)
{
tRefMapI aRefMapI;
aRefMapI = gEndianMaps->fServerToLocalRefMap.find(inServerRef);
if (aRefMapI != gEndianMaps->fServerToLocalRefMap.end())
{
gEndianMaps->fServerToLocalRefMap.erase(aRefMapI);
}
}
}
UInt32 CDSRefMap::GetLocalRefFromServerMap( UInt32 inServerRef )
{
UInt32 retVal = 0;
pthread_once( &_gGlobalsInitialized, __InitGlobals );
if (inServerRef != 0)
{
tRefMapI aRefMapI;
aRefMapI = gEndianMaps->fServerToLocalRefMap.find(inServerRef);
if (aRefMapI != gEndianMaps->fServerToLocalRefMap.end())
{
retVal = aRefMapI->second;
}
}
return(retVal);
}
void CDSRefMap::MapMsgIDToServerRef( UInt32 inMsgID, UInt32 inServerRef )
{
pthread_once( &_gGlobalsInitialized, __InitGlobals );
if (inMsgID != 0 && inServerRef != 0)
{
gEndianMaps->fMsgIDToServerRefMap[inMsgID] = inServerRef;
}
}
void CDSRefMap::RemoveMsgIDToServerRefMap( UInt32 inMsgID )
{
pthread_once( &_gGlobalsInitialized, __InitGlobals );
if (inMsgID != 0)
{
tRefMapI aRefMapI;
aRefMapI = gEndianMaps->fMsgIDToServerRefMap.find(inMsgID);
if (aRefMapI != gEndianMaps->fMsgIDToServerRefMap.end())
{
gEndianMaps->fMsgIDToServerRefMap.erase(aRefMapI);
}
}
}
UInt32 CDSRefMap::GetServerRefFromMsgIDMap( UInt32 inMsgID )
{
UInt32 retVal = 0;
pthread_once( &_gGlobalsInitialized, __InitGlobals );
if (inMsgID != 0)
{
tRefMapI aRefMapI;
aRefMapI = gEndianMaps->fMsgIDToServerRefMap.find(inMsgID);
if (aRefMapI != gEndianMaps->fMsgIDToServerRefMap.end())
{
retVal = aRefMapI->second;
}
}
return(retVal);
}
void CDSRefMap::MapMsgIDToCustomCode( UInt32 inMsgID, UInt32 inCustomCode )
{
pthread_once( &_gGlobalsInitialized, __InitGlobals );
if (inMsgID != 0 && inCustomCode != 0)
{
gEndianMaps->fMsgIDToCustomCodeMap[inMsgID] = inCustomCode;
}
}
void CDSRefMap::RemoveMsgIDToCustomCodeMap( UInt32 inMsgID )
{
pthread_once( &_gGlobalsInitialized, __InitGlobals );
if (inMsgID != 0)
{
tRefMapI aRefMapI;
aRefMapI = gEndianMaps->fMsgIDToCustomCodeMap.find(inMsgID);
if (aRefMapI != gEndianMaps->fMsgIDToCustomCodeMap.end())
{
gEndianMaps->fMsgIDToCustomCodeMap.erase(aRefMapI);
}
}
}
UInt32 CDSRefMap::GetCustomCodeFromMsgIDMap( UInt32 inMsgID )
{
pthread_once( &_gGlobalsInitialized, __InitGlobals );
UInt32 retVal = 0;
if (inMsgID != 0)
{
tRefMapI aRefMapI;
aRefMapI = gEndianMaps->fMsgIDToCustomCodeMap.find(inMsgID);
if (aRefMapI != gEndianMaps->fMsgIDToCustomCodeMap.end())
{
retVal = aRefMapI->second;
}
}
return(retVal);
}
#endif