Barrier.h

Go to the documentation of this file.

 
#ifndef _MADARA_CONTAINERS_BARRIER_H_
#define _MADARA_CONTAINERS_BARRIER_H_
 
#include <vector>
#include <string>
#include "madara/LockType.h"
#include "madara/knowledge/KnowledgeBase.h"
#include "madara/knowledge/ThreadSafeContext.h"
#include "madara/knowledge/KnowledgeUpdateSettings.h"
#include "madara/knowledge/containers/IntegerStaged.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
  {
    type result = 1;
 
    // check the barriers for 
    for ( ; last_failed_check_ < participants_ ; ++last_failed_check_)
    {
      // this guy isn't up to our barrier yet?
      if (barrier_[last_failed_check_] < *barrier_[id_])
      {
        // load from the kb to check for updates
        barrier_[last_failed_check_].read();
 
        // if he's still not up to our barrier yet, the barrier isn't done
        if (barrier_[last_failed_check_] < *barrier_[id_])
        {
          result = 0;
          break;
        }
      }
    }
 
    return result;
  }
 
  mutable ThreadSafeContext* context_;
 
  size_t id_;
 
  size_t participants_;
  
  mutable size_t last_failed_check_;
 
  mutable std::vector<IntegerStaged> barrier_;
};
}  // namespace containers
}  // namespace knowledge
}  // namespace madara
 
#endif  // _MADARA_CONTAINERS_BARRIER_H_