libretro/scummvm
1
0
Fork 0
mirror of https://github.com/libretro/scummvm.git synced 2025-03-07 02:39:56 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

SWORD25: brought CallBackRegisry class to our naming standards

Browse Source 
svn-id: r53257
This commit is contained in:
Eugene Sandulenko 2010-08-18 10:52:00 +00:00
parent 596684101e
commit e71337861f
6 changed files with 50 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
engines/sword25/gfx/animation.cpp
View File

@ -673,7 +673,7 @@ void BS_Animation::PersistCallbackVector(BS_OutputPersistenceBlock &Writer, cons
// Alle Callbacks einzeln persistieren.
Common::Array<ANIMATION_CALLBACK_DATA>::const_iterator It = Vector.begin();
while (It != Vector.end()) {
Writer.Write(BS_CallbackRegistry::GetInstance().ResolveCallbackPointer((void (*)(int))It->Callback));
Writer.Write(CallbackRegistry::getInstance().resolveCallbackPointer((void (*)(int))It->Callback));
Writer.Write(It->Data);
++It;
@ -696,7 +696,7 @@ void BS_Animation::UnpersistCallbackVector(BS_InputPersistenceBlock &Reader, Com
Common::String CallbackFunctionName;
Reader.Read(CallbackFunctionName);
CallbackData.Callback = reinterpret_cast<ANIMATION_CALLBACK>(BS_CallbackRegistry::GetInstance().ResolveCallbackFunction(CallbackFunctionName));
CallbackData.Callback = reinterpret_cast<ANIMATION_CALLBACK>(CallbackRegistry::getInstance().resolveCallbackFunction(CallbackFunctionName));
Reader.Read(CallbackData.Data);

6
engines/sword25/gfx/graphicengine_script.cpp
View File

@ -91,9 +91,9 @@ std::auto_ptr<ActionCallback> ActionCallbackPtr;
struct CallbackfunctionRegisterer {
CallbackfunctionRegisterer() {
BS_CallbackRegistry::GetInstance().RegisterCallbackFunction("LuaLoopPointCB", (void ( *)(int))AnimationLoopPointCallback);
BS_CallbackRegistry::GetInstance().RegisterCallbackFunction("LuaActionCB", (void ( *)(int))AnimationActionCallback);
BS_CallbackRegistry::GetInstance().RegisterCallbackFunction("LuaDeleteCB", (void ( *)(int))AnimationDeleteCallback);
CallbackRegistry::getInstance().registerCallbackFunction("LuaLoopPointCB", (void ( *)(int))AnimationLoopPointCallback);
CallbackRegistry::getInstance().registerCallbackFunction("LuaActionCB", (void ( *)(int))AnimationActionCallback);
CallbackRegistry::getInstance().registerCallbackFunction("LuaDeleteCB", (void ( *)(int))AnimationDeleteCallback);
}
};
static CallbackfunctionRegisterer Instance;

4
engines/sword25/input/inputengine_script.cpp
View File

@ -97,8 +97,8 @@ Common::SharedPtr<CommandCallbackClass> CommandCallbackPtr;
struct CallbackfunctionRegisterer {
CallbackfunctionRegisterer() {
BS_CallbackRegistry::GetInstance().RegisterCallbackFunction("LuaCommandCB", TheCommandCallback);
BS_CallbackRegistry::GetInstance().RegisterCallbackFunction("LuaCharacterCB", TheCharacterCallback);
CallbackRegistry::getInstance().registerCallbackFunction("LuaCommandCB", TheCommandCallback);
CallbackRegistry::getInstance().registerCallbackFunction("LuaCharacterCB", TheCharacterCallback);
}
};
static CallbackfunctionRegisterer Instance;

8
engines/sword25/input/scummvminput.cpp
View File

@ -343,7 +343,7 @@ bool ScummVMInput::Persist(BS_OutputPersistenceBlock &Writer) {
{
Common::List<CommandCallback>::const_iterator It = m_CommandCallbacks.begin();
while (It != m_CommandCallbacks.end()) {
Writer.Write(BS_CallbackRegistry::GetInstance().ResolveCallbackPointer(*It));
Writer.Write(CallbackRegistry::getInstance().resolveCallbackPointer(*It));
++It;
}
}
@ -355,7 +355,7 @@ bool ScummVMInput::Persist(BS_OutputPersistenceBlock &Writer) {
{
Common::List<CharacterCallback>::const_iterator It = m_CharacterCallbacks.begin();
while (It != m_CharacterCallbacks.end()) {
Writer.Write(BS_CallbackRegistry::GetInstance().ResolveCallbackPointer(*It));
Writer.Write(CallbackRegistry::getInstance().resolveCallbackPointer(*It));
++It;
}
}
@ -379,7 +379,7 @@ bool ScummVMInput::Unpersist(BS_InputPersistenceBlock &Reader) {
Reader.Read(CallbackFunctionName);
m_CommandCallbacks.push_back(reinterpret_cast<CommandCallback>(
BS_CallbackRegistry::GetInstance().ResolveCallbackFunction(CallbackFunctionName)));
CallbackRegistry::getInstance().resolveCallbackFunction(CallbackFunctionName)));
}
// Character-Callbackliste leeren.
@ -394,7 +394,7 @@ bool ScummVMInput::Unpersist(BS_InputPersistenceBlock &Reader) {
Common::String CallbackFunctionName;
Reader.Read(CallbackFunctionName);
m_CharacterCallbacks.push_back(reinterpret_cast<CharacterCallback>(BS_CallbackRegistry::GetInstance().ResolveCallbackFunction(CallbackFunctionName)));
m_CharacterCallbacks.push_back(reinterpret_cast<CharacterCallback>(CallbackRegistry::getInstance().resolveCallbackFunction(CallbackFunctionName)));
}
return Reader.IsGood();

52
engines/sword25/kernel/callbackregistry.cpp
View File

@ -60,72 +60,72 @@ namespace Sword25 {
// -----------------------------------------------------------------------------
bool BS_CallbackRegistry::RegisterCallbackFunction(const Common::String &Name, CallbackPtr Ptr) {
if (Name == "") {
bool CallbackRegistry::registerCallbackFunction(const Common::String &name, CallbackPtr ptr) {
if (name == "") {
BS_LOG_ERRORLN("The empty string is not allowed as a callback function name.");
return false;
}
if (FindPtrByName(Name) != 0) {
BS_LOG_ERRORLN("There is already a callback function with the name \"%s\".", Name.c_str());
if (findPtrByName(name) != 0) {
BS_LOG_ERRORLN("There is already a callback function with the name \"%s\".", name.c_str());
return false;
}
if (FindNameByPtr(Ptr) != "") {
BS_LOG_ERRORLN("There is already a callback function with the pointer 0x%x.", Ptr);
if (findNameByPtr(ptr) != "") {
BS_LOG_ERRORLN("There is already a callback function with the pointer 0x%x.", ptr);
return false;
}
StoreCallbackFunction(Name, Ptr);
storeCallbackFunction(name, ptr);
return true;
}
// -----------------------------------------------------------------------------
CallbackPtr BS_CallbackRegistry::ResolveCallbackFunction(const Common::String &Name) const {
CallbackPtr Result = FindPtrByName(Name);
CallbackPtr CallbackRegistry::resolveCallbackFunction(const Common::String &name) const {
CallbackPtr result = findPtrByName(name);
if (!Result) {
BS_LOG_ERRORLN("There is no callback function with the name \"%s\".", Name.c_str());
if (!result) {
BS_LOG_ERRORLN("There is no callback function with the name \"%s\".", name.c_str());
}
return Result;
return result;
}
// -----------------------------------------------------------------------------
Common::String BS_CallbackRegistry::ResolveCallbackPointer(CallbackPtr Ptr) const {
const Common::String &Result = FindNameByPtr(Ptr);
Common::String CallbackRegistry::resolveCallbackPointer(CallbackPtr ptr) const {
const Common::String &result = findNameByPtr(ptr);
if (Result == "") {
BS_LOG_ERRORLN("There is no callback function with the pointer 0x%x.", Ptr);
if (result == "") {
BS_LOG_ERRORLN("There is no callback function with the pointer 0x%x.", ptr);
}
return Result;
return result;
}
// -----------------------------------------------------------------------------
CallbackPtr BS_CallbackRegistry::FindPtrByName(const Common::String &Name) const {
CallbackPtr CallbackRegistry::findPtrByName(const Common::String &name) const {
// Eintrag in der Map finden und den Pointer zurückgeben.
NameToPtrMap::const_iterator It = m_NameToPtrMap.find(Name);
return It == m_NameToPtrMap.end() ? 0 : It->_value;
NameToPtrMap::const_iterator it = _nameToPtrMap.find(name);
return it == _nameToPtrMap.end() ? 0 : it->_value;
}
// -----------------------------------------------------------------------------
Common::String BS_CallbackRegistry::FindNameByPtr(CallbackPtr Ptr) const {
Common::String CallbackRegistry::findNameByPtr(CallbackPtr ptr) const {
// Eintrag in der Map finden und den Namen zurückgeben.
PtrToNameMap::const_iterator It = m_PtrToNameMap.find(Ptr);
return It == m_PtrToNameMap.end() ? "" : It->_value;
PtrToNameMap::const_iterator it = _ptrToNameMap.find(ptr);
return it == _ptrToNameMap.end() ? "" : it->_value;
}
// -----------------------------------------------------------------------------
void BS_CallbackRegistry::StoreCallbackFunction(const Common::String &Name, CallbackPtr Ptr) {
void CallbackRegistry::storeCallbackFunction(const Common::String &name, CallbackPtr ptr) {
// Callback-Funktion in beide Maps eintragen.
m_NameToPtrMap[Name] = Ptr;
m_PtrToNameMap[Ptr] = Name;
_nameToPtrMap[name] = ptr;
_ptrToNameMap[ptr] = name;
}
} // End of namespace Sword25

26
engines/sword25/kernel/callbackregistry.h
View File

@ -52,22 +52,22 @@ namespace Sword25 {
// Klassendeklaration
// -----------------------------------------------------------------------------
typedef void (*CallbackPtr)(int Command);
typedef void (*CallbackPtr)(int command);
class BS_CallbackRegistry {
class CallbackRegistry {
public:
static BS_CallbackRegistry &GetInstance() {
static BS_CallbackRegistry Instance;
return Instance;
static CallbackRegistry &getInstance() {
static CallbackRegistry _instance;
return _instance;
}
bool RegisterCallbackFunction(const Common::String &Name, CallbackPtr Ptr);
CallbackPtr ResolveCallbackFunction(const Common::String &Name) const;
Common::String ResolveCallbackPointer(CallbackPtr Ptr) const;
bool registerCallbackFunction(const Common::String &name, CallbackPtr ptr);
CallbackPtr resolveCallbackFunction(const Common::String &name) const;
Common::String resolveCallbackPointer(CallbackPtr ptr) const;
private:
typedef Common::HashMap<Common::String, CallbackPtr, Common::CaseSensitiveString_Hash, Common::CaseSensitiveString_EqualTo> NameToPtrMap;
NameToPtrMap m_NameToPtrMap;
NameToPtrMap _nameToPtrMap;
struct CallbackPtr_EqualTo {
bool operator()(CallbackPtr x, CallbackPtr y) const {
@ -81,11 +81,11 @@ private:
};
typedef Common::HashMap<CallbackPtr, Common::String, CallbackPtr_Hash, CallbackPtr_EqualTo> PtrToNameMap;
PtrToNameMap m_PtrToNameMap;
PtrToNameMap _ptrToNameMap;
CallbackPtr FindPtrByName(const Common::String &Name) const;
Common::String FindNameByPtr(CallbackPtr Ptr) const;
void StoreCallbackFunction(const Common::String &Name, CallbackPtr Ptr);
CallbackPtr findPtrByName(const Common::String &name) const;
Common::String findNameByPtr(CallbackPtr ptr) const;
void storeCallbackFunction(const Common::String &name, CallbackPtr ptr);
};
} // End of namespace Sword25