IntegerVector3D.h

Go to the documentation of this file.

 
#ifndef _MADARA_CONTAINERS_INTEGER_VECTOR3D_H_
#define _MADARA_CONTAINERS_INTEGER_VECTOR3D_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 IntegerVector3D : public BaseContainer
{
public:
  struct Indices
  {
    std::size_t x, y, z;
  };
 
  typedef Indices Dimensions;
 
  typedef KnowledgeRecord::Integer type;
 
  IntegerVector3D(
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings(),
      const std::string& delimiter = ".");
 
  IntegerVector3D(const std::string& name, KnowledgeBase& knowledge,
      const Dimensions& dimensions = {0, 0, 0}, bool delete_vars = true,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings(),
      const std::string& delimiter = ".");
 
  IntegerVector3D(const std::string& name, Variables& knowledge,
      const Dimensions& dimensions = {0, 0, 0}, bool delete_vars = true,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings(),
      const std::string& delimiter = ".");
 
  IntegerVector3D(const IntegerVector3D& rhs);
 
  virtual ~IntegerVector3D();
 
  void copy_to(std::vector<std::vector<std::vector<type> > >& target) const;
 
  void modify(void);
 
  void modify(const Indices& index);
 
  void operator=(const IntegerVector3D& rhs);
 
  void resize(const Dimensions& dimensions, bool delete_vars = true);
 
  Dimensions size(void) const;
 
  void set_name(const std::string& var_name, KnowledgeBase& knowledge,
      const Dimensions& dimensions = {0, 0, 0});
 
  void set_name(const std::string& var_name, Variables& knowledge,
      const Dimensions& dimensions = {0, 0, 0});
 
  void set_name(const std::string& var_name, ThreadSafeContext& knowledge,
      const Dimensions& dimensions = {0, 0, 0});
 
  void set_delimiter(const std::string& delimiter);
 
  std::string get_delimiter(void);
 
  type operator[](const Indices& index) const;
 
  bool exists(const Indices& index) const;
 
  int set(const Indices& index, type value);
 
  int set(const std::vector<std::vector<std::vector<type> > >& value);
 
  int set(const Indices& index, type value,
      const KnowledgeUpdateSettings& settings);
 
  int set(const std::vector<std::vector<std::vector<type> > >& value,
      const KnowledgeUpdateSettings& settings);
 
  void set_quality(const Indices& index, uint32_t quality,
      const KnowledgeReferenceSettings& settings = KnowledgeReferenceSettings(
          false));
 
  VariableReference get_size_ref(void);
 
  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_;
 
  std::vector<std::vector<std::vector<VariableReference> > > vector_;
 
  VariableReference size_;
 
  std::string delimiter_;
};
}
}
}
 
#endif  // _MADARA_CONTAINERS_INTEGER_VECTOR3D_H_