lyrgb/exc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

visualization of bsort, manager now responsible for updates and time

Browse Source 
split timeractions from timers into seperate header
integrated the experiments into an improved displaynumbers, which
includes the vector as well as bars above them
outsourced the calculation of delta time to the manager to clean up main()
This commit is contained in:
my name
2026-07-17 00:04:28 +02:00
parent db8fc15560
commit 9dbc24efc1
5 changed files with 120 additions and 63 deletions
Download Patch File Download Diff File Expand all files Collapse all files
cpp/ui/ncurses/hw/hwcurses.cpp
+23 -12
View File
@@ -1,4 +1,5 @@
#include "timer.hpp"
#include "timeractions.hpp"
#include <chrono>
#include <clocale>
#include <cstdio>
@@ -24,16 +25,18 @@ void myupdatedisplay(const timer &timer_input) {
"test: █");
}
void createbalk(const timer &timer_input, cchar_t &input_char) {
int ticnt = timer_input.triggercounter;
mvwvline_set(stdscr, LINES - ticnt, ticnt, &input_char, ticnt);
}
std::vector<int> mynumbers = {1, 2, 3, 4, 5, 6, 7, 8, 9};
std::vector<int> myothernumbers = {1, 4, 9, 8, 6, 2, 3, 5, 7};
void displaynumbers(int myy, std::vector<int> &input_numbers) {
void displaynumbers(int startx, int starty, std::vector<int> &input_numbers, cchar_t &input_char) {
for (size_t i = 0; i < input_numbers.size(); i++) {
mvprintw(myy, 10 + i, "%d,", input_numbers[i]);
/**
I make a horizontal line of i chars, which are supposed to represent mynumbers
above that, I want a line of bars.
_all_ bars stretch from LINES-1 to LINES-1-numbervalue
**/
mvprintw(LINES -1 - starty, i + startx, "%d,", input_numbers[i]);
mvwvline_set(stdscr, LINES-1-input_numbers[i]-starty, i+startx, &input_char, input_numbers[i]);
}
}
@@ -53,20 +56,28 @@ void myinitialize() {
int main() {
myinitialize();
cchar_t my_c_char = {.attr= A_NORMAL, .chars={L'█'}, .ext_color = 0};
//create actions, then put them in timers, then put them into the timermanager
auto myaction = std::make_unique<swapaction>(mynumbers);
auto clocktimer = std::make_unique<timer>("secondsprinter", 1, 10, std::move(myaction));
auto clocktimer =
std::make_unique<timer>("secondsprinter", 1, 10, std::move(myaction));
auto myothersort = std::make_unique<sortaction>(myothernumbers);
auto sorttimer =
std::make_unique<timer>("sorttimer", 0.1, std::move(myothersort));
timermanager mytimermanager;
mytimermanager.addtimer(std::move(clocktimer));
displaynumbers(2, mynumbers);
// calculate delta between current and previous time
mytimermanager.addtimer(std::move(sorttimer));
while (true) {
erase();
mytimermanager.updatetimers();
displaynumbers(3, mynumbers);
displaynumbers(0,0,mynumbers, my_c_char);
displaynumbers(10, 10, myothernumbers, my_c_char);
refresh();
std::this_thread::sleep_for(std::chrono::milliseconds(500));
cpp/ui/ncurses/hw/timer.cpp
+12 -32
View File
@@ -11,14 +11,14 @@
// infinite timer
timer::timer(std::string name_input, size_t interval_input,
std::unique_ptr<timeraction> action_input)
: time_interval(interval_input), name(name_input), is_infinite(true),
action(std::move(action_input)) {}
: time_interval(interval_input), name(name_input), is_infinite(true),
action(std::move(action_input)) {}
// limited timer
timer::timer(std::string name, size_t interval_input, int triggeramount,
std::unique_ptr<timeraction> action_input)
: triggeramount(triggeramount), time_interval(interval_input), name(name),
action(std::move(action_input)) {}
: triggeramount(triggeramount), time_interval(interval_input), name(name),
action(std::move(action_input)) {}
// callbackfunc once enough time has accumulated
void timer::updatetime(double DeltaTime) {
@@ -40,14 +40,18 @@ void timermanager::addtimer(std::unique_ptr<timer> input_timer) {
}
void timermanager::updatetimers() {
//get dtime
auto currenttime = std::chrono::steady_clock::now();
std::chrono::duration<double> myDeltaTime = currenttime - prevtime;
double dtime = myDeltaTime.count();
//update timers with dtime
for (auto &mytimer : timers) {
auto currenttime = std::chrono::steady_clock::now();
std::chrono::duration<double> myDeltaTime = currenttime - prevtime;
double dtime = myDeltaTime.count();
mytimer->updatetime(dtime);
prevtime = currenttime;
mvprintw(12, 0, "updated timer %s", mytimer->name.c_str());
}
//reset for next tick
prevtime = currenttime;
timers.erase(std::remove_if(timers.begin(), timers.end(),
[](auto &timer) { return timer->is_expired; }),
timers.end());
@@ -56,28 +60,4 @@ void timermanager::updatetimers() {
}
timermanager::timermanager(): prevtime(std::chrono::steady_clock::now()){}
swapaction::swapaction(std::vector<int> &input_vector): input_vector(input_vector){}
void swapaction::update(const timer &input_timer){
if (!iscomplete) {
int temp = input_vector[it_i];
input_vector[it_i] = input_vector[input_vector.size() -1 - it_i];
input_vector[input_vector.size() - 1 - it_i] = temp;
it_i++;
if(it_i>=input_vector.size() / 2){iscomplete=true;}
}
}
printaction::printaction(std::vector<balkjes> &input_vector): input_vector(input_vector) {}
void printaction::update(const timer &input_timer) {
if(!iscomplete) {
// for each it_i add a balkje then eventually print it
if (it_i>=10) {
iscomplete=true;
}
}
}
cpp/ui/ncurses/hw/timer.hpp
-19
View File
@@ -62,25 +62,6 @@ public:
void updatetimers();
};
class swapaction : public timeraction {
public:
size_t it_i = 0;
bool iscomplete = false;
std::vector<int> &input_vector;
swapaction(std::vector<int> &input_vector);
void update(const timer &t);
};
class printaction : public timeraction {
public:
size_t it_i = 0;
bool iscomplete = false;
std::vector<balkjes> &input_vector;
printaction(std::vector<balkjes> &input_vector);
void update(const timer &t);
};
#endif
cpp/ui/ncurses/hw/timeractions.cpp
+53
View File
@@ -0,0 +1,53 @@
#include <vector>
#include "timer.hpp"
#include "timeractions.hpp"
#include <algorithm>
#include <chrono>
#include <cstddef>
#include <memory>
#include <ncurses.h>
#include <string>
#include <vector>
swapaction::swapaction(std::vector<int> &input_vector): input_vector(input_vector){}
void swapaction::update(const timer &input_timer){
if (!iscomplete) {
int temp = input_vector[it_i];
input_vector[it_i] = input_vector[input_vector.size() -1 - it_i];
input_vector[input_vector.size() - 1 - it_i] = temp;
it_i++;
if(it_i>=input_vector.size() / 2){iscomplete=true;}
}
}
sortaction::sortaction(std::vector<int> &input_vector): input_vector(input_vector) {}
//sorts the included array using bsort and external iterators rather than for loops
void sortaction::update(const timer &input_timer) {
if (!iscomplete) {
/**
we take a number, it_i loop
compare it with its neighbour, it_j loop
if it's larger swap it
keep going until it_i == length - sorted numbers
once that is true, reset it_j and advance it_i
**/
if (input_vector[it_j]>input_vector[it_j+1]) {
// int temp = input_vector[it_j + 1];
// input_vector[it_j + 1] = input_vector[it_j];
// input_vector[it_j] = temp;
std::swap(input_vector[it_j], input_vector[it_j+1]);
}
it_j++;
if (it_j >= input_vector.size() - 1 - it_i) {
it_j = 0;
it_i++;
}
if (it_i>=input_vector.size()) {
iscomplete=true;
}
}
}
cpp/ui/ncurses/hw/timeractions.hpp
+32
View File
@@ -0,0 +1,32 @@
#ifndef TIMERACTIONS_HPP
#define TIMERACTIONS_HPP
#include "timer.hpp"
#include <chrono>
#include <cstddef>
#include <functional>
#include <memory>
#include <ncurses.h>
#include <string>
#include <vector>
class swapaction : public timeraction {
public:
size_t it_i = 0;
bool iscomplete = false;
std::vector<int> &input_vector;
swapaction(std::vector<int> &input_vector);
void update(const timer &t);
};
class sortaction : public timeraction {
public:
size_t it_i = 0;
size_t it_j = 0;
bool iscomplete = false;
std::vector<int> &input_vector;
sortaction(std::vector<int> &input_vector);
void update(const timer &t);
};
#endif