FlexMap.h

Go to the documentation of this file.

 
#ifndef _MADARA_CONTAINERS_FLEX_MAP_H_
#define _MADARA_CONTAINERS_FLEX_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 "String.h"
#include "Integer.h"
#include "Double.h"
#include "Map.h"
#include "StringVector.h"
#include "DoubleVector.h"
#include "IntegerVector.h"
#include "BufferVector.h"
#include "NativeDoubleVector.h"
#include "NativeIntegerVector.h"
#include "BaseContainer.h"
 
namespace madara
{
namespace knowledge
{
namespace containers
{
class FlexMap;
 
class MADARA_EXPORT FlexMap : public BaseContainer
{
public:
  FlexMap(const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings(),
      const std::string& delimiter = ".");
 
  FlexMap(const std::string& name, KnowledgeBase& knowledge,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings(),
      const std::string& delimiter = ".");
 
  FlexMap(const std::string& name, Variables& knowledge,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings(),
      const std::string& delimiter = ".");
 
  FlexMap(const FlexMap& rhs);
 
  virtual ~FlexMap();
 
  void modify(void);
 
  void operator=(const FlexMap& rhs);
 
  void exchange(
      FlexMap& other, bool refresh_keys = true, bool delete_keys = true);
 
  FlexMap operator[](const std::string& key);
 
  FlexMap operator[](size_t index);
 
  knowledge::KnowledgeRecord to_record(
      const KnowledgeRecord& default_value = KnowledgeRecord(0)) const;
 
  void to_container(BufferVector& target) const;
 
  void to_container(DoubleVector& target) const;
 
  void to_container(IntegerVector& target) const;
 
  void to_container(NativeDoubleVector& target) const;
 
  void to_container(NativeIntegerVector& target) const;
 
  void to_container(StringVector& target) const;
 
  void to_container(Double& target) const;
 
  void to_container(Integer& target) const;
 
  void to_container(String& target) const;
 
  void to_container(Map& target) const;
 
  knowledge::KnowledgeRecord::Integer to_integer(
      KnowledgeRecord::Integer default_value = 0) const;
 
  double to_double(double default_value = 0.0) const;
 
  std::string to_string(const std::string& default_value = "") const;
 
  size_t size(bool first_level_keys_only = true) const;
 
  void keys(std::vector<std::string>& curkeys,
      bool first_level_keys_only = true) const;
 
  bool exists(const std::string& key, bool first_level_key = false) const;
 
  bool exists(void) const;
 
  void set_name(const std::string& var_name, KnowledgeBase& knowledge);
 
  void set_name(const std::string& var_name, Variables& knowledge);
 
  void set_delimiter(const std::string& delimiter);
 
  std::string get_delimiter(void);
 
  void clear(void);
 
  void erase(const std::string& key, bool delete_subkeys = true);
 
  bool is_true(void) const;
 
  bool is_false(void) const;
 
  int read_file(const std::string& filename);
 
  int read_file(
      const std::string& filename, const KnowledgeUpdateSettings& settings);
 
  int set(knowledge::KnowledgeRecord::Integer value =
              knowledge::KnowledgeRecord::MODIFIED);
 
  void operator=(knowledge::KnowledgeRecord::Integer value);
 
  void operator=(int value);
 
  void operator=(double value);
 
  void operator=(const std::string value);
 
  void operator=(const std::vector<KnowledgeRecord::Integer>& value);
 
  void operator=(const std::vector<double>& value);
 
  int set(
      KnowledgeRecord::Integer value, const KnowledgeUpdateSettings& settings);
 
  int set_index(size_t index, knowledge::KnowledgeRecord::Integer value);
 
  int set_index(size_t index, knowledge::KnowledgeRecord::Integer value,
      const KnowledgeUpdateSettings& settings);
 
  int set(const knowledge::KnowledgeRecord::Integer* value, uint32_t size);
 
  int set(const knowledge::KnowledgeRecord::Integer* value, uint32_t size,
      const KnowledgeUpdateSettings& settings);
 
  int set(const std::vector<KnowledgeRecord::Integer>& value);
 
  int set(const std::vector<KnowledgeRecord::Integer>& value,
      const KnowledgeUpdateSettings& settings);
 
  int set(double value);
 
  int set(double value, const KnowledgeUpdateSettings& settings);
 
  int set_index(size_t index, double value);
 
  int set_index(
      size_t index, double value, const KnowledgeUpdateSettings& settings);
 
  int set(const double* value, uint32_t size);
 
  int set(const double* value, uint32_t size,
      const KnowledgeUpdateSettings& settings);
 
  int set(const std::vector<double>& value);
 
  int set(const std::vector<double>& value,
      const KnowledgeUpdateSettings& settings);
 
  int set(const std::string& value);
 
  int set(const std::string& value, const KnowledgeUpdateSettings& settings);
 
  int set_file(const unsigned char* value, size_t size);
 
  int set_file(const unsigned char* value, size_t size,
      const KnowledgeUpdateSettings& settings);
 
  int set_jpeg(const unsigned char* value, size_t size);
 
  int set_jpeg(const unsigned char* value, size_t size,
      const KnowledgeUpdateSettings& settings);
 
  void set_quality(uint32_t quality,
      const KnowledgeReferenceSettings& settings = KnowledgeReferenceSettings(
          false));
 
  std::string get_debug_info(void);
 
  virtual BaseContainer* clone(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 update_variable(void) const;
 
  typedef std::map<std::string, VariableReference> InternalFlexMap;
 
  ThreadSafeContext* context_;
 
  mutable VariableReference variable_;
 
  std::string delimiter_;
};
}
}
}
 
#endif  // _MADARA_CONTAINERS_FLEX_MAP_H_