NativeDoubleVectorStaged.h

Go to the documentation of this file.

#ifndef _MADARA_NATIVE_DOUBLE_VECTOR_STAGED_H_
#define _MADARA_NATIVE_DOUBLE_VECTOR_STAGED_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 NativeDoubleVectorStaged : public BaseContainer
      {
      public:
        typedef double  type;
        
        NativeDoubleVectorStaged (const KnowledgeUpdateSettings & settings =
          KnowledgeUpdateSettings ());

        NativeDoubleVectorStaged (const std::string & name, 
          KnowledgeBase & knowledge,
          int size = -1,
          const KnowledgeUpdateSettings & settings =
            KnowledgeUpdateSettings ());
      
        NativeDoubleVectorStaged (const std::string & name,
          Variables & knowledge,
          int size = -1,
          const KnowledgeUpdateSettings & settings =
            KnowledgeUpdateSettings ());
      
        NativeDoubleVectorStaged (const NativeDoubleVectorStaged & rhs);

        virtual ~NativeDoubleVectorStaged ();
        
        void modify (void);

        void operator= (const NativeDoubleVectorStaged & rhs);

        void operator= (const std::vector <type> & rhs);

        void push_back (type value);

        void resize (size_t size);

        void exchange (NativeDoubleVectorStaged & other);

        void transfer_to (NativeDoubleVectorStaged & other);
        
        void copy_to (KnowledgeVector & target) const;
        
        size_t size (void) const;
      
        void set_name (const std::string & var_name,
          KnowledgeBase & knowledge, int size = -1,
          bool sync = true);
        
        void set_name (const std::string & var_name,
          Variables & knowledge, int size = -1,
          bool sync = true);
        
        void set_name (const std::string & var_name,
          ThreadSafeContext & knowledge, int size = -1,
          bool sync = true);

        type operator[] (size_t index) const;

        void set (size_t index,
          type value);

        void set (
          const std::vector <type> & value);
       
        void set_quality (size_t index, uint32_t quality,
               const KnowledgeReferenceSettings & settings =
                       KnowledgeReferenceSettings (false));
      
        knowledge::KnowledgeRecord to_record (size_t index) const;
      
        knowledge::KnowledgeRecord to_record (void) const;

        std::string get_debug_info (void);

        virtual BaseContainer * clone (void) const;

        bool is_true (void) const;

        bool is_false (void) const;

        void read (void);

        void write (void);

      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_;

        VariableReference vector_;

        KnowledgeRecord value_;

        bool has_changed_;
      };

      typedef  NativeDoubleVectorStaged   NativeDoubleArrayStaged;
    }
  }
}

#include "NativeDoubleVectorStaged.inl"

#endif // _MADARA_NATIVE_DOUBLE_VECTOR_STAGED_H_