EngineConfig.h

#ifndef ENGINECONFIG_H_
#define ENGINECONFIG_H_

// Tools
#include "tools/ToolsConfig.h"
#include "tools/FUX.h"

class EngineConfig
{
public:
    EngineConfig()
    {
        write_period = 30.0;
        buffer_reserve = 3;
        max_repeat_count = 100;
        ignored_future = 60.0;
        get_threshold = 20.0;
        file_size_limit = 100*1024*1024; // 100MB Default
        disconnect_on_disable = false;

        chunk_period = write_period;
    }
    
    double getWritePeriod() const       { return write_period; }

    size_t getBufferReserve() const     { return buffer_reserve; }
    
    size_t getSuggestedBufferSpace(double scan_period) const
    {
        if (scan_period <= 0)
            return 1;
        size_t num = (size_t)(write_period * buffer_reserve / scan_period);
        if (num < 3)
            return 3;
        return num;
    }
    
    size_t getMaxRepeatCount() const    { return max_repeat_count; }
    
    double getIgnoredFutureSecs() const { return ignored_future; }

    double getGetThreshold() const      { return get_threshold; }

    size_t getFileSizeLimit() const     { return file_size_limit; }
    
    bool getDisconnectOnDisable() const { return disconnect_on_disable; }

    double getChunkPeriod() const       { return chunk_period; }
    
    void addToFUX(class FUX::Element *doc);
    
protected:
    double write_period;
    size_t buffer_reserve;
    size_t max_repeat_count;
    double ignored_future;
    double get_threshold;
    size_t file_size_limit;
    bool   disconnect_on_disable;

    double chunk_period;
    
};

class WritableEngineConfig : public EngineConfig
{
public:    
    void setWritePeriod(double secs)    { write_period = secs; }

    void setBufferReserve(size_t times) { buffer_reserve = times; }

    void setMaxRepeatCount(size_t count) { max_repeat_count = count; }

    void setIgnoredFutureSecs(double secs) { ignored_future = secs; }

    void setGetThreshold(double secs) { get_threshold = secs; }
    
    void setFileSizeLimit(size_t bytes) { file_size_limit = bytes; }
    
    void setDisconnectOnDisable(bool yes_no) { disconnect_on_disable = yes_no;}

    void setChunkPeriod(double secs)    { chunk_period = secs; }

};

class EngineConfigListener {

 public:
  
    virtual ~EngineConfigListener();
    
    virtual void addChannel(const stdString &group_name,
                            const stdString &channel_name,
                            double scan_period,
                            bool disabling, bool monitor) = 0;
};

class EngineConfigParser : public WritableEngineConfig
{
public:
    EngineConfigParser();
    
     void read(const char *filename, EngineConfigListener *listener);

private:
    EngineConfigListener *listener;
    void handle_group(FUX::Element *group);
    void handle_channel(const stdString &group_name,
                        FUX::Element *channel);
};

#endif /*ENGINECONFIG_H_*/