Queue.h

Go to the documentation of this file.

#ifndef _MADARA_CONTAINERS_QUEUE_H_
#define _MADARA_CONTAINERS_QUEUE_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 "Vector.h"
#include "Integer.h"

namespace madara
{
  namespace knowledge
  {
    namespace containers
    {
      class MADARA_Export Queue
      {
      public:
        Queue (const KnowledgeUpdateSettings & settings =
          KnowledgeUpdateSettings ());
      
        Queue (const std::string & name,
                KnowledgeBase & knowledge,
                const KnowledgeUpdateSettings & settings =
                  KnowledgeUpdateSettings ());
      
        Queue (const std::string & name,
                Variables & knowledge,
                const KnowledgeUpdateSettings & settings =
                  KnowledgeUpdateSettings ());
      
        Queue (const std::string & name,
               KnowledgeBase & knowledge,
               int size,
               const KnowledgeUpdateSettings & settings =
                 KnowledgeUpdateSettings ());
      
        Queue (const std::string & name,
               Variables & knowledge,
               int size,
               const KnowledgeUpdateSettings & settings =
                 KnowledgeUpdateSettings ());
      
        Queue (const Queue & rhs);

        virtual ~Queue () = default;
        
        void operator= (const Queue & rhs);

        std::string get_name (void) const;
        
        void set_name (const std::string & var_name,
          KnowledgeBase & knowledge);
        
        void set_name (const std::string & var_name,
          Variables & knowledge);
        
        bool operator== (const Queue & value) const;
        
        bool operator!= (const Queue & value) const;
        
        bool enqueue (const knowledge::KnowledgeRecord & record);

        template<typename... Args>
        bool emplace (Args&&... args);
        
        knowledge::KnowledgeRecord dequeue (bool wait = true);
        
        knowledge::KnowledgeRecord inspect (size_t position);

        void clear (void);

        size_t count (void);

        size_t size (void);

        KnowledgeUpdateSettings set_settings (
          const KnowledgeUpdateSettings & settings);

        void set_quality (uint32_t quality,
               const KnowledgeReferenceSettings & settings =
                       KnowledgeReferenceSettings (false));
      
        void resize (int size = -1);

      private:
        inline knowledge::KnowledgeRecord::Integer increment (
          knowledge::KnowledgeRecord::Integer base,
          knowledge::KnowledgeRecord::Integer value)
        {
          return (base + value) % queue_.size ();
        }


        
      
        mutable MADARA_LOCK_TYPE mutex_;

        mutable ThreadSafeContext * context_;

        std::string name_;

        Integer count_;

        Integer head_;

        Integer tail_;

        Vector queue_;

        KnowledgeUpdateSettings settings_;
      };
    }
  }
}


#include "Queue.inl"

#endif // _MADARA_CONTAINERS_QUEUE_H_