aboutsummaryrefslogtreecommitdiff
path: root/engines/wintermute/system
diff options
context:
space:
mode:
Diffstat (limited to 'engines/wintermute/system')
-rw-r--r--engines/wintermute/system/sys_class.cpp42
-rw-r--r--engines/wintermute/system/sys_class.h36
-rw-r--r--engines/wintermute/system/sys_class_registry.cpp46
-rw-r--r--engines/wintermute/system/sys_class_registry.h44
-rw-r--r--engines/wintermute/system/sys_instance.cpp4
-rw-r--r--engines/wintermute/system/sys_instance.h12
6 files changed, 92 insertions, 92 deletions
diff --git a/engines/wintermute/system/sys_class.cpp b/engines/wintermute/system/sys_class.cpp
index be70f8b8bd..32704e0a0e 100644
--- a/engines/wintermute/system/sys_class.cpp
+++ b/engines/wintermute/system/sys_class.cpp
@@ -36,7 +36,7 @@
namespace WinterMute {
//////////////////////////////////////////////////////////////////////////
-CSysClass::CSysClass(const AnsiString &name, PERSISTBUILD build, PERSISTLOAD load, bool persistent_class) {
+SystemClass::SystemClass(const AnsiString &name, PERSISTBUILD build, PERSISTLOAD load, bool persistent_class) {
_name = name;
_build = build;
@@ -46,18 +46,18 @@ CSysClass::CSysClass(const AnsiString &name, PERSISTBUILD build, PERSISTLOAD loa
_persistent = persistent_class;
_numInst = 0;
- CSysClassRegistry::getInstance()->registerClass(this);
+ SystemClassRegistry::getInstance()->registerClass(this);
}
//////////////////////////////////////////////////////////////////////////
-CSysClass::~CSysClass() {
- CSysClassRegistry::getInstance()->unregisterClass(this);
+SystemClass::~SystemClass() {
+ SystemClassRegistry::getInstance()->unregisterClass(this);
removeAllInstances();
}
//////////////////////////////////////////////////////////////////////////
-bool CSysClass::removeAllInstances() {
+bool SystemClass::removeAllInstances() {
Instances::iterator it;
for (it = _instances.begin(); it != _instances.end(); ++it) {
delete(it->_value);
@@ -69,21 +69,21 @@ bool CSysClass::removeAllInstances() {
}
//////////////////////////////////////////////////////////////////////////
-CSysInstance *CSysClass::addInstance(void *instance, int id, int savedId) {
- CSysInstance *inst = new CSysInstance(instance, id, this);
+SystemInstance *SystemClass::addInstance(void *instance, int id, int savedId) {
+ SystemInstance *inst = new SystemInstance(instance, id, this);
inst->setSavedID(savedId);
_instances[inst] = (inst);
_instanceMap[instance] = inst;
- CSysClassRegistry::getInstance()->addInstanceToTable(inst, instance);
+ SystemClassRegistry::getInstance()->addInstanceToTable(inst, instance);
return inst;
}
//////////////////////////////////////////////////////////////////////////
-bool CSysClass::removeInstance(void *instance) {
+bool SystemClass::removeInstance(void *instance) {
InstanceMap::iterator mapIt = _instanceMap.find(instance);
if (mapIt == _instanceMap.end()) return false;
@@ -99,14 +99,14 @@ bool CSysClass::removeInstance(void *instance) {
}
//////////////////////////////////////////////////////////////////////////
-int CSysClass::getInstanceID(void *pointer) {
+int SystemClass::getInstanceID(void *pointer) {
InstanceMap::iterator mapIt = _instanceMap.find(pointer);
if (mapIt == _instanceMap.end()) return -1;
else return (mapIt->_value)->getID();
}
//////////////////////////////////////////////////////////////////////////
-void *CSysClass::idToPointer(int savedID) {
+void *SystemClass::idToPointer(int savedID) {
//slow
Instances::iterator it;
for (it = _instances.begin(); it != _instances.end(); ++it) {
@@ -116,19 +116,19 @@ void *CSysClass::idToPointer(int savedID) {
}
//////////////////////////////////////////////////////////////////////////
-int CSysClass::getNumInstances() {
+int SystemClass::getNumInstances() {
return _instances.size();
}
//////////////////////////////////////////////////////////////////////////
-void CSysClass::dump(Common::WriteStream *stream) {
+void SystemClass::dump(Common::WriteStream *stream) {
Common::String str;
str = Common::String::format("%03d %c %-20s instances: %d\n", _iD, _persistent ? 'p' : ' ', _name.c_str(), getNumInstances());
stream->write(str.c_str(), str.size());
}
//////////////////////////////////////////////////////////////////////////
-void CSysClass::saveTable(CBGame *gameRef, CBPersistMgr *persistMgr) {
+void SystemClass::saveTable(BaseGame *gameRef, BasePersistenceManager *persistMgr) {
persistMgr->putString(_name.c_str());
persistMgr->putDWORD(_iD);
persistMgr->putDWORD(_instances.size());
@@ -140,7 +140,7 @@ void CSysClass::saveTable(CBGame *gameRef, CBPersistMgr *persistMgr) {
}
//////////////////////////////////////////////////////////////////////////
-void CSysClass::loadTable(CBGame *gameRef, CBPersistMgr *persistMgr) {
+void SystemClass::loadTable(BaseGame *gameRef, BasePersistenceManager *persistMgr) {
_savedID = persistMgr->getDWORD();
int numInstances = persistMgr->getDWORD();
@@ -156,7 +156,7 @@ void CSysClass::loadTable(CBGame *gameRef, CBPersistMgr *persistMgr) {
Instances::iterator it = _instances.begin();
if (it != _instances.end()) {
(it->_value)->setSavedID(instID);
- CSysClassRegistry::getInstance()->addInstanceToTable((it->_value), (it->_value)->getInstance());
+ SystemClassRegistry::getInstance()->addInstanceToTable((it->_value), (it->_value)->getInstance());
} else gameRef->LOG(0, "Warning: instance %d of persistent class %s not found", i, _name.c_str());
}
// normal instances, create empty objects
@@ -166,14 +166,14 @@ void CSysClass::loadTable(CBGame *gameRef, CBPersistMgr *persistMgr) {
warning("HALT");
}
- addInstance(emptyObject, CSysClassRegistry::getInstance()->getNextID(), instID);
+ addInstance(emptyObject, SystemClassRegistry::getInstance()->getNextID(), instID);
}
}
}
//////////////////////////////////////////////////////////////////////////
-void CSysClass::saveInstances(CBGame *Game, CBPersistMgr *persistMgr) {
+void SystemClass::saveInstances(BaseGame *Game, BasePersistenceManager *persistMgr) {
Instances::iterator it;
for (it = _instances.begin(); it != _instances.end(); ++it) {
// write instace header
@@ -187,13 +187,13 @@ void CSysClass::saveInstances(CBGame *Game, CBPersistMgr *persistMgr) {
}
//////////////////////////////////////////////////////////////////////////
-void CSysClass::loadInstance(void *instance, CBPersistMgr *persistMgr) {
+void SystemClass::loadInstance(void *instance, BasePersistenceManager *persistMgr) {
_load(instance, persistMgr);
}
//////////////////////////////////////////////////////////////////////////
-void CSysClass::resetSavedIDs() {
+void SystemClass::resetSavedIDs() {
Instances::iterator it;
for (it = _instances.begin(); it != _instances.end(); ++it) {
(it->_value)->setSavedID(-1);
@@ -201,7 +201,7 @@ void CSysClass::resetSavedIDs() {
}
//////////////////////////////////////////////////////////////////////////
-void CSysClass::instanceCallback(SYS_INSTANCE_CALLBACK lpCallback, void *lpData) {
+void SystemClass::instanceCallback(SYS_INSTANCE_CALLBACK lpCallback, void *lpData) {
Instances::iterator it;
for (it = _instances.begin(); it != _instances.end(); ++it) {
lpCallback((it->_value)->getInstance(), lpData);
diff --git a/engines/wintermute/system/sys_class.h b/engines/wintermute/system/sys_class.h
index f807ea677c..bd534f8bb0 100644
--- a/engines/wintermute/system/sys_class.h
+++ b/engines/wintermute/system/sys_class.h
@@ -36,10 +36,10 @@
#include "common/stream.h"
namespace WinterMute {
-class CSysInstance;
-class CBGame;
-class CBPersistMgr;
-class CSysClass;
+class SystemInstance;
+class BaseGame;
+class BasePersistenceManager;
+class SystemClass;
}
@@ -52,8 +52,8 @@ template<> struct Hash<void *> : public UnaryFunction<void *, uint> {
}
};
-template<> struct Hash<WinterMute::CSysInstance *> : public UnaryFunction<WinterMute::CSysInstance *, uint> {
- uint operator()(WinterMute::CSysInstance *val) const {
+template<> struct Hash<WinterMute::SystemInstance *> : public UnaryFunction<WinterMute::SystemInstance *, uint> {
+ uint operator()(WinterMute::SystemInstance *val) const {
return (uint)((size_t)val);
}
};
@@ -63,14 +63,14 @@ template<> struct Hash<WinterMute::CSysInstance *> : public UnaryFunction<Winter
namespace WinterMute {
-class CSysClass {
+class SystemClass {
public:
- CSysClass(const AnsiString &name, PERSISTBUILD build, PERSISTLOAD load, bool persistent_class);
- ~CSysClass();
+ SystemClass(const AnsiString &name, PERSISTBUILD build, PERSISTLOAD load, bool persistent_class);
+ ~SystemClass();
int getNumInstances();
bool removeInstance(void *instance);
- CSysInstance *addInstance(void *instance, int id, int savedId = -1);
+ SystemInstance *addInstance(void *instance, int id, int savedId = -1);
bool removeAllInstances();
int getInstanceID(void *pointer);
@@ -95,11 +95,11 @@ public:
return _name;
}
- void saveTable(CBGame *Game, CBPersistMgr *PersistMgr);
- void loadTable(CBGame *Game, CBPersistMgr *PersistMgr);
+ void saveTable(BaseGame *Game, BasePersistenceManager *PersistMgr);
+ void loadTable(BaseGame *Game, BasePersistenceManager *PersistMgr);
- void saveInstances(CBGame *Game, CBPersistMgr *PersistMgr);
- void loadInstance(void *instance, CBPersistMgr *PersistMgr);
+ void saveInstances(BaseGame *Game, BasePersistenceManager *PersistMgr);
+ void loadInstance(void *instance, BasePersistenceManager *PersistMgr);
void instanceCallback(SYS_INSTANCE_CALLBACK lpCallback, void *lpData);
@@ -110,18 +110,18 @@ public:
private:
int _numInst;
bool _persistent;
- CSysClass *_next;
+ SystemClass *_next;
int _iD;
int _savedID;
AnsiString _name;
PERSISTBUILD _build;
PERSISTLOAD _load;
- //typedef std::set<CSysInstance *> Instances;
- typedef Common::HashMap<CSysInstance *, CSysInstance *> Instances;
+ //typedef std::set<SystemInstance *> Instances;
+ typedef Common::HashMap<SystemInstance *, SystemInstance *> Instances;
Instances _instances;
- typedef Common::HashMap<void *, CSysInstance *> InstanceMap;
+ typedef Common::HashMap<void *, SystemInstance *> InstanceMap;
InstanceMap _instanceMap;
};
diff --git a/engines/wintermute/system/sys_class_registry.cpp b/engines/wintermute/system/sys_class_registry.cpp
index ce14b01385..7f7814f75c 100644
--- a/engines/wintermute/system/sys_class_registry.cpp
+++ b/engines/wintermute/system/sys_class_registry.cpp
@@ -37,31 +37,31 @@
namespace WinterMute {
//////////////////////////////////////////////////////////////////////////
-CSysClassRegistry::CSysClassRegistry() {
+SystemClassRegistry::SystemClassRegistry() {
_count = 0;
_disabled = false;
}
//////////////////////////////////////////////////////////////////////////
-CSysClassRegistry::~CSysClassRegistry() {
+SystemClassRegistry::~SystemClassRegistry() {
unregisterClasses();
}
//////////////////////////////////////////////////////////////////////////
-CSysClassRegistry *CSysClassRegistry::getInstance() {
+SystemClassRegistry *SystemClassRegistry::getInstance() {
return g_wintermute->getClassRegistry();
}
-void CSysClassRegistry::unregisterClasses() {
- // CSysClass calls UnregisterClass upon destruction.
+void SystemClassRegistry::unregisterClasses() {
+ // SystemClass calls UnregisterClass upon destruction.
while (_classes.size() > 0) {
delete _classes.begin()->_value;
}
}
//////////////////////////////////////////////////////////////////////////
-bool CSysClassRegistry::registerClass(CSysClass *classObj) {
+bool SystemClassRegistry::registerClass(SystemClass *classObj) {
classObj->setID(_count++);
//_classes.insert(classObj);
_classes[classObj] = classObj;
@@ -74,7 +74,7 @@ bool CSysClassRegistry::registerClass(CSysClass *classObj) {
//////////////////////////////////////////////////////////////////////////
-bool CSysClassRegistry::unregisterClass(CSysClass *classObj) {
+bool SystemClassRegistry::unregisterClass(SystemClass *classObj) {
Classes::iterator it = _classes.find(classObj);
if (it == _classes.end()) return false;
@@ -82,7 +82,7 @@ bool CSysClassRegistry::unregisterClass(CSysClass *classObj) {
if (classObj->getNumInstances() != 0) {
char str[MAX_PATH_LENGTH];
sprintf(str, "Memory leak@class %-20s: %d instance(s) left\n", classObj->getName().c_str(), classObj->getNumInstances());
- CBPlatform::outputDebugString(str);
+ BasePlatform::outputDebugString(str);
}
_classes.erase(it);
@@ -98,18 +98,18 @@ bool CSysClassRegistry::unregisterClass(CSysClass *classObj) {
//////////////////////////////////////////////////////////////////////////
-bool CSysClassRegistry::registerInstance(const char *className, void *instance) {
+bool SystemClassRegistry::registerInstance(const char *className, void *instance) {
if (_disabled) return true;
NameMap::iterator mapIt = _nameMap.find(className);
if (mapIt == _nameMap.end()) return false;
- CSysInstance *inst = (*mapIt)._value->addInstance(instance, _count++);
+ SystemInstance *inst = (*mapIt)._value->addInstance(instance, _count++);
return (inst != NULL);
}
//////////////////////////////////////////////////////////////////////////
-void CSysClassRegistry::addInstanceToTable(CSysInstance *instance, void *pointer) {
+void SystemClassRegistry::addInstanceToTable(SystemInstance *instance, void *pointer) {
_instanceMap[pointer] = instance;
if (instance->getSavedID() >= 0)
@@ -117,12 +117,12 @@ void CSysClassRegistry::addInstanceToTable(CSysInstance *instance, void *pointer
}
//////////////////////////////////////////////////////////////////////////
-int CSysClassRegistry::getNextID() {
+int SystemClassRegistry::getNextID() {
return _count++;
}
//////////////////////////////////////////////////////////////////////////
-bool CSysClassRegistry::unregisterInstance(const char *className, void *instance) {
+bool SystemClassRegistry::unregisterInstance(const char *className, void *instance) {
NameMap::iterator mapIt = _nameMap.find(className);
if (mapIt == _nameMap.end()) return false;
(*mapIt)._value->removeInstance(instance);
@@ -136,14 +136,14 @@ bool CSysClassRegistry::unregisterInstance(const char *className, void *instance
//////////////////////////////////////////////////////////////////////////
-bool CSysClassRegistry::getPointerID(void *pointer, int *classID, int *instanceID) {
+bool SystemClassRegistry::getPointerID(void *pointer, int *classID, int *instanceID) {
if (pointer == NULL) return true;
InstanceMap::iterator it = _instanceMap.find(pointer);
if (it == _instanceMap.end()) return false;
- CSysInstance *inst = (*it)._value;
+ SystemInstance *inst = (*it)._value;
*instanceID = inst->getID();
*classID = inst->getClass()->getID();
@@ -151,13 +151,13 @@ bool CSysClassRegistry::getPointerID(void *pointer, int *classID, int *instanceI
}
//////////////////////////////////////////////////////////////////////////
-void *CSysClassRegistry::idToPointer(int classID, int instanceID) {
+void *SystemClassRegistry::idToPointer(int classID, int instanceID) {
SavedInstanceMap::iterator it = _savedInstanceMap.find(instanceID);
if (it == _savedInstanceMap.end()) return NULL;
else return (*it)._value->getInstance();
}
-bool checkHeader(const char *tag, CBPersistMgr *pm) {
+bool checkHeader(const char *tag, BasePersistenceManager *pm) {
char *test = pm->getString();
Common::String verify = test;
delete[] test;
@@ -169,7 +169,7 @@ bool checkHeader(const char *tag, CBPersistMgr *pm) {
}
//////////////////////////////////////////////////////////////////////////
-bool CSysClassRegistry::saveTable(CBGame *gameRef, CBPersistMgr *persistMgr, bool quickSave) {
+bool SystemClassRegistry::saveTable(BaseGame *gameRef, BasePersistenceManager *persistMgr, bool quickSave) {
persistMgr->putString("<CLASS_REGISTRY_TABLE>");
persistMgr->putDWORD(_classes.size());
@@ -193,7 +193,7 @@ bool CSysClassRegistry::saveTable(CBGame *gameRef, CBPersistMgr *persistMgr, boo
//////////////////////////////////////////////////////////////////////////
-bool CSysClassRegistry::loadTable(CBGame *gameRef, CBPersistMgr *persistMgr) {
+bool SystemClassRegistry::loadTable(BaseGame *gameRef, BasePersistenceManager *persistMgr) {
checkHeader("<CLASS_REGISTRY_TABLE>", persistMgr);
// reset SavedID of current instances
@@ -228,7 +228,7 @@ bool CSysClassRegistry::loadTable(CBGame *gameRef, CBPersistMgr *persistMgr) {
//////////////////////////////////////////////////////////////////////////
-bool CSysClassRegistry::saveInstances(CBGame *gameRef, CBPersistMgr *persistMgr, bool quickSave) {
+bool SystemClassRegistry::saveInstances(BaseGame *gameRef, BasePersistenceManager *persistMgr, bool quickSave) {
Classes::iterator it;
@@ -260,7 +260,7 @@ bool CSysClassRegistry::saveInstances(CBGame *gameRef, CBPersistMgr *persistMgr,
}
//////////////////////////////////////////////////////////////////////////
-bool CSysClassRegistry::loadInstances(CBGame *gameRef, CBPersistMgr *persistMgr) {
+bool SystemClassRegistry::loadInstances(BaseGame *gameRef, BasePersistenceManager *persistMgr) {
// get total instances
int numInstances = persistMgr->getDWORD();
@@ -296,7 +296,7 @@ bool CSysClassRegistry::loadInstances(CBGame *gameRef, CBPersistMgr *persistMgr)
//////////////////////////////////////////////////////////////////////////
-bool CSysClassRegistry::enumInstances(SYS_INSTANCE_CALLBACK lpCallback, const char *className, void *lpData) {
+bool SystemClassRegistry::enumInstances(SYS_INSTANCE_CALLBACK lpCallback, const char *className, void *lpData) {
NameMap::iterator mapIt = _nameMap.find(className);
if (mapIt == _nameMap.end()) return STATUS_FAILED;
@@ -306,7 +306,7 @@ bool CSysClassRegistry::enumInstances(SYS_INSTANCE_CALLBACK lpCallback, const ch
//////////////////////////////////////////////////////////////////////////
-void CSysClassRegistry::dumpClasses(Common::WriteStream *stream) {
+void SystemClassRegistry::dumpClasses(Common::WriteStream *stream) {
Classes::iterator it;
for (it = _classes.begin(); it != _classes.end(); ++it)
(it->_value)->dump(stream);
diff --git a/engines/wintermute/system/sys_class_registry.h b/engines/wintermute/system/sys_class_registry.h
index e17ae9bf78..d668c57803 100644
--- a/engines/wintermute/system/sys_class_registry.h
+++ b/engines/wintermute/system/sys_class_registry.h
@@ -39,13 +39,13 @@
#include "common/stream.h"
namespace WinterMute {
-class CSysClass;
+class SystemClass;
}
namespace Common {
template<typename T> struct Hash;
-template<> struct Hash<WinterMute::CSysClass *> : public UnaryFunction<WinterMute::CSysClass *, uint> {
- uint operator()(WinterMute::CSysClass *val) const {
+template<> struct Hash<WinterMute::SystemClass *> : public UnaryFunction<WinterMute::SystemClass *, uint> {
+ uint operator()(WinterMute::SystemClass *val) const {
return (uint)((size_t)val);
}
};
@@ -54,50 +54,50 @@ template<> struct Hash<WinterMute::CSysClass *> : public UnaryFunction<WinterMut
namespace WinterMute {
-class CBGame;
-class CBPersistMgr;
-class CSysInstance;
+class BaseGame;
+class BasePersistenceManager;
+class SystemInstance;
-class CSysClassRegistry {
+class SystemClassRegistry {
void unregisterClasses();
public:
void registerClasses(); // persistent.cpp
- static CSysClassRegistry *getInstance();
+ static SystemClassRegistry *getInstance();
- CSysClassRegistry();
- virtual ~CSysClassRegistry();
+ SystemClassRegistry();
+ virtual ~SystemClassRegistry();
bool enumInstances(SYS_INSTANCE_CALLBACK lpCallback, const char *className, void *lpData);
- bool loadTable(CBGame *Game, CBPersistMgr *PersistMgr);
- bool saveTable(CBGame *Game, CBPersistMgr *PersistMgr, bool quickSave);
- bool loadInstances(CBGame *Game, CBPersistMgr *PersistMgr);
- bool saveInstances(CBGame *Game, CBPersistMgr *PersistMgr, bool quickSave);
+ bool loadTable(BaseGame *Game, BasePersistenceManager *PersistMgr);
+ bool saveTable(BaseGame *Game, BasePersistenceManager *PersistMgr, bool quickSave);
+ bool loadInstances(BaseGame *Game, BasePersistenceManager *PersistMgr);
+ bool saveInstances(BaseGame *Game, BasePersistenceManager *PersistMgr, bool quickSave);
void *idToPointer(int classID, int instanceID);
bool getPointerID(void *pointer, int *classID, int *instanceID);
- bool registerClass(CSysClass *classObj);
- bool unregisterClass(CSysClass *classObj);
+ bool registerClass(SystemClass *classObj);
+ bool unregisterClass(SystemClass *classObj);
bool registerInstance(const char *className, void *instance);
bool unregisterInstance(const char *className, void *instance);
void dumpClasses(Common::WriteStream *stream);
int getNextID();
- void addInstanceToTable(CSysInstance *instance, void *pointer);
+ void addInstanceToTable(SystemInstance *instance, void *pointer);
bool _disabled;
int _count;
- typedef Common::HashMap<CSysClass *, CSysClass *> Classes;
+ typedef Common::HashMap<SystemClass *, SystemClass *> Classes;
Classes _classes;
- typedef Common::HashMap<AnsiString, CSysClass *> NameMap;
+ typedef Common::HashMap<AnsiString, SystemClass *> NameMap;
NameMap _nameMap;
- typedef Common::HashMap<int, CSysClass *> IdMap;
+ typedef Common::HashMap<int, SystemClass *> IdMap;
IdMap _idMap;
- typedef Common::HashMap<void *, CSysInstance *> InstanceMap;
+ typedef Common::HashMap<void *, SystemInstance *> InstanceMap;
InstanceMap _instanceMap;
- typedef Common::HashMap<int, CSysInstance *> SavedInstanceMap;
+ typedef Common::HashMap<int, SystemInstance *> SavedInstanceMap;
SavedInstanceMap _savedInstanceMap;
};
diff --git a/engines/wintermute/system/sys_instance.cpp b/engines/wintermute/system/sys_instance.cpp
index c34c3cc64a..a5ef69647c 100644
--- a/engines/wintermute/system/sys_instance.cpp
+++ b/engines/wintermute/system/sys_instance.cpp
@@ -33,7 +33,7 @@
namespace WinterMute {
//////////////////////////////////////////////////////////////////////////
-CSysInstance::CSysInstance(void *instance, int id, CSysClass *sysClass) {
+SystemInstance::SystemInstance(void *instance, int id, SystemClass *sysClass) {
_instance = instance;
_id = id;
_savedID = -1;
@@ -43,7 +43,7 @@ CSysInstance::CSysInstance(void *instance, int id, CSysClass *sysClass) {
}
//////////////////////////////////////////////////////////////////////////
-CSysInstance::~CSysInstance() {
+SystemInstance::~SystemInstance() {
}
} // end of namespace WinterMute
diff --git a/engines/wintermute/system/sys_instance.h b/engines/wintermute/system/sys_instance.h
index 6becd491af..493055a8fd 100644
--- a/engines/wintermute/system/sys_instance.h
+++ b/engines/wintermute/system/sys_instance.h
@@ -31,12 +31,12 @@
namespace WinterMute {
-class CSysClass;
+class SystemClass;
-class CSysInstance {
+class SystemInstance {
public:
- CSysInstance(void *Instance, int ID, CSysClass *sysClass);
- virtual ~CSysInstance();
+ SystemInstance(void *Instance, int ID, SystemClass *sysClass);
+ virtual ~SystemInstance();
int getID() const {
return _id;
@@ -47,7 +47,7 @@ public:
void *getInstance() const {
return _instance;
}
- CSysClass *getClass() const {
+ SystemClass *getClass() const {
return _class;
}
@@ -60,7 +60,7 @@ private:
int _id;
int _savedID;
void *_instance;
- CSysClass *_class;
+ SystemClass *_class;
};
} // end of namespace WinterMute
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-14 17:35:30 +0000