CircularBufferConsumer.h

Go to the documentation of this file.

 
#ifndef _MADARA_KNOWLEDGE_CONTAINERS_CIRCULARBUFFERCONSUMER_H_
#define _MADARA_KNOWLEDGE_CONTAINERS_CIRCULARBUFFERCONSUMER_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 CircularBufferConsumer
{
public:
  CircularBufferConsumer();
 
  CircularBufferConsumer(const std::string& name, KnowledgeBase& knowledge);
 
  CircularBufferConsumer(const std::string& name, Variables& knowledge);
 
  virtual ~CircularBufferConsumer() = default;
 
  std::string get_name(void) const;
 
  void set_name(const std::string& name, KnowledgeBase& knowledge);
 
  void set_name(const std::string& name, Variables& knowledge);
 
  bool operator==(const CircularBufferConsumer& value) const;
 
  bool operator!=(const CircularBufferConsumer& value) const;
 
  KnowledgeRecord consume(void) const;
 
  KnowledgeRecord consume(size_t& dropped) const;
 
  template<typename T>
  void consume(T& value) const;
 
  template<typename T>
  void consume(T& value, size_t& dropped) const;
 
  std::vector<KnowledgeRecord> consume_latest(size_t count) const;
 
  std::vector<KnowledgeRecord> consume_latest(
      size_t count, size_t& dropped) const;
 
  template<typename T>
  void consume_latest(size_t count, std::vector<T>& values) const;
 
  template<typename T>
  void consume_latest(
      size_t count, std::vector<T>& values, size_t& dropped) const;
 
  std::vector<KnowledgeRecord> consume_earliest(size_t count) const;
 
  std::vector<KnowledgeRecord> consume_earliest(
      size_t count, size_t& dropped) const;
 
  template<typename T>
  void consume_earliest(size_t count, std::vector<T>& values) const;
 
  template<typename T>
  void consume_earliest(
      size_t count, std::vector<T>& values, size_t& dropped) const;
 
  size_t get_dropped(void) const;
 
  knowledge::KnowledgeRecord inspect(KnowledgeRecord::Integer position) const;
 
  template<typename T>
  void inspect(KnowledgeRecord::Integer position, T& value) const;
 
  std::vector<KnowledgeRecord> inspect(
      KnowledgeRecord::Integer position, size_t count) const;
 
  template<typename T>
  void inspect(KnowledgeRecord::Integer position, size_t count,
      std::vector<T>& values) const;
 
  knowledge::KnowledgeRecord peek_latest(void) const;
 
  template<typename T>
  void peek_latest(T& value) const;
 
  std::vector<KnowledgeRecord> peek_latest(size_t count) const;
 
  template<typename T>
  void peek_latest(size_t count, std::vector<T>& values) const;
 
  size_t remaining(void) const;
 
  size_t count(void) const;
 
  size_t size(void) const;
 
  void resize(void);
 
  void set_index(KnowledgeRecord::Integer index);
 
  void resync(void);
 
private:
  KnowledgeRecord::Integer increment(
      KnowledgeRecord::Integer base, KnowledgeRecord::Integer value) const;
 
 
  mutable ThreadSafeContext* context_;
 
  std::string name_;
 
  Integer index_;
 
  mutable KnowledgeRecord::Integer local_index_;
 
  Vector buffer_;
 
  // Call to throw if preconditions aren't met
  void check_name(const char* func) const;
  void check_context(const char* func) const;
  void check_all(const char* func) const;
};
}
}
}
 
#include "CircularBufferConsumer.inl"
 
#endif  // _MADARA_KNOWLEDGE_CONTAINERS_CIRCULARBUFFERCONSUMER_H_