Sean/CPP
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add support for callbacks

Browse Source
This commit is contained in:
Sean
2025-08-14 12:47:10 -04:00
parent 5756642ddb
commit 8b4769bf7e
10 changed files with 431 additions and 130 deletions
Download Patch File Download Diff File Expand all files Collapse all files

41
common/callback.hpp Executable file
View File

@@ -0,0 +1,41 @@
#ifndef _COMMON_CALLBACK_HPP_
#define _COMMON_CALLBACK_HPP_
#ifndef _COMMON_CALLBACKDATA_HPP_
#include <common/cbdata.hpp>
#endif
#ifndef _COMMON_PURECALLBACK_HPP_
#include <common/pcallbck.hpp>
#endif
#ifndef _COMMON_CALLBACKPOINTER_HPP_
#include <common/cbptr.hpp>
#endif
template <class T,class D>
class Callback : public PureCallback<D>
{
public:
typedef LONG (T::*PFNMETHOD)(CallbackData<D> &callbackData);
Callback(void);
Callback(const Callback<T,D> &someCallback);
Callback(T *lpObject,PFNMETHOD lpMethod);
virtual ~Callback();
void setObject(T *lpObject);
void setMethod(PFNMETHOD lpMethod);
void setCallback(T *lpObject,PFNMETHOD lpMethod);
WORD operator==(const Callback<T,D> &someCallback)const;
void operator=(const Callback<T,D> &someCallback);
LONG operator*(CallbackData<D> &someCallbackData);
private:
T *mlpObject;
LONG (T::*mlpMethod)(CallbackData<D> &someCallbackData);
};
template <class T,class D>
inline
LONG Callback<T,D>::operator*(CallbackData<D> &someCallbackData)
{
if((!mlpObject)||(!mlpMethod))return (LONG)0;
return (mlpObject->*mlpMethod)(someCallbackData);
}
#include <common/callback.tpp>
#endif

60
common/callback.tpp Executable file
View File

@@ -0,0 +1,60 @@
#ifndef _COMMON_CALLBACK_TPP_
#define _COMMON_CALLBACK_TPP_
template <class T,class D>
Callback<T,D>::Callback(void)
: mlpObject(0), mlpMethod(0)
{
}
template <class T,class D>
Callback<T,D>::Callback(const Callback<T,D> &someCallback)
: mlpObject(someCallback.mlpObject), mlpMethod(someCallback.mlpMethod)
{
}
template <class T,class D>
Callback<T,D>::Callback(T *lpObject,PFNMETHOD lpMethod)
: mlpObject(lpObject), mlpMethod(lpMethod)
{
}
template <class T,class D>
Callback<T,D>::~Callback()
{
}
template <class T,class D>
WORD Callback<T,D>::operator==(const Callback<T,D> &someCallback)const
{
return (mlpObject==someCallback.mlpObject && mlpMethod==someCallback.mlpMethod);
}
template <class T,class D>
void Callback<T,D>::operator=(const Callback<T,D> &someCallback)
{
mlpObject=someCallback.mlpObject;
mlpMethod=someCallback.mlpMethod;
}
template <class T,class D>
void Callback<T,D>::setObject(T *lpObject)
{
mlpObject=lpObject;
}
template <class T,class D>
void Callback<T,D>::setMethod(PFNMETHOD lpMethod)
{
mlpMethod=lpMethod;
}
template <class T,class D>
void Callback<T,D>::setCallback(T *lpObject,PFNMETHOD lpMethod)
{
mlpObject=lpObject;
mlpMethod=lpMethod;
}
#endif

70
common/cbdata.hpp Executable file
View File

@@ -0,0 +1,70 @@
#ifndef _COMMON_CALLBACKDATA_HPP_
#define _COMMON_CALLBACKDATA_HPP_
#ifndef _COMMON_WINDOWS_HPP_
#include <common/windows.hpp>
#endif
template<class T>
class CallbackData
{
public:
typedef LONG ReturnType;
CallbackData(void);
CallbackData(T &data);
CallbackData(const CallbackData &someCallbackData);
virtual ~CallbackData();
CallbackData &operator=(const CallbackData &someCallbackData);
T &getData(void);
void setData(T &data);
private:
SmartPointer<T> mData;
};
template<class T>
inline
CallbackData<T>::CallbackData(void)
{
}
template<class T>
inline
CallbackData<T>::CallbackData(T &data)
{
mData=&data;
}
template <class T>
inline
CallbackData<T>::CallbackData(const CallbackData &someCallbackData)
{
*this=someCallbackData;
}
template <class T>
inline
CallbackData<T>::~CallbackData()
{
}
template <class T>
inline
CallbackData<T> &CallbackData<T>::operator=(const CallbackData<T> &someCallbackData)
{
mData = someCallbackData.mData;
return *this;
}
template <class T>
inline
T &CallbackData<T>::getData(void)
{
return *mData;
}
template <class T>
inline
void CallbackData<T>::setData(T &data)
{
mData=&data;
}
#endif

