Engine.h

#ifndef __ENGINE_H_
#define __ENGINE_H_

// tools
#include "tools/Guard.h"

// engine
#include "engine/EngineConfig.h"
#include "engine/ScanList.h"
#include "engine/ProcessVariableContext.h"

#include "engine/GroupInfo.h"
#include "engine/ArchiveChannel.h"
#include "engine/ArchiveChannelStateListener.h"

class Engine : public Guardable, public EngineConfigListener {

 public:

  static const double MAX_DELAY; 
    
    Engine(const std::string& index_name);
    
    virtual ~Engine();

 public:

    // Guardable API
    
    virtual OrderedMutex& getMutex();

 public:

    // EngineConfigListener API

    virtual void addChannel(const std::string& group_name,
                            const std::string& channel_name,
                            double scan_period,
                            bool disabling, 
                            bool monitor) = 0;

 public:

    virtual void read_config(Guard& guard, const std::string& file_name) = 0;
                               
    virtual unsigned long write(Guard& guard) = 0;

 public:

    inline const std::string& getIndexName(Guard& guard) const;

    inline void setDescription(Guard& guard, const std::string& description);
    
    inline const std::string& getDescription(Guard& guard) const;
    
    inline const epicsTime& getStartTime(Guard& guard) const;

    inline const epicsTime& getNextWriteTime(Guard& guard) const;

    inline void attachToProcessVariableContext(Guard& guard);
      
    inline double getWriteDuration(Guard& guard) const;
    
    inline size_t  getWriteCount(Guard& guard) const;
  
    inline double getProcessDelayAvg(Guard& guard) const;

 public:
    
    inline const EngineConfig& getConfig(Guard& guard) const;

    inline WritableEngineConfig& getWritableConfig(Guard& guard);

    virtual void write_config(Guard& guard);

 public:

    GroupInfo* addGroup(Guard& guard, const std::string& group_name); 

    inline const stdList<GroupInfo *>& getGroups(Guard& guard) const;

    GroupInfo* findGroup(Guard& engine_guard, const std::string& name); 
   
    inline const stdList<ArchiveChannel *>& getChannels(Guard& guard) const;

    ArchiveChannel* findChannel(Guard& engine_guard, const std::string &name); 

    size_t getNumConnected(Guard& guard) const;

public:

    void start(Guard& guard);

    inline  bool isRunning(Guard& guard) const;     

    bool process(); 

    void stop(Guard& guard);

 protected:

    OrderedMutex              mutex;

    bool                      is_running;
    epicsTime                 start_time;
    stdString                 index_name;
    stdString                 description;
    EngineConfigParser        config;
    ScanList                  scan_list;

    ProcessVariableContext    pv_context;

    stdList<GroupInfo *>      groups;   // scan-groups of channels
    stdList<ArchiveChannel *> channels; // all the channels

    double                    write_duration;   // Updated by process()
    size_t                    write_count;      // process()
    double                    process_delay_avg;// process()
    epicsTime                 next_write_time;  // process()
};



inline const std::string& 
Engine::getIndexName(Guard& guard) const { 
  return index_name; 
}

inline void 
Engine::setDescription(Guard& guard, const std::string& description){
  this->description = description;
}

inline const std::string& 
Engine::getDescription(Guard& guard) const { 
  return description; 
}

inline const epicsTime& 
Engine::getStartTime(Guard& guard) const { 
  return start_time; 
}

inline const epicsTime& 
Engine::getNextWriteTime(Guard& guard) const { 
  return next_write_time; 
}

inline void 
Engine::attachToProcessVariableContext(Guard& guard) { 
  Guard ctx_guard(__FILE__, __LINE__, pv_context);
  pv_context.attach(ctx_guard);
}

   
inline double 
Engine::getWriteDuration(Guard& guard) const { 
  return write_duration; 
}

inline size_t  
Engine::getWriteCount(Guard& guard) const { 
  return write_count; 
}

inline double  
Engine::getProcessDelayAvg(Guard& guard) const { 
  return process_delay_avg;
}

    
inline const EngineConfig& 
Engine::getConfig(Guard& guard) const { 
  return config; 
}
   
inline WritableEngineConfig& 
Engine::getWritableConfig(Guard& guard) { 
  return config; 
}

// 

inline const stdList<GroupInfo *>& 
Engine::getGroups(Guard& guard) const { 
  return groups; 
}

inline const stdList<ArchiveChannel *>& 
Engine::getChannels(Guard& guard) const { 
  return channels; 
}


//

inline bool Engine::isRunning(Guard& guard) const {
  return is_running;
}

#endif /* ENGINE_H_*/