Map.h

Go to the documentation of this file.

 
#ifndef _MADARA_CONTAINERS_MAP_H_
#define _MADARA_CONTAINERS_MAP_H_
 
#include <vector>
#include <map>
#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 Map : public BaseContainer
{
public:
  Map(const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings(),
      const std::string& delimiter = ".");
 
  Map(const std::string& name, KnowledgeBase& knowledge,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings(),
      const std::string& delimiter = ".");
 
  Map(const std::string& name, Variables& knowledge,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings(),
      const std::string& delimiter = ".");
 
  Map(const Map& rhs);
 
  virtual ~Map();
 
  void modify(void);
 
  void modify(const std::string& index);
 
  void operator=(const Map& rhs);
 
  void exchange(Map& other, bool refresh_keys = true, bool delete_keys = true);
 
  knowledge::KnowledgeRecord operator[](const std::string& key);
 
  knowledge::KnowledgeRecord to_record(const std::string& key);
 
  size_t size(void) const;
 
  std::vector<std::string> sync_keys(void);
 
  void keys(std::vector<std::string>& curkeys) const;
 
  bool exists(const std::string& key) const;
 
  bool has_prefix(const std::string& prefix) const;
 
  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_delimiter(const std::string& delimiter, bool sync = true);
 
  std::string get_delimiter(void);
 
  void clear(bool clear_knowledge = true);
 
  void reset(void);
 
  void erase(const std::string& key);
 
  int read_file(const std::string& key, const std::string& filename);
 
  int read_file(const std::string& key, const std::string& filename,
      const KnowledgeUpdateSettings& settings);
 
  int set(const std::string& key,
      madara::knowledge::KnowledgeRecord::Integer value =
          madara::knowledge::KnowledgeRecord::MODIFIED);
 
  int set(const std::string& key,
      madara::knowledge::KnowledgeRecord::Integer value,
      const KnowledgeUpdateSettings& settings);
 
  int set(const std::string& key, const KnowledgeRecord& value,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  int set_index(const std::string& key, size_t index,
      madara::knowledge::KnowledgeRecord::Integer value);
 
  int set_index(const std::string& key, size_t index,
      madara::knowledge::KnowledgeRecord::Integer value,
      const KnowledgeUpdateSettings& settings);
 
  int set(const std::string& key,
      const madara::knowledge::KnowledgeRecord::Integer* value, uint32_t size);
 
  int set(const std::string& key,
      const madara::knowledge::KnowledgeRecord::Integer* value, uint32_t size,
      const KnowledgeUpdateSettings& settings);
 
  int set(const std::string& key,
      const std::vector<KnowledgeRecord::Integer>& value);
 
  int set(const std::string& key,
      const std::vector<KnowledgeRecord::Integer>& value,
      const KnowledgeUpdateSettings& settings);
 
  int set(const std::string& key, double value);
 
  int set(const std::string& key, double value,
      const KnowledgeUpdateSettings& settings);
 
  int set_index(const std::string& key, size_t index, double value);
 
  int set_index(const std::string& key, size_t index, double value,
      const KnowledgeUpdateSettings& settings);
 
  int set(const std::string& key, const double* value, uint32_t size);
 
  int set(const std::string& key, const double* value, uint32_t size,
      const KnowledgeUpdateSettings& settings);
 
  int set(const std::string& key, const std::vector<double>& value);
 
  int set(const std::string& key, const std::vector<double>& value,
      const KnowledgeUpdateSettings& settings);
 
  int set(const std::string& key, const std::string& value);
 
  int set(const std::string& key, const std::string& value,
      const KnowledgeUpdateSettings& settings);
 
  int set_file(const std::string& key, const unsigned char* value, size_t size);
 
  int set_file(const std::string& key, const unsigned char* value, size_t size,
      const KnowledgeUpdateSettings& settings);
 
  int set_jpeg(const std::string& key, const unsigned char* value, size_t size);
 
  int set_jpeg(const std::string& key, const unsigned char* value, size_t size,
      const KnowledgeUpdateSettings& settings);
 
  void set_quality(const std::string& key, 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);
 
  typedef std::map<std::string, VariableReference> InternalMap;
 
  ThreadSafeContext* context_;
 
  InternalMap map_;
 
  std::string delimiter_;
};
}
}
}
 
#endif  // _MADARA_CONTAINERS_MAP_H_