From 7943591f6e02e0feae178f550c772626efcb3a68 Mon Sep 17 00:00:00 2001 From: NaifBanana <30419422+NaifBanana@users.noreply.github.com> Date: Sat, 15 Jun 2024 03:02:26 -0500 Subject: [PATCH] Screw the container double pointer it is --- includes/Events.h | 52 ++++++++++++++++----------- source/Events.cpp | 90 +++++++++++++++++++++++------------------------ source/funcs.cpp | 45 ++++++++++++++++-------- source/main.cpp | 2 -- 4 files changed, 107 insertions(+), 82 deletions(-) diff --git a/includes/Events.h b/includes/Events.h index 5f5dfa6..0b4212b 100644 --- a/includes/Events.h +++ b/includes/Events.h @@ -14,24 +14,26 @@ using state_register = std::atomic; namespace NB { +extern std::invalid_argument null_mask_error; + void NULL_FUNC(); -class NBEvent { +class NBEvents { friend class NBEventListener; public: - NBEvent(); - NBEvent(const uint64_t, void (*initFunc)() = NULL_FUNC, const char* initName=""); - NBEvent(const uint64_t, const char* initName=""); - NBEvent(NBEvent&); - NBEvent& operator=(NBEvent& cpy); - ~NBEvent(); + NBEvents(const uint64_t, void (*initFunc)() = NULL_FUNC, const char* initName=""); + NBEvents(const uint64_t, const char* initName=""); + NBEvents(const NBEvents&); + NBEvents& operator=(const NBEvents&); + ~NBEvents(); const std::string getName() const; const uint64_t getMask() const; void setMask(const uint64_t); void setName(const char*); void setFunc(void (*newFunc)()); - virtual const uint64_t check(const uint64_t) const; + virtual const uint64_t check(const uint64_t) const = 0; + virtual NBEvents* clone() const = 0; protected: uint64_t mask = 0x0; @@ -40,15 +42,25 @@ protected: }; -class NBState : public NBEvent { +class NBEventBasic : public NBEvents { friend class NBEventListener; public: - using NBEvent::NBEvent; + using NBEvents::NBEvents; + NBEventBasic* clone() const override; const uint64_t check(const uint64_t) const override; }; +class NBEventState : public NBEvents { +friend class NBEventListener; +public: + using NBEvents::NBEvents; + + NBEventState* clone() const override; + const uint64_t check(const uint64_t) const override; +}; + enum NBStateChangeType : uint8_t { STATE_RAISE, STATE_DROP, STATE_SET }; @@ -60,26 +72,26 @@ struct NBStateChange { class NBEventListener { public: - NBEventListener(NBEvent*, uint16_t, state_register* initStatePtr=nullptr, const uint64_t initState=(uint64_t)0x0); + NBEventListener(NBEvents**, uint16_t, const uint64_t initState=(uint64_t)0x0, state_register* initStatePtr=nullptr); template - NBEventListener(std::array eventArray, state_register* initStatePtr=nullptr, const uint64_t initState=(uint64_t)0x0) - : NBEventListener(eventArray.data(), eventArray.size(), initStatePtr, initState) {} - NBEvent& operator[](int); + NBEventListener(std::array eventArray, const uint64_t initState=(uint64_t)0x0, state_register* initStatePtr=nullptr) + : NBEventListener(eventArray.data(), eventArray.size(), initState, initStatePtr) {} state_register* getStatePtr() const; const uint64_t getState() const; void raiseFlags(const uint64_t); - void raiseFlags(const NBEvent&); + void raiseFlags(const NBEvents&); void dropFlags(const uint64_t); - void dropFlags(const NBEvent&); + void dropFlags(const NBEvents&); const bool snoop(const uint64_t) const; - const bool snoop(const NBEvent&) const; - void setState(const uint64_t); + const bool snoop(const NBEvents&) const; void listen(); - void listen(const NBEvent&); + void listen(const NBEvents&); protected: - NBEvent* eventList; + void _setState(const uint64_t); + + NBEvents** eventList; uint16_t numEvents; state_register* state; std::mutex bufferLock; diff --git a/source/Events.cpp b/source/Events.cpp index 6625bb0..f18677a 100644 --- a/source/Events.cpp +++ b/source/Events.cpp @@ -1,24 +1,27 @@ #include "Events.h" -namespace NB { -std::invalid_argument null_mask_error("NULL MASK NOT ALLOWED"); +namespace NB { void NULL_FUNC() {} -NBEvent::NBEvent() {} +std::invalid_argument null_mask_error("NULL MASK NOT ALLOWED"); + +NBEvents::NBEvents(const uint64_t initMask, void (*initFunc)(), const char* initName): + mask(initMask), func(initFunc), name(initName) { + if (mask == 0x0) { + throw null_mask_error; + } -NBEvent::NBEvent(const uint64_t initMask, void (*initFunc)(), const char* initName) : mask{initMask}, func{initFunc}, name{initName} { - if (mask == 0x0) { - throw null_mask_error; - } } -NBEvent::NBEvent(const uint64_t initMask, const char* initName) : NBEvent(initMask, NULL_FUNC, initName) {} +NBEvents::NBEvents(const uint64_t initMask, const char* initName): + NBEvents(initMask, NULL_FUNC, initName) {} -NBEvent::NBEvent(NBEvent& cpy) : NBEvent(cpy.mask, cpy.func, cpy.name.c_str()) {} +NBEvents::NBEvents(const NBEvents& cpy) +:NBEvents(cpy.mask, cpy.func, cpy.name.c_str()) {} -NBEvent& NBEvent::operator=(NBEvent& cpy) { - func = cpy.func; +NBEvents& NBEvents::operator=(const NBEvents& cpy) { + func = cpy.func; name = cpy.name; mask = cpy.mask; if (mask==0x0) { @@ -27,29 +30,29 @@ NBEvent& NBEvent::operator=(NBEvent& cpy) { return *this; } -NBEvent::~NBEvent() {} +NBEvents::~NBEvents() { func = nullptr; } -const uint64_t NBEvent::getMask() const { - return mask; -} +const std::string NBEvents::getName() const { return name; } -const std::string NBEvent::getName() const { - return name; -} +const uint64_t NBEvents::getMask() const { return mask; } -void NBEvent::setFunc(void (*newFunc)()) { - func = newFunc; -} - -void NBEvent::setMask(const uint64_t newMask) { +void NBEvents::setMask(const uint64_t newMask) { mask = newMask; } -void NBEvent::setName(const char* newName) { +void NBEvents::setName(const char* newName) { name = newName; } -const uint64_t NBEvent::check(const uint64_t refState) const{ +void NBEvents::setFunc(void (*newFunc)()) { + func = newFunc; +} + +NBEventBasic* NBEventBasic::clone() const { return new NBEventBasic(*this); } + +NBEventState* NBEventState::clone() const { return new NBEventState(*this); } + +const uint64_t NBEventBasic::check(const uint64_t refState) const { if ((mask!=0) && ((refState&mask)==mask)) { func(); return refState&(~mask); @@ -57,37 +60,34 @@ const uint64_t NBEvent::check(const uint64_t refState) const{ return refState; } -const uint64_t NBState::check(const uint64_t refState) const { +const uint64_t NBEventState::check(const uint64_t refState) const { if ((mask!=0) && ((refState&mask)==mask)) { func(); } return refState; } -NBEventListener::NBEventListener(NBEvent* initEventList, uint16_t initNum, state_register* initStatePtr, const uint64_t initState) - : stateBuffer() { +NBEventListener::NBEventListener(NBEvents** initEventList, uint16_t initNum, const uint64_t initState, state_register* initStatePtr) { if (initStatePtr == nullptr) { state = new state_register; + } else { + state = initStatePtr; } - std::atomic_store(state, initState); + state->store(initState); numEvents = initNum; - eventList = new NBEvent[numEvents]; + eventList = new NBEvents*[numEvents]; for (uint16_t i = 0; i < initNum; ++i) { - eventList[i] = initEventList[i]; + eventList[i] = initEventList[i]->clone(); } } -NBEvent& NBEventListener::operator[](int ind) { - return eventList[ind % numEvents]; -} - state_register* NBEventListener::getStatePtr() const { return state; } const uint64_t NBEventListener::getState() const { - return std::atomic_load(state); + return state->load(); } void NBEventListener::raiseFlags(const uint64_t newState) { @@ -96,7 +96,7 @@ void NBEventListener::raiseFlags(const uint64_t newState) { bufferLock.unlock(); } -void NBEventListener::raiseFlags(const NBEvent& newEvent) { +void NBEventListener::raiseFlags(const NBEvents& newEvent) { raiseFlags(newEvent.mask); } @@ -106,7 +106,7 @@ void NBEventListener::dropFlags(const uint64_t dropState) { bufferLock.unlock(); } -void NBEventListener::dropFlags(const NBEvent& dropEvent) { +void NBEventListener::dropFlags(const NBEvents& dropEvent) { dropFlags(dropEvent.mask); } @@ -114,21 +114,21 @@ const bool NBEventListener::snoop(const uint64_t refState) const { return ((getState()&refState)==refState); } -const bool NBEventListener::snoop(const NBEvent& refEvent) const { +const bool NBEventListener::snoop(const NBEvents& refEvent) const { return snoop(refEvent.mask); } -void NBEventListener::setState(const uint64_t newState) { +void NBEventListener::_setState(const uint64_t newState) { bufferLock.lock(); std::queue().swap(stateBuffer); bufferLock.unlock(); - std::atomic_store(state, newState); + state->store(newState); } void NBEventListener::listen() { uint64_t oldState = getState(); for (uint16_t i = 0; i < numEvents; ++i) { - oldState = eventList[i].check(oldState); + oldState = eventList[i]->check(oldState); } NBStateChange curr; bufferLock.lock(); @@ -149,13 +149,13 @@ void NBEventListener::listen() { } } bufferLock.unlock(); - setState(oldState); + _setState(oldState); } -void NBEventListener::listen(const NBEvent& refEvent) { +void NBEventListener::listen(const NBEvents& refEvent) { uint64_t oldState = getState(); oldState = refEvent.check(oldState); - setState(oldState); + _setState(oldState); } }; \ No newline at end of file diff --git a/source/funcs.cpp b/source/funcs.cpp index 8a52bb8..f6af38c 100644 --- a/source/funcs.cpp +++ b/source/funcs.cpp @@ -8,24 +8,38 @@ void bPressAlert() { std::cout << "B PRESSED\n"; } -NB::NBEvent aKeyEvent(A_PRESSED, aPressAlert, "A_PRESSED"); -NB::NBEvent bKeyEvent(B_PRESSED, bPressAlert, "B_PRESSED"); -NB::NBEvent windowCloseEvent(CLOSE_WIND_SIG, stopWindows, "CLOSE_WINDOWS_SIG"); +void windowCloseAlert() { + std::cout << "WINDOW SHOULD CLOSE\n"; +} -NB::NBState windowAIsReadyState(WINDOW_READY_A, "WINDOW_A_READY"); -NB::NBState windowBIsReadyState(WINDOW_READY_B, "WINDOW_B_READY"); -NB::NBState windowShouldCloseState(WINDOW_SHOULD_CLOSE, "WINDOW_CLOSING_STATE"); -NB::NBState programCloseState(PROGRAM_SHOULD_CLOSE, "PROGRAM_CLOSING_STATE"); +NB::NBEventBasic aKeyEvent(A_PRESSED, aPressAlert, "A_PRESSED"); +NB::NBEventBasic bKeyEvent(B_PRESSED, bPressAlert, "B_PRESSED"); +NB::NBEventBasic windowCloseEvent(CLOSE_WIND_SIG, stopWindows, "CLOSE_WINDOWS_SIG"); -std::array event_list= { - windowCloseEvent, - bKeyEvent, - aKeyEvent, +NB::NBEventState windowAIsReadyState(WINDOW_READY_A, "WINDOW_A_READY"); +NB::NBEventState windowBIsReadyState(WINDOW_READY_B, "WINDOW_B_READY"); +NB::NBEventState windowShouldCloseState(WINDOW_SHOULD_CLOSE, windowCloseAlert, "WINDOW_CLOSING_STATE"); +NB::NBEventState programCloseState(PROGRAM_SHOULD_CLOSE, "PROGRAM_CLOSING_STATE"); + +// std::array event_list= { +// windowCloseEvent, +// bKeyEvent, +// aKeyEvent, + +// windowAIsReadyState, +// windowBIsReadyState, +// windowShouldCloseState, +// programCloseState +// }; +std::array event_list= { + &windowCloseEvent, + &bKeyEvent, + &aKeyEvent, - windowAIsReadyState, - windowBIsReadyState, - windowShouldCloseState, - programCloseState + &windowAIsReadyState, + &windowBIsReadyState, + &windowShouldCloseState, + &programCloseState }; NB::NBEventListener my_listener(event_list); @@ -66,6 +80,7 @@ void stopWindows() { int renderingProcessA() { std::cout << "Howdy from rendering A!\n"; + std::cout << "FROM RENDERING A I SEE IN EVENT LIST " << event_list[3]->getName() << "\n"; if ( aWindow->init() ) { return -1; } my_listener.raiseFlags(WINDOW_READY_A); diff --git a/source/main.cpp b/source/main.cpp index 416f12d..203ce95 100644 --- a/source/main.cpp +++ b/source/main.cpp @@ -14,7 +14,6 @@ extern NB::NBEventListener my_listener; int main() { std::cout << "Hello World!\n"; -{ NB::NBWindow windowa(800, 600, "Multithreading?"); NB::NBWindow windowb(800, 600, "Multithreading!"); aWindow = &windowa; @@ -33,7 +32,6 @@ int main() { } std::cout << "YOUVE REACHED THE END OF THE MAIN THREAD!\n"; -} state_register* state = my_listener.getStatePtr(); delete state;