Timer now contains an invoker instead of inheriting

the idea is that an invoker holds a weak_ptr to a steppable. and
anything with an invoker can advance a steppable

app::add_sort has become too heavy because of the way timer and
invoker are initialized now.

src/Invoker.hpp

@@ -0,0 +1,18 @@
+#ifndef INVOKER_HPP
+#define INVOKER_HPP
+
+#include "steppable.hpp"
+#include <memory>
+class Invoker {
+public:
+	std::weak_ptr<Steppable> target;
+
+	Invoker(std::shared_ptr<Steppable> t) { target = t;}
+	void request() {
+		if (auto sp = target.lock()) {
+			sp->step();
+		}
+	}
+};
+
+#endif

src/core/app.cpp

@@ -1,4 +1,5 @@
 #include <SFML/Graphics/Font.hpp>
+#include <chrono>
 #include <iostream>
 #include <memory>
 #include <thread>
@@ -25,22 +26,35 @@ string arraytostr(shared_ptr<SortInput> input) {
 	return stringrep.str();
 }
 
-App::App(unique_ptr<ViewSession> myviewsession)
-		: viewsession(std::move(myviewsession)) {}
+App::App(unique_ptr<ViewSession> myviewsession, unique_ptr<TimerManager> mytimermanager)
+		: viewsession(std::move(myviewsession)),
+			timermanager(std::move(mytimermanager)) {}
 
-//connects data with logic and invoker
-void App::setup_session(shared_ptr<SortInput> myinput, string sorttype) {
-	cout << "adding sort " << sorttype << "\n";
-	//push data to app
-	inputs.push_back(myinput);
-	//connect data to logic
+//connects data with the correct sort
+shared_ptr<Steppable> make_sort(std::shared_ptr<SortInput> input, std::string sorttype) {
 	if (sorttype == "bsort") {
-		sortsession.add_session(myinput, sorttype);
+		return make_shared<SteppedBsort>(input);
 	}
-	//connect logic to timer (should not be hardcoded to timers)
-	auto prs = sortsession.sortsessions.back().get();
-	timermanager.add_timer(
-			0, [prs]() { return prs->step(); }, std::chrono::milliseconds(250));
+	return nullptr;
+}
+
+//creates a Sortbinding, actually does too much
+void App::add_sort(shared_ptr<SortInput> myinput, string sorttype) {
+	cout << "adding sort " << sorttype << "\n";
+	//insert data
+	inputs.push_back(myinput);
+	//connect data with logic into a sort
+	std::shared_ptr<Steppable> mysorter = make_sort(myinput, sorttype);
+
+	//connect the sort with its invoker
+	unique_ptr<Invoker> myinvoker = make_unique<Invoker>(mysorter);
+
+	//move the sort into app
+	sortbindings.push_back(SortBinding{myinput, std::move(mysorter)});
+
+	//create the timer with the invoker and add it to app
+	Timer timer(0, std::move(myinvoker), chrono::milliseconds(250));
+	timermanager->add_timer(std::move(timer));
 }
 
 void App::run() {
@@ -51,7 +65,7 @@ void App::run() {
 				viewsession->mywindow.close();
 		}
 
-		//draw
+		// draw
 		viewsession->mywindow.clear(sf::Color::Black);
 		viewsession->mywindow.draw(viewsession->text);
 		viewsession->text.setString(arraytostr(inputs[0]));
@@ -61,8 +75,8 @@ void App::run() {
 		}
 		viewsession->mywindow.display();
 
-		//update logic
-		timermanager.update_timers();
+		// update logic
+		timermanager->update_timers();
 		this_thread::sleep_for(std::chrono::milliseconds(250));
 	}
 }

src/core/app.hpp

@@ -6,6 +6,7 @@
 #include <SFML/Graphics/RenderWindow.hpp>
 #include <SFML/Graphics/Text.hpp>
 #include <memory>
+#include <vector>
 
 #include "../timer.hpp"
 #include "../sorters.hpp"
@@ -15,13 +16,13 @@
 //for now data, mutation, and rendering
 struct App{
 	std::vector<std::shared_ptr<SortInput>> inputs;
-	SortSession sortsession;
+	std::vector<SortBinding> sortbindings;
 	std::unique_ptr<ViewSession> viewsession;
-	TimerManager timermanager;
+	std::unique_ptr<TimerManager> timermanager;
 
-	App(std::unique_ptr<ViewSession> myviewsession);
+	App(std::unique_ptr<ViewSession> myviewsession, std::unique_ptr<TimerManager> mytimermanager);
 
-	void setup_session(std::shared_ptr<SortInput> myinput, std::string sorttype);
+	void add_sort(std::shared_ptr<SortInput> myinput, std::string sorttype);
 	void run();
 };
 

src/sessions.hpp

@@ -9,19 +9,6 @@
 #include "sorters.hpp"
 
 //owns and manages the sorters that mutate data, but does not own the data itself
