Vector.h

Go to the documentation of this file.

#ifndef _MADARA_CONTAINERS_VECTOR_H_
#define _MADARA_CONTAINERS_VECTOR_H_

#include <vector>
#include <string>
#include <iostream>
#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
    {
      // forward declare a friend class
      class Queue;

      class MADARA_Export Vector : public BaseContainer
      {
      public:
        friend class Queue;

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

        Vector (const std::string & name, 
          KnowledgeBase & knowledge,
          int size = -1,
          bool delete_vars = true,
          const KnowledgeUpdateSettings & settings =
            KnowledgeUpdateSettings (),
          const std::string & delimiter = ".");
      
        Vector (const std::string & name,
          Variables & knowledge,
          int size = -1,
          bool delete_vars = true,
          const KnowledgeUpdateSettings & settings =
            KnowledgeUpdateSettings (),
          const std::string & delimiter = ".");
      
        Vector (const Vector & rhs);

        virtual ~Vector ();
        
        void modify (void);

        void modify (size_t index);
    
        void operator= (const Vector & rhs);

        void push_back (KnowledgeRecord value);

        void resize (int size = -1, bool delete_vars = true);
      
        void exchange (Vector & other, bool refresh_keys = true,
          bool delete_keys = true);

        void transfer_to (Vector & other);

        size_t size (void) const;
      
        void set_name (const std::string & var_name,
          KnowledgeBase & knowledge, int size = -1);
        
        void set_name (const std::string & var_name,
          Variables & knowledge, int size = -1);
        
        void set_name (const std::string & var_name,
          ThreadSafeContext & knowledge, int size = -1);

        void set_delimiter (const std::string & delimiter);

        std::string get_delimiter (void);

        knowledge::KnowledgeRecord operator[] (size_t index) const;
        
        knowledge::KnowledgeRecord to_record (size_t index) const;
        
        void copy_to (KnowledgeVector & target) const;
        
        bool exists (size_t index) const;
      
        int read_file (size_t index, 
                       const std::string & filename);
      
        int read_file (size_t index, 
                       const std::string & filename, 
          const KnowledgeUpdateSettings & settings);
      
        int set_file (size_t index,
          const unsigned char * value, size_t size);
      
        int set_file (size_t index,
          const unsigned char * value, size_t size, 
          const KnowledgeUpdateSettings & settings);
      
        int set_jpeg (size_t index,
          const unsigned char * value, size_t size);
              
        int set_jpeg (size_t index,
          const unsigned char * value, size_t size, 
          const KnowledgeUpdateSettings & settings);
        
        int set (size_t index,
          madara::knowledge::KnowledgeRecord::Integer value = 
            madara::knowledge::KnowledgeRecord::MODIFIED);

        int set (size_t index,
          madara::knowledge::KnowledgeRecord::Integer value, 
          const KnowledgeUpdateSettings & settings);

        int set_index (size_t index,
          size_t sub_index,
          madara::knowledge::KnowledgeRecord::Integer value);
        
        int set_index (size_t index,
          size_t sub_index,
          madara::knowledge::KnowledgeRecord::Integer value,
          const KnowledgeUpdateSettings & settings);
        
        int set (size_t index,
          const madara::knowledge::KnowledgeRecord::Integer * value,
          uint32_t size);
       
        int set (size_t index,
          const madara::knowledge::KnowledgeRecord::Integer * value,
          uint32_t size,
          const KnowledgeUpdateSettings & settings);
       
        int set (size_t index,
          const std::vector <KnowledgeRecord::Integer> & value);
       
        int set (size_t index,
          const std::vector <KnowledgeRecord::Integer> & value,
          const KnowledgeUpdateSettings & settings);
       
        int set (size_t index, double value);

        int set (size_t index, double value, 
          const KnowledgeUpdateSettings & settings);
        
        int set_index (size_t index,
          size_t sub_index,
          double value);

        int set_index (size_t index,
          size_t sub_index,
          double value,
          const KnowledgeUpdateSettings & settings);
        
        int set (size_t index,
          const double * value,
          uint32_t size);
       
        int set (size_t index,
          const double * value,
          uint32_t size,
          const KnowledgeUpdateSettings & settings);
       
        int set (size_t index,
          const std::vector <double> & value);
        
        int set (size_t index,
          const std::vector <double> & value,
          const KnowledgeUpdateSettings & settings);
        
        int set (size_t index, const std::string & value);
        
        int set (size_t index, const std::string & value, 
          const KnowledgeUpdateSettings & settings);
        
        void set_quality (size_t 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 <VariableReference> vector_;

        VariableReference size_;

        std::string delimiter_;
      };

      typedef  Vector   Array;
    }
  }
}




#endif // _MADARA_CONTAINERS_VECTOR_H_