BaseController.h

Go to the documentation of this file.

 
#ifndef   _GAMS_BASE_CONTROLLER_H_
#define   _GAMS_BASE_CONTROLLER_H_
 
#include "ControllerSettings.h"
 
#include "gams/GamsExport.h"
#include "gams/variables/Agent.h"
#include "gams/variables/Swarm.h"
#include "gams/variables/Self.h"
#include "gams/variables/Sensor.h"
#include "gams/variables/AlgorithmStatus.h"
#include "gams/variables/PlatformStatus.h"
#include "gams/algorithms/BaseAlgorithm.h"
#include "gams/platforms/BasePlatform.h"
#include "gams/algorithms/AlgorithmFactory.h"
#include "gams/platforms/PlatformFactory.h"
#include "gams/groups/GroupBase.h"
 
#include "madara/knowledge/containers/String.h"
#include "madara/knowledge/containers/Vector.h"
 
#ifdef _GAMS_JAVA_
#include <jni.h>
#endif
 
namespace gams
{
  namespace controllers
  {
    class GAMS_EXPORT BaseController
    {
    public:
      BaseController(madara::knowledge::KnowledgeBase & knowledge,
        const ControllerSettings & settings = ControllerSettings());
 
      virtual ~BaseController();
 
      virtual int monitor(void);
 
      virtual int system_analyze(void);
 
      virtual int analyze(void);
 
      virtual int plan(void);
 
      virtual int execute(void);
 
      int run_once(void);
 
      int run(double loop_period,
        double max_runtime = -1,
        double send_period = -1.0);
      
      inline int run_hz(double loop_hz = 0.0,
        double max_runtime = -1,
        double send_hz = -1.0)
      {
        double loop_rate, send_rate;
 
        // check for bad data
        if(loop_hz <= 0.0)
          loop_rate = 0.0;
        // otherwise, set rate to 1s divided by the intended hz
        else
          loop_rate = 1.0 / loop_hz;
 
        // copy from loop hz if send hz is non-positive
        if(send_hz <= 0)
          send_rate = loop_rate;
        // otherwise, set rate to 1s divided by the intended hz
        else
          send_rate = 1.0 / send_hz;
 
        return run(loop_rate, max_runtime, send_rate);
      }
 
      int run(void);
 
      void init_accent(const std::string & algorithm,
        const madara::knowledge::KnowledgeMap & args =
          madara::knowledge::KnowledgeMap());
 
      void clear_accents(void);
 
      void add_platform_factory(
        const std::vector <std::string> & aliases,
        platforms::PlatformFactory * factory);
      
      void add_algorithm_factory(
        const std::vector <std::string> & aliases,
        algorithms::AlgorithmFactory * factory);
 
      void init_algorithm(const std::string & algorithm,
        const madara::knowledge::KnowledgeMap & args = madara::knowledge::KnowledgeMap());
 
      void init_algorithm(algorithms::BaseAlgorithm * algorithm);
 
      void init_platform(const std::string & platform,
        const madara::knowledge::KnowledgeMap & args =
          madara::knowledge::KnowledgeMap());
       
      void init_platform(platforms::BasePlatform * platform);
      
      void configure(const ControllerSettings & settings);
 
#ifdef _GAMS_JAVA_
      void init_algorithm(jobject algorithm);
      
      void init_platform(jobject platform);
#endif
 
      void init_vars(const madara::knowledge::KnowledgeRecord::Integer & id = 0,
        const madara::knowledge::KnowledgeRecord::Integer & agents = -1);
 
      void init_vars(const std::string & self_prefix,
        const std::string & group_name = "");
 
      void init_vars(const std::string & self_prefix,
        const groups::GroupBase * group);
 
      void init_vars(platforms::BasePlatform & platform);
      
      void init_vars(algorithms::BaseAlgorithm & algorithm);
 
      algorithms::BaseAlgorithm * get_algorithm(void);
      
      platforms::BasePlatform * get_platform(void);
 
      variables::Sensors * get_sensors(void);
      
      madara::knowledge::KnowledgeBase * get_kb(void);
      
      variables::Self * get_self(void);
 
      void save_checkpoint(void);
 
    protected:
 
      algorithms::Algorithms accents_;
 
      algorithms::BaseAlgorithm * algorithm_;
 
      variables::Algorithms algorithms_;
      
      variables::Agents agents_;
 
      madara::knowledge::KnowledgeBase & knowledge_;
 
      platforms::BasePlatform * platform_;
 
      variables::Platforms platforms_;
 
      variables::Self self_;
 
      variables::Sensors sensors_;
 
      variables::Swarm swarm_;
 
      ControllerSettings settings_;
 
      int checkpoint_count_;
    private:
 
      int run_once_(void);
    };
  }
}
 
#endif // _GAMS_BASE_CONTROLLER_H_