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_