process.h

#ifndef _ELMA_PROCESS_H
#define _ELMA_PROCESS_H

#include <string>
#include <chrono>
#include <functional>

#include "elma.h"

namespace elma {

    class Manager;
    class Channel;

    using std::string;
    using namespace std::chrono;


     class Process {

        public:

        friend class Manager;

        typedef enum { UNINITIALIZED, STOPPED, RUNNING } status_type;

        Process(int n = 0) : _name("unnamed process"), _status(UNINITIALIZED), _manager_ptr(NULL), _priority(n) {}


        Process(std::string name, int n = 0) : _name(name), _status(UNINITIALIZED), _manager_ptr(NULL), _priority(n) {}
        virtual ~Process() = default;

        // Interface for derived classes

        virtual void init() = 0;

        virtual void start() = 0;

        virtual void update() = 0;

        virtual void stop() = 0;

        // Inline methods that just replace method calls with their bodies

        inline string name() { return _name; }

        inline void set_name(std::string str) { _name = str; }        

        inline status_type status() { return _status; }

        inline high_resolution_clock::duration period() { return _period; }

        inline int num_updates() { return _num_updates; }

        inline time_point<high_resolution_clock> start_time() { return _start_time; }

        inline high_resolution_clock::duration last_update() { return _last_update; }

        inline high_resolution_clock::duration previous_update() { return _previous_update; }

        // documentation for these methods is in process.cc
        Channel& channel(string name);
        double milli_time();
        double delta();

        void watch(string event_name, std::function<void(Event&)> handler);
        void emit(const Event& event);

        void http_get(std::string url, std::function<void(json&)> handler);

        void halt();

        void set_manager(Manager * m_ptr);

        private:

        // Manager interface
        void _init();
        void _start(high_resolution_clock::duration elapsed);
        void _update(high_resolution_clock::duration elapsed);
        void _stop();

        // Instance variables
        string _name;
        status_type _status;
        high_resolution_clock::duration _period,          // request time between updates
                                        _previous_update, // duration from start to update before last
                                        _last_update;     // duration from start to last update
        time_point<high_resolution_clock> _start_time;    // time of most recent start
        int _num_updates, _priority;                      // number of times update() has been called

        protected:
        Manager * _manager_ptr;                           // a pointer to the manager

    };

}

#endif