Merge pull request #13 from CAHEK7/StaticThreadController

Static thread controller

Author: ivanseidel

README.md

@@ -32,15 +32,18 @@ It should be noted that these are not “threads” in the real computer-science
 There are many examples showing many ways to use it. Here, we will explain Class itself,
 what it does and "how" it does.
 
-There are basicaly, two Classes included in this Library:
-`Thread` and `ThreadController` (that inherits from Thread).
+There are basicaly, three Classes included in this Library:
+`Thread`, `ThreadController` and `StaticThreadController` (both controllers inherit from Thread).
 
 - `Thread class`: This is the basic class, witch contains methods to set and run callbacks,
   check if the Thread should be runned, and also creates a unique ThreadID on the instantiation.
 
 - `ThreadController class`: Responsable for "holding" multiple Threads. Can also be called
   as "a group of Threads", and is used to perform run in every Thread ONLY when needed.
 
+- `StaticThreadController class`: Slighly faster and smaller version of `ThreadController`.
+  It works similar to `ThreadController`, but once constructed it can't add or remove threads to run.
+
 * The instantiation of a Thread class is very simple:
 
 ```c++
@@ -79,7 +82,8 @@ if(myThread.shouldRun()){
 
 Now that you got the idea, let's think a little bit: What if i have 3, 5, 100 Threads. Do I need to check EACH one?!?
 
-* The answer is: NO. Create a `ThreadController`, and put all your boring-complex Threads inside it!
+* The answer is: NO. Create a `ThreadController` or `StaticThreadController`,
+and put all your boring-complex Threads inside it!
 
 ```c++
 // Instantiate a new ThreadController
@@ -90,11 +94,18 @@ controller.add(&hisThread);
 controller.add(&sensorReadings);
 ...
 ```
+or
+```c++
+// Instantiate a new StaticThreadController with the number of threads to be supplied as template parameter
+StaticThreadController<3> controller (&myThread, &hisThread, &sensorReadings);
+// You don't need to do anything else, controller now contains all the threads.
+...
+```
 
 * You have created, configured, grouped it. What is missing? Yes, whe should RUN it!
 
 ```c++
