DoubleStaged.h

Go to the documentation of this file.

#ifndef _MADARA_KNOWLEDGE_CONTAINERS_DOUBLESTAGED_H_
#define _MADARA_KNOWLEDGE_CONTAINERS_DOUBLESTAGED_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 DoubleStaged : public BaseContainer
      {
      public:
        typedef double  type;

        DoubleStaged (const KnowledgeUpdateSettings & settings =
          KnowledgeUpdateSettings ());

        DoubleStaged (const std::string & name,
          KnowledgeBase & knowledge,
          const KnowledgeUpdateSettings & settings =
          KnowledgeUpdateSettings ());

        DoubleStaged (const std::string & name,
          Variables & knowledge,
          const KnowledgeUpdateSettings & settings =
          KnowledgeUpdateSettings ());

        DoubleStaged (const std::string & name,
          KnowledgeBase & knowledge,
          type value,
          const KnowledgeUpdateSettings & settings =
          KnowledgeUpdateSettings ());

        DoubleStaged (const std::string & name,
          Variables & knowledge,
          type value,
          const KnowledgeUpdateSettings & settings =
          KnowledgeUpdateSettings ());

        DoubleStaged (const DoubleStaged & rhs);

        virtual ~DoubleStaged ();

        void modify (void);

        void operator= (const DoubleStaged & rhs);

        void read (void);

        void write (void);

        void set_name (const std::string & var_name,
          KnowledgeBase & knowledge,
          bool sync = true);

        void set_name (const std::string & var_name,
          Variables & knowledge,
          bool sync = true);

        void set_name (const std::string & var_name,
          ThreadSafeContext & knowledge,
          bool sync = true);

        void exchange (DoubleStaged & other);

        type operator= (type value);

        bool operator== (const DoubleStaged & value) const;

        bool operator!= (const DoubleStaged & value) const;

        bool operator== (type value) const;

        bool operator!= (type value) const;

        bool operator< (type value) const;

        bool operator<= (type value) const;

        bool operator> (type value) const;

        bool operator>= (type value) const;

        type operator* (void) const;

        bool exists (void) const;

        type operator+= (type value);

        type operator-= (type value);

        type operator++ (void);

        type operator-- (void);

        knowledge::KnowledgeRecord to_record (void) const;

        double to_double (void) const;

        knowledge::KnowledgeRecord::Integer to_integer (void) const;

        std::string to_string (void) const;

        void set_quality (uint32_t quality,
          const KnowledgeReferenceSettings & settings =
          KnowledgeReferenceSettings (false));


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

        VariableReference variable_;

        type value_;

        bool has_changed_;
      };
    } // containers
  } // knowledge
} // madara

#include "DoubleStaged.inl"

#endif // _MADARA_KNOWLEDGE_CONTAINERS_DOUBLESTAGED_H_