NativeCircularBufferConsumer.h

Go to the documentation of this file.

#ifndef _MADARA_KNOWLEDGE_CONTAINERS_NATIVECIRCULARBUFFERCONSUMER_H_
#define _MADARA_KNOWLEDGE_CONTAINERS_NATIVECIRCULARBUFFERCONSUMER_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 NativeCircularBufferConsumer
{
public:
  NativeCircularBufferConsumer();
 
  NativeCircularBufferConsumer(
      const std::string& name, KnowledgeBase& knowledge);
 
  NativeCircularBufferConsumer(const std::string& name, Variables& knowledge);
 
  virtual ~NativeCircularBufferConsumer() = 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);
 
  void set_name(const std::string& name, ThreadSafeContext& context);
 
  bool operator==(const NativeCircularBufferConsumer& value) const;
 
  bool operator!=(const NativeCircularBufferConsumer& value) const;
 
  inline madara::knowledge::KnowledgeRecord consume(void) const;
 
  KnowledgeRecord consume(size_t& dropped) const;
 
  template<typename T>
  void consume(T& value, size_t& dropped) const;
 
  template<typename T>
  void peek_latest(size_t count, std::vector<T>& values) const;
 
  inline std::vector<KnowledgeRecord> peek_latest(size_t count) const;
 
  inline madara::knowledge::KnowledgeRecord peek_latest(void) const;
 
  inline std::vector<KnowledgeRecord> consume_latest(size_t count) const;
 
  inline madara::knowledge::KnowledgeRecord consume_latest(void) 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;
 
  size_t get_dropped(void) const;
 
  size_t remaining(void) const;
 
  size_t count(void) const;
 
  size_t size(void) const;
 
  size_t get_index()
  {
    return local_index_;
  }
 
  void set_index(size_t index);
 
  KnowledgeRecord get_record() const;
 
  template<typename T>
  void consume_many(size_t count, std::vector<T>& values) const;
 
  std::vector<KnowledgeRecord> consume_many(size_t count) const;
 
  std::vector<KnowledgeRecord> consume_many(
      size_t count, size_t& dropped) 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;
 
  madara::knowledge::KnowledgeRecord inspect(
      KnowledgeRecord::Integer position) const;
 
private:
  mutable ThreadSafeContext* context_;
 
  VariableReference ref_;
 
  mutable size_t local_index_;
 
  // Call to throw if preconditions aren't met
  static void check_name(const char* func, const char* name);
  void check_context(const char* func) const;
};
} // containers
} // knowledge
} // madara
 
#include "NativeCircularBufferConsumer.inl"
 
#endif  // _MADARA_KNOWLEDGE_CONTAINERS_NATIVECIRCULARBUFFERCONSUMER_H_