-struct SortSession {
-	std::vector<std::unique_ptr<Steppable>> sortsessions;
-
-	SortSession(){
-	}
-
-	//connects data with a sorter and controls it through a timer
-	void add_session(std::shared_ptr<SortInput> input, std::string sorttype){
-		if(sorttype == "bsort"){
-			sortsessions.push_back(make_unique<SteppedBsort>(input));
-		};
-	}
-};
 
 //sfml/render
 struct ViewSession{

src/sorters.cpp

@@ -1,4 +1,5 @@
 #include <cstdio>
+#include <iostream>
 #include <memory>
 #include <utility>
 #include "sorters.hpp"
@@ -7,10 +8,10 @@ using namespace std;
 
 SteppedBsort::SteppedBsort(shared_ptr<SortInput> input): data(input) {};
 
-bool SteppedBsort:: step(){
-	if(is_finished==true) {
+void SteppedBsort:: step(){
+	cout << "step in SteppedBsort\n";
+	if(is_finished) {
 		printf("finished");
-		return true;
 			}
 	if(data->values[j]>data->values[j+1])
 		{
@@ -25,6 +26,4 @@ bool SteppedBsort:: step(){
 	if (i==data->values.size()-1){
 		is_finished=true;
 	}
-
-	return false;
 }

src/sorters.hpp

@@ -6,6 +6,7 @@
 #include <string>
 #include <vector>
 
+#include "Invoker.hpp"
 #include "steppable.hpp"
 
 //ground truth domain data
@@ -37,7 +38,13 @@ public:
 
 	SteppedBsort(std::shared_ptr<SortInput> data);
 
-	bool step();
+	void step();
 };
 
+struct SortBinding {
+	std::shared_ptr<SortInput> input;
+	std::shared_ptr<Steppable> sort;
+	//SortBinding(std::shared_ptr<SortInput> input, std::unique_ptr<Steppable> sort, std::unique_ptr<Invoker> invoker);
+	
+};
 #endif

src/sortui.cpp

@@ -14,6 +14,7 @@
 #include "core/app.hpp"
 #include "sessions.hpp"
 #include "sorters.hpp"
+#include "timer.hpp"
 
 using namespace std::chrono;
 using namespace std;
@@ -28,11 +29,14 @@ int main() {
 	auto myinput2 = make_shared<SortInput>("arr2", dataprovider());
 
 	auto myviewsession = make_unique<ViewSession>();
+	auto mytimermanager = make_unique<TimerManager>();
 
 	//create app with initialized dependencies
-	App myapp(std::move(myviewsession));
+	App myapp(std::move(myviewsession),std::move(mytimermanager));
+
 	//add and connect data
-	myapp.setup_session(myinput, "bsort");
+	myapp.add_sort(myinput, "bsort");
+
 	//actually start the app
 	myapp.run();
 }

src/steppable.hpp

@@ -8,7 +8,7 @@ public:
 	virtual ~Steppable() = default;
 	bool is_finished = 0;
 	size_t stepcount = 0;
-	virtual bool step() = 0;
+	virtual void step() = 0;
 };
 
 #endif

src/timer.cpp

@@ -1,33 +1,34 @@
 #include <chrono>
-#include <functional>
-#include <utility>
+#include <iostream>
+#include <memory>
 
 #include "timer.hpp"
+#include "Invoker.hpp"
 
 using namespace std::chrono;
 using namespace std;
 
-Timer::Timer(size_t triggeramount, function<bool()> myaction, milliseconds triggerinterval)
+Timer::Timer(size_t triggeramount, std::unique_ptr<Invoker> invoker, milliseconds triggerinterval)
 	:triggeramount(triggeramount)
-	, callback(myaction)
-	, triggerinterval(triggerinterval) {}
+	 , invoker(std::move(invoker))
+	 , triggerinterval(triggerinterval){}
 
 void Timer::add_time(milliseconds deltatime) {
 	accumulator += deltatime;
 	if (accumulator >= triggerinterval) {
 		accumulator -= triggerinterval;
-		callback();
+		cout << "request in timer\n";
+		invoker->request();
 		triggercount++;
-		if (!isinfinite && triggercount >= triggeramount){
+		if (triggeramount != 0 && triggercount >= triggeramount){
 			isexpired=true;
 		}
 	}
-};
+}
 
-void TimerManager::add_timer(size_t triggeramount, function<bool()> myaction, std::chrono::milliseconds triggerinterval) {
-	Timer mynewtimer(triggeramount, myaction, triggerinterval);
-	timers.push_back(std::move(mynewtimer));
-};
+void TimerManager::add_timer(Timer timer){
+	timers.push_back(std::move(timer));
+}
 
 void TimerManager::update_timers() {
 	steady_clock::time_point currenttime =

src/timer.hpp

@@ -3,22 +3,20 @@
 
 #include <cstddef>
 #include <ctime>
-#include <functional>
 #include <chrono>
+#include <memory>
 #include <vector>
 
+#include "Invoker.hpp"
 //check if the timer is still valid, check if enough time has passed and if so, actuate action
 class Timer {
 public:
 	size_t triggeramount;
 	bool isexpired = false;
-	bool isinfinite = false;
 	size_t triggercount = 0;
+	std::unique_ptr<Invoker> invoker;
 
-	std::function<bool()> callback;
-
-	Timer(size_t triggeramount, std::function<bool()> myaction, std::chrono::milliseconds triggerinterval);
-
+	Timer(size_t triggeramount, std::unique_ptr<Invoker> invoker, std::chrono::milliseconds triggerinterval);
 	void add_time(std::chrono::milliseconds deltatime);
 
 private:
@@ -32,7 +30,8 @@ class TimerManager {
 public:
 	std::vector<Timer> timers;
 	TimerManager(){previoustime = std::chrono::steady_clock::now();}
-	void add_timer(size_t triggeramount, std::function<bool()> myaction, std::chrono::milliseconds triggerinterval);
+	//void add_timer(size_t triggeramount, std::function<bool()> myaction, std::chrono::milliseconds triggerinterval);
+	void add_timer(Timer timer);
 	void delete_timer();
 	void update_timers();