StringStaged.h

Go to the documentation of this file.

 
#ifndef _MADARA_KNOWLEDGE_CONTAINERS_STRINGSTAGED_H_
#define _MADARA_KNOWLEDGE_CONTAINERS_STRINGSTAGED_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 "BaseContainer.h"
 
namespace madara
{
namespace knowledge
{
namespace containers
{
class MADARA_EXPORT StringStaged : public BaseContainer
{
public:
  typedef std::string type;
 
  StringStaged(
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  StringStaged(const std::string& name, KnowledgeBase& knowledge,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  StringStaged(const std::string& name, Variables& knowledge,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  StringStaged(const std::string& name, KnowledgeBase& knowledge,
      const type& value,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  StringStaged(const std::string& name, Variables& knowledge, const type& value,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  StringStaged(const StringStaged& rhs);
 
  virtual ~StringStaged();
 
  void modify(void);
 
  void operator=(const StringStaged& rhs);
 
  void read(void);
 
  void write(void);
 
  void set_name(
      const std::string& var_name, KnowledgeBase& knowledge, bool sync = true);
 
  void set_name(
      const std::string& var_name, Variables& knowledge, bool sync = true);
 
  void set_name(const std::string& var_name, ThreadSafeContext& knowledge,
      bool sync = true);
 
  void exchange(StringStaged& other);
 
  type operator=(const type& value);
 
  bool operator==(const StringStaged& value) const;
 
  bool operator!=(const StringStaged& value) const;
 
  bool operator==(const type& value) const;
 
  bool operator!=(const type& value) const;
 
  bool operator<(const type& value) const;
 
  bool operator<=(const type& value) const;
 
  bool operator>(const type& value) const;
 
  bool operator>=(const type& value) const;
 
  type operator*(void)const;
 
  bool exists(void) const;
 
  type operator+=(const type& value);
 
  type operator-=(const type& value);
 
  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));
 
  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);
 
  ThreadSafeContext* context_;
 
  VariableReference variable_;
 
  type value_;
 
  bool has_changed_;
};
}  // containers
}  // knowledge
}  // madara
 
#include "StringStaged.inl"
 
#endif  // _MADARA_KNOWLEDGE_CONTAINERS_STRINGSTAGED_H_