CircularBuffer.h

Go to the documentation of this file.

 
#ifndef _MADARA_KNOWLEDGE_CONTAINERS_CIRCULARBUFFER_H_
#define _MADARA_KNOWLEDGE_CONTAINERS_CIRCULARBUFFER_H_
 
#include <vector>
#include <string>
#include "madara/MadaraExport.h"
#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 CircularBuffer
{
public:
  CircularBuffer(
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  CircularBuffer(const std::string& name, KnowledgeBase& knowledge,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  CircularBuffer(const std::string& name, Variables& knowledge,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  CircularBuffer(const std::string& name, KnowledgeBase& knowledge, int size,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  CircularBuffer(const std::string& name, Variables& knowledge, int size,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  virtual ~CircularBuffer() = 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 CircularBuffer& value) const;
 
  bool operator!=(const CircularBuffer& value) const;
 
  void add(const knowledge::KnowledgeRecord& record);
 
  template<typename T>
  void add(const T& value);
 
  void add(const std::vector<KnowledgeRecord>& records);
 
  template<typename T>
  void add(const std::vector<T>& values);
 
  knowledge::KnowledgeRecord get(void) const;
 
  template<typename T>
  void get(T& value) const;
 
  std::vector<KnowledgeRecord> get_latest(size_t count) const;
 
  template<typename T>
  void get_latest(size_t count, std::vector<T>& values) const;
 
  std::vector<KnowledgeRecord> get_earliest(size_t count) const;
 
  template<typename T>
  void get_earliest(size_t count, std::vector<T>& values) 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;
 
  void clear(void);
 
  size_t count(void) const;
 
  size_t size(void) const;
 
  KnowledgeUpdateSettings set_settings(const KnowledgeUpdateSettings& settings);
 
  void set_quality(uint32_t quality,
      const KnowledgeReferenceSettings& settings = KnowledgeReferenceSettings(
          false));
 
  void resize(int size = -1);
 
  void set_index(KnowledgeRecord::Integer index);
 
private:
  KnowledgeRecord::Integer increment(
      KnowledgeRecord::Integer base, KnowledgeRecord::Integer value) const;
 
 
  mutable ThreadSafeContext* context_;
 
  std::string name_;
 
  Integer index_;
 
  Vector buffer_;
 
  VariableReference size_ref_;
 
  KnowledgeUpdateSettings settings_;
 
  // 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 "CircularBuffer.inl"
 
#endif  // _MADARA_KNOWLEDGE_CONTAINERS_CIRCULARBUFFER_H_