cleanup, timermanager in App is a dependency that takes timers again.

App now adds already constructed Timers
Timer is now an Invoker that takes a weak_ptr to a steppable with a
request()rather than a bool callback.
should eventually be changed to composition

src/Invoker.hpp

@@ -0,0 +1,19 @@
+#ifndef INVOKER_HPP
+#define INVOKER_HPP
+
+#include "steppable.hpp"
+#include <memory>
+class Invoker {
+public:
+  virtual ~Invoker() = default;
+  std::weak_ptr<Steppable> target;
+
+  void set_target(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,26 @@ string arraytostr(shared_ptr<SortInput> input) {
 	return stringrep.str();
 }
 
-App::App(unique_ptr<ViewSession> myviewsession)
+App::App(unique_ptr<ViewSession> myviewsession, unique_ptr<TimerManager> mytimermanager)
-		: viewsession(std::move(myviewsession)) {}
+		: viewsession(std::move(myviewsession)),
+			timermanager(std::move(mytimermanager)) {}
 
-//connects data with logic and invoker
+//connects data with the correct sort
-void App::setup_session(shared_ptr<SortInput> myinput, string sorttype) {
+shared_ptr<Steppable> make_sort(std::shared_ptr<SortInput> input, std::string sorttype) {
-	cout << "adding sort " << sorttype << "\n";
-	//push data to app
-	inputs.push_back(myinput);
-	//connect data to logic
 	if (sorttype == "bsort") {
-		sortsession.add_session(myinput, sorttype);
+		return make_shared<SteppedBsort>(input);
 	}
-	//connect logic to timer (should not be hardcoded to timers)
+	return nullptr;
-	auto prs = sortsession.sortsessions.back().get();
+}
-	timermanager.add_timer(
+
-			0, [prs]() { return prs->step(); }, std::chrono::milliseconds(250));
+//creates a Sortbinding, actually does too much
+void App::add_sort(shared_ptr<SortInput> myinput, string sorttype, Invoker &invoker) {
+	cout << "adding sort " << sorttype << "\n";
+	inputs.push_back(myinput);
+	std::shared_ptr<Steppable> mysorter = make_sort(myinput, sorttype);
+
+	sortbindings.push_back(SortBinding{myinput, std::move(mysorter)});
+	invoker.set_target(sortbindings.back().sort);
 }
 
 void App::run() {
@@ -62,7 +67,7 @@ void App::run() {
 		viewsession->mywindow.display();
 
 		// update logic
-		timermanager.update_timers();
+		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, Invoker& invoker);
 	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(){
+void SteppedBsort:: step(){
-	if(is_finished==true) {
+	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

@@ -38,13 +38,14 @@ public:
 
 	SteppedBsort(std::shared_ptr<SortInput> data);
 
-	bool step();
+	void step();
 };
 
 struct SortBinding {
 	std::shared_ptr<SortInput> input;
-	std::unique_ptr<Steppable> sort;
+	std::shared_ptr<Steppable> sort;
-	std::unique_ptr<Invoker> invoker;
-};
 
+	//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,16 @@ 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");
+	Timer timer(0, chrono::milliseconds(250));
+	myapp.timermanager->timers.push_back(timer);
+	myapp.add_sort(myinput, "bsort", myapp.timermanager->timers.back());
+
 	//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,37 +1,31 @@
 #include <chrono>
-#include <functional>
+#include <iostream>
-#include <utility>
 
 #include "timer.hpp"
 
 using namespace std::chrono;
 using namespace std;
 
-Timer::Timer(size_t triggeramount, function<bool()> myaction, milliseconds triggerinterval)
+Timer::Timer(size_t triggeramount, milliseconds triggerinterval)
 	:triggeramount(triggeramount)
-	, callback(myaction)
 	, triggerinterval(triggerinterval) {}
 
 void Timer::add_time(milliseconds deltatime) {
 	accumulator += deltatime;
 	if (accumulator >= triggerinterval) {
 		accumulator -= triggerinterval;
+		cout << "request in timer\n";
 		request();
 		triggercount++;
-		if (!isinfinite && triggercount >= triggeramount){
+		if (triggeramount != 0 && triggercount >= triggeramount){
 			isexpired=true;
 		}
 	}
-};
-
-void Timer::request() {
-		callback();	
 }
 
-void TimerManager::add_timer(size_t triggeramount, function<bool()> myaction, std::chrono::milliseconds triggerinterval) {
+void TimerManager::add_timer(Timer timer){
-	Timer mynewtimer(triggeramount, myaction, triggerinterval);
+	timers.push_back(timer);
-	timers.push_back(std::move(mynewtimer));
+}
-};
 
 void TimerManager::update_timers() {
 	steady_clock::time_point currenttime =

src/timer.hpp

@@ -3,7 +3,6 @@
 
 #include <cstddef>
 #include <ctime>
-#include <functional>
 #include <chrono>
 #include <vector>
 
@@ -13,17 +12,11 @@ class Timer: public Invoker {
 public:
 	size_t triggeramount;
 	bool isexpired = false;
-	bool isinfinite = false;
 	size_t triggercount = 0;
 
-	std::function<bool()> callback;
+	Timer(size_t triggeramount, std::chrono::milliseconds triggerinterval);
-
-	Timer(size_t triggeramount, std::function<bool()> myaction, std::chrono::milliseconds triggerinterval);
-	
 	void add_time(std::chrono::milliseconds deltatime);
 
-	void request();
-
 private:
 	std::chrono::milliseconds accumulator = std::chrono::milliseconds(0);
 	std::chrono::milliseconds triggerinterval = std::chrono::milliseconds(1000); //default to 1 sec
@@ -35,7 +28,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();