Queue.inl

Go to the documentation of this file.

 
#ifndef _MADARA_CONTAINERS_QUEUE_INL_
#define _MADARA_CONTAINERS_QUEUE_INL_
 
#include <sstream>
 
#include "Queue.h"
#include "madara/knowledge/ContextGuard.h"
 
inline madara::knowledge::containers::Queue::Queue(
    const KnowledgeUpdateSettings& settings)
  : context_(0), settings_(settings)
{
}
 
inline madara::knowledge::containers::Queue::Queue(const std::string& name,
    KnowledgeBase& knowledge, const KnowledgeUpdateSettings& settings)
  : context_(&(knowledge.get_context())),
    name_(name),
    count_(name + ".count", knowledge, 0),
    head_(name + ".head", knowledge, 0),
    tail_(name + ".tail", knowledge, 0),
    queue_(name, knowledge),
    settings_(settings)
{
  resize();
}
 
inline madara::knowledge::containers::Queue::Queue(const std::string& name,
    Variables& knowledge, const KnowledgeUpdateSettings& settings)
  : context_(knowledge.get_context()),
    name_(name),
    count_(name + ".count", knowledge),
    head_(name + ".head", knowledge),
    tail_(name + ".tail", knowledge),
    queue_(name, knowledge),
    settings_(settings)
{
  resize();
}
 
inline madara::knowledge::containers::Queue::Queue(const std::string& name,
    KnowledgeBase& knowledge, int size, const KnowledgeUpdateSettings& settings)
  : context_(&(knowledge.get_context())),
    name_(name),
    count_(name + ".count", knowledge, 0),
    head_(name + ".head", knowledge, 0),
    tail_(name + ".tail", knowledge, 0),
    queue_(name, knowledge, size, false, settings),
    settings_(settings)
{
}
 
inline madara::knowledge::containers::Queue::Queue(const std::string& name,
    Variables& knowledge, int size, const KnowledgeUpdateSettings& settings)
  : context_(knowledge.get_context()),
    name_(name),
    count_(name + ".count", knowledge, 0),
    head_(name + ".head", knowledge, 0),
    tail_(name + ".tail", knowledge, 0),
    queue_(name, knowledge, size, false, settings),
    settings_(settings)
{
}
 
inline madara::knowledge::containers::Queue::Queue(const Queue& rhs)
  : context_(rhs.context_),
    name_(rhs.name_),
    count_(rhs.count_),
    head_(rhs.head_),
    tail_(rhs.tail_),
    queue_(rhs.queue_),
    settings_(rhs.settings_)
{
}
 
inline void madara::knowledge::containers::Queue::operator=(const Queue& rhs)
{
  if (this != &rhs)
  {
    MADARA_GUARD_TYPE guard(mutex_), guard2(rhs.mutex_);
 
    this->context_ = rhs.context_;
    this->name_ = rhs.name_;
    this->count_ = rhs.count_;
    this->head_ = rhs.head_;
    this->tail_ = rhs.tail_;
    this->queue_ = rhs.queue_;
    this->settings_ = rhs.settings_;
  }
}
 
inline bool madara::knowledge::containers::Queue::operator==(
    const Queue& value) const
{
  return name_ == value.get_name();
}
 
inline bool madara::knowledge::containers::Queue::operator!=(
    const Queue& value) const
{
  return name_ != value.get_name();
}
 
template<typename... Args>
inline bool madara::knowledge::containers::Queue::emplace(Args&&... args)
{
  return enqueue(KnowledgeRecord(std::forward<Args>(args)...));
}
 
inline void madara::knowledge::containers::Queue::clear(void)
{
  if (context_ && name_ != "" && count_ > 0)
  {
    ContextGuard context_guard(*context_);
    MADARA_GUARD_TYPE guard(mutex_);
 
    count_ = 0;
    head_ = *tail_;
  }
}
 
inline madara::knowledge::KnowledgeRecord
madara::knowledge::containers::Queue::inspect(size_t position)
{
  madara::knowledge::KnowledgeRecord result;
  if (context_ && name_ != "" && (KnowledgeRecord::Integer)position < *count_)
  {
    ContextGuard context_guard(*context_);
    MADARA_GUARD_TYPE guard(mutex_);
 
    size_t index =
        (size_t)increment(*head_, (KnowledgeRecord::Integer)position);
 
    result = context_->get(queue_.vector_[index], settings_);
  }
  return result;
}
 
inline std::string madara::knowledge::containers::Queue::get_name(void) const
{
  MADARA_GUARD_TYPE guard(mutex_);
  return name_;
}
 
inline size_t madara::knowledge::containers::Queue::size(void)
{
  return queue_.size();
}
 
inline size_t madara::knowledge::containers::Queue::count(void)
{
  return (size_t)(*count_);
}
 
inline void madara::knowledge::containers::Queue::resize(int size)
{
  if (context_)
  {
    ContextGuard context_guard(*context_);
    MADARA_GUARD_TYPE guard(mutex_);
 
    queue_.resize(size, false);
 
    if (count_ > (KnowledgeRecord::Integer)queue_.size())
    {
      count_ = (KnowledgeRecord::Integer)size;
    }
  }
}
 
inline madara::knowledge::KnowledgeUpdateSettings
madara::knowledge::containers::Queue::set_settings(
    const KnowledgeUpdateSettings& settings)
{
  MADARA_GUARD_TYPE guard(mutex_);
 
  KnowledgeUpdateSettings old_settings = settings_;
 
  settings_ = settings;
 
  return old_settings;
}
 
inline void madara::knowledge::containers::Queue::set_quality(
    uint32_t quality, const KnowledgeReferenceSettings& settings)
{
  if (context_)
  {
    ContextGuard context_guard(*context_);
    MADARA_GUARD_TYPE guard(mutex_);
    context_->set_quality(name_, quality, true, settings);
  }
}
 
#endif  //  _MADARA_CONTAINERS_QUEUE_INL_