How to achieve event compression in C++ - c++

Question

In my application i'm getting series of Windows events and i want to compress them and process unique events in c++.
For example: Event W1, W2, W3, W4 ...., Event E1, E2... etc.,
If I'm getting only W1 series in timeframe I want to process only one event by compressing remaining events of same series.
#include <iostream>
#include <string>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <process.h>
#include <list>
#include <vector>
#include<Windows.h>
#include <future>
#include <fstream>
static const char* WFEVENTNAME_EVENT1 = "Global\\WFEVENTNAME_EVENT1";
static const char* WFEVENTNAME_EVENT2 = "Global\\WFEVENTNAME_EVENT2";
static const char* WFEVENTNAME_EVENT3 = "Global\\WFEVENTNAME_EVENT3";
static const char* WFEVENTNAME_EVENT4 = "Global\\WFEVENTNAME_EVENT4";
static const char* WFEVENTNAME_EVENT5 = "Global\\WFEVENTNAME_EVENT5";
static const char* WFEVENTNAME_EVENT6 = "Global\\WFEVENTNAME_EVENT6";
static const char* WFEVENTNAME_EVENT7 = "Global\\WFEVENTNAME_EVENT7";
static const char* WFEVENTNAME_EVENT8 = "Global\\WFEVENTNAME_EVENT8";
static const char* WFEVENTNAME_EVENT9 = "Global\\WFEVENTNAME_EVENT9";
static const char* WFEVENTNAME_EVENT10 = "Global\\WFEVENTNAME_EVENT10";
static const char* WFEVENTNAME_EVENT11 = "Global\\WFEVENTNAME_EVENT11";
std::ofstream outfile;
typedef std::lock_guard<std::mutex> lockMutex;
typedef std::unique_lock<std::mutex> ulock;
class Handler1
{
public:
bool ProcessMessage(std::string messageName)
{
printf("Processed Handler1\n");
return true;
}
};
class Handler2
{
public:
bool ProcessMessage(std::string messageName)
{
printf("Processed Handler2\n");
return true;
}
};
class Handler3
{
public:
bool ProcessMessage(std::string messageName)
{
printf("Processed Handler3\n");
return true;
}
};
class Handler4
{
public:
bool ProcessMessage(std::string messageName)
{
printf("Processed Handler4\n");
return true;
}
};
class Handler5
{
public:
bool ProcessMessage(std::string messageName)
{
printf("Processed Handler5\n");
return true;
}
};
class Handler6
{
public:
bool ProcessMessage(std::string messageName)
{
printf("Processed Handler6\n");
return true;
}
};
unsigned _stdcall threadFuncToCollectSenderEvents(void* senderObject);
unsigned _stdcall threadFuncToProcessSenderEvents(void* senderObject);
class MessagingEventsNotifier
{
public:
MessagingEventsNotifier()
{
_beginthreadex(0, 0, threadFuncToCollectSenderEvents, this, 0, 0);
_beginthreadex(0, 0, threadFuncToProcessSenderEvents, this, 0, 0);
}
std::list<std::string> mySenderEvents;
std::mutex myMutex;
/// To notify to process the collected event
std::condition_variable myConsumer;
Handler1* myConnectionHandler;
Handler2* myHandler2;
Handler3* myLandmarkWorkflowHandler;
Handler4* myHandler4;
Handler5* myHandler5;
Handler6* myHandler6;
std::vector<HANDLE> myThreadHandles;
};
unsigned _stdcall threadFuncToCollectSenderEvents(void* senderObject)
{
MessagingEventsNotifier *senderEventObject = static_cast<MessagingEventsNotifier*>(senderObject);
while (true)
{
HANDLE hEvents[8];
hEvents[0] = CreateEventA(NULL, false, false, WFEVENTNAME_EVENT3);
hEvents[1] = CreateEventA(NULL, false, false, WFEVENTNAME_EVENT9);
hEvents[2] = CreateEventA(NULL, false, false, WFEVENTNAME_EVENT5);
hEvents[3] = CreateEventA(NULL, false, false, WFEVENTNAME_EVENT6);
hEvents[4] = CreateEventA(NULL, false, false, WFEVENTNAME_EVENT1);
hEvents[5] = CreateEventA(NULL, false, false, WFEVENTNAME_EVENT7);
hEvents[6] = CreateEventA(NULL, false, false, WFEVENTNAME_EVENT2);
hEvents[7] = CreateEventA(NULL, false, false, WFEVENTNAME_EVENT10);
DWORD result = WaitForMultipleObjects(8, hEvents, false, INFINITE);
lockMutex l(senderEventObject->myMutex);
if ((result - WAIT_OBJECT_0) == 0)
{
senderEventObject->mySenderEvents.push_back(WFEVENTNAME_EVENT3);
}
else if ((result - WAIT_OBJECT_0) == 1)
{
senderEventObject->mySenderEvents.push_back(WFEVENTNAME_EVENT9);
}
else if ((result - WAIT_OBJECT_0) == 2)
{
senderEventObject->mySenderEvents.push_back(WFEVENTNAME_EVENT5);
}
else if ((result - WAIT_OBJECT_0) == 3)
{
senderEventObject->mySenderEvents.push_back(WFEVENTNAME_EVENT6);
}
else if ((result - WAIT_OBJECT_0) == 4)
{
senderEventObject->mySenderEvents.push_back(WFEVENTNAME_EVENT1);
}
else if ((result - WAIT_OBJECT_0) == 5)
{
senderEventObject->mySenderEvents.push_back(WFEVENTNAME_EVENT7);
}
else if ((result - WAIT_OBJECT_0) == 6)
{
senderEventObject->mySenderEvents.push_back(WFEVENTNAME_EVENT2);
}
else if ((result - WAIT_OBJECT_0) == 7)
{
senderEventObject->mySenderEvents.push_back(WFEVENTNAME_EVENT10);
}
senderEventObject->myConsumer.notify_one();
}
return true;
}
unsigned _stdcall threadFuncToProcessSenderEvents(void* senderObject)
{
MessagingEventsNotifier *senderEventObject = static_cast<MessagingEventsNotifier*>(senderObject);
ulock unlockMutex(senderEventObject->myMutex);
while (true)
{
senderEventObject->myConsumer.wait(unlockMutex);
if (senderEventObject->mySenderEvents.size() <= 0)
{
continue;
}
senderEventObject->mySenderEvents.unique();
for (std::list<std::string>::iterator it = senderEventObject->mySenderEvents.begin();
it != senderEventObject->mySenderEvents.end(); ++it)
{
i++;
std::string str = "Count = " + std::to_string(i) + "\n";
outfile.write(str.c_str(), str.size());
outfile.flush();
printf("Processed Events Count: %d\n", i);
std::string eventName = *it;
if (eventName == WFEVENTNAME_EVENT3)
{
senderEventObject->myLandmarkWorkflowHandler->ProcessMessage(WFEVENTNAME_EVENT3);
Sleep(10);
}
else if (eventName == WFEVENTNAME_EVENT9)
{
senderEventObject->myHandler2->ProcessMessage(WFEVENTNAME_EVENT9);
Sleep(10);
}
else if (eventName == WFEVENTNAME_EVENT5)
{
senderEventObject->myHandler5->ProcessMessage(WFEVENTNAME_EVENT5);
Sleep(10);
}
else if (eventName == WFEVENTNAME_EVENT6)
{
senderEventObject->myHandler5->ProcessMessage(WFEVENTNAME_EVENT6);
Sleep(10);
}
else if (eventName == WFEVENTNAME_EVENT1)
{
senderEventObject->myConnectionHandler->ProcessMessage(WFEVENTNAME_EVENT1);
Sleep(10);
}
else if (eventName == WFEVENTNAME_EVENT7)
{
senderEventObject->myConnectionHandler->ProcessMessage(WFEVENTNAME_EVENT7);
Sleep(10);
}
else if (eventName == WFEVENTNAME_EVENT2)
{
senderEventObject->myHandler4->ProcessMessage(WFEVENTNAME_EVENT2);
Sleep(10);
}
else if (eventName == WFEVENTNAME_EVENT10)
{
senderEventObject->myHandler6->ProcessMessage(WFEVENTNAME_EVENT10);
Sleep(10);
}
}
senderEventObject->mySenderEvents.clear();
}
}
int main()
{
MessagingEventsNotifier obj;
for (int i = 1; i < 50; i++)
{
HANDLE handle1 = CreateEvent(NULL, 0, 0, WFEVENTNAME_EVENT10);
SetEvent(handle1);
Sleep(5);
if (i % 2 == 0)
{
HANDLE handle2 = CreateEvent(NULL, 0, 0, WFEVENTNAME_EVENT3);
SetEvent(handle2);
Sleep(5);
}
if (i % 3 == 0)
{
HANDLE handle3 = CreateEvent(NULL, 0, 0, WFEVENTNAME_EVENT2);
SetEvent(handle3);
Sleep(5);
}
if (i % 5 == 0)
{
HANDLE handle3 = CreateEvent(NULL, 0, 0, WFEVENTNAME_EVENT6);
SetEvent(handle3);
Sleep(5);
}
if (i % 10 == 0)
{
HANDLE handle4 = CreateEvent(NULL, 0, 0, WFEVENTNAME_EVENT9);
SetEvent(handle4);
Sleep(5);
}
}
HANDLE hEvent = CreateEventA(NULL, false, false, "SSSS");
DWORD result = WaitForSingleObject(hEvent, INFINITE);
}
There are two threads:
one will collect events
another will process them sequentially.
My question is: whilst processing we might miss few events to collect; how to handle this scenario ?
I wanted to design the windows events mechanism and compression too.
Please help me in achieving this kind of mechanism.

Answer 1

Maintain a list of events and the timestamps of when they were last processed.
When an you encounter an event, search for it in the list:
if found, check if required time has passed,
if passed, process it and update its timestamp
else ignore
if not found, add it to list with the timestamp and process it.