-// call run on a Thread or a ThreadController to run it
+// call run on a Thread, a ThreadController or a StaticThreadController to run it
 controller.run();
 ```
 
@@ -126,6 +137,12 @@ or disable a GROUP of Threads, think about putting all of them inside a ThreadCo
 and adding this ThreadController to another ThreadController (YES! One ThreadController 
 inside another). Check `ControllerInController` example.
 
+* There is a `StaticThreadController` which is better to use when you know exact number of
+threads to run. You cannot add or remove threads in runtime, but `StaticThreadController`
+doesn't have additional memory overhead to keep all the treads together, doesn't have any
+limitations how many threads to store (except of available memory) and also the code may be slighly
+more optimized because all the threads always exist and no need to do any runtime checks.
+
 * Check the full example `CustomTimedThread` for a cool application of Threads that runs
 for a period, after a button is pressed.
 
@@ -177,5 +194,12 @@ interrupts(); // This will enable the interrupts egain. DO NOT FORGET!
   inside the ThreadController. If cached is `false`, will force the calculation of threads.
 - `Thread* ThreadController::get(int index)` - Returns the Thread on the position `index`.
 
+
+- `void StaticThreadController::run()` - This will run the all `Threads` within the `StaicThreadController`,
+  only if needed (if shouldRun returns true);
+- `int StaticThreadController::size()` - Returns how many Threads are allocated inside the StaticThreadController.
+- `Thread* ThreadController::get(int index)` - Returns the Thread on the position `index` and `nullptr` if `index`
+  is out of bounds.
+
 ### You don't need to know:
 - Nothing, yet ;)

StaticThreadController.h

@@ -0,0 +1,75 @@
+/*
+	StaticThreadController.h - Controlls a list of Threads with different timings
+
+	Basicaly, what it does is to keep track of current Threads and run when
+	necessary.
+
+	StaticThreadController is an extended class of Thread, because of that,
+	it allows you to add a StaticThreadController inside another kind of ThreadController...
+
+	It works exact as ThreadController except you can't add or remove treads dynamically.
+
+	Created by Alex Eremin, September, 2016.
+	Released into the public domain.
+*/
+
+#ifndef StaticThreadController_h
+#define StaticThreadController_h
+
+#include "Thread.h"
+
+template <int N>
+class StaticThreadController: public Thread{
+protected:
+        //since this is a static controller, the pointers themselves can be const
+	//it should be distinguished from 'const Thread* thread[N]'
+	Thread * const thread[N];
+public:
+	template <typename... T>
+        StaticThreadController(T... params) :
+		Thread(),
+		thread{params...}
+	{
+	#ifdef USE_THREAD_NAMES
+		// Overrides name
+		ThreadName = "StaticThreadController ";
+		ThreadName = ThreadName + ThreadID;
+	#endif
+	};
+
+	// run() Method is overrided
+	void run() override
+	{
+		// Run this thread before
+		if(_onRun != nullptr && shouldRun())
+			_onRun();
+
+		for(int i = 0; i < N; i++){
+			// Is enabled? Timeout exceeded?
+			if(thread[i]->shouldRun()){
+				thread[i]->run();
+			}
+		}
+
+		// StaticThreadController extends Thread, so we should flag as runned thread
+		runned();
+	}
+
+	// Return the quantity of Threads
+	static constexpr int size() { return N; };
+
+	// Return the I Thread on the array
+	// Returns nullptr if index is out of bounds
+	Thread* get(int index) {
+		return (index >= 0 && index < N) ? thread[index] : nullptr;
+	};
+
+	// Return the I Thread on the array
+	// Doesn't perform any bounds checks and behaviour is
+	// unpredictable in case of index > N
+	Thread& operator[](int index) {
+		return *thread[index];
+	};
+};
+
+#endif

examples/StaticThreadController/StaticThreadController.ino

@@ -0,0 +1,56 @@
+#include <Thread.h>
+#include <StaticThreadController.h>
+
+//My Thread (as a pointer)
+Thread* myThread = new Thread();
+//His Thread (not pointer)
+Thread hisThread = Thread();
+
+// callback for myThread
+void niceCallback(){
+	Serial.print("COOL! I'm running on: ");
+	Serial.println(millis());
+}
+
+// callback for hisThread
+void boringCallback(){
+	Serial.println("BORING...");
+}
+
+// callback for theThread
+void justCallback(){
+	Serial.println("executing...");
+}
+
+//The Thread (as a pointer) with justCallback initialized
+Thread* theThread = new Thread(justCallback);
+
+// StaticThreadController that will controll all threads
+// All non-pointers go with '&', but pointers go without '&', 
+StaticThreadController<3> controll (myThread, &hisThread, theThread);
+
+void setup(){
+	Serial.begin(9600);
+
+	// Configure myThread
+	myThread->onRun(niceCallback);
+	myThread->setInterval(500);
+
+	// Configure hisThread
+	hisThread.onRun(boringCallback);
+	hisThread.setInterval(250);
+
+	// Set interval for theThread using StaticThreadController interface
+	controll[3].setInterval(375);
+}
+
+void loop(){
+	// run StaticThreadController
+	// this will check every thread inside ThreadController,
+	// if it should run. If yes, he will run it;
+	controll.run();
+
+	// Rest of code
+	float h = 3.1415;
+	h/=2;
+}

keywords.txt

@@ -8,6 +8,7 @@
 
 Thread	KEYWORD1
 ThreadController	KEYWORD1
+StaticThreadController	KEYWORD1
 
 #######################################
 # Methods and Functions (KEYWORD2)
@@ -19,7 +20,7 @@ shouldRun	KEYWORD2
 onRun	KEYWORD2
 run	KEYWORD2
 
-# Specific of ThreadController
+# Specific of ThreadController or StaticThreadController
 add	KEYWORD2
 remove	KEYWORD2
 clear	KEYWORD2