DoubleVector3D.h

Go to the documentation of this file.

#ifndef _MADARA_CONTAINERS_DOUBLE_VECTOR3D_H_
#define _MADARA_CONTAINERS_DOUBLE_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 DoubleVector3D : public BaseContainer
      {
      public:
        struct Indices
        {
          std::size_t x, y, z;
        };

        typedef Indices  Dimensions;

        typedef double type;

        DoubleVector3D (const KnowledgeUpdateSettings & settings =
          KnowledgeUpdateSettings (),
          const std::string & delimiter = ".");

        DoubleVector3D (const std::string & name, 
          KnowledgeBase & knowledge,
          const Dimensions & dimensions = {0,0,0},
          bool delete_vars = true,
          const KnowledgeUpdateSettings & settings =
            KnowledgeUpdateSettings (),
          const std::string & delimiter = ".");
      
        DoubleVector3D (const std::string & name,
          Variables & knowledge,
          const Dimensions & dimensions = {0,0,0},
          bool delete_vars = true,
          const KnowledgeUpdateSettings & settings =
            KnowledgeUpdateSettings (),
          const std::string & delimiter = ".");
      
        DoubleVector3D (const DoubleVector3D & rhs);

        virtual ~DoubleVector3D ();
        
        void copy_to (
          std::vector<std::vector<std::vector<type> > > & target) const;

        void modify (void);

        void modify (const Indices & index);
    
        void operator= (const DoubleVector3D & 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_DOUBLE_VECTOR3D_H_