manager.cc

#include <stdexcept>
#include <iostream>
#include <algorithm>
#include <mutex>
#include "elma.h"

namespace elma {

    Manager& Manager::schedule(
        Process& process, 
        high_resolution_clock::duration period) {

        process._period = period;
        _processes.push_back(&process); 
        process._manager_ptr = this;            

        if (Priority_min > process._priority || process._priority > Priority_max ){
            throw Exception("Priority must be between -5(low priority) and 15(high priority)");
        }    

        return *this;

    }

    Manager& Manager::remove(Process& process) {
        process.stop();
        auto i = remove_if(_processes.begin(), _processes.end(), [&](Process * p) {
            return p == &process; 
        });
        _processes.erase(i, _processes.end());
        return *this;
    }

    Manager& Manager::add_channel(Channel& channel) {
        _channels[channel.name()] = &channel;
        return *this;
    }

    Channel& Manager::channel(string name) {
        if ( _channels.find(name) != _channels.end() ) {
          return *(_channels[name]);
        } else {
            throw Exception("Tried to access an unregistered or non-existant channel.");
        }
    }    

    Manager& Manager::watch(std::string event_name, std::function<void(Event&)> handler) {
        event_handlers[event_name].push_back(handler);
        return *this;
    }

    Manager& Manager::emit(const Event& event) {
        Event e = event; // make a copy so we can change propagation
        if ( event_handlers.find(event.name()) != event_handlers.end() ) {
            for ( auto handler : event_handlers[event.name()] ) {
                if ( e.propagate() ) {
                  handler(e);
                }
            }
        }
        return *this;
    }

    Manager& Manager::all(std::function< void(Process&) > f) {
        for(auto process_ptr : _processes) {
            f(*process_ptr);
        }
        return *this;
    }

    Manager& Manager::init() {
        sort_processes();  
        return all([](Process& p) { p._init();});
    }

    Manager& Manager::start() {
        _running = true;
        return all([this](Process& p) { p._start(_elapsed) ;});
    }    

    Manager& Manager::stop() {
        _running  = false;
        return all([](Process& p) { p._stop(); });
    }    

    Manager& Manager::update() {
        _update_mutex.lock();
        _client.process_responses();
        all([this](Process& p) {
            if ( _elapsed >= p.last_update() + p.period() ) {
                p._update(_elapsed);
            }
        });
        _update_mutex.unlock();
        return *this;
    }

    Manager& Manager::sort_processes() {

        std::sort(_processes.begin(), _processes.end(),[](const Process * lhs, const Process * rhs){
            return lhs->_priority > rhs->_priority;
        });  

        return *this;
    }

    Manager& Manager::use_simulated_time() { 
        _simulated_time = true; 
        return *this;
    };

    Manager& Manager::use_real_time() { 
        _simulated_time = false; 
        return *this;
    };
    
    Manager& Manager::set_priority(Process& process, int priority) {

        if (Priority_min <= priority && priority <= Priority_max  ){
            process._priority = priority;
            sort_processes();
        } else {
            throw Exception("Priority must be between -5(low priority) and 15(high priority)");
        }    
        return *this;
    }

    Manager& Manager::run(high_resolution_clock::duration runtime) {

        return run([&]() { return _elapsed < runtime; });

    }

    Manager& Manager::run() {

        return run([&]() { return _running; });

    }  

    Manager& Manager::run(std::function<bool()> condition)  {

        _start_time = high_resolution_clock::now();
        _elapsed = high_resolution_clock::duration::zero();
        start();        

        while ( condition() ) {
            update();
            std::this_thread::sleep_for(_nice_sleep_amount);
            update_elapsed_time();
        }

        stop();

        return *this;

    }

    void Manager::update_elapsed_time() {

        // Only run in simulated time if we have the flag set and have processes.
        if(_simulated_time && !_processes.empty()) {

            // Find the process that has the smallest time till next update.
            auto min_iter = std::min_element(_processes.begin(), _processes.end() ,[](Process * lhs, Process * rhs) {
                auto lhsTime = lhs->last_update() + lhs->period();
                auto rhsTime = rhs->last_update() + rhs->period();
                return lhsTime < rhsTime;
            });

            Process* nextup = *min_iter;

            auto newTime = nextup->last_update() + nextup->period();

            _elapsed = newTime;

        } else {

            _elapsed = high_resolution_clock::now() - _start_time;

        }
    }

}