HiveController.h

Go to the documentation of this file.

 
#pragma once
 
#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/controllers/BaseController.h"
#include "madara/transport/SharedMemoryPush.h"
 
#include "madara/knowledge/containers/String.h"
#include "madara/knowledge/containers/Vector.h"
#include "madara/knowledge/Hive.h"
 
#ifdef _GAMS_JAVA_
#include <jni.h>
#endif
 
namespace gams
{
  namespace controllers
  {
    class GAMS_EXPORT HiveController
    {
    public:
      HiveController();
 
      HiveController(
        madara::knowledge::Hive & hive,
        size_t init_id = 0, size_t num_controllers = 1,
        const ControllerSettings & settings = ControllerSettings());
 
      virtual ~HiveController();
 
      void add_algorithm_factory(
        const std::vector <std::string> & aliases,
        algorithms::AlgorithmFactory * factory);
 
      void add_platform_factory(
        const std::vector <std::string> & aliases,
        platforms::PlatformFactory * factory);
      
      void add_transports(
        const madara::transport::QoSTransportSettings & source_settings);
 
      void clear_knowledge(void);
 
      void evaluate(const std::string & logic,
        const madara::knowledge::EvalSettings & settings =
          madara::knowledge::EvalSettings::DELAY);
 
      void evaluate(size_t controller_index, const std::string & logic,
        const madara::knowledge::EvalSettings & settings =
          madara::knowledge::EvalSettings::DELAY);
 
      void init_accent(
        const std::string & algorithm,
        const madara::knowledge::KnowledgeMap & args = madara::knowledge::KnowledgeMap());
 
      void init_accent(size_t controller_index,
        const std::string & algorithm,
        const madara::knowledge::KnowledgeMap & args = madara::knowledge::KnowledgeMap());
 
      void init_algorithm(
        const std::string & algorithm,
        const madara::knowledge::KnowledgeMap & args = madara::knowledge::KnowledgeMap());
 
      void init_algorithm(size_t controller_index,
        const std::string & algorithm,
        const madara::knowledge::KnowledgeMap & args = madara::knowledge::KnowledgeMap());
 
      void init_algorithm(size_t controller_index,
        algorithms::BaseAlgorithm * algorithm);
 
      void init_platform(
        const std::string & platform,
        const madara::knowledge::KnowledgeMap & args =
          madara::knowledge::KnowledgeMap());
       
      void init_platform(size_t controller_index,
        const std::string & platform,
        const madara::knowledge::KnowledgeMap & args =
          madara::knowledge::KnowledgeMap());
       
      void init_platform(size_t controller_index,
        platforms::BasePlatform * platform);
           
#ifdef _GAMS_JAVA_
      void init_algorithm(size_t controller_index, jobject algorithm);
      
      void init_platform(size_t controller_index, jobject platform);
#endif
 
      void init_vars(const madara::knowledge::KnowledgeRecord::Integer & id = 0,
        const madara::knowledge::KnowledgeRecord::Integer & processes = -1);
      
      void refresh_vars(bool init_non_self_vars = false);
      
      void init_vars(size_t controller_index,
        platforms::BasePlatform & platform);
      
      void init_vars(size_t controller_index,
        algorithms::BaseAlgorithm & algorithm);
 
      algorithms::BaseAlgorithm * get_algorithm(size_t controller_index = 0);
      
      platforms::BasePlatform * get_platform(size_t controller_index = 0);
 
      size_t get_num_controllers(void);
 
      madara::knowledge::KnowledgeBase get_kb(size_t controller_index);
 
      void clear_accents(size_t controller_index = 0);
 
      void resize(size_t init_id, size_t num_controllers,
        bool init_non_self_vars = false);
 
      int run_once(void);
 
      int run(void);
 
      inline void set_hive(madara::knowledge::Hive& hive)
      {
        hive_ = &hive;
      }
      
      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);
      }
 
    protected:
 
      size_t offset_;
 
      std::vector <BaseController *> controllers_;
 
      madara::knowledge::Hive * hive_;
 
      ControllerSettings settings_;
    };
  }
}