Barrier.h

Go to the documentation of this file.

#ifndef _MADARA_CONTAINERS_BARRIER_H_
#define _MADARA_CONTAINERS_BARRIER_H_

#ifndef _MADARA_NO_KARL_

#include <vector>
#include <string>
#include "madara/LockType.h"
#include "madara/knowledge/KnowledgeBase.h"
#include "madara/knowledge/ThreadSafeContext.h"
#include "madara/knowledge/KnowledgeUpdateSettings.h"
#include "BaseContainer.h"

namespace madara
{
  namespace knowledge
  {
    namespace containers
    {
      class MADARA_Export Barrier : public BaseContainer
      {
      public:
        typedef knowledge::KnowledgeRecord::Integer  type;
        
        Barrier (const KnowledgeUpdateSettings & settings =
          KnowledgeUpdateSettings ());
      
        Barrier (const std::string & name,
                KnowledgeBase & knowledge,
                const KnowledgeUpdateSettings & settings =
                  KnowledgeUpdateSettings ());
      
        Barrier (const std::string & name,
                Variables & knowledge,
                const KnowledgeUpdateSettings & settings =
                  KnowledgeUpdateSettings ());
      
        Barrier (const std::string & name,
                KnowledgeBase & knowledge,
                int id,
                int participants,
                const KnowledgeUpdateSettings & settings =
                  KnowledgeUpdateSettings ());
      
        Barrier (const std::string & name,
                Variables & knowledge,
                int id,
                int participants,
                const KnowledgeUpdateSettings & settings =
                  KnowledgeUpdateSettings ());
      
        Barrier (const Barrier & rhs);

        ~Barrier ();
        
        void operator= (const Barrier & rhs);

        size_t get_id (void) const;
        
        size_t get_participants (void) const;
        
        inline type get_round (void) const
        {
          return to_integer ();
        }

        void set (type value);

        void set_name (const std::string & var_name,
          KnowledgeBase & knowledge,
          int id,
          int participants);
        
        void set_name (const std::string & var_name,
          Variables & knowledge,
          int id,
          int participants);
        
        void set_name (const std::string & var_name,
          ThreadSafeContext & knowledge,
          int id,
          int participants);

        type operator= (type value);
        
        void next (void);
        
        bool is_done (void);
        
        void modify (void);

        knowledge::KnowledgeRecord to_record (void) const;

        double to_double (void) const;
        
        knowledge::KnowledgeRecord::Integer to_integer (void) const;
        
        std::string to_string (void) const;
        
        bool operator== (const Barrier & value) const;
        
        bool operator!= (const Barrier & value) const;
        
        void set_quality (uint32_t quality,
               const KnowledgeReferenceSettings & settings =
                       KnowledgeReferenceSettings (false));
      
        void resize (size_t id = 0, size_t participants = 1);

        std::string get_debug_info (void);

        virtual BaseContainer * clone (void) const;

        bool is_true (void) const;

        bool is_false (void) const;

      private:

        virtual bool is_true_ (void) const;

        virtual bool is_false_ (void) const;

        virtual void modify_ (void);

        virtual std::string get_debug_info_ (void);

        void build_aggregate_barrier (void);
        
        inline type barrier_result (void) const
        {
          return context_->evaluate (aggregate_barrier_, no_harm).to_integer ();
        }

        void build_var (void);

        void init_noharm (void);

        mutable ThreadSafeContext * context_;

        VariableReference variable_;

        size_t id_;

        size_t participants_;

        CompiledExpression aggregate_barrier_;
        
        EvalSettings no_harm;

        std::string variable_name_;
      };
    }
  }
}



#endif // _MADARA_NO_KARL_


#endif // _MADARA_CONTAINERS_BARRIER_H_