Counter.h

Go to the documentation of this file.

 
#ifndef _MADARA_CONTAINERS_COUNTER_H_
#define _MADARA_CONTAINERS_COUNTER_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 Counter : public BaseContainer
{
public:
  typedef knowledge::KnowledgeRecord::Integer type;
 
  Counter(const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  Counter(const std::string& name, KnowledgeBase& knowledge,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  Counter(const std::string& name, Variables& knowledge,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  Counter(const std::string& name, KnowledgeBase& knowledge, int id,
      int counters, type value = 0,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  Counter(const std::string& name, Variables& knowledge, int id, int counters,
      type value = 0,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  Counter(const Counter& rhs);
 
  ~Counter();
 
  void operator=(const Counter& rhs);
 
  int get_id(void) const;
 
  int get_counters(void) const;
 
  void set_name(const std::string& var_name, KnowledgeBase& knowledge);
 
  void set_name(const std::string& var_name, Variables& knowledge);
 
  void modify(void);
 
  type operator=(type value);
 
  bool operator==(const Counter& value) const;
 
  bool operator!=(const Counter& value) const;
 
  bool operator==(type value) const;
 
  bool operator!=(type value) const;
 
  bool operator<(type value) const;
 
  bool operator<=(type value) const;
 
  bool operator>(type value) const;
 
  bool operator>=(type value) const;
 
  type operator*(void)const;
 
  void operator+=(type value);
 
  void operator-=(type value);
 
  void operator++(void);
 
  void operator--(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;
 
  void set_quality(uint32_t quality,
      const KnowledgeReferenceSettings& settings = KnowledgeReferenceSettings(
          false));
 
  void resize(int id = 0, int counters = 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_count(void);
 
  void build_var(void);
 
  void init_noharm(void);
 
  inline type get_count(void) const
  {
    return context_->evaluate(aggregate_count_, no_harm).to_integer();
  }
 
  inline std::string get_count_string(void) const
  {
    return context_->evaluate(aggregate_count_, no_harm).to_string();
  }
 
  inline double get_count_double(void) const
  {
    return context_->evaluate(aggregate_count_, no_harm).to_double();
  }
 
  inline knowledge::KnowledgeRecord get_count_record(void) const
  {
    return context_->evaluate(aggregate_count_, no_harm);
  }
 
  mutable ThreadSafeContext* context_;
 
  VariableReference variable_;
 
  int id_;
 
  int counters_;
 
  CompiledExpression aggregate_count_;
 
  EvalSettings no_harm;
};
}
}
}
 
#endif  // _MADARA_NO_KARL_
 
#endif  // _MADARA_CONTAINERS_COUNTER_H_