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 & processes = -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);

      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_