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

Convert custom HeadSpin integer types to standard types from stdint.h

Browse Source
This commit is contained in:
Adam Johnson
2012-01-19 21:19:26 -05:00
parent a0d54e2644
commit 5027b5a4ac
1301 changed files with 14497 additions and 14532 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54
Sources/Plasma/NucleusLib/pnFactory/plCreatable.h
View File

@ -55,10 +55,10 @@ class plCreatable : public hsRefCnt
{
public:
virtual const char* ClassName() const = 0;
virtual plCreatable* GetInterface(UInt16 hClass) { return nil; }
virtual const plCreatable* GetConstInterface(UInt16 hClass) const { return nil; }
static hsBool HasBaseClass(UInt16 hBase) { return false; }
virtual UInt16 ClassIndex() const = 0;
virtual plCreatable* GetInterface(uint16_t hClass) { return nil; }
virtual const plCreatable* GetConstInterface(uint16_t hClass) const { return nil; }
static hsBool HasBaseClass(uint16_t hBase) { return false; }
virtual uint16_t ClassIndex() const = 0;
virtual void Read(hsStream* s, hsResMgr* mgr) {}
virtual void Write(hsStream* s, hsResMgr* mgr) {}
@ -86,8 +86,8 @@ public:
//
// CLASSNAME_REGISTER( plClassName ) - Sets up identification for this
// class. The exposed methods are
// static UInt16 Index() - returns the index for that class.
// virtual UInt16 ClassIndex() - returns index for this object's class.
// static uint16_t Index() - returns the index for that class.
// virtual uint16_t ClassIndex() - returns index for this object's class.
// static plClassName* Convert(plCreatable* c) - if c exposes an interface
// as plClassName, return that, else nil. Incs the ref count of the object.
// static plClassName* ConvertNoRef(plCreatable* c) - Same as Convert(), but
@ -102,7 +102,7 @@ public:
// exactly of type plClassName
// GETINTERFACE_NONE - Never provide an interface as plClassName.
// Instead of using these macros, the class can provide a method
// virtual plCreatable* GetInterface(UInt16 hClass) which returns an object of
// virtual plCreatable* GetInterface(uint16_t hClass) which returns an object of
// type matching class handle hClass.
// Insert into public section of class definition (like right after CLASSNAME_REGISTER).
//
@ -163,15 +163,15 @@ public:
public: \
virtual const char* ClassName() const { return #plClassName; } \
private: \
static UInt16 plClassName##ClassIndex; \
static void SetClassIndex(UInt16 hClass) { \
static uint16_t plClassName##ClassIndex; \
static void SetClassIndex(uint16_t hClass) { \
plClassName##ClassIndex = hClass; \
} \
public: \
virtual UInt16 ClassIndex() const { \
virtual uint16_t ClassIndex() const { \
return plClassName::Index(); \
} \
static UInt16 Index() { \
static uint16_t Index() { \
return plClassName##ClassIndex; \
} \
static plClassName * Create() { \
@ -194,25 +194,25 @@ public: \
hsRefCnt_SafeRef(retVal); \
return retVal; \
} \
static hsBool HasDerivedClass(UInt16 hDer) { \
static hsBool HasDerivedClass(uint16_t hDer) { \
return plFactory::DerivesFrom(plClassName##ClassIndex, hDer); \
} \
friend class plClassName##__Creator;
#define GETINTERFACE_ANY( plClassName, plBaseName ) \
static hsBool HasBaseClass(UInt16 hBaseClass) { \
static hsBool HasBaseClass(uint16_t hBaseClass) { \
if( hBaseClass == plClassName##ClassIndex ) \
return true; \
else \
return plBaseName::HasBaseClass(hBaseClass); \
} \
virtual plCreatable* GetInterface(UInt16 hClass) { \
virtual plCreatable* GetInterface(uint16_t hClass) { \
if( hClass == plClassName##ClassIndex ) \
return this; \
else \
return plBaseName::GetInterface(hClass); \
} \
virtual const plCreatable* GetConstInterface(UInt16 hClass) const { \
virtual const plCreatable* GetConstInterface(uint16_t hClass) const { \
if( hClass == plClassName##ClassIndex ) \
return this; \
else \
@ -220,22 +220,22 @@ virtual const plCreatable* GetConstInterface(UInt16 hClass) const { \
}
#define GETINTERFACE_EXACT( plClassName ) \
static hsBool HasBaseClass(UInt16 hBaseClass) { \
static hsBool HasBaseClass(uint16_t hBaseClass) { \
return hBaseClass == plClassName##ClassIndex; \
} \
virtual plCreatable* GetInterface(UInt16 hClass) { \
virtual plCreatable* GetInterface(uint16_t hClass) { \
return hClass == plClassName##ClassIndex ? this : nil; \
} \
virtual const plCreatable* GetConstInterface(UInt16 hClass) const { \
virtual const plCreatable* GetConstInterface(uint16_t hClass) const { \
return hClass == plClassName##ClassIndex ? this : nil; \
}
#define GETINTERFACE_NONE( plClassName ) \
static hsBool HasBaseClass(UInt16 hBaseClass) { return false; } \
virtual plCreatable* GetInterface(UInt16 hClass) { \
static hsBool HasBaseClass(uint16_t hBaseClass) { return false; } \
virtual plCreatable* GetInterface(uint16_t hClass) { \
return nil; \
} \
virtual const plCreatable* GetConstInterface(UInt16 hClass) const { \
virtual const plCreatable* GetConstInterface(uint16_t hClass) const { \
return nil; \
}
@ -243,13 +243,13 @@ virtual const plCreatable* GetConstInterface(UInt16 hClass) const { \
// Macro for converting to base class OR a class member
//
#define GETINTERFACE_ANY_AUX( plClassName, plBaseName, plAuxClassName, plAuxClassMember ) \
static hsBool HasBaseClass(UInt16 hBaseClass) { \
static hsBool HasBaseClass(uint16_t hBaseClass) { \
if( hBaseClass == plClassName##ClassIndex ) \
return true; \
else \
return plBaseName::HasBaseClass(hBaseClass); \
} \
virtual plCreatable* GetInterface(UInt16 hClass) { \
virtual plCreatable* GetInterface(uint16_t hClass) { \
if( hClass == plClassName##ClassIndex ) \
return this; \
else \
@ -258,7 +258,7 @@ virtual plCreatable* GetInterface(UInt16 hClass) { \
else \
return plBaseName::GetInterface(hClass); \
} \
virtual const plCreatable* GetConstInterface(UInt16 hClass) const { \
virtual const plCreatable* GetConstInterface(uint16_t hClass) const { \
if( hClass == plClassName##ClassIndex ) \
return this; \
else \
@ -269,17 +269,17 @@ virtual const plCreatable* GetConstInterface(UInt16 hClass) const { \
}
#define plBeginInterfaceMap( plClassName, plBaseName ) \
static hsBool HasBaseClass(UInt16 hBaseClass) { \
static hsBool HasBaseClass(uint16_t hBaseClass) { \
if( hBaseClass == plClassName##ClassIndex ) \
return true; \
else \
return plBaseName::HasBaseClass(hBaseClass); \
} \
virtual plCreatable* GetInterface(UInt16 hClass) { \
virtual plCreatable* GetInterface(uint16_t hClass) { \
/* NOTE: pulling const off the ptr should be ok, right? */ \
return const_cast<plCreatable*>( GetConstInterface( hClass ) ); \
} \
virtual const plCreatable* GetConstInterface(UInt16 hClass) const { \
virtual const plCreatable* GetConstInterface(uint16_t hClass) const { \
typedef plBaseName MyBaseClass; \
if( hClass == plClassName##ClassIndex ) \
return this

28
Sources/Plasma/NucleusLib/pnFactory/plCreator.h
View File

@ -59,9 +59,9 @@ public:
virtual ~plCreator() { }
virtual plCreatable* Create() const = 0;
virtual UInt16 ClassIndex() = 0;
virtual uint16_t ClassIndex() = 0;
virtual const char* ClassName() const = 0;
virtual hsBool HasBaseClass(UInt16 hBase) = 0;
virtual hsBool HasBaseClass(uint16_t hBase) = 0;
friend class plFactory;
};
@ -81,16 +81,16 @@ public:
plFactory::UnRegister(CLASS_INDEX_SCOPED(plClassName), this); \
} \
\
virtual hsBool HasBaseClass(UInt16 hBase) { return plClassName::HasBaseClass(hBase); } \
virtual hsBool HasBaseClass(uint16_t hBase) { return plClassName::HasBaseClass(hBase); } \
\
virtual UInt16 ClassIndex() { return CLASS_INDEX_SCOPED(plClassName); } \
virtual uint16_t ClassIndex() { return CLASS_INDEX_SCOPED(plClassName); } \
virtual const char* ClassName() const { return #plClassName; } \
\
virtual plCreatable* Create() const { return TRACKED_NEW plClassName; } \
\
}; \
static plClassName##__Creator static##plClassName##__Creator; \
UInt16 plClassName::plClassName##ClassIndex = 0; //
uint16_t plClassName::plClassName##ClassIndex = 0; //
#define REGISTER_NONCREATABLE( plClassName ) \
\
@ -107,16 +107,16 @@ public:
plFactory::UnRegister(CLASS_INDEX_SCOPED(plClassName), this); \
} \
\
virtual hsBool HasBaseClass(UInt16 hBase) { return plClassName::HasBaseClass(hBase); } \
virtual hsBool HasBaseClass(uint16_t hBase) { return plClassName::HasBaseClass(hBase); } \
\
virtual UInt16 ClassIndex() { return CLASS_INDEX_SCOPED(plClassName); } \
virtual uint16_t ClassIndex() { return CLASS_INDEX_SCOPED(plClassName); } \
virtual const char* ClassName() const { return #plClassName; } \
\
virtual plCreatable* Create() const { return nil; } \
\
}; \
static plClassName##__Creator static##plClassName##__Creator; \
UInt16 plClassName::plClassName##ClassIndex = 0; //
uint16_t plClassName::plClassName##ClassIndex = 0; //
#define DECLARE_EXTERNAL_CREATABLE( plClassName ) \
\
@ -140,16 +140,16 @@ public:
plFactory::UnRegister(EXTERN_CLASS_INDEX_SCOPED(plClassName), this); \
} \
\
virtual hsBool HasBaseClass(UInt16 hBase) { return plClassName::HasBaseClass(hBase); } \
virtual hsBool HasBaseClass(uint16_t hBase) { return plClassName::HasBaseClass(hBase); } \
\
virtual UInt16 ClassIndex() { return EXTERN_CLASS_INDEX_SCOPED(plClassName); } \
virtual uint16_t ClassIndex() { return EXTERN_CLASS_INDEX_SCOPED(plClassName); } \
virtual const char* ClassName() const { return #plClassName; } \
\
virtual plCreatable* Create() const { return TRACKED_NEW plClassName; } \
\
}; \
static plClassName##__Creator static##plClassName##__Creator; \
UInt16 plClassName::plClassName##ClassIndex = 0; //
uint16_t plClassName::plClassName##ClassIndex = 0; //
#define REGISTER_EXTERNAL_CREATABLE(plClassName) \
static##plClassName##__Creator.Register(); //
@ -172,16 +172,16 @@ public:
plFactory::UnRegister(EXTERN_CLASS_INDEX_SCOPED(plClassName), this); \
} \
\
virtual hsBool HasBaseClass(UInt16 hBase) { return plClassName::HasBaseClass(hBase); } \
virtual hsBool HasBaseClass(uint16_t hBase) { return plClassName::HasBaseClass(hBase); } \
\
virtual UInt16 ClassIndex() { return EXTERN_CLASS_INDEX_SCOPED(plClassName); } \
virtual uint16_t ClassIndex() { return EXTERN_CLASS_INDEX_SCOPED(plClassName); } \
virtual const char* ClassName() const { return #plClassName; } \
\
virtual plCreatable* Create() const { return nil; } \
\
}; \
static plClassName##__Creator static##plClassName##__Creator; \
UInt16 plClassName::plClassName##ClassIndex = 0; //
uint16_t plClassName::plClassName##ClassIndex = 0; //
#endif // plCreator_inc

34
Sources/Plasma/NucleusLib/pnFactory/plFactory.cpp
View File

@ -73,7 +73,7 @@ hsBool plFactory::ICreateTheFactory()
return theFactory != nil;
}
UInt16 plFactory::IGetNumClasses()
uint16_t plFactory::IGetNumClasses()
{
return plCreatableIndex::plNumClassIndices;
}
@ -97,7 +97,7 @@ void plFactory::IShutdown()
theFactory = nil;
}
UInt16 plFactory::IRegister(UInt16 hClass, plCreator* worker)
uint16_t plFactory::IRegister(uint16_t hClass, plCreator* worker)
{
delete fCreators[hClass];
fCreators[hClass] = worker;
@ -107,7 +107,7 @@ UInt16 plFactory::IRegister(UInt16 hClass, plCreator* worker)
//
// return true if creator exists
//
bool plFactory::CanCreate(UInt16 hClass)
bool plFactory::CanCreate(uint16_t hClass)
{
if( hClass & 0x8000 ) // nil creatable
return false;
@ -121,7 +121,7 @@ bool plFactory::CanCreate(UInt16 hClass)
return ( theFactory->fCreators[ hClass ] != nil ); // check creator
}
plCreatable* plFactory::ICreate(UInt16 hClass)
plCreatable* plFactory::ICreate(uint16_t hClass)
{
if (CanCreate(hClass))
{
@ -135,7 +135,7 @@ plCreatable* plFactory::ICreate(UInt16 hClass)
return nil;
}
void plFactory::UnRegister(UInt16 hClass, plCreator* worker)
void plFactory::UnRegister(uint16_t hClass, plCreator* worker)
{
if( theFactory )
{
@ -146,12 +146,12 @@ void plFactory::UnRegister(UInt16 hClass, plCreator* worker)
}
}
void plFactory::IUnRegister(UInt16 hClass)
void plFactory::IUnRegister(uint16_t hClass)
{
fCreators[hClass] = nil;
}
UInt16 plFactory::Register(UInt16 hClass, plCreator* worker)
uint16_t plFactory::Register(uint16_t hClass, plCreator* worker)
{
if( !theFactory && !ICreateTheFactory() )
return nil;
@ -160,7 +160,7 @@ UInt16 plFactory::Register(UInt16 hClass, plCreator* worker)
return theFactory->IRegister(hClass, worker);
}
plCreatable* plFactory::Create(UInt16 hClass)
plCreatable* plFactory::Create(uint16_t hClass)
{
if( !theFactory && !ICreateTheFactory() )
return nil;
@ -170,7 +170,7 @@ plCreatable* plFactory::Create(UInt16 hClass)
UInt16 plFactory::GetNumClasses()
uint16_t plFactory::GetNumClasses()
{
if( !theFactory && !ICreateTheFactory() )
return 0;
@ -178,7 +178,7 @@ UInt16 plFactory::GetNumClasses()
return theFactory->IGetNumClasses();
}
hsBool plFactory::IDerivesFrom(UInt16 hBase, UInt16 hDer)
hsBool plFactory::IDerivesFrom(uint16_t hBase, uint16_t hDer)
{
if( hDer >= fCreators.GetCount() )
return false;
@ -186,7 +186,7 @@ hsBool plFactory::IDerivesFrom(UInt16 hBase, UInt16 hDer)
return fCreators[hDer] ? fCreators[hDer]->HasBaseClass(hBase) : false;
}
hsBool plFactory::DerivesFrom(UInt16 hBase, UInt16 hDer)
hsBool plFactory::DerivesFrom(uint16_t hBase, uint16_t hDer)
{
if( !theFactory && !ICreateTheFactory() )
return 0;
@ -195,7 +195,7 @@ hsBool plFactory::DerivesFrom(UInt16 hBase, UInt16 hDer)
}
// slow lookup for things like console
UInt16 plFactory::FindClassIndex(const char* className)
uint16_t plFactory::FindClassIndex(const char* className)
{
int numClasses=GetNumClasses();
@ -214,12 +214,12 @@ UInt16 plFactory::FindClassIndex(const char* className)
}
hsBool plFactory::IIsValidClassIndex(UInt16 hClass)
hsBool plFactory::IIsValidClassIndex(uint16_t hClass)
{
return ( hClass < fCreators.GetCount() );
}
hsBool plFactory::IsValidClassIndex(UInt16 hClass)
hsBool plFactory::IsValidClassIndex(uint16_t hClass)
{
return theFactory->IIsValidClassIndex(hClass);
}
@ -265,7 +265,7 @@ plFactory* plFactory::GetTheFactory()
}
// For my own nefarious purposes... hsStatusMessage plCreatableIndex
const char *plFactory::GetNameOfClass(UInt16 type)
const char *plFactory::GetNameOfClass(uint16_t type)
{
if( type < GetNumClasses() )
{
@ -311,7 +311,7 @@ const char *plFactory::GetNameOfClass(UInt16 type)
**
*/
void plFactory::IValidate(UInt16 keyIndex)
void plFactory::IValidate(uint16_t keyIndex)
{
int FactoryIndex = GetNumClasses();
@ -347,7 +347,7 @@ void plFactory::IValidate(UInt16 keyIndex)
}
void plFactory::Validate(UInt16 keyIndex)
void plFactory::Validate(uint16_t keyIndex)
{
theFactory->IValidate(keyIndex);

34
Sources/Plasma/NucleusLib/pnFactory/plFactory.h
View File

@ -61,13 +61,13 @@ private:
hsTArray<plCreator*> fCreators;
void IForceShutdown();
void IUnRegister(UInt16 hClass);
UInt16 IRegister(UInt16 hClass, plCreator* worker);
void IUnRegister(uint16_t hClass);
uint16_t IRegister(uint16_t hClass, plCreator* worker);
hsBool IIsEmpty();
UInt16 IGetNumClasses();
plCreatable* ICreate(UInt16 hClass);
hsBool IDerivesFrom(UInt16 hBase, UInt16 hDer);
hsBool IIsValidClassIndex(UInt16 hClass);
uint16_t IGetNumClasses();
plCreatable* ICreate(uint16_t hClass);
hsBool IDerivesFrom(uint16_t hBase, uint16_t hDer);
hsBool IIsValidClassIndex(uint16_t hClass);
static hsBool ICreateTheFactory();
static void IShutdown();
@ -82,28 +82,28 @@ public:
static plFactory* GetTheFactory();
static UInt16 Register(UInt16 hClass, plCreator* worker); // returns hClass
static void UnRegister(UInt16 hClass, plCreator* worker);
static uint16_t Register(uint16_t hClass, plCreator* worker); // returns hClass
static void UnRegister(uint16_t hClass, plCreator* worker);
static bool CanCreate(UInt16 hClass); // return true if creator exists. doesn't assert
static plCreatable* Create(UInt16 hClass);
static bool CanCreate(uint16_t hClass); // return true if creator exists. doesn't assert
static plCreatable* Create(uint16_t hClass);
static hsBool DerivesFrom(UInt16 hBase, UInt16 hDer);
static hsBool DerivesFrom(uint16_t hBase, uint16_t hDer);
static UInt16 GetNumClasses();
static uint16_t GetNumClasses();
static UInt16 FindClassIndex(const char* className); // slow lookup for things like console
static uint16_t FindClassIndex(const char* className); // slow lookup for things like console
static hsBool IsValidClassIndex(UInt16 hClass);
static hsBool IsValidClassIndex(uint16_t hClass);
// Don't call this unless you're a DLL being initialized.
static void SetTheFactory(plFactory* fac);
static const char *GetNameOfClass(UInt16 type);
static const char *GetNameOfClass(uint16_t type);
#ifdef HS_DEBUGGING
void IValidate(UInt16 keyIndex);
static void Validate(UInt16 keyIndex);
void IValidate(uint16_t keyIndex);
static void Validate(uint16_t keyIndex);
#endif
};