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_