Algorithm class abstraction (#11)

* Abstracting algorithm construct into object

* Fixing virtual function override problem

* Fixing return types of some functions

breadcrumbs/include/AlgoBreadcrumbs.hpp

@@ -0,0 +1,18 @@
+
+#ifndef ALGO_BREADCRUMBS_HPP
+#define ALGO_BREADCRUMBS_HPP
+
+#include "Algorithm.hpp"
+
+class AlgoBreadcrumbs : public Algorithm
+{
+public:
+	using Algorithm::Algorithm;
+
+	VOID loop();
+	BOOLEAN loopCondition();
+private:
+	INT iterations = 1;
+};
+
+#endif

breadcrumbs/include/Algorithm.hpp

@@ -0,0 +1,28 @@
+
+#ifndef ALGORITHM_HPP
+#define ALGORITHM_HPP
+
+#include "IOProcessor.hpp"
+
+class Algorithm
+{
+public:
+	explicit Algorithm(IOProcessor* ins, SIZE_T num_inputs, IOProcessor* outs, SIZE_T num_outputs);
+
+	virtual VOID loop() = 0;
+	virtual BOOLEAN loopCondition() { return FALSE; };
+
+	VOID startIOProcessors();
+	VOID waitForIOProcessors();
+	VOID stopIOProcessors();
+
+	// Updates Algorithm key/value store with IO key/value stores
+	VOID pollInputs();
+	// Updates IO key/value stores with Algorithm key/value store
+	VOID pollOutputs();
+private:
+	SIZE_T numInputs, numOutputs;
+	IOProcessor* inputs, *outputs;
+};
+
+#endif

breadcrumbs/include/IOProcessor.hpp

@@ -17,13 +17,15 @@
 class IOProcessor
 {
 public:
+	IOProcessor(LPCVOID pThreadArgs) { threadArgs = pThreadArgs; };
+
 	// Thread routine for implementation to override
-	virtual VOID threadRuntime() = 0;
+	virtual VOID threadRuntime(IOProcessor *ioProc) = 0;
 	// Thread initialization, should not be called directly!
-	static DWORD threadInit(LPVOID pIOProcessor);
+	static DWORD threadInit(LPVOID pThreadArgs);
 
 	// Async control
-	UINT8 startThread(LPVOID pThreadArgs);
+	UINT8 startThread();
 	BOOL waitForThread();
 
 	// Sync control

breadcrumbs/src/io/out_procs/VirtualOutputProcessor.hpp → breadcrumbs/include/VirtualOutputProcessor.hpp

@@ -11,7 +11,9 @@
 class VirtualOutputProcessor : public IOProcessor
 {
 public:
-	void threadRuntime();
+	using IOProcessor::IOProcessor;
+
+	VOID threadRuntime(IOProcessor* ioProc);
 };
 
 #endif

breadcrumbs/src/Breadcrumbs.cpp

@@ -1,15 +1,30 @@
+
 #include <stdio.h>
 
-#include "io/out_procs/VirtualOutputProcessor.hpp"
+#include "AlgoBreadcrumbs.hpp"
+#include "VirtualOutputProcessor.hpp"
 
 
-int main() {
+int main()
+{
 
+	// Initialization
 	int threadID = 0;
-	IOProcessor *processor;
-	processor = new VirtualOutputProcessor();
-	processor->startThread(&threadID);
+	IOProcessor *processor = new VirtualOutputProcessor((LPCVOID) &threadID);
+	Algorithm* algorithm = new AlgoBreadcrumbs(NULL, 0, processor, 1);
+
+	// Starting
+	algorithm->startIOProcessors();
+
+	// Loop
+	while (algorithm->loopCondition())
+	{
+		algorithm->pollInputs();
+		algorithm->loop();
+		algorithm->pollOutputs();
+	}
 
+	// Cleanup
 	processor->waitForThread();
 	delete processor;
 

breadcrumbs/src/algos/AlgoBreadcrumbs.cpp

@@ -0,0 +1,13 @@
+
+#include "AlgoBreadcrumbs.hpp"
+
+
+VOID AlgoBreadcrumbs::loop()
+{
+	printf("Breadcrumbs algorithm loop!\n");
+}
+
+BOOLEAN AlgoBreadcrumbs::loopCondition()
+{
+	return --iterations >= 0;
+}

breadcrumbs/src/algos/Algorithm.cpp

@@ -0,0 +1,41 @@
+
+#include "Algorithm.hpp"
+
+Algorithm::Algorithm(IOProcessor* ins, SIZE_T numIns, IOProcessor* outs, SIZE_T numOuts) 
+{ 
+	numInputs = numIns; numOutputs = numOuts;
+	inputs = ins; outputs = outs; 
+}
+
+VOID Algorithm::startIOProcessors()
+{
+	int i;
+	for (i = 0; i < numInputs; i++)
+		(inputs + i)->startThread();
+	for (i = 0; i < numOutputs; i++)
+		(outputs + i)->startThread();
+}
+
+VOID Algorithm::waitForIOProcessors()
+{
+	int i;
+	for (i = 0; i < numInputs; i++)
+		(inputs + i)->waitForThread();
+	for (i = 0; i < numOutputs; i++)
+		(outputs + i)->waitForThread();
+}
+
+VOID Algorithm::stopIOProcessors()
+{
+	waitForIOProcessors();
+}
+
+VOID Algorithm::pollInputs()
+{
+
+}
+
+VOID Algorithm::pollOutputs()
+{
+
+}

breadcrumbs/src/io/IOProcessor.cpp

@@ -2,15 +2,15 @@
 #include "IOProcessor.hpp"
 
 
-DWORD IOProcessor::threadInit(LPVOID pIOProcessor)
+DWORD IOProcessor::threadInit(LPVOID pThreadArgs)
 {
-	((IOProcessor*) pIOProcessor)->threadRuntime();
+	IOProcessor* pIOProcessor = (IOProcessor*)pThreadArgs;
+	pIOProcessor->threadRuntime(pIOProcessor);
 	return 0;
 }
 
-UINT8 IOProcessor::startThread(LPVOID pThreadArgs)
+UINT8 IOProcessor::startThread()
 {
-	this->threadArgs = pThreadArgs;
 	hThread = CreateThread(
 		NULL,                   // default security attributes
 		0,                      // use default stack size  

breadcrumbs/src/io/out_procs/VirtualOutputProcessor.cpp

@@ -2,7 +2,7 @@
 #include "VirtualOutputProcessor.hpp"
 
 
-void VirtualOutputProcessor::threadRuntime()
+VOID VirtualOutputProcessor::threadRuntime(IOProcessor* ioProc)
 {
 	printf("VirtualOutputProcessor %d started.\n", *((int*) threadArgs));
 }