You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
741 lines
21 KiB
741 lines
21 KiB
/*==LICENSE==* |
|
|
|
CyanWorlds.com Engine - MMOG client, server and tools |
|
Copyright (C) 2011 Cyan Worlds, Inc. |
|
|
|
This program is free software: you can redistribute it and/or modify |
|
it under the terms of the GNU General Public License as published by |
|
the Free Software Foundation, either version 3 of the License, or |
|
(at your option) any later version. |
|
|
|
This program is distributed in the hope that it will be useful, |
|
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
GNU General Public License for more details. |
|
|
|
You should have received a copy of the GNU General Public License |
|
along with this program. If not, see <http://www.gnu.org/licenses/>. |
|
|
|
Additional permissions under GNU GPL version 3 section 7 |
|
|
|
If you modify this Program, or any covered work, by linking or |
|
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK, |
|
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent |
|
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK |
|
(or a modified version of those libraries), |
|
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA, |
|
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG |
|
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the |
|
licensors of this Program grant you additional |
|
permission to convey the resulting work. Corresponding Source for a |
|
non-source form of such a combination shall include the source code for |
|
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered |
|
work. |
|
|
|
You can contact Cyan Worlds, Inc. by email legal@cyan.com |
|
or by snail mail at: |
|
Cyan Worlds, Inc. |
|
14617 N Newport Hwy |
|
Mead, WA 99021 |
|
|
|
*==LICENSE==*/ |
|
////////////////////////////////////////////////////////////////////////////// |
|
// |
|
// plResManagerHelper - The wonderful helper class that can receive messages |
|
// for the resManager. |
|
// |
|
//// History ///////////////////////////////////////////////////////////////// |
|
// |
|
// 6.7.2002 mcn - Created |
|
// |
|
////////////////////////////////////////////////////////////////////////////// |
|
|
|
#include "hsTypes.h" |
|
#include "plResManagerHelper.h" |
|
#include "plResManager.h" |
|
#include "plRegistryNode.h" |
|
#include "plRegistryHelpers.h" |
|
//#include "plRegistry.h" |
|
#include "plResMgrSettings.h" |
|
|
|
#include "../pnKeyedObject/plFixedKey.h" |
|
#include "../plMessage/plResMgrHelperMsg.h" |
|
#include "../plStatusLog/plStatusLog.h" |
|
#include "hsTimer.h" |
|
|
|
#ifdef MCN_RESMGR_DEBUGGING |
|
|
|
static const int kLogSize = 40; |
|
static const float kUpdateDelay = 0.5f; |
|
|
|
#include "../plInputCore/plInputInterface.h" |
|
#include "../plInputCore/plInputDevice.h" |
|
#include "../plInputCore/plInputInterfaceMgr.h" |
|
#include "../pnInputCore/plInputMap.h" |
|
#include "../plMessage/plInputEventMsg.h" |
|
#include "../plMessage/plInputIfaceMgrMsg.h" |
|
#include "../pnKeyedObject/plKeyImp.h" |
|
|
|
#endif |
|
|
|
/// Logging #define for easier use |
|
#define kResMgrLog( level ) if( plResMgrSettings::Get().GetLoggingLevel() >= level ) plStatusLog::AddLineS( "resources.log", |
|
|
|
|
|
|
|
//// Constructor/Destructor ////////////////////////////////////////////////// |
|
|
|
plResManagerHelper *plResManagerHelper::fInstance = nil; |
|
|
|
plResManagerHelper::plResManagerHelper( plResManager *resMgr ) |
|
{ |
|
fResManager = resMgr; |
|
fInstance = this; |
|
|
|
fInShutdown = false; |
|
#ifdef MCN_RESMGR_DEBUGGING |
|
fDebugScreen = nil; |
|
fCurrAge = -1; |
|
fCurrAgeExpanded = false; |
|
fRefreshing = false; |
|
fDebugDisplayType = 0; |
|
#endif |
|
} |
|
plResManagerHelper::~plResManagerHelper() |
|
{ |
|
fInstance = nil; |
|
} |
|
|
|
//// Shutdown //////////////////////////////////////////////////////////////// |
|
|
|
void plResManagerHelper::Shutdown( void ) |
|
{ |
|
EnableDebugScreen( false ); |
|
UnRegisterAs( kResManagerHelper_KEY ); |
|
} |
|
|
|
//// Init //////////////////////////////////////////////////////////////////// |
|
|
|
void plResManagerHelper::Init( void ) |
|
{ |
|
RegisterAs( kResManagerHelper_KEY ); |
|
} |
|
|
|
//// MsgReceive ////////////////////////////////////////////////////////////// |
|
|
|
hsBool plResManagerHelper::MsgReceive( plMessage *msg ) |
|
{ |
|
plResMgrHelperMsg *refferMsg = plResMgrHelperMsg::ConvertNoRef( msg ); |
|
if( refferMsg != nil ) |
|
{ |
|
if( refferMsg->GetCommand() == plResMgrHelperMsg::kKeyRefList ) |
|
{ |
|
// Message to let go of these keys. So unref the key list, destroy it and we're done! |
|
kResMgrLog( 2 ) 0xff80ff80, "Dropping page keys after timed delay" ); |
|
hsStatusMessage( "*** Dropping page keys after timed delay ***" ); |
|
|
|
delete refferMsg->fKeyList; |
|
refferMsg->fKeyList = nil; |
|
} |
|
else if( refferMsg->GetCommand() == plResMgrHelperMsg::kUpdateDebugScreen ) |
|
{ |
|
IUpdateDebugScreen(); |
|
} |
|
else if( refferMsg->GetCommand() == plResMgrHelperMsg::kEnableDebugScreen ) |
|
EnableDebugScreen( true ); |
|
else if( refferMsg->GetCommand() == plResMgrHelperMsg::kDisableDebugScreen ) |
|
EnableDebugScreen( false ); |
|
|
|
return true; |
|
} |
|
|
|
return hsKeyedObject::MsgReceive( msg ); |
|
} |
|
|
|
//// Read/Write ////////////////////////////////////////////////////////////// |
|
|
|
void plResManagerHelper::Read( hsStream *s, hsResMgr *mgr ) |
|
{ |
|
hsAssert( false, "You should never read me in!" ); |
|
} |
|
|
|
void plResManagerHelper::Write( hsStream *s, hsResMgr *mgr ) |
|
{ |
|
hsAssert( false, "You should never write me out!" ); |
|
} |
|
|
|
//// LoadAndHoldPageKeys ///////////////////////////////////////////////////// |
|
// Loads and refs the keys for the given page, then sends the ref list as |
|
// a list to ourself, time delayed 1 second, so that we can unref them one |
|
// second later. |
|
|
|
void plResManagerHelper::LoadAndHoldPageKeys( plRegistryPageNode *page ) |
|
{ |
|
hsAssert( GetKey() != nil, "Can't load and hold keys when we don't have a key for the helper" ); |
|
|
|
// Create our msg |
|
plResMgrHelperMsg *refferMsg = TRACKED_NEW plResMgrHelperMsg( plResMgrHelperMsg::kKeyRefList ); |
|
refferMsg->fKeyList = TRACKED_NEW plResPageKeyRefList; |
|
|
|
fResManager->LoadPageKeys(page); |
|
page->IterateKeys( refferMsg->fKeyList ); |
|
|
|
// Load and ref the keys |
|
#ifdef HS_DEBUGGING |
|
char msg[ 256 ]; |
|
sprintf( msg, "*** Temporarily loading keys for room %s>%s based on FindKey() query, will drop in 1 sec ***", page->GetPageInfo().GetAge(), page->GetPageInfo().GetPage() ); |
|
hsStatusMessage( msg ); |
|
#endif |
|
kResMgrLog( 2 ) 0xff80ff80, "Temporarily loading keys for room %s>%s, will drop in 1 sec", page->GetPageInfo().GetAge(), page->GetPageInfo().GetPage() ); |
|
|
|
// Deliver the message to ourselves! |
|
refferMsg->SetTimeStamp( hsTimer::GetSysSeconds() + 1.f ); |
|
refferMsg->Send( GetKey() ); |
|
} |
|
|
|
#ifdef MCN_RESMGR_DEBUGGING |
|
|
|
////////////////////////////////////////////////////////////////////////////// |
|
//// plResMgrDebugInterface Definition /////////////////////////////////////// |
|
////////////////////////////////////////////////////////////////////////////// |
|
|
|
class plResMgrDebugInterface : public plInputInterface |
|
{ |
|
protected: |
|
plResManagerHelper * const fParent; |
|
|
|
virtual ControlEventCode *IGetOwnedCodeList( void ) const |
|
{ |
|
static ControlEventCode codes[] = { END_CONTROLS }; |
|
return codes; |
|
} |
|
|
|
public: |
|
|
|
plResMgrDebugInterface( plResManagerHelper * const mgr ) : fParent( mgr ) { SetEnabled( true ); } |
|
|
|
virtual UInt32 GetPriorityLevel( void ) const { return kGUISystemPriority + 10; } |
|
virtual hsBool InterpretInputEvent( plInputEventMsg *pMsg ) |
|
{ |
|
plKeyEventMsg *pKeyMsg = plKeyEventMsg::ConvertNoRef( pMsg ); |
|
if( pKeyMsg != nil && pKeyMsg->GetKeyDown() ) |
|
{ |
|
if( pKeyMsg->GetKeyCode() == KEY_UP && fParent->fCurrAge >= 0 ) |
|
{ |
|
fParent->fCurrAge--; |
|
fParent->IUpdateDebugScreen( true ); |
|
return true; |
|
} |
|
else if( pKeyMsg->GetKeyCode() == KEY_DOWN ) |
|
{ |
|
fParent->fCurrAge++; |
|
fParent->IUpdateDebugScreen( true ); |
|
return true; |
|
} |
|
else if( pKeyMsg->GetKeyCode() == KEY_ENTER ) |
|
{ |
|
fParent->fCurrAgeExpanded = !fParent->fCurrAgeExpanded; |
|
fParent->IUpdateDebugScreen( true ); |
|
return true; |
|
} |
|
else if( pKeyMsg->GetKeyCode() == KEY_ESCAPE ) |
|
{ |
|
plResMgrHelperMsg *msg = TRACKED_NEW plResMgrHelperMsg( plResMgrHelperMsg::kDisableDebugScreen ); |
|
msg->Send( fParent->GetKey() ); |
|
return true; |
|
} |
|
else if( pKeyMsg->GetKeyCode() == KEY_RIGHT ) |
|
{ |
|
if( !fParent->fCurrAgeExpanded ) |
|
fParent->fCurrAgeExpanded = true; |
|
else |
|
{ |
|
fParent->fDebugDisplayType++; |
|
if( fParent->fDebugDisplayType == plResManagerHelper::kMaxDisplayType ) |
|
fParent->fDebugDisplayType = 0; |
|
} |
|
fParent->IUpdateDebugScreen( true ); |
|
return true; |
|
} |
|
else if( pKeyMsg->GetKeyCode() == KEY_LEFT ) |
|
{ |
|
fParent->fCurrAgeExpanded = false; |
|
fParent->IUpdateDebugScreen( true ); |
|
return true; |
|
} |
|
} |
|
|
|
return false; |
|
} |
|
|
|
virtual UInt32 GetCurrentCursorID( void ) const { return 0; } |
|
virtual hsBool HasInterestingCursorID( void ) const { return false; } |
|
}; |
|
|
|
#endif |
|
|
|
//// EnableDebugScreen /////////////////////////////////////////////////////// |
|
|
|
void plResManagerHelper::EnableDebugScreen( hsBool enable ) |
|
{ |
|
#ifdef MCN_RESMGR_DEBUGGING |
|
if( enable ) |
|
{ |
|
if( fDebugScreen == nil ) |
|
{ |
|
fDebugScreen = plStatusLogMgr::GetInstance().CreateStatusLog( kLogSize, "ResManager Status", plStatusLog::kFilledBackground | plStatusLog::kDontWriteFile ); |
|
fRefreshing = true; |
|
|
|
plResMgrHelperMsg *msg = TRACKED_NEW plResMgrHelperMsg( plResMgrHelperMsg::kUpdateDebugScreen ); |
|
// msg->SetTimeStamp( hsTimer::GetSysSeconds() + kUpdateDelay ); |
|
msg->Send( GetKey() ); |
|
|
|
fDebugInput = TRACKED_NEW plResMgrDebugInterface( this ); |
|
plInputIfaceMgrMsg *imsg = TRACKED_NEW plInputIfaceMgrMsg( plInputIfaceMgrMsg::kAddInterface ); |
|
imsg->SetIFace( fDebugInput ); |
|
imsg->Send(); |
|
} |
|
} |
|
else |
|
{ |
|
fRefreshing = false; |
|
if( fDebugScreen != nil ) |
|
{ |
|
delete fDebugScreen; |
|
fDebugScreen = nil; |
|
|
|
plInputIfaceMgrMsg *imsg = TRACKED_NEW plInputIfaceMgrMsg( plInputIfaceMgrMsg::kRemoveInterface ); |
|
imsg->SetIFace( fDebugInput ); |
|
imsg->Send(); |
|
|
|
hsRefCnt_SafeUnRef( fDebugInput ); |
|
fDebugInput = nil; |
|
} |
|
} |
|
#endif |
|
} |
|
|
|
//// IUpdateDebugScreen ///////////////////////////////////////////////////// |
|
|
|
#ifdef MCN_RESMGR_DEBUGGING |
|
class plDebugPrintIterator : public plRegistryPageIterator, plRegistryKeyIterator |
|
{ |
|
public: |
|
plStatusLog *fLog; |
|
UInt8 fStep, fLines; |
|
UInt32 &fLoadedCount, &fHoldingCount, fPageCount, fAgeIndex; |
|
char fCurrAge[ 128 ]; |
|
UInt32 fLoadedKeys, fTotalKeys, fTotalSize, fLoadedSize; |
|
|
|
plResManagerHelper *fParent; |
|
|
|
plDebugPrintIterator( plResManagerHelper *parent, plStatusLog *log, UInt32 &loadedCount, UInt32 &holdingCount ) |
|
: fParent( parent ), fLog( log ), fStep( 0 ), fLines( 0 ), fLoadedCount( loadedCount ), fHoldingCount( holdingCount ) |
|
{ |
|
fLoadedCount = fHoldingCount = 0; |
|
fCurrAge[ 0 ] = 0; |
|
fPageCount = 0; |
|
fAgeIndex = 0; |
|
} |
|
|
|
virtual hsBool EatPage( plRegistryPageNode *page ) |
|
{ |
|
if( fStep == 0 ) |
|
{ |
|
fLog->AddLineF( 0xff80ff80, "Loaded Pages" ); |
|
fStep = 1; |
|
fLines++; |
|
} |
|
else if( fStep == 1 && page != nil && !page->IsLoaded() ) |
|
{ |
|
fStep = 2; |
|
fLog->AddLineF( 0xff80ff80, "Holding Pages" ); |
|
fLines++; |
|
} |
|
|
|
if( page != nil && page->IsLoaded() ) |
|
fLoadedCount++; |
|
else if( page != nil ) |
|
fHoldingCount++; |
|
|
|
// Changed ages? |
|
if( page == nil || strcmp( fCurrAge, page->GetPageInfo().GetAge() ) != 0 ) |
|
{ |
|
// Print some info for the last age we were on |
|
if( fCurrAge[ 0 ] != 0 ) |
|
{ |
|
if( fParent->fCurrAge != fAgeIndex || !fParent->fCurrAgeExpanded ) |
|
{ |
|
if( fLines < kLogSize - 4 ) |
|
{ |
|
UInt32 color = plStatusLog::kWhite; |
|
if( fParent->fCurrAge == fAgeIndex ) |
|
color = plStatusLog::kYellow; |
|
|
|
fLog->AddLineF( color, " %s (%d pages)", fCurrAge, fPageCount ); |
|
fLines++; |
|
} |
|
else if( fLines == kLogSize - 4 ) |
|
{ |
|
fLog->AddLineF( plStatusLog::kWhite, " ..." ); |
|
fLines++; |
|
} |
|
} |
|
fAgeIndex++; |
|
} |
|
fPageCount = 0; |
|
if( page != nil ) |
|
strncpy( fCurrAge, page->GetPageInfo().GetAge(), sizeof( fCurrAge ) - 1 ); |
|
else |
|
fCurrAge[ 0 ] = 0; |
|
|
|
if( fParent->fCurrAge == fAgeIndex && fParent->fCurrAgeExpanded ) |
|
{ |
|
// Print header now, since we won't be printing a footer |
|
if( fLines < kLogSize - 4 ) |
|
{ |
|
fLog->AddLineF( plStatusLog::kYellow, " %s>", fCurrAge ); |
|
fLines++; |
|
} |
|
else if( fLines == kLogSize - 4 ) |
|
{ |
|
fLog->AddLineF( plStatusLog::kWhite, " ..." ); |
|
fLines++; |
|
} |
|
} |
|
} |
|
|
|
fPageCount++; |
|
|
|
if( fParent->fCurrAge == fAgeIndex && fParent->fCurrAgeExpanded && page != nil ) |
|
{ |
|
// Count keys for this page |
|
fTotalKeys = fLoadedKeys = fTotalSize = fLoadedSize = 0; |
|
page->IterateKeys( this ); |
|
|
|
// Print page for this expanded age view |
|
if( fLines < kLogSize - 4 ) |
|
{ |
|
if( fParent->fDebugDisplayType == plResManagerHelper::kSizes ) |
|
fLog->AddLineF( plStatusLog::kWhite, " %s (%d keys @ %4.1fk, %d loaded @ %4.1fk)", page->GetPageInfo().GetPage(), fTotalKeys, fTotalSize / 1024.f, fLoadedKeys, fLoadedSize / 1024.f ); |
|
else if( fParent->fDebugDisplayType == plResManagerHelper::kPercents ) |
|
fLog->AddLineF( plStatusLog::kWhite, " %s (%d%% loaded of %d keys @ %4.1fk)", page->GetPageInfo().GetPage(), fLoadedSize * 100 / ( fTotalSize > 0 ? fTotalSize : -1 ), fTotalKeys, fTotalSize / 1024.f ); |
|
else //if( fParent->fDebugDisplayType == plResManagerHelper::kBars ) |
|
{ |
|
const int startPos = 20, length = 32; |
|
|
|
char line[ 128 ]; |
|
memset( line, ' ', sizeof( line ) - 1 ); |
|
line[ 127 ] = 0; |
|
if( strlen( page->GetPageInfo().GetPage() ) < startPos - 2 ) |
|
memcpy( line + 2, page->GetPageInfo().GetPage(), strlen( page->GetPageInfo().GetPage() ) ); |
|
else |
|
memcpy( line + 2, page->GetPageInfo().GetPage(), startPos - 2 ); |
|
|
|
line[ startPos ] = '|'; |
|
if( fTotalSize == 0 ) |
|
{ |
|
line[ startPos + 1 ] = '|'; |
|
line[ startPos + 2 ] = 0; |
|
} |
|
else |
|
{ |
|
char temp[ 12 ]; |
|
sprintf( temp, "%d%%", fLoadedSize * 100 / fTotalSize ); |
|
|
|
line[ startPos + length + 1 ] = '|'; |
|
int i, sum = 0; |
|
for( i = startPos + 1; i < startPos + length + 1 && sum < fLoadedSize; i++ ) |
|
{ |
|
line[ i ] = '='; |
|
sum += fTotalSize / length; |
|
} |
|
line[ startPos + length + 2 ] = 0; |
|
|
|
memcpy( line + startPos + 1, temp, strlen( temp ) ); |
|
} |
|
|
|
fLog->AddLine( line, plStatusLog::kWhite ); |
|
} |
|
fLines++; |
|
} |
|
else if( fLines == kLogSize - 4 ) |
|
{ |
|
fLog->AddLineF( plStatusLog::kWhite, " ..." ); |
|
fLines++; |
|
} |
|
} |
|
|
|
return true; |
|
} |
|
|
|
virtual hsBool EatKey( const plKey& key ) |
|
{ |
|
if( key->ObjectIsLoaded() ) |
|
{ |
|
fLoadedKeys++; |
|
fLoadedSize += ((plKeyImp *)key)->GetDataLen(); |
|
} |
|
fTotalKeys++; |
|
fTotalSize += ((plKeyImp *)key)->GetDataLen(); |
|
return true; |
|
} |
|
}; |
|
#endif |
|
|
|
void plResManagerHelper::IUpdateDebugScreen( hsBool force ) |
|
{ |
|
#ifdef MCN_RESMGR_DEBUGGING |
|
|
|
if( !fRefreshing ) |
|
return; |
|
|
|
plRegistry *reg = fResManager->IGetRegistry(); |
|
UInt32 loadedCnt, holdingCnt; |
|
|
|
fDebugScreen->Clear(); |
|
|
|
plDebugPrintIterator iter( this, fDebugScreen, loadedCnt, holdingCnt ); |
|
reg->IterateAllPages( &iter ); |
|
iter.EatPage( nil ); // Force a final update |
|
|
|
fDebugScreen->AddLineF( plStatusLog::kGreen, "%d pages loaded, %d holding", loadedCnt, holdingCnt ); |
|
|
|
if( fCurrAge >= iter.fAgeIndex ) |
|
fCurrAge = -1; |
|
|
|
// Repump our update |
|
if( !force ) |
|
{ |
|
plResMgrHelperMsg *msg = TRACKED_NEW plResMgrHelperMsg( plResMgrHelperMsg::kUpdateDebugScreen ); |
|
msg->SetTimeStamp( hsTimer::GetSysSeconds() + kUpdateDelay ); |
|
msg->Send( GetKey() ); |
|
} |
|
|
|
#endif |
|
} |
|
|
|
#if 0 |
|
// FIXME |
|
hsBool VerifyKeyUnloaded(const char* logFile, const plKey& key); |
|
// Verifies that a key which shouldn't be loaded isn't, and if it is tries to figure out why. |
|
void VerifyAgeUnloaded(const char* logFile, const char* age); |
|
|
|
// Helper for VerifyKeyUnloaded |
|
hsBool IVerifyKeyUnloadedRecur(const char* logFile, const plKey& baseKey, const plKey& upKey, const char* baseAge); |
|
bool ILookForCyclesRecur(const char* logFile, const plKey& key, hsTArray<plKey>& tree, int& cycleStart); |
|
|
|
bool plResManager::ILookForCyclesRecur(const char* logFile, const plKey& key, hsTArray<plKey>& tree, int& cycleStart) |
|
{ |
|
int idx = tree.Find(key); |
|
tree.Append(key); |
|
if (tree.kMissingIndex != idx) |
|
{ |
|
cycleStart = idx; |
|
// Found a cycle. |
|
return true; |
|
} |
|
|
|
// Now recurse up the active reference tree. |
|
for (int i = 0; i < key->GetNumNotifyCreated(); i++) |
|
{ |
|
if (key->GetActiveBits().IsBitSet(i)) |
|
{ |
|
for (int j = 0; j < key->GetNotifyCreated(i)->GetNumReceivers(); j++) |
|
{ |
|
plKey reffer = key->GetNotifyCreated(i)->GetReceiver(j); |
|
|
|
if (ILookForCyclesRecur(logFile, reffer, tree, cycleStart)) |
|
return true; |
|
} |
|
} |
|
} |
|
tree.Pop(); |
|
return false; |
|
} |
|
|
|
bool plResManager::IVerifyKeyUnloadedRecur(const char* logFile, const plKey& baseKey, const plKey& upKey, const char* baseAge) |
|
{ |
|
const plPageInfo& pageInfo = FindPage(upKey->GetUoid().GetLocation())->GetPageInfo(); |
|
const char* upAge = pageInfo.GetAge(); |
|
const char* upPage = pageInfo.GetPage(); |
|
|
|
if( !upKey->GetActiveRefs() ) |
|
{ |
|
// We've hit a key active reffing us that should be inactive. |
|
// If it's object is loaded, then it somehow missed getting unloaded. |
|
// Else it must have missed letting go of us when it got unloaded. |
|
if( upKey->ObjectIsLoaded() ) |
|
{ |
|
plStatusLog::AddLineS(logFile, "\tHeld by %s [%s] page %s which is loaded but nothing is reffing", |
|
upKey->GetName(), |
|
plFactory::GetNameOfClass(upKey->GetUoid().GetClassType()), |
|
upPage); |
|
|
|
return true; |
|
} |
|
else |
|
{ |
|
plStatusLog::AddLineS(logFile, "\tHeld by %s [%s] page %s which isn't even loaded", |
|
upKey->GetName(), |
|
plFactory::GetNameOfClass(upKey->GetUoid().GetClassType()), |
|
upPage); |
|
|
|
return true; |
|
} |
|
} |
|
|
|
// if the age of this key is different from the age on the baseKey, |
|
// we've got a cross age active ref, which is illegal. |
|
if( stricmp(upAge, baseAge) ) |
|
{ |
|
plStatusLog::AddLineS(logFile, "\tHeld by %s [%s] which is in a different age %s-%s", |
|
upKey->GetName(), |
|
plFactory::GetNameOfClass(upKey->GetUoid().GetClassType()), |
|
upAge, |
|
upPage); |
|
|
|
return true; |
|
} |
|
|
|
int numActive = 0; |
|
int i; |
|
for( i = 0; i < upKey->GetNumNotifyCreated(); i++ ) |
|
{ |
|
if( upKey->GetActiveBits().IsBitSet(i) ) |
|
{ |
|
numActive++; |
|
} |
|
} |
|
if( numActive < upKey->GetActiveRefs() ) |
|
{ |
|
// Someone has AddRef'd us |
|
plStatusLog::AddLineS(logFile, "\tHeld by %s [%s] page %s which is loaded due to %d AddRef(s)", |
|
upKey->GetName(), |
|
plFactory::GetNameOfClass(upKey->GetUoid().GetClassType()), |
|
upPage, |
|
upKey->GetActiveRefs()-numActive); |
|
|
|
return true; |
|
} |
|
|
|
// Now recurse up the active reference tree. |
|
for( i = 0; i < upKey->GetNumNotifyCreated(); i++ ) |
|
{ |
|
if( upKey->GetActiveBits().IsBitSet(i) ) |
|
{ |
|
int j; |
|
for( j = 0; j < upKey->GetNotifyCreated(i)->GetNumReceivers(); j++ ) |
|
{ |
|
plKey reffer = upKey->GetNotifyCreated(i)->GetReceiver(j); |
|
|
|
|
|
if( IVerifyKeyUnloadedRecur(logFile, baseKey, reffer, baseAge) ) |
|
{ |
|
return true; |
|
} |
|
} |
|
} |
|
} |
|
return false; |
|
} |
|
|
|
hsBool plResManager::VerifyKeyUnloaded(const char* logFile, const plKey& key) |
|
{ |
|
if( key->ObjectIsLoaded() ) |
|
{ |
|
const plPageInfo& pageInfo = FindPage(key->GetUoid().GetLocation())->GetPageInfo(); |
|
const char* age = pageInfo.GetAge(); |
|
const char* page = pageInfo.GetPage(); |
|
|
|
plStatusLog::AddLineS(logFile, "=================================="); |
|
plStatusLog::AddLineS(logFile, "Object %s [%s] page %s is loaded", key->GetName(), plFactory::GetNameOfClass(key->GetUoid().GetClassType()), page); |
|
|
|
hsTArray<plKey> tree; |
|
int cycleStart; |
|
hsBool hasCycle = ILookForCyclesRecur(logFile, key, tree, cycleStart); |
|
if( hasCycle ) |
|
{ |
|
plStatusLog::AddLineS(logFile, "\t%s [%s] held by dependency cycle", key->GetName(), plFactory::GetNameOfClass(key->GetUoid().GetClassType())); |
|
int i; |
|
for( i = cycleStart; i < tree.GetCount(); i++ ) |
|
{ |
|
plStatusLog::AddLineS(logFile, "\t%s [%s]", tree[i]->GetName(), plFactory::GetNameOfClass(tree[i]->GetUoid().GetClassType())); |
|
} |
|
plStatusLog::AddLineS(logFile, "\tEnd Cycle"); |
|
return true; |
|
} |
|
else |
|
{ |
|
return IVerifyKeyUnloadedRecur(logFile, key, key, age); |
|
} |
|
} |
|
return false; |
|
} |
|
|
|
class plValidateKeyIterator : public plRegistryKeyIterator |
|
{ |
|
protected: |
|
plRegistry* fRegistry; |
|
const char* fLogFile; |
|
|
|
public: |
|
plValidateKeyIterator(const char* logFile, plRegistry* reg) |
|
{ |
|
fRegistry = reg; |
|
fLogFile = logFile; |
|
} |
|
virtual hsBool EatKey(const plKey& key) |
|
{ |
|
fRegistry->VerifyKeyUnloaded(fLogFile, key); |
|
return true; |
|
} |
|
}; |
|
|
|
class plValidatePageIterator : public plRegistryPageIterator |
|
{ |
|
protected: |
|
const char* fAge; |
|
plRegistryKeyIterator* fIter; |
|
|
|
public: |
|
plValidatePageIterator(const char* age, plRegistryKeyIterator* iter) : fAge(age), fIter(iter) {} |
|
|
|
|
|
virtual hsBool EatPage( plRegistryPageNode *keyNode ) |
|
{ |
|
if( !stricmp(fAge, keyNode->GetPageInfo().GetAge()) ) |
|
return keyNode->IterateKeys( fIter ); |
|
return true; |
|
} |
|
}; |
|
|
|
void plResManager::VerifyAgeUnloaded(const char* logFile, const char* age) |
|
{ |
|
hsBool autoLog = false; |
|
char buff[256]; |
|
if( !logFile || !*logFile ) |
|
{ |
|
sprintf(buff, "%s.log", age); |
|
logFile = buff; |
|
autoLog = true; |
|
} |
|
|
|
if( !autoLog ) |
|
{ |
|
plStatusLog::AddLineS(logFile, "///////////////////////////////////"); |
|
plStatusLog::AddLineS(logFile, "Begin Verification of age %s", age); |
|
} |
|
|
|
plValidateKeyIterator keyIter(logFile, this); |
|
plValidatePageIterator pageIter(age, &keyIter); |
|
|
|
IterateAllPages(&pageIter); |
|
|
|
if( !autoLog ) |
|
{ |
|
plStatusLog::AddLineS(logFile, "End Verification of age %s", age); |
|
plStatusLog::AddLineS(logFile, "///////////////////////////////////"); |
|
} |
|
} |
|
#endif
|
|
|