Counter.h

Go to the documentation of this file.

#ifndef _MADARA_CONTAINERS_COUNTER_H_
#define _MADARA_CONTAINERS_COUNTER_H_

#ifndef _MADARA_NO_KARL_

#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 Counter : public BaseContainer
      {
      public:
        typedef knowledge::KnowledgeRecord::Integer  type;
        
        Counter (const KnowledgeUpdateSettings & settings =
          KnowledgeUpdateSettings ());
      
        Counter (const std::string & name,
                KnowledgeBase & knowledge,
                const KnowledgeUpdateSettings & settings =
                  KnowledgeUpdateSettings ());
      
        Counter (const std::string & name,
                Variables & knowledge,
                const KnowledgeUpdateSettings & settings =
                  KnowledgeUpdateSettings ());
      
        Counter (const std::string & name,
                KnowledgeBase & knowledge,
                int id,
                int counters,
                type value = 0,
                const KnowledgeUpdateSettings & settings =
                  KnowledgeUpdateSettings ());
      
        Counter (const std::string & name,
                Variables & knowledge,
                int id,
                int counters,
                type value = 0,
                const KnowledgeUpdateSettings & settings =
                  KnowledgeUpdateSettings ());
      
        Counter (const Counter & rhs);

        ~Counter ();
        
        void operator= (const Counter & rhs);

        int get_id (void) const;
        
        int get_counters (void) const;
        
        void set_name (const std::string & var_name,
          KnowledgeBase & knowledge);
        
        void set_name (const std::string & var_name,
          Variables & knowledge);
        
        void modify (void);

        type operator= (type value);
        
        bool operator== (const Counter & value) const;
        
        bool operator!= (const Counter & 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;
      
        void operator+= (type value);
        
        void operator-= (type value);
        
        void operator++ (void);
        
        void 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));
      
        void resize (int id = 0, int counters = 1);

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

        void build_aggregate_count (void);
        
        void build_var (void);

        void init_noharm (void);

        inline type get_count (void) const
        {
          return context_->evaluate (aggregate_count_, no_harm).to_integer ();
        }
        
        inline std::string get_count_string (void) const
        {
          return context_->evaluate (aggregate_count_, no_harm).to_string ();
        }
        
        inline double get_count_double (void) const
        {
          return context_->evaluate (aggregate_count_, no_harm).to_double ();
        }
        
        inline knowledge::KnowledgeRecord get_count_record (void) const
        {
          return context_->evaluate (aggregate_count_, no_harm);
        }

        mutable ThreadSafeContext * context_;

        VariableReference variable_;

        int id_;

        int counters_;

        CompiledExpression aggregate_count_;

        EvalSettings no_harm;
      };
    }
  }
}

#endif // _MADARA_NO_KARL_

#endif // _MADARA_CONTAINERS_COUNTER_H_