process.cc

#include <stdexcept>
#include "elma.h"

namespace elma {


    Channel& Process::channel(string name) {
        if ( _manager_ptr == NULL ) {
            throw Exception("Cannot access channels in a process before the process is scheduled.");
        } else {
            return _manager_ptr->channel(name);
        }
    }

    void Process::watch(string event_name, std::function<void(Event&)> handler) {
        if ( _manager_ptr == NULL ) {
            throw Exception("Cannot access events in a process before the process is scheduled.");
        } else {        
            _manager_ptr->watch(event_name, handler);
        }
    }

    void Process::emit(const Event& event) {
        if ( _manager_ptr == NULL ) {
            throw Exception("Cannot access events in a process before the process is scheduled.");
        } else {        
            _manager_ptr->emit(event);
        }
    }

    void Process::http_get(std::string url, std::function<void(json&)> handler) {
        _manager_ptr->client().get(url,handler);
    }


    double Process::milli_time() {
        duration<double, std::milli> time = last_update();
        return time.count();
    }


    double Process::delta() { 
        duration<double, std::milli> diff = last_update() - previous_update();
        return diff.count();
    }

    // Manager interface for the _init method. Do not call directly. 
    void Process::_init() { 
        _status = STOPPED;     
        init();
    }
    // Manager interface for the _start method. Do not call directly. 
    void Process::_start(high_resolution_clock::duration elapsed) { 
        _status = RUNNING; 
        _start_time = high_resolution_clock::now();
        _last_update = elapsed;
        _num_updates = 0;
        start();
    }

    // Manager interface for the _update method. Do not call directly. 
    void Process::_update(high_resolution_clock::duration elapsed) {
        _previous_update = _last_update;
        _last_update = elapsed;
        update();
        _num_updates++;
    }

    // Manager interface for the _stop method. Do not call directly. 
    void Process::_stop() { 
        _status = STOPPED; 
        stop();
    }       

    void Process::halt() { _manager_ptr->stop(); }  

    void Process::set_manager(Manager * m_ptr) {
        if ( _manager_ptr == NULL ) {
            _manager_ptr = m_ptr;
        } else {
            throw Exception("A process cannot have two managers");
        }
    }           

}