From 8b4769bf7e3c91ac0b8949881c6f8f43de5615b3 Mon Sep 17 00:00:00 2001 From: Sean Date: Thu, 14 Aug 2025 12:47:10 -0400 Subject: [PATCH] Add support for callbacks --- common/callback.hpp | 41 ++++++ common/callback.tpp | 60 +++++++++ common/cbdata.hpp | 70 +++++++++++ common/cbptr.hpp | 81 ++++++++++++ common/pcallbck.hpp | 35 ++++++ common/pointer.hpp | 17 ++- ctest/.vscode/settings.json | 7 +- ctest/CMakeLists.txt | 4 +- ctest/Untitled-1 | 1 - ctest/main.cpp | 245 ++++++++++++++++++------------------ 10 files changed, 431 insertions(+), 130 deletions(-) create mode 100755 common/callback.hpp create mode 100755 common/callback.tpp create mode 100755 common/cbdata.hpp create mode 100755 common/cbptr.hpp create mode 100755 common/pcallbck.hpp delete mode 100644 ctest/Untitled-1 diff --git a/common/callback.hpp b/common/callback.hpp new file mode 100755 index 0000000..dcc718b --- /dev/null +++ b/common/callback.hpp @@ -0,0 +1,41 @@ +#ifndef _COMMON_CALLBACK_HPP_ +#define _COMMON_CALLBACK_HPP_ +#ifndef _COMMON_CALLBACKDATA_HPP_ +#include +#endif +#ifndef _COMMON_PURECALLBACK_HPP_ +#include +#endif +#ifndef _COMMON_CALLBACKPOINTER_HPP_ +#include +#endif + +template +class Callback : public PureCallback +{ +public: + typedef LONG (T::*PFNMETHOD)(CallbackData &callbackData); + Callback(void); + Callback(const Callback &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 &someCallback)const; + void operator=(const Callback &someCallback); + LONG operator*(CallbackData &someCallbackData); +private: + T *mlpObject; + LONG (T::*mlpMethod)(CallbackData &someCallbackData); +}; + +template +inline +LONG Callback::operator*(CallbackData &someCallbackData) +{ + if((!mlpObject)||(!mlpMethod))return (LONG)0; + return (mlpObject->*mlpMethod)(someCallbackData); +} +#include +#endif diff --git a/common/callback.tpp b/common/callback.tpp new file mode 100755 index 0000000..119242d --- /dev/null +++ b/common/callback.tpp @@ -0,0 +1,60 @@ +#ifndef _COMMON_CALLBACK_TPP_ +#define _COMMON_CALLBACK_TPP_ + +template +Callback::Callback(void) +: mlpObject(0), mlpMethod(0) +{ +} + +template +Callback::Callback(const Callback &someCallback) +: mlpObject(someCallback.mlpObject), mlpMethod(someCallback.mlpMethod) +{ +} + + +template +Callback::Callback(T *lpObject,PFNMETHOD lpMethod) +: mlpObject(lpObject), mlpMethod(lpMethod) +{ +} + +template +Callback::~Callback() +{ +} + +template +WORD Callback::operator==(const Callback &someCallback)const +{ + return (mlpObject==someCallback.mlpObject && mlpMethod==someCallback.mlpMethod); +} + +template +void Callback::operator=(const Callback &someCallback) +{ + mlpObject=someCallback.mlpObject; + mlpMethod=someCallback.mlpMethod; +} + +template +void Callback::setObject(T *lpObject) +{ + mlpObject=lpObject; +} + +template +void Callback::setMethod(PFNMETHOD lpMethod) +{ + mlpMethod=lpMethod; +} + +template +void Callback::setCallback(T *lpObject,PFNMETHOD lpMethod) +{ + mlpObject=lpObject; + mlpMethod=lpMethod; +} + +#endif diff --git a/common/cbdata.hpp b/common/cbdata.hpp new file mode 100755 index 0000000..ddcf104 --- /dev/null +++ b/common/cbdata.hpp @@ -0,0 +1,70 @@ +#ifndef _COMMON_CALLBACKDATA_HPP_ +#define _COMMON_CALLBACKDATA_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif + +template +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 mData; +}; + +template +inline +CallbackData::CallbackData(void) +{ +} + +template +inline +CallbackData::CallbackData(T &data) +{ + mData=&data; +} + +template +inline +CallbackData::CallbackData(const CallbackData &someCallbackData) +{ + *this=someCallbackData; +} + +template +inline +CallbackData::~CallbackData() +{ +} + +template +inline +CallbackData &CallbackData::operator=(const CallbackData &someCallbackData) +{ + mData = someCallbackData.mData; + return *this; +} + +template +inline +T &CallbackData::getData(void) +{ + return *mData; +} + +template +inline +void CallbackData::setData(T &data) +{ + mData=&data; +} +#endif diff --git a/common/cbptr.hpp b/common/cbptr.hpp new file mode 100755 index 0000000..d702c96 --- /dev/null +++ b/common/cbptr.hpp @@ -0,0 +1,81 @@ +#ifndef _COMMON_CALLBACKPOINTER_HPP_ +#define _COMMON_CALLBACKPOINTER_HPP_ +#ifndef _COMMON_WINDOWS_HPP_ +#include +#endif +#ifndef _COMMON_PURECALLBACK_HPP_ +#include +#endif + +template +class CallbackPointer +{ +public: + CallbackPointer(void); + CallbackPointer(PureCallback *lpCallback); + CallbackPointer(const CallbackPointer &someCallbackPointer); + virtual ~CallbackPointer(); + void operator=(CallbackPointer &someCallbackPointer); + WORD operator==(const CallbackPointer &someCallbackPointer)const; + LONG callback(CallbackData &someCallbackData); + bool isOkay(void)const; +private: + PureCallback *mlpCallback; +}; + +template +inline +CallbackPointer::CallbackPointer(void) +: mlpCallback(0) +{ +} + +template +inline +CallbackPointer::CallbackPointer(PureCallback *lpCallback) +: mlpCallback(lpCallback) +{ +} + +template +inline +CallbackPointer::CallbackPointer(const CallbackPointer &someCallbackPointer) +: mlpCallback(someCallbackPointer.mlpCallback) +{ +} + +template +inline +CallbackPointer::~CallbackPointer() +{ +} + +template +inline +void CallbackPointer::operator=(CallbackPointer &someCallbackPointer) +{ + mlpCallback=someCallbackPointer.mlpCallback; +} + +template +inline +WORD CallbackPointer::operator==(const CallbackPointer &someCallbackPointer)const +{ + return (mlpCallback==someCallbackPointer.mlpCallback); +} + +template +inline +LONG CallbackPointer::callback(CallbackData &someCallbackData) +{ + if(!mlpCallback)return (LONG)0; + return mlpCallback->operator*(someCallbackData); +} + +template +inline +bool CallbackPointer::isOkay(void)const +{ + return mlpCallback?true:false; +} +#endif \ No newline at end of file diff --git a/common/pcallbck.hpp b/common/pcallbck.hpp new file mode 100755 index 0000000..e4bf419 --- /dev/null +++ b/common/pcallbck.hpp @@ -0,0 +1,35 @@ +#ifndef _COMMON_PURECALLBACK_HPP_ +#define _COMMON_PURECALLBACK_HPP_ +#ifndef _COMMON_CALLBACKDATA_HPP_ +#include +#endif + +template +class PureCallback +{ +public: + PureCallback(void); + virtual ~PureCallback(); + virtual LONG operator*(CallbackData &someCallbackData)=0; +private: +}; + +template +inline +PureCallback::PureCallback(void) +{ +} + +template +inline +PureCallback::~PureCallback() +{ +} + +template +inline +LONG PureCallback::operator*(CallbackData &/*someCallbackData*/) +{ + return 0; +} +#endif \ No newline at end of file diff --git a/common/pointer.hpp b/common/pointer.hpp index 99c2968..5c777a4 100755 --- a/common/pointer.hpp +++ b/common/pointer.hpp @@ -14,7 +14,8 @@ template class SmartPointer { public: - SmartPointer(void); +// SmartPointer(void); + SmartPointer(bool createNew=false); SmartPointer(T FAR *lpSmartPointer,PointerDisposition::Disposition disposition=PointerDisposition::Assume); SmartPointer(const SmartPointer &someSmartPointer); virtual ~SmartPointer(); @@ -36,11 +37,23 @@ private: PointerDisposition::Disposition mDisposition; }; +// template +// inline +// SmartPointer::SmartPointer(void) +// : mlpSmartPointer(0), mDisposition(PointerDisposition::Assume) +// { +// } + template inline -SmartPointer::SmartPointer(void) +SmartPointer::SmartPointer(bool createNew) : mlpSmartPointer(0), mDisposition(PointerDisposition::Assume) { + if(createNew) + { + mlpSmartPointer = ::new T(); + mDisposition = PointerDisposition::Delete; + } } template diff --git a/ctest/.vscode/settings.json b/ctest/.vscode/settings.json index 6b7d21e..3182969 100644 --- a/ctest/.vscode/settings.json +++ b/ctest/.vscode/settings.json @@ -48,6 +48,11 @@ "streambuf": "cpp", "typeinfo": "cpp", "fstream": "cpp", - "iostream": "cpp" + "iostream": "cpp", + "complex": "cpp", + "cstring": "cpp", + "semaphore": "cpp", + "stop_token": "cpp", + "thread": "cpp" } } \ No newline at end of file diff --git a/ctest/CMakeLists.txt b/ctest/CMakeLists.txt index 0941df3..82c58f5 100644 --- a/ctest/CMakeLists.txt +++ b/ctest/CMakeLists.txt @@ -1,10 +1,10 @@ cmake_minimum_required(VERSION 3.10.0) -set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -I/home/pi/Boneyard") +set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -I/home/pi/CPP") project(tester VERSION 0.1.0 LANGUAGES C CXX) add_executable(tester main.cpp) -add_subdirectory(/home/pi/Boneyard/common /home/pi/Boneyard/common/build) +add_subdirectory(/home/pi/CPP/common /home/pi/CPP/common/build) target_link_libraries(tester PRIVATE common) diff --git a/ctest/Untitled-1 b/ctest/Untitled-1 deleted file mode 100644 index 8b13789..0000000 --- a/ctest/Untitled-1 +++ /dev/null @@ -1 +0,0 @@ - diff --git a/ctest/main.cpp b/ctest/main.cpp index a61c51d..80f65f6 100644 --- a/ctest/main.cpp +++ b/ctest/main.cpp @@ -10,144 +10,141 @@ #include #include #include +#include #include +#include - -// #include // For standard input/output operations (like std::cout) -// #include // For file stream operations (like std::ifstream) -// #include // For using std::string -// int main() -// { -// Profiler profiler = Profiler(); -// std::ifstream inputFile("/mnt/mariadb/backupdb.sql"); - -// if (!inputFile.is_open()) -// { -// std::cerr << "Error: Could not open the file." << std::endl; -// return 1; // Indicate an error -// } - -// DWORD lines = 0; -// std::string line; -// while (std::getline(inputFile, line)) -// { -// lines++; -// if(!(lines%1000000)) -// { -// std::cout << "reading " << lines << " " << line << std::endl; -// } -// } - -// inputFile.close(); -// std::cout << "Done, total took " << profiler.end() << " (ms)" << std::endl; -// return 0; // Indicate successful execution -// } - -// int main(int argc, char ** argv) -// { -// Profiler profiler = Profiler(); -// FileIO inputFile = FileIO("/mnt/mariadb/backupdb.sql"); -// inputFile.setBufferLength(500000000); -// // FileIO inputFile = FileIO("/home/pi/Boneyard/ctest/main.cpp"); -// String strLine = String(); -// DWORD length = 0; -// DWORD lines = 0; - -// printf("opening...\n"); -// while(inputFile.readLine(strLine)) -// { -// lines++; -// // printf("reading %d %s\n",lines,(char*)strLine); -// if(!(lines%1000000)) -// { -// printf("reading %d %s\n",lines,(char*)strLine); -// } -// } -// printf("Done, read %d lines\n",lines); -// inputFile.close(); -// printf("done, took %d(ms)...\n",profiler.end()); - -// return 0; -// } - -std::tuple foo() +class Info { - return std::make_tuple(2,3,4); + public: + Info(); + ~Info(); + String getMessage(void); + void setMessage(const String &message); + private: + String mMessage; +}; + +Info::Info() +{ + std::cout << "Info" << std::endl; +} + +Info::~Info() +{ + std::cout << "~Info" << std::endl; +} + +String Info::getMessage(void) +{ + return mMessage; +} + +void Info::setMessage(const String &message) +{ + mMessage = message; +} + +class B +{ + public: + B(); + LONG callback(CallbackData &callbackData); + ~B(); + private: + String mFoo; +}; + +B::B() +{ +} + +B::~B() +{ +} + +LONG B::callback(CallbackData &callbackData) +{ + std::cout << "callback with data " << callbackData.getData().getMessage().str() << std::endl; + return 0; +} + +class Monitor +{ + public: + Monitor(); + ~Monitor(); + void setCallback(Callback &callback); + void doCallback(CallbackData &callbackData); + private: + Callback mCallback; +}; + +Monitor::Monitor() +{ + std::cout << "Monitor" << std::endl; +} + + +Monitor::~Monitor() +{ + std::cout << "~Monitor" << std::endl; +} + +void Monitor::setCallback(Callback &callback) +{ + mCallback=callback; +} + +void Monitor::doCallback(CallbackData &callbackData) +{ + CallbackPointer cbptr(&mCallback); + cbptr.callback(callbackData); } int main(int argc, char ** argv) { - // std::complex c{4.0,3.0}; + // std::vector myBigVec(10000000, 2011); + // std::vector s1; + // std::vector s2; + + // s1.push_back("hello"); + // s1.push_back("world"); + + // s2 = std::move(s1); + Monitor monitor; +// SmartPointer b(::new B(),PointerDisposition::Delete); + SmartPointer b(true); + Callback callback(&(*b),&B::callback); + monitor.setCallback(callback); - // FileIO fileIO = FileIO("/mnt/mariadb/backupdb.sql"); - // std::cout << "Reading ... " << std::endl; - // int lines =0; - // String strLine; - // while(fileIO.readLine(strLine)) - // { - // lines++; - // if(!(lines%1000000)) - // { - // printf("reading %d %s\n",lines,(char*)strLine); - // } - // } - // fileIO.close(); -} - -void stdLibStuff() -{ - // std::vector numbers; - // numbers.push_back(100); - // numbers.push_back(50); - // numbers.push_back(100); - - // int *p=&numbers[0]; - // int *p1=&numbers[1]; - // int *p2=&numbers[2]; - - // int max = *std::max_element(numbers.begin(), numbers.end()); - -// std::cout << typeid(max_it).name() << std::endl; - // if(max_it == p)std::cout << "p" << std::endl; - // if(max_it == p1) std::cout << "p1" << std::endl; - // if(max_it == p2)std::cout << "p2" << std::endl; - - -// std::cout << *max_it << std::endl; - - - // int max_value = *max_it; - // std::max(*numbers.begin()); - - -// std::cout << std::max(numbers) << std::endl; -// Block numbers; - - - -// numbers.insert(newInt(100); - -// std::cout<< std::min(100,50) << std::endl; - // std::string s = "hello"; - // std::cout << s << std::endl; - // std::vector strings; - // strings.push_back("hello"); - // strings.push_back("world"); - - // for (const std::string& s : strings) - // { - // std::cout << s << " "; - // } - - // char buffer[] = "Another direct copy"; - - // int a = sizeof(buffer); + Info info; + info.setMessage("Hello"); + CallbackData callbackData(info); + monitor.doCallback(callbackData); } + + + + +// Callback callback(&(*b),C + + +// SmartPointer b1 = b; +// b1->foo(); +// b->foo(); + +// String str="Hello"; +// b->setFoo(str); +// str="Goodbye"; +// String str2=b->getFoo(); +// str2="world"; + void readFile() { // MemoryMappedFile memoryMappedFile("/home/pi/Boneyard/ctest/main.cpp",MemoryMappedFile::CreationFlags::ReadOnly);