81
common/cbptr.hpp Executable file
View File

@@ -0,0 +1,81 @@
#ifndef _COMMON_CALLBACKPOINTER_HPP_
#define _COMMON_CALLBACKPOINTER_HPP_
#ifndef _COMMON_WINDOWS_HPP_
#include <common/windows.hpp>
#endif
#ifndef _COMMON_PURECALLBACK_HPP_
#include <common/pcallbck.hpp>
#endif
template <class T>
class CallbackPointer
{
public:
CallbackPointer(void);
CallbackPointer(PureCallback<T> *lpCallback);
CallbackPointer(const CallbackPointer<T> &someCallbackPointer);
virtual ~CallbackPointer();
void operator=(CallbackPointer &someCallbackPointer);
WORD operator==(const CallbackPointer &someCallbackPointer)const;
LONG callback(CallbackData<T> &someCallbackData);
bool isOkay(void)const;
private:
PureCallback<T> *mlpCallback;
};
template <class T>
inline
CallbackPointer<T>::CallbackPointer(void)
: mlpCallback(0)
{
}
template <class T>
inline
CallbackPointer<T>::CallbackPointer(PureCallback<T> *lpCallback)
: mlpCallback(lpCallback)
{
}
template <class T>
inline
CallbackPointer<T>::CallbackPointer(const CallbackPointer<T> &someCallbackPointer)
: mlpCallback(someCallbackPointer.mlpCallback)
{
}
template <class T>
inline
CallbackPointer<T>::~CallbackPointer()
{
}
template <class T>
inline
void CallbackPointer<T>::operator=(CallbackPointer<T> &someCallbackPointer)
{
mlpCallback=someCallbackPointer.mlpCallback;
}
template <class T>
inline
WORD CallbackPointer<T>::operator==(const CallbackPointer<T> &someCallbackPointer)const
{
return (mlpCallback==someCallbackPointer.mlpCallback);
}
template <class T>
inline
LONG CallbackPointer<T>::callback(CallbackData<T> &someCallbackData)
{
if(!mlpCallback)return (LONG)0;
return mlpCallback->operator*(someCallbackData);
}
template <class T>
inline
bool CallbackPointer<T>::isOkay(void)const
{
return mlpCallback?true:false;
}
#endif

35
common/pcallbck.hpp Executable file
View File

@@ -0,0 +1,35 @@
#ifndef _COMMON_PURECALLBACK_HPP_
#define _COMMON_PURECALLBACK_HPP_
#ifndef _COMMON_CALLBACKDATA_HPP_
#include <common/cbdata.hpp>
#endif
template <class T>
class PureCallback
{
public:
PureCallback(void);
virtual ~PureCallback();
virtual LONG operator*(CallbackData<T> &someCallbackData)=0;
private:
};
template <class T>
inline
PureCallback<T>::PureCallback(void)
{
}
template <class T>
inline
PureCallback<T>::~PureCallback()
{
}
template <class T>
inline
LONG PureCallback<T>::operator*(CallbackData<T> &/*someCallbackData*/)
{
return 0;
}
#endif

17
common/pointer.hpp
View File

@@ -14,7 +14,8 @@ template <class T>
class SmartPointer
{
public:
SmartPointer(void);
// SmartPointer(void);
SmartPointer(bool createNew=false);
SmartPointer(T FAR *lpSmartPointer,PointerDisposition::Disposition disposition=PointerDisposition::Assume);
SmartPointer(const SmartPointer<T> &someSmartPointer);
virtual ~SmartPointer();
@@ -36,11 +37,23 @@ private:
PointerDisposition::Disposition mDisposition;
};
// template <class T>
// inline
// SmartPointer<T>::SmartPointer(void)
// : mlpSmartPointer(0), mDisposition(PointerDisposition::Assume)
// {
// }
template <class T>
inline
SmartPointer<T>::SmartPointer(void)
SmartPointer<T>::SmartPointer(bool createNew)
: mlpSmartPointer(0), mDisposition(PointerDisposition::Assume)
{
if(createNew)
{
mlpSmartPointer = ::new T();
mDisposition = PointerDisposition::Delete;
}
}
template <class T>