OU/CWE-ou-minkata
1
0
Fork 0
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git synced 2025-07-17 10:52:46 +00:00
Code Releases Activity

Obliterate hsBool

Browse Source
This commit is contained in:
Adam Johnson
2012-07-11 01:28:00 -04:00
parent 5f78b33db4
commit a709e17069
1041 changed files with 7889 additions and 8070 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
Sources/Plasma/PubUtilLib/plResMgr/plBSDiffBuffer.h
View File

@ -75,8 +75,8 @@ class plBSDiffBuffer
{
protected:
hsBool fWriting;
uint32_t fNewLength, fPatchLength;
bool fWriting;
uint32_t fNewLength, fPatchLength;
unsigned char* fPatchBuffer;
public:

6
Sources/Plasma/PubUtilLib/plResMgr/plDiffBuffer.h
View File

@ -81,13 +81,13 @@ class plDiffBuffer
{
protected:
hsBool fWriting, f16BitMode;
uint32_t fNewLength;
bool fWriting, f16BitMode;
uint32_t fNewLength;
hsRAMStream *fStream;
// Support for BSDiff patch buffers (Patching only)
plBSDiffBuffer *fBSDiffBuffer;
hsBool fIsBSDiff;
bool fIsBSDiff;
public:

24
Sources/Plasma/PubUtilLib/plResMgr/plKeyFinder.cpp
View File

@ -81,7 +81,7 @@ const char* plKeyFinder::GetLastErrorString() // For Console display
//
// Does name string compare with potentially mangled (ie. [1 0 0]foo) names
//
hsBool NameMatches(const char* obName, const char* pKName, hsBool subString)
bool NameMatches(const char* obName, const char* pKName, bool subString)
{
if (!obName || !pKName)
return false;
@ -117,7 +117,7 @@ hsBool NameMatches(const char* obName, const char* pKName, hsBool subString)
}
plKey plKeyFinder::StupidSearch(const char * age, const char * rm,
const char *className, const plString &obName, hsBool subString)
const char *className, const plString &obName, bool subString)
{
uint16_t ty = plFactory::FindClassIndex(className);
return StupidSearch(age, rm, ty, obName, subString);
@ -128,21 +128,21 @@ class plKeyFinderIter : public plRegistryKeyIterator, public plRegistryPageItera
protected:
uint16_t fClassType;
plString fObjName;
hsBool fSubstr;
bool fSubstr;
plKey fFoundKey;
const char *fAgeName;
public:
plKey GetFoundKey( void ) const { return fFoundKey; }
plKeyFinderIter( uint16_t classType, const plString &obName, hsBool substr )
plKeyFinderIter( uint16_t classType, const plString &obName, bool substr )
: fFoundKey( nil ), fClassType( classType ), fObjName( obName ), fSubstr( substr ) { }
plKeyFinderIter( uint16_t classType, const plString &obName, hsBool substr, const char *ageName )
plKeyFinderIter( uint16_t classType, const plString &obName, bool substr, const char *ageName )
: fFoundKey( nil ), fClassType( classType ), fObjName( obName ), fSubstr( substr ),
fAgeName( ageName ) {}
virtual hsBool EatKey( const plKey& key )
virtual bool EatKey( const plKey& key )
{
if( key->GetUoid().GetClassType() == fClassType &&
NameMatches( fObjName.c_str(), key->GetUoid().GetObjectName().c_str(), fSubstr ) )
@ -154,7 +154,7 @@ public:
return true;
}
virtual hsBool EatPage( plRegistryPageNode *pageNode )
virtual bool EatPage( plRegistryPageNode *pageNode )
{
#ifndef _DEBUG
try
@ -182,7 +182,7 @@ public:
};
plKey plKeyFinder::StupidSearch(const char * age, const char * rm,
uint16_t classType, const plString &obName, hsBool subString)
uint16_t classType, const plString &obName, bool subString)
{
if (obName.IsNull())
return nil;
@ -286,7 +286,7 @@ class plKeyFinderIterator : public plRegistryKeyIterator, public plRegistryPageI
plKeyFinderIterator( uint16_t classType, const plString &obName, std::vector<plKey>& foundKeys )
: fClassType( classType ), fObjName( obName ), fFoundKeys( foundKeys ) { }
virtual hsBool EatKey( const plKey& key )
virtual bool EatKey( const plKey& key )
{
if( key->GetUoid().IsValid() && key->GetUoid().GetClassType() == fClassType &&
key->GetUoid().GetObjectName().Find( fObjName ) >= 0 )
@ -297,9 +297,9 @@ class plKeyFinderIterator : public plRegistryKeyIterator, public plRegistryPageI
return true;
}
virtual hsBool EatPage( plRegistryPageNode *page )
virtual bool EatPage( plRegistryPageNode *page )
{
hsBool ret = page->IterateKeys( this );
bool ret = page->IterateKeys( this );
return ret;
}
};
@ -346,7 +346,7 @@ class plPageFinder : public plRegistryPageIterator
plPageFinder( plRegistryPageNode **page, const char *ageS, const char *pageS ) : fPagePtr( page ), fFindString( pageS ), fAgeString( ageS )
{ *fPagePtr = nil; }
virtual hsBool EatPage( plRegistryPageNode *node )
virtual bool EatPage( plRegistryPageNode *node )
{
static char str[ 512 ];
const plPageInfo &info = node->GetPageInfo();

4
Sources/Plasma/PubUtilLib/plResMgr/plKeyFinder.h
View File

@ -89,8 +89,8 @@ public:
static plKeyFinder& Instance();
// These are Stupid search because they just do string searchs on the objects.
plKey StupidSearch(const char * age, const char * rm, const char *className, const plString &obName, hsBool subString=false);
plKey StupidSearch(const char * age, const char * rm, uint16_t objType, const plString &obName, hsBool subString=false);
plKey StupidSearch(const char * age, const char * rm, const char *className, const plString &obName, bool subString=false);
plKey StupidSearch(const char * age, const char * rm, uint16_t objType, const plString &obName, bool subString=false);
eErrCodes GetLastErrorCode() { return fLastError; }
const char* GetLastErrorString(); // For Console display

2
Sources/Plasma/PubUtilLib/plResMgr/plLoc.h
View File

@ -68,7 +68,7 @@ public:
void ClearThrowBack() { fThrowBack = NULL; fThrowBackLevel = 0; }
bool ThrowBackAvailable() { return (fThrowBack == NULL) ? false: true; }
int NextLine(char **pP); // returns an Allocated string in pP of next valid line, and Level #, or LOC_EOF
hsBool8 Ready() { return fpFile ? true: false; }
bool8 Ready() { return fpFile ? true: false; }
private:
FILE * fpFile;
char * fThrowBack; // If a line is not used, it can be thrown back...unget()

6
Sources/Plasma/PubUtilLib/plResMgr/plLocalization.cpp
View File

@ -87,7 +87,7 @@ plLocalization::encodingTypes plLocalization::fUnicodeEncoding[] =
Enc_UTF8, // kJapanese
};
hsBool plLocalization::IGetLocalized(const char* name, Language lang, char* localizedName)
bool plLocalization::IGetLocalized(const char* name, Language lang, char* localizedName)
{
const char* underscore = strrchr(name, '_');
@ -113,7 +113,7 @@ hsBool plLocalization::IGetLocalized(const char* name, Language lang, char* loca
return false;
}
hsBool plLocalization::ExportGetLocalized(const char* name, int lang, char* localizedName)
bool plLocalization::ExportGetLocalized(const char* name, int lang, char* localizedName)
{
return IGetLocalized(name, Language(lang+1), localizedName) &&
plFileUtils::FileExists(localizedName);
@ -184,7 +184,7 @@ std::vector<std::wstring> plLocalization::StringToLocal(const std::wstring & loc
}
}
// now sortedTagLocs has the indexes of tagLocs sorted from smallest loc to highest loc
hsBool noTags = true;
bool noTags = true;
for (i=0; i<kNumLanguages; i++)
{
int lang = sortedTagLocs[i]; // the language we are extracting

12
Sources/Plasma/PubUtilLib/plResMgr/plLocalization.h
View File

@ -80,7 +80,7 @@ protected:
static bool fUsesUnicode[kNumLanguages];
static encodingTypes fUnicodeEncoding[kNumLanguages];
static hsBool IGetLocalized(const char* name, Language lang, char* localizedName);
static bool IGetLocalized(const char* name, Language lang, char* localizedName);
public:
static void SetLanguage(Language lang) { fLanguage = lang; }
@ -88,16 +88,16 @@ public:
static const char* GetLanguageName(Language lang) { return fLangNames[lang]; }
static hsBool UsingUnicode() { return fUsesUnicode[fLanguage]; }
static bool UsingUnicode() { return fUsesUnicode[fLanguage]; }
static encodingTypes UnicodeEncoding() { return fUnicodeEncoding[fLanguage]; }
// Returns true if we're using localized assets. If it returns false, you
// don't need to bother calling GetLocalized
static hsBool IsLocalized() { return fLanguage != kEnglish; }
static bool IsLocalized() { return fLanguage != kEnglish; }
// Pass in a key name and this will give you the localized name
// Returns false if the original keyname is not for a localized asset
static hsBool GetLocalized(const char* name, char* localizedName) { return IGetLocalized(name, fLanguage, localizedName); }
static bool GetLocalized(const char* name, char* localizedName) { return IGetLocalized(name, fLanguage, localizedName); }
//
// Export only
@ -115,9 +115,9 @@ public:
// }
//
static int GetNumLocales() { return kNumLanguages - 1; }
static hsBool ExportGetLocalized(const char* name, int lang, char* localizedName);
static bool ExportGetLocalized(const char* name, int lang, char* localizedName);
// Just tells us if this is localized, doesn't actually convert it for us
static hsBool IsLocalizedName(const char* name) { return IGetLocalized(name, kEnglish, nil); }
static bool IsLocalizedName(const char* name) { return IGetLocalized(name, kEnglish, nil); }
// Converts a vector of translated strings to a encoded string that can be decoded by StringToLocal()
// The index in the vector of a string is it's language

2
Sources/Plasma/PubUtilLib/plResMgr/plPageInfo.cpp
View File

@ -198,7 +198,7 @@ void plPageInfo::Write( hsStream *s )
//// IsValid /////////////////////////////////////////////////////////////////
// Just a simple test for now.
hsBool plPageInfo::IsValid( void ) const
bool plPageInfo::IsValid( void ) const
{
return fLocation.IsValid();
}

2
Sources/Plasma/PubUtilLib/plResMgr/plPageInfo.h
View File

@ -101,7 +101,7 @@ public:
void Read( hsStream *s );
void Write( hsStream *s );
hsBool IsValid( void ) const;
bool IsValid( void ) const;
uint32_t GetDataStart( void ) const { return fDataStart; }
void SetDataStart( uint32_t s ) { fDataStart = s; }

4
Sources/Plasma/PubUtilLib/plResMgr/plRegistryHelpers.cpp
View File

@ -46,13 +46,13 @@ plKeyCollector::plKeyCollector( hsTArray<plKey> &keys ) : fKeys( keys )
{
}
hsBool plKeyCollector::EatKey(const plKey& key)
bool plKeyCollector::EatKey(const plKey& key)
{
fKeys.Append(key);
return true;
}
hsBool plIndirectUnloadIterator::EatPage(plRegistryPageNode* page)
bool plIndirectUnloadIterator::EatPage(plRegistryPageNode* page)
{
page->IterateKeys(this);
return true;

11
Sources/Plasma/PubUtilLib/plResMgr/plRegistryHelpers.h
View File

@ -65,14 +65,14 @@ class plRegistryKeyIterator
{
public:
virtual ~plRegistryKeyIterator() {}
virtual hsBool EatKey(const plKey& key) = 0;
virtual bool EatKey(const plKey& key) = 0;
};
class plRegistryPageIterator
{
public:
virtual ~plRegistryPageIterator() {}
virtual hsBool EatPage(plRegistryPageNode* keyNode) = 0;
virtual bool EatPage(plRegistryPageNode* keyNode) = 0;
};
@ -85,7 +85,7 @@ protected:
public:
plKeyCollector(hsTArray<plKey>& keys);
virtual hsBool EatKey(const plKey& key);
virtual bool EatKey(const plKey& key);
};
// If you loaded keys with another iterator, this will ensure that they're unloaded
@ -94,9 +94,8 @@ class plIndirectUnloadIterator : public plRegistryPageIterator, public plRegistr
public:
plIndirectUnloadIterator() {}
hsBool EatKey(const plKey& key) { return true; }
hsBool EatPage(plRegistryPageNode* page);
bool EatKey(const plKey& key) { return true; }
bool EatPage(plRegistryPageNode* page);
};
#endif // _plRegistryHelpers_h

12
Sources/Plasma/PubUtilLib/plResMgr/plRegistryNode.cpp
View File

@ -221,7 +221,7 @@ protected:
public:
plWriteIterator(hsStream* s) : fStream(s) {}
virtual hsBool EatKey(const plKey& key)
virtual bool EatKey(const plKey& key)
{
plKeyImp* imp = (plKeyImp*)key;
imp->WriteObject(fStream);
@ -283,7 +283,7 @@ void plRegistryPageNode::Write()
//// IterateKeys /////////////////////////////////////////////////////////////
hsBool plRegistryPageNode::IterateKeys(plRegistryKeyIterator* iterator) const
bool plRegistryPageNode::IterateKeys(plRegistryKeyIterator* iterator) const
{
KeyMap::const_iterator it = fKeyLists.begin();
for (; it != fKeyLists.end(); it++)
@ -300,7 +300,7 @@ hsBool plRegistryPageNode::IterateKeys(plRegistryKeyIterator* iterator) const
// Restricted version that only iterates through the keys of a given class
// type.
hsBool plRegistryPageNode::IterateKeys(plRegistryKeyIterator* iterator, uint16_t classToRestrictTo) const
bool plRegistryPageNode::IterateKeys(plRegistryKeyIterator* iterator, uint16_t classToRestrictTo) const
{
plRegistryKeyList* keyList = IGetKeyList(classToRestrictTo);
if (keyList != nil)
@ -345,7 +345,7 @@ void plRegistryPageNode::AddKey(plKeyImp* key)
// "\n\n(Key name: %s, Class: %s, Loc: %s)", key->GetUoid().GetObjectName(),
// plFactory::GetNameOfClass(classType), key->GetUoid().GetLocation().StringIze(tempStr));
//hsStatusMessage(str);
hsBool recovered = false;
bool recovered = false;
// Attempt recovery
for (int i = 0; i < 500; i++)
@ -383,14 +383,14 @@ void plRegistryPageNode::SetKeyUsed(plKeyImp* key)
keys->SetKeyUsed(key);
}
hsBool plRegistryPageNode::SetKeyUnused(plKeyImp* key)
bool plRegistryPageNode::SetKeyUnused(plKeyImp* key)
{
plRegistryKeyList* keys = IGetKeyList(key->GetUoid().GetClassType());
if (keys == nil)
return false;
plRegistryKeyList::LoadStatus loadStatusChange;
hsBool removed = keys->SetKeyUnused(key, loadStatusChange);
bool removed = keys->SetKeyUnused(key, loadStatusChange);
// If the key type just changed load status, update our load counts
if (loadStatusChange == plRegistryKeyList::kDynUnloaded)

16
Sources/Plasma/PubUtilLib/plResMgr/plRegistryNode.h
View File

@ -83,7 +83,7 @@ protected:
hsBufferedStream fStream; // Stream for reading/writing our page
uint8_t fOpenRequests; // How many handles there are to fStream (or
// zero if it's closed)
hsBool fIsNewPage; // True if this page is new (not read off disk)
bool fIsNewPage; // True if this page is new (not read off disk)
plRegistryPageNode() {}
@ -98,18 +98,18 @@ public:
plRegistryPageNode(const plLocation& location, const char* age, const char* page, const char* dataPath);
~plRegistryPageNode();
hsBool IsValid() const { return fValid == kPageOk; }
bool IsValid() const { return fValid == kPageOk; }
PageCond GetPageCondition() { return fValid; }
// True if we have any static or dynamic keys loaded
hsBool IsLoaded() const { return fDynLoadedTypes > 0 || fStaticLoadedTypes > 0; }
bool IsLoaded() const { return fDynLoadedTypes > 0 || fStaticLoadedTypes > 0; }
// True if all of our static keys are loaded
hsBool IsFullyLoaded() const { return (fStaticLoadedTypes == fKeyLists.size() && !fKeyLists.empty()) || fIsNewPage; }
bool IsFullyLoaded() const { return (fStaticLoadedTypes == fKeyLists.size() && !fKeyLists.empty()) || fIsNewPage; }
// Export time only. If we want to reuse a page, load the keys we want then
// call SetNewPage, so it will be considered a new page from now on. That
// way we won't try to load it's keys again.
hsBool IsNewPage() const { return fIsNewPage; }
bool IsNewPage() const { return fIsNewPage; }
void SetNewPage() { fIsNewPage = true; }
const plPageInfo& GetPageInfo() const { return fPageInfo; }
@ -128,10 +128,10 @@ public:
// When all the static keys are unused we can free the memory associated with
// them. When a dynamic key is unused we just delete it right away.
void SetKeyUsed(plKeyImp* key);
hsBool SetKeyUnused(plKeyImp* key);
bool SetKeyUnused(plKeyImp* key);
hsBool IterateKeys(plRegistryKeyIterator* iterator) const;
hsBool IterateKeys(plRegistryKeyIterator* iterator, uint16_t classToRestrictTo) const;
bool IterateKeys(plRegistryKeyIterator* iterator) const;
bool IterateKeys(plRegistryKeyIterator* iterator, uint16_t classToRestrictTo) const;
// Call this to get a read stream for the page. If a valid pointer is
// returned, make sure to call CloseStream when you're done using it.

54
Sources/Plasma/PubUtilLib/plResMgr/plResManager.cpp
View File

@ -66,7 +66,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
#include "pnNetCommon/plSynchedObject.h"
#include "pnNetCommon/plNetApp.h"
hsBool gDataServerLocal = false;
bool gDataServerLocal = false;
/// Logging #define for easier use
#define kResMgrLog(level, log) if (plResMgrSettings::Get().GetLoggingLevel() >= level) log
@ -121,7 +121,7 @@ plResManager::~plResManager()
hsAssert(!fInited,"ResMgr not shutdown");
}
hsBool plResManager::IInit()
bool plResManager::IInit()
{
if (fInited)
return true;
@ -163,7 +163,7 @@ hsBool plResManager::IInit()
return true;
}
hsBool plResManager::IReset() // Used to Re-Export (number of times)
bool plResManager::IReset() // Used to Re-Export (number of times)
{
BeginShutdown();
IShutdown();
@ -268,7 +268,7 @@ plDispatchBase *plResManager::Dispatch()
}
void plResManager::LogReadTimes(hsBool logReadTimes)
void plResManager::LogReadTimes(bool logReadTimes)
{
fLogReadTimes = logReadTimes;
if (fLogReadTimes)
@ -303,7 +303,7 @@ hsKeyedObject* plResManager::IGetSharedObject(plKeyImp* pKey)
//// ReadObject /////////////////////////////////////////////////////////////
// Given a key, goes off and reads in the actual object from its source
hsBool plResManager::ReadObject(plKeyImp* key)
bool plResManager::ReadObject(plKeyImp* key)
{
// Read in the object. If while we are doing this something else requests a
// load (through AddViaNotify or ReadKeyNotifyMe) we consider it a child load
@ -351,7 +351,7 @@ hsBool plResManager::ReadObject(plKeyImp* key)
return ret;
}
hsBool plResManager::IReadObject(plKeyImp* pKey, hsStream *stream)
bool plResManager::IReadObject(plKeyImp* pKey, hsStream *stream)
{
static uint64_t totalTime = 0;
@ -476,7 +476,7 @@ public:
fResMgr->IterateAllPages(this);
}
virtual hsBool EatPage(plRegistryPageNode* page)
virtual bool EatPage(plRegistryPageNode* page)
{
fResMgr->UnloadPageObjects(page, fHint);
return true;
@ -495,7 +495,7 @@ static bool sFirstTime = true;
#endif
// Just the scene nodes (and objects referenced by the node... and so on)
void plResManager::IPageOutSceneNodes(hsBool forceAll)
void plResManager::IPageOutSceneNodes(bool forceAll)
{
plSynchEnabler ps(false); // disable dirty tracking while paging out
@ -626,14 +626,14 @@ void plResManager::GetLocationStrings(const plLocation& loc, char* ageBuffer, ch
hsStrcpy(pageBuffer, info.GetPage());
}
hsBool plResManager::AddViaNotify(plRefMsg* msg, plRefFlags::Type flags)
bool plResManager::AddViaNotify(plRefMsg* msg, plRefFlags::Type flags)
{
hsAssert(msg && msg->GetRef() && msg->GetRef()->GetKey(), "Improperly filled out ref message");
plKey key = msg->GetRef()->GetKey(); // for linux build
return AddViaNotify(key, msg, flags);
}
hsBool plResManager::AddViaNotify(const plKey &key, plRefMsg* msg, plRefFlags::Type flags)
bool plResManager::AddViaNotify(const plKey &key, plRefMsg* msg, plRefFlags::Type flags)
{
hsAssert(key, "Can't add without a Key");
if (!key)
@ -654,7 +654,7 @@ hsBool plResManager::AddViaNotify(const plKey &key, plRefMsg* msg, plRefFlags::T
return true;
}
hsBool plResManager::SendRef(hsKeyedObject* ko, plRefMsg* refMsg, plRefFlags::Type flags)
bool plResManager::SendRef(hsKeyedObject* ko, plRefMsg* refMsg, plRefFlags::Type flags)
{
if (!ko)
return false;
@ -674,7 +674,7 @@ hsBool plResManager::SendRef(hsKeyedObject* ko, plRefMsg* refMsg, plRefFlags::Ty
// This doesn't mean you are guaranteed to have your ref at the return of SendRef,
// because if it's not in memory, we don't wait around while we load it, we just
// return false.
hsBool plResManager::SendRef(const plKey& key, plRefMsg* refMsg, plRefFlags::Type flags)
bool plResManager::SendRef(const plKey& key, plRefMsg* refMsg, plRefFlags::Type flags)
{
if (!key)
{
@ -847,7 +847,7 @@ plKey plResManager::ReRegister(const plString& nm, const plUoid& oid)
plKey plResManager::ReadKey(hsStream* s)
{
hsBool nonNil = s->ReadBool();
bool nonNil = s->ReadBool();
if (!nonNil)
return nil;
@ -939,7 +939,7 @@ plKey plResManager::ICloneKey(const plUoid& objUoid, uint32_t playerID, uint32_t
// When support for paging is added, key->UnRegister() should not clear its notify lists.
// Return true if successful.
//
hsBool plResManager::Unload(const plKey& objKey)
bool plResManager::Unload(const plKey& objKey)
{
if (objKey)
{
@ -1034,7 +1034,7 @@ public:
plResHolderIterator(const char* age, hsTArray<plKey>& keys, plResManager* resMgr)
: fAgeName(age), fKeys(keys), fResMgr(resMgr) {}
virtual hsBool EatPage(plRegistryPageNode* page)
virtual bool EatPage(plRegistryPageNode* page)
{
if (stricmp(page->GetPageInfo().GetAge(), fAgeName) == 0)
{
@ -1137,7 +1137,7 @@ class plOurRefferAndFinder : public plRegistryKeyIterator
plOurRefferAndFinder( hsTArray<plKey> &refArray, uint16_t classToFind, plKey &foundKey )
: fRefArray( refArray ), fClassToFind( classToFind ), fFoundKey( foundKey ) { }
virtual hsBool EatKey( const plKey& key )
virtual bool EatKey( const plKey& key )
{
// This is cute. Thanks to our new plKey smart pointers, all we have to
// do is append the key to our ref array. This automatically guarantees us
@ -1268,7 +1268,7 @@ public:
}
pMsg1->Send(fDestKey);
}
virtual hsBool EatPage(plRegistryPageNode* page)
virtual bool EatPage(plRegistryPageNode* page)
{
if (stricmp(page->GetPageInfo().GetAge(), fAgeName) == 0)
{
@ -1302,7 +1302,7 @@ void plResManager::PageInAge(const char *age)
// Runs through all the pages and ensures they are all up-to-date in version
// numbers and that no out-of-date objects exist in them
hsBool plResManager::VerifyPages()
bool plResManager::VerifyPages()
{
hsTArray<plRegistryPageNode*> invalidPages, newerPages;
PageMap::iterator it = fAllPages.begin();
@ -1415,7 +1415,7 @@ static void ICatPageNames(hsTArray<plRegistryPageNode*>& pages, char* buf, int b
}
}
hsBool plResManager::IDeleteBadPages(hsTArray<plRegistryPageNode*>& invalidPages, hsBool conflictingSeqNums)
bool plResManager::IDeleteBadPages(hsTArray<plRegistryPageNode*>& invalidPages, bool conflictingSeqNums)
{
#ifndef PLASMA_EXTERNAL_RELEASE
if (!hsMessageBox_SuppressPrompts)
@ -1454,7 +1454,7 @@ hsBool plResManager::IDeleteBadPages(hsTArray<plRegistryPageNode*>& invalidPages
// than the "current" one), warns the user about them but does nothing to
// them.
hsBool plResManager::IWarnNewerPages(hsTArray<plRegistryPageNode*> &newerPages)
bool plResManager::IWarnNewerPages(hsTArray<plRegistryPageNode*> &newerPages)
{
#ifndef PLASMA_EXTERNAL_RELEASE
if (!hsMessageBox_SuppressPrompts)
@ -1495,7 +1495,7 @@ public:
void UnRef() { fRefArray.Reset(); }
virtual hsBool EatKey(const plKey& key)
virtual bool EatKey(const plKey& key)
{
// This is cute. Thanks to our new plKey smart pointers, all we have to
// do is append the key to our ref array. This automatically guarantees us
@ -1608,7 +1608,7 @@ void plResManager::UnloadPageObjects(plRegistryPageNode* pageNode, uint16_t clas
class plUnloadObjectsIterator : public plRegistryKeyIterator
{
public:
virtual hsBool EatKey(const plKey& key)
virtual bool EatKey(const plKey& key)
{
sIReportLeak((plKeyImp*)key, nil);
return true;
@ -1725,7 +1725,7 @@ protected:
public:
plKeyIterEater(plRegistryKeyIterator* iter) : fIter(iter) {}
virtual hsBool EatPage(plRegistryPageNode* keyNode)
virtual bool EatPage(plRegistryPageNode* keyNode)
{
return keyNode->IterateKeys(fIter);
}
@ -1733,13 +1733,13 @@ public:
//// IterateKeys /////////////////////////////////////////////////////////////
hsBool plResManager::IterateKeys(plRegistryKeyIterator* iterator)
bool plResManager::IterateKeys(plRegistryKeyIterator* iterator)
{
plKeyIterEater myEater(iterator);
return IteratePages(&myEater, nil);
}
hsBool plResManager::IterateKeys(plRegistryKeyIterator* iterator, const plLocation& pageToRestrictTo)
bool plResManager::IterateKeys(plRegistryKeyIterator* iterator, const plLocation& pageToRestrictTo)
{
plRegistryPageNode* page = FindPage(pageToRestrictTo);
if (page == nil)
@ -1755,7 +1755,7 @@ hsBool plResManager::IterateKeys(plRegistryKeyIterator* iterator, const plLocati
//// IteratePages ////////////////////////////////////////////////////////////
// Iterate through all LOADED pages
hsBool plResManager::IteratePages(plRegistryPageIterator* iterator, const char* ageToRestrictTo)
bool plResManager::IteratePages(plRegistryPageIterator* iterator, const char* ageToRestrictTo)
{
ILockPages();
@ -1784,7 +1784,7 @@ hsBool plResManager::IteratePages(plRegistryPageIterator* iterator, const char*
//// IterateAllPages /////////////////////////////////////////////////////////
// Iterate through ALL pages
hsBool plResManager::IterateAllPages(plRegistryPageIterator* iterator)
bool plResManager::IterateAllPages(plRegistryPageIterator* iterator)
{
ILockPages();

52
Sources/Plasma/PubUtilLib/plResMgr/plResManager.h
View File

@ -78,7 +78,7 @@ public:
// Load and Unload
//---------------------------
virtual void Load (const plKey& objKey); // places on list to be loaded
virtual hsBool Unload(const plKey& objKey); // Unregisters (deletes) an object, Return true if successful
virtual bool Unload(const plKey& objKey); // Unregisters (deletes) an object, Return true if successful
virtual plKey CloneKey(const plKey& objKey);
//---------------------------
@ -93,11 +93,11 @@ public:
//---------------------------
// Establish reference linkage
//---------------------------
virtual hsBool AddViaNotify(const plKey& key, plRefMsg* msg, plRefFlags::Type flags);
virtual hsBool AddViaNotify(plRefMsg* msg, plRefFlags::Type flags); // msg->fRef->GetKey() == sentKey
virtual bool AddViaNotify(const plKey& key, plRefMsg* msg, plRefFlags::Type flags);
virtual bool AddViaNotify(plRefMsg* msg, plRefFlags::Type flags); // msg->fRef->GetKey() == sentKey
virtual hsBool SendRef(const plKey& key, plRefMsg* refMsg, plRefFlags::Type flags);
virtual hsBool SendRef(hsKeyedObject* ko, plRefMsg* refMsg, plRefFlags::Type flags);
virtual bool SendRef(const plKey& key, plRefMsg* refMsg, plRefFlags::Type flags);
virtual bool SendRef(hsKeyedObject* ko, plRefMsg* refMsg, plRefFlags::Type flags);
//---------------------------
// Reding and Writing keys
@ -142,22 +142,22 @@ public:
// read causes all the other objects to be read before it returns. In some
// cases though (mostly just the texture file), this doesn't work. In that
// case, we just want to force it to stay open until we're done reading the age.
void KeepPageOpen(const plLocation& page, hsBool keepOpen);
void KeepPageOpen(const plLocation& page, bool keepOpen);
// We're on the way down, act accordingly.
virtual void BeginShutdown();
// Determines whether the time to read each object is dumped to a log
void LogReadTimes(hsBool logReadTimes);
void LogReadTimes(bool logReadTimes);
// All keys version
hsBool IterateKeys(plRegistryKeyIterator* iterator);
bool IterateKeys(plRegistryKeyIterator* iterator);
// Single page version
hsBool IterateKeys(plRegistryKeyIterator* iterator, const plLocation& pageToRestrictTo);
bool IterateKeys(plRegistryKeyIterator* iterator, const plLocation& pageToRestrictTo);
// Iterate through loaded pages
hsBool IteratePages(plRegistryPageIterator* iterator, const char* ageToRestrictTo = nil);
bool IteratePages(plRegistryPageIterator* iterator, const char* ageToRestrictTo = nil);
// Iterate through ALL pages, loaded or not
hsBool IterateAllPages(plRegistryPageIterator* iterator);
bool IterateAllPages(plRegistryPageIterator* iterator);
// Helpers for key iterators
void LoadPageKeys(plRegistryPageNode* pageNode);
@ -167,7 +167,7 @@ public:
plRegistryPageNode* FindPage(const char* age, const char* page) const;
// Runs through all the pages and verifies that the data versions are good
hsBool VerifyPages();
bool VerifyPages();
protected:
friend class hsKeyedObject;
@ -175,8 +175,8 @@ protected:
friend class plResManagerHelper;
virtual plKey ReRegister(const plString& nm, const plUoid& uoid);
virtual hsBool ReadObject(plKeyImp* key); // plKeys call this when needed
virtual hsBool IReadObject(plKeyImp* pKey, hsStream *stream);
virtual bool ReadObject(plKeyImp* key); // plKeys call this when needed
virtual bool IReadObject(plKeyImp* pKey, hsStream *stream);
plCreatable* IReadCreatable(hsStream* s) const;
plKey ICloneKey(const plUoid& objUoid, uint32_t playerID, uint32_t cloneID);
@ -184,19 +184,19 @@ protected:
virtual void IKeyReffed(plKeyImp* key);
virtual void IKeyUnreffed(plKeyImp* key);
virtual hsBool IReset();
virtual hsBool IInit();
virtual bool IReset();
virtual bool IInit();
virtual void IShutdown();
void IPageOutSceneNodes(hsBool forceAll);
void IPageOutSceneNodes(bool forceAll);
void IDropAllAgeKeys();
hsKeyedObject* IGetSharedObject(plKeyImp* pKey);
void IUnloadPageKeys(plRegistryPageNode* pageNode, hsBool dontClear = false);
void IUnloadPageKeys(plRegistryPageNode* pageNode, bool dontClear = false);
hsBool IDeleteBadPages(hsTArray<plRegistryPageNode*>& invalidPages, hsBool conflictingSeqNums);
hsBool IWarnNewerPages(hsTArray<plRegistryPageNode*>& newerPages);
bool IDeleteBadPages(hsTArray<plRegistryPageNode*>& invalidPages, bool conflictingSeqNums);
bool IWarnNewerPages(hsTArray<plRegistryPageNode*>& newerPages);
void ILockPages();
void IUnlockPages();
@ -208,11 +208,11 @@ protected:
plRegistryPageNode* CreatePage(const plLocation& location, const char* age, const char* page);
hsBool fInited;
uint16_t fPageOutHint;
bool fInited;
uint16_t fPageOutHint;
// True if we're reading in an object. We only read one object at a time
hsBool fReadingObject;
bool fReadingObject;
std::vector<plKey> fQueuedReads;
std::string fDataPath;
@ -229,10 +229,10 @@ protected:
plResManagerHelper *fMyHelper;
hsBool fLogReadTimes;
bool fLogReadTimes;
uint8_t fPageListLock; // Number of locks on the page lists. If it's greater than zero, they can't be modified
hsBool fPagesNeedCleanup; // True if something modified the page lists while they were locked.
uint8_t fPageListLock; // Number of locks on the page lists. If it's greater than zero, they can't be modified
bool fPagesNeedCleanup; // True if something modified the page lists while they were locked.
typedef std::set<plRegistryPageNode*> PageSet;
typedef std::map<plLocation, plRegistryPageNode*> PageMap;

28
Sources/Plasma/PubUtilLib/plResMgr/plResManagerHelper.cpp
View File

@ -123,7 +123,7 @@ void plResManagerHelper::Init( void )
//// MsgReceive //////////////////////////////////////////////////////////////
hsBool plResManagerHelper::MsgReceive( plMessage *msg )
bool plResManagerHelper::MsgReceive( plMessage *msg )
{
plResMgrHelperMsg *refferMsg = plResMgrHelperMsg::ConvertNoRef( msg );
if( refferMsg != nil )
@ -215,7 +215,7 @@ class plResMgrDebugInterface : public plInputInterface
plResMgrDebugInterface( plResManagerHelper * const mgr ) : fParent( mgr ) { SetEnabled( true ); }
virtual uint32_t GetPriorityLevel( void ) const { return kGUISystemPriority + 10; }
virtual hsBool InterpretInputEvent( plInputEventMsg *pMsg )
virtual bool InterpretInputEvent( plInputEventMsg *pMsg )
{
plKeyEventMsg *pKeyMsg = plKeyEventMsg::ConvertNoRef( pMsg );
if( pKeyMsg != nil && pKeyMsg->GetKeyDown() )
@ -269,14 +269,14 @@ class plResMgrDebugInterface : public plInputInterface
}
virtual uint32_t GetCurrentCursorID( void ) const { return 0; }
virtual hsBool HasInterestingCursorID( void ) const { return false; }
virtual bool HasInterestingCursorID( void ) const { return false; }
};
#endif
//// EnableDebugScreen ///////////////////////////////////////////////////////
void plResManagerHelper::EnableDebugScreen( hsBool enable )
void plResManagerHelper::EnableDebugScreen( bool enable )
{
#ifdef MCN_RESMGR_DEBUGGING
if( enable )
@ -338,7 +338,7 @@ class plDebugPrintIterator : public plRegistryPageIterator, plRegistryKeyIterato
fAgeIndex = 0;
}
virtual hsBool EatPage( plRegistryPageNode *page )
virtual bool EatPage( plRegistryPageNode *page )
{
if( fStep == 0 )
{
@ -469,7 +469,7 @@ class plDebugPrintIterator : public plRegistryPageIterator, plRegistryKeyIterato
return true;
}
virtual hsBool EatKey( const plKey& key )
virtual bool EatKey( const plKey& key )
{
if( key->ObjectIsLoaded() )
{
@ -483,7 +483,7 @@ class plDebugPrintIterator : public plRegistryPageIterator, plRegistryKeyIterato
};
#endif
void plResManagerHelper::IUpdateDebugScreen( hsBool force )
void plResManagerHelper::IUpdateDebugScreen( bool force )
{
#ifdef MCN_RESMGR_DEBUGGING
@ -517,12 +517,12 @@ void plResManagerHelper::IUpdateDebugScreen( hsBool force )
#if 0
// FIXME
hsBool VerifyKeyUnloaded(const char* logFile, const plKey& key);
bool 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 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)
@ -640,7 +640,7 @@ bool plResManager::IVerifyKeyUnloadedRecur(const char* logFile, const plKey& bas
return false;
}
hsBool plResManager::VerifyKeyUnloaded(const char* logFile, const plKey& key)
bool plResManager::VerifyKeyUnloaded(const char* logFile, const plKey& key)
{
if( key->ObjectIsLoaded() )
{
@ -653,7 +653,7 @@ hsBool plResManager::VerifyKeyUnloaded(const char* logFile, const plKey& key)
hsTArray<plKey> tree;
int cycleStart;
hsBool hasCycle = ILookForCyclesRecur(logFile, key, tree, cycleStart);
bool 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()));
@ -685,7 +685,7 @@ public:
fRegistry = reg;
fLogFile = logFile;
}
virtual hsBool EatKey(const plKey& key)
virtual bool EatKey(const plKey& key)
{
fRegistry->VerifyKeyUnloaded(fLogFile, key);
return true;
@ -702,7 +702,7 @@ public:
plValidatePageIterator(const char* age, plRegistryKeyIterator* iter) : fAge(age), fIter(iter) {}
virtual hsBool EatPage( plRegistryPageNode *keyNode )
virtual bool EatPage( plRegistryPageNode *keyNode )
{
if( !stricmp(fAge, keyNode->GetPageInfo().GetAge()) )
return keyNode->IterateKeys( fIter );
@ -712,7 +712,7 @@ public:
void plResManager::VerifyAgeUnloaded(const char* logFile, const char* age)
{
hsBool autoLog = false;
bool autoLog = false;
char buff[256];
if( !logFile || !*logFile )
{

14
Sources/Plasma/PubUtilLib/plResMgr/plResManagerHelper.h
View File

@ -79,14 +79,14 @@ class plResManagerHelper : public hsKeyedObject
plResManager *fResManager;
static plResManagerHelper *fInstance;
hsBool fInShutdown;
bool fInShutdown;
#ifdef MCN_RESMGR_DEBUGGING
friend class plDebugPrintIterator;
friend class plResMgrDebugInterface;
plStatusLog *fDebugScreen;
hsBool fRefreshing, fCurrAgeExpanded;
bool fRefreshing, fCurrAgeExpanded;
int fCurrAge;
int fDebugDisplayType;
@ -100,7 +100,7 @@ class plResManagerHelper : public hsKeyedObject
plResMgrDebugInterface *fDebugInput;
#endif
void IUpdateDebugScreen( hsBool force = false );
void IUpdateDebugScreen( bool force = false );
public:
@ -110,7 +110,7 @@ class plResManagerHelper : public hsKeyedObject
CLASSNAME_REGISTER( plResManagerHelper );
GETINTERFACE_ANY( plResManagerHelper, hsKeyedObject );
virtual hsBool MsgReceive( plMessage *msg );
virtual bool MsgReceive( plMessage *msg );
virtual void Read( hsStream *s, hsResMgr *mgr );
virtual void Write( hsStream *s, hsResMgr *mgr );
@ -120,11 +120,11 @@ class plResManagerHelper : public hsKeyedObject
void LoadAndHoldPageKeys( plRegistryPageNode *page );
void EnableDebugScreen( hsBool enable );
void EnableDebugScreen( bool enable );
// Please let the res manager handle telling this.
void SetInShutdown(hsBool b) { fInShutdown = b; }
hsBool GetInShutdown() const { return fInShutdown; }
void SetInShutdown(bool b) { fInShutdown = b; }
bool GetInShutdown() const { return fInShutdown; }
static plResManagerHelper *GetInstance( void ) { return fInstance; }
};