Multicontroller.h

Go to the documentation of this file.

#ifndef   _GAMS_CONTROLLERS_MULTICONTROLLER_H_
#define   _GAMS_CONTROLLERS_MULTICONTROLLER_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 "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 Multicontroller
    {
    public:
      Multicontroller (madara::knowledge::KnowledgeBase & knowledge);

      virtual ~Multicontroller ();

      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 = 0.0,
        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);
      }

      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);
           
#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 (platforms::BasePlatform & platform);
      
      void init_vars (algorithms::BaseAlgorithm & algorithm);

      algorithms::BaseAlgorithm * get_algorithm (void);
      
      platforms::BasePlatform * get_platform (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_;

    private:

      int run_once_ (void);
    };
  }
}

#endif // _GAMS_CONTROLLERS_MULTICONTROLLER_H_