ThreadSafeContext.h

Go to the documentation of this file.

#ifndef MADARA_THREADSAFECONTEXT_H
#define MADARA_THREADSAFECONTEXT_H
 
#include "madara/knowledge/FileHeader.h"
#include "madara/logger/Logger.h"
 
#include <string>
#include <map>
#include <memory>
#include <fstream>
#include "madara/utility/IntTypes.h"
 
#include "madara/MadaraExport.h"
#include "madara/LockType.h"
#include "madara/knowledge/KnowledgeRecord.h"
#include "madara/knowledge/KnowledgeRequirements.h"
#include "madara/knowledge/VariableReference.h"
#include "madara/knowledge/FunctionMap.h"
#include "madara/knowledge/KnowledgeUpdateSettings.h"
#include "madara/knowledge/KnowledgeReferenceSettings.h"
#include "madara/knowledge/CompiledExpression.h"
#include "madara/knowledge/CheckpointSettings.h"
#include "madara/knowledge/BaseStreamer.h"
#include "madara/transport/MessageHeader.h"
 
#ifdef _MADARA_JAVA_
#include "madara_jni.h"
#endif
 
#ifdef _MADARA_PYTHON_CALLBACKS_
#include "madara/Boost.h"
#include "boost/python/object.hpp"
#endif
 
namespace madara
{
namespace expression
{
class Interpreter;
class CompositeArrayReference;
class VariableNode;
}
 
namespace knowledge
{
 
typedef std::map<std::string, bool> CopySet;
 
typedef std::vector<std::string> PrefixVector;
 
class KnowledgeBaseImpl;
 
class MADARA_EXPORT ThreadSafeContext
{
public:
  friend class KnowledgeBaseImpl;
  friend class expression::CompositeArrayReference;
  friend class expression::VariableNode;
 
  ThreadSafeContext();
 
  ~ThreadSafeContext(void);
 
  madara::knowledge::KnowledgeRecord get(
      const std::string& key, const KnowledgeReferenceSettings& settings =
                                  KnowledgeReferenceSettings()) const;
 
  madara::knowledge::KnowledgeRecord get(const VariableReference& variable,
      const KnowledgeReferenceSettings& settings =
          KnowledgeReferenceSettings()) const;
 
  madara::knowledge::KnowledgeRecord get_actual(
      const std::string& key, const KnowledgeReferenceSettings& settings =
                                  KnowledgeReferenceSettings()) const;
 
  madara::knowledge::KnowledgeRecord get_actual(
      const VariableReference& variable,
      const KnowledgeReferenceSettings& settings =
          KnowledgeReferenceSettings()) const;
 
private:
  madara::knowledge::KnowledgeRecord* with(
      const std::string& key, const KnowledgeReferenceSettings& settings =
                                  KnowledgeReferenceSettings());
 
  madara::knowledge::KnowledgeRecord* with(const VariableReference& variable,
      const KnowledgeReferenceSettings& settings =
          KnowledgeReferenceSettings());
  const madara::knowledge::KnowledgeRecord* with(
      const std::string& key, const KnowledgeReferenceSettings& settings =
                                  KnowledgeReferenceSettings()) const;
 
  const madara::knowledge::KnowledgeRecord* with(
      const VariableReference& variable,
      const KnowledgeReferenceSettings& settings =
          KnowledgeReferenceSettings()) const;
 
  template<typename T>
  using MethodType = std::shared_ptr<T> (KnowledgeRecord::*)(void);
 
  template<typename T, MethodType<T> Get, typename K>
  std::shared_ptr<T> get_shared(
      K&& key, const KnowledgeReferenceSettings& settings)
  {
    auto rec = with(std::forward<K>(key), settings);
    if (rec)
    {
      return (rec->*Get)();
    }
    return nullptr;
  }
 
  template<typename T>
  using ConstMethodType = std::shared_ptr<T> (KnowledgeRecord::*)(void) const;
 
  template<typename T, ConstMethodType<T> Get, typename K>
  std::shared_ptr<T> get_shared(
      K&& key, const KnowledgeReferenceSettings& settings) const
  {
    auto rec = with(std::forward<K>(key), settings);
    if (rec)
    {
      return (rec->*Get)();
    }
    return nullptr;
  }
 
public:
  std::shared_ptr<const std::string> share_string(
      const std::string& key, const KnowledgeReferenceSettings& settings =
                                  KnowledgeReferenceSettings()) const
  {
    return get_shared<const std::string, &KnowledgeRecord::share_string>(
        key, settings);
  }
 
  std::shared_ptr<const std::string> share_string(
      const VariableReference& key, const KnowledgeReferenceSettings& settings =
                                        KnowledgeReferenceSettings()) const
  {
    return get_shared<const std::string, &KnowledgeRecord::share_string>(
        key, settings);
  }
 
  std::shared_ptr<const std::vector<KnowledgeRecord::Integer>> share_integers(
      const std::string& key, const KnowledgeReferenceSettings& settings =
                                  KnowledgeReferenceSettings()) const
  {
    return get_shared<const std::vector<KnowledgeRecord::Integer>,
        &KnowledgeRecord::share_integers>(key, settings);
  }
 
  std::shared_ptr<const std::vector<KnowledgeRecord::Integer>> share_integers(
      const VariableReference& key, const KnowledgeReferenceSettings& settings =
                                        KnowledgeReferenceSettings()) const
  {
    return get_shared<const std::vector<KnowledgeRecord::Integer>,
        &KnowledgeRecord::share_integers>(key, settings);
  }
 
  std::shared_ptr<const std::vector<double>> share_doubles(
      const std::string& key, const KnowledgeReferenceSettings& settings =
                                  KnowledgeReferenceSettings()) const
  {
    return get_shared<const std::vector<double>,
        &KnowledgeRecord::share_doubles>(key, settings);
  }
 
  std::shared_ptr<const std::vector<double>> share_doubles(
      const VariableReference& key, const KnowledgeReferenceSettings& settings =
                                        KnowledgeReferenceSettings()) const
  {
    return get_shared<const std::vector<double>,
        &KnowledgeRecord::share_doubles>(key, settings);
  }
 
  std::shared_ptr<const std::vector<unsigned char>> share_binary(
      const std::string& key, const KnowledgeReferenceSettings& settings =
                                  KnowledgeReferenceSettings()) const
  {
    return get_shared<const std::vector<unsigned char>,
        &KnowledgeRecord::share_binary>(key, settings);
  }
 
  std::shared_ptr<const std::vector<unsigned char>> share_binary(
      const VariableReference& key, const KnowledgeReferenceSettings& settings =
                                        KnowledgeReferenceSettings()) const
  {
    return get_shared<const std::vector<unsigned char>,
        &KnowledgeRecord::share_binary>(key, settings);
  }
 
  VariableReference get_ref(
      const std::string& key, const KnowledgeReferenceSettings& settings =
                                  KnowledgeReferenceSettings());
 
  VariableReference get_ref(
      const std::string& key, const KnowledgeReferenceSettings& settings =
                                  KnowledgeReferenceSettings()) const;
 
  KnowledgeRecord retrieve_index(const std::string& key, size_t index,
      const KnowledgeReferenceSettings& settings =
          KnowledgeReferenceSettings());
 
  KnowledgeRecord retrieve_index(const VariableReference& variable,
      size_t index,
      const KnowledgeReferenceSettings& settings =
          KnowledgeReferenceSettings());
 
  KnowledgeRecord* get_record(
      const std::string& key, const KnowledgeReferenceSettings& settings =
                                  KnowledgeReferenceSettings());
 
  int set_xml(const std::string& key, const char* value, size_t size,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  int set_xml(const VariableReference& variable, const char* value, size_t size,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  int set_jpeg(const std::string& key, const unsigned char* value, size_t size,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  int set_jpeg(const VariableReference& variable, const unsigned char* value,
      size_t size,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  int set_file(const std::string& key, const unsigned char* value, size_t size,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  int set_file(const VariableReference& variable, const unsigned char* value,
      size_t size,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  int set_text(const std::string& key, const char* value, size_t size,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  int set_text(const VariableReference& variable, const char* value,
      size_t size,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  template<typename T>
  int set_index(const std::string& key, size_t index, T&& value,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  template<typename T>
  int set_index(const VariableReference& variable, size_t index, T&& value,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  template<typename T>
  int set_index_unsafe(const VariableReference& variable, size_t index,
      T&& value,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  template<typename T>
  int set(const std::string& key, T&& value,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  template<typename T>
  int set(const VariableReference& variable, T&& value,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  template<typename T>
  int set(const std::string& key, const T* value, uint32_t size,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  template<typename T>
  int set(const VariableReference& variable, const T* value, uint32_t size,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  template<typename T>
  int set_unsafe(const VariableReference& variable, T&& value,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  template<typename T>
  int set_unsafe(const VariableReference& variable, const T* array, size_t size,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  int read_file(const std::string& key, const std::string& filename,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  int read_file(const VariableReference& variable, const std::string& filename,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  int set_if_unequal(const std::string& key,
      madara::knowledge::KnowledgeRecord::Integer value, uint32_t quality,
      uint64_t clock,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  int set_if_unequal(const std::string& key, double value, uint32_t quality,
      uint64_t clock,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  int set_if_unequal(const std::string& key, const std::string& value,
      uint32_t quality, uint64_t clock,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  int update_record_from_external(const std::string& key,
      const knowledge::KnowledgeRecord& rhs,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings(true));
 
  int update_record_from_external(const VariableReference& target,
      const knowledge::KnowledgeRecord& new_value,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings(true));
 
  uint32_t get_quality(
      const std::string& key, const KnowledgeReferenceSettings& settings =
                                  KnowledgeReferenceSettings());
 
  uint32_t get_write_quality(
      const std::string& key, const KnowledgeReferenceSettings& settings =
                                  KnowledgeReferenceSettings());
 
  uint32_t set_quality(const std::string& key, uint32_t quality,
      bool force_update, const KnowledgeReferenceSettings& settings);
 
  void set_changed(void);
 
  void set_write_quality(const std::string& key, uint32_t quality,
      const KnowledgeReferenceSettings& settings);
 
  const VariableReferenceMap& get_modifieds(void) const;
 
  KnowledgeMap get_modifieds_current(
      const std::map<std::string, bool> & send_list, bool reset = true);
 
  void add_modifieds(const VariableReferences& modifieds) const;
 
  VariableReferences save_modifieds(void) const;
 
  std::string debug_modifieds(void) const;
 
  const VariableReferenceMap& get_local_modified(void) const;
 
  void reset_modified(void);
 
  void reset_checkpoint(void) const;
 
  void apply_modified(void);
 
  void mark_modified(const VariableReference& variable,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  void mark_modified(const std::string& key,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  void mark_to_send(const VariableReference& variable,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  void mark_to_send(const std::string& key,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  void mark_to_checkpoint(const VariableReference& variable,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  void mark_to_checkpoint(const std::string& key,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  void reset_modified(const std::string& key);
 
  madara::knowledge::KnowledgeRecord inc(const std::string& key,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  madara::knowledge::KnowledgeRecord inc(const VariableReference& variable,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  void wait_for_change(bool extra_release = false);
 
  madara::knowledge::KnowledgeRecord dec(const std::string& key,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  madara::knowledge::KnowledgeRecord dec(const VariableReference& variable,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  bool clear(
      const std::string& key, const KnowledgeReferenceSettings& settings =
                                  KnowledgeReferenceSettings());
 
  bool clear(const VariableReference& variable);
 
  bool delete_variable(
      const std::string& key, const KnowledgeReferenceSettings& settings =
                                  KnowledgeReferenceSettings());
 
  bool delete_variable(
      const VariableReference& var, const KnowledgeReferenceSettings& settings =
                                        KnowledgeReferenceSettings());
 
  void delete_variables(KnowledgeMap::iterator begin,
      KnowledgeMap::iterator end,
      const KnowledgeReferenceSettings& settings =
          KnowledgeReferenceSettings());
 
  void delete_prefix(
      const std::string& prefix, const KnowledgeReferenceSettings& settings =
                                     KnowledgeReferenceSettings());
 
  bool delete_expression(const std::string& expression);
 
  bool exists(
      const std::string& key, const KnowledgeReferenceSettings& settings =
                                  KnowledgeReferenceSettings()) const;
 
  bool exists(const VariableReference& variable,
      const KnowledgeReferenceSettings& settings = KnowledgeReferenceSettings(
          false)) const;
 
  void print(unsigned int level) const;
 
  void print(const std::string& statement, unsigned int level) const;
 
  void clear(bool erase = false);
 
  void lock(void) const;
 
  bool try_lock(void) const;
 
  void unlock(void) const;
 
  uint64_t inc_clock(
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  uint64_t inc_clock(const std::string& key,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  uint64_t set_clock(uint64_t clock);
 
  uint64_t set_clock(const std::string& key, uint64_t clock,
      const KnowledgeReferenceSettings& settings =
          KnowledgeReferenceSettings());
 
  uint64_t get_clock(void) const;
 
  uint64_t get_clock(
      const std::string& key, const KnowledgeReferenceSettings& settings =
                                  KnowledgeReferenceSettings()) const;
 
  void signal(bool lock = true) const;
 
  std::string expand_statement(const std::string& statement) const;
 
  void copy(const ThreadSafeContext& source, const KnowledgeRequirements& reqs,
      const KnowledgeUpdateSettings& settings);
 
  void copy(const ThreadSafeContext& source,
      const CopySet& copy_set = CopySet(), bool clean_copy = false,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
#ifndef _MADARA_NO_KARL_
 
  CompiledExpression compile(const std::string& expression);
 
  void define_function(const std::string& name,
      knowledge::KnowledgeRecord (*func)(FunctionArguments&, Variables&),
      const KnowledgeReferenceSettings& settings =
          KnowledgeReferenceSettings());
 
  void define_function(const std::string& name,
      knowledge::KnowledgeRecord (*func)(
          const char*, FunctionArguments&, Variables&),
      const KnowledgeReferenceSettings& settings =
          KnowledgeReferenceSettings());
 
#ifdef _MADARA_JAVA_
  void define_function(const std::string& name, jobject callable,
      const KnowledgeReferenceSettings& settings =
          KnowledgeReferenceSettings());
#endif
 
#ifdef _MADARA_PYTHON_CALLBACKS_
  void define_function(const std::string& name, boost::python::object callable,
      const KnowledgeReferenceSettings& settings =
          KnowledgeReferenceSettings());
#endif
 
  void define_function(const std::string& name, const std::string& expression,
      const KnowledgeReferenceSettings& settings =
          KnowledgeReferenceSettings());
 
  void define_function(const std::string& name,
      const CompiledExpression& expression,
      const KnowledgeReferenceSettings& settings =
          KnowledgeReferenceSettings());
 
  Function* retrieve_function(
      const std::string& name, const KnowledgeReferenceSettings& settings =
                                   KnowledgeReferenceSettings());
 
  knowledge::KnowledgeRecord evaluate(CompiledExpression expression,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  knowledge::KnowledgeRecord evaluate(expression::ComponentNode* root,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
#endif  // _MADARA_NO_KARL_
 
  void to_string(std::string& target, const std::string& array_delimiter = ",",
      const std::string& record_delimiter = ";\n",
      const std::string& key_val_delimiter = "=") const;
 
  size_t to_vector(const std::string& subject, unsigned int start,
      unsigned int end, std::vector<KnowledgeRecord>& target);
 
  void get_matches(const std::string& prefix, const std::string& suffix,
      VariableReferences& matches);
 
  size_t to_map(const std::string& subject,
      std::map<std::string, knowledge::KnowledgeRecord>& target);
 
  void add_logger(const std::string& filename);
 
  int get_log_level(void);
 
  void set_log_level(int level);
 
  logger::Logger& get_logger(void) const;
 
  void attach_logger(logger::Logger& logger) const;
 
  size_t to_map(const std::string& prefix, const std::string& delimiter,
      const std::string& suffix, std::vector<std::string>& next_keys,
      std::map<std::string, knowledge::KnowledgeRecord>& result,
      bool just_keys);
 
  knowledge::KnowledgeMap to_map(const std::string& prefix) const;
 
  knowledge::KnowledgeMap to_map_stripped(const std::string& prefix) const;
 
  int64_t save_context(
      const std::string& filename, const std::string& id = "") const;
 
  int64_t save_context(const CheckpointSettings& settings) const;
 
  int64_t save_as_json(const std::string& filename) const;
 
  int64_t save_as_json(const CheckpointSettings& settings) const;
 
  int64_t save_as_karl(const std::string& filename) const;
 
  int64_t save_as_karl(const CheckpointSettings& settings) const;
 
  int64_t load_context(const std::string& filename, std::string& id,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings(
          true, true, true, false));
 
  int64_t load_context(const std::string& filename, FileHeader& meta,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings(
          true, true, true, false));
 
  int64_t load_context(CheckpointSettings& checkpoint_settings,
      const KnowledgeUpdateSettings& update_settings = KnowledgeUpdateSettings(
          true, true, true, false));
 
  KnowledgeRecord evaluate_file(CheckpointSettings& checkpoint_settings,
      const KnowledgeUpdateSettings& update_settings = KnowledgeUpdateSettings(
          true, true, true, false));
 
  std::string file_to_string(CheckpointSettings& checkpoint_settings);
 
  int64_t save_checkpoint(
      const std::string& filename, const std::string& id = "") const;
 
  int64_t save_checkpoint(const CheckpointSettings& settings) const;
 
  std::unique_ptr<BaseStreamer> attach_streamer(
      std::unique_ptr<BaseStreamer> streamer)
  {
    MADARA_GUARD_TYPE guard(mutex_);
 
    using std::swap;
    swap(streamer, streamer_);
 
    return streamer;
  }
 
  KnowledgeMap& get_map_unsafe(void)
  {
    return map_;
  }
 
  const KnowledgeMap& get_map_unsafe(void) const
  {
    return map_;
  }
  
  template<typename Callable>
  auto invoke(const std::string& key, Callable&& callable,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings())
      -> decltype(utility::invoke_(
          std::forward<Callable>(callable), std::declval<KnowledgeRecord&>()))
  {
    MADARA_GUARD_TYPE guard(mutex_);
    auto ref = get_ref(key, settings);
    return utility::invoke_(std::forward<Callable>(callable), *ref.get_record_unsafe());
  }
 
  template<typename Callable>
  auto invoke(const VariableReference& key, Callable&& callable,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings())
      -> decltype(utility::invoke_(
          std::forward<Callable>(callable), std::declval<KnowledgeRecord&>()))
  {
    MADARA_GUARD_TYPE guard(mutex_);
    (void)settings;
    return utility::invoke_(std::forward<Callable>(callable), *key.get_record_unsafe());
  }
 
  template<typename Callable>
  auto invoke(const std::string& key, Callable&& callable,
      const KnowledgeReferenceSettings& settings = KnowledgeReferenceSettings())
      const -> decltype(utility::invoke_(
          std::forward<Callable>(callable), std::declval<KnowledgeRecord&>()))
  {
    MADARA_GUARD_TYPE guard(mutex_);
    const KnowledgeRecord* ptr = with(key, settings);
    if (ptr)
    {
      return utility::invoke_(std::forward<Callable>(callable), *ptr);
    }
    const KnowledgeRecord empty;
    return utility::invoke_(std::forward<Callable>(callable), empty);
  }
 
  template<typename Callable>
  auto invoke(const VariableReference& key, Callable&& callable,
      const KnowledgeReferenceSettings& settings = KnowledgeReferenceSettings())
      const -> decltype(utility::invoke_(
          std::forward<Callable>(callable), std::declval<KnowledgeRecord&>()))
  {
    MADARA_GUARD_TYPE guard(mutex_);
    (void)settings;
    return utility::invoke_(std::forward<Callable>(callable),
        const_cast<const KnowledgeRecord&>(*key.get_record_unsafe()));
  }
 
  template<typename Callable>
  auto cinvoke(const std::string& key, Callable&& callable,
      const KnowledgeReferenceSettings& settings = KnowledgeReferenceSettings())
      const -> decltype(utility::invoke_(
          std::forward<Callable>(callable), std::declval<KnowledgeRecord&>()))
  {
    return invoke(key, std::forward<Callable>(callable), settings);
  }
 
  template<typename Callable>
  auto cinvoke(const VariableReference& key, Callable&& callable,
      const KnowledgeReferenceSettings& settings = KnowledgeReferenceSettings())
      const -> decltype(utility::invoke_(
          std::forward<Callable>(callable), std::declval<KnowledgeRecord&>()))
  {
    return invoke(key, std::forward<Callable>(callable), settings);
  }
 
  template<typename Func>
  void for_each(Func&& func) const
  {
    MADARA_GUARD_TYPE guard(mutex_);
 
    std::for_each(map_.begin(), map_.end(), func);
  }
 
protected:
private:
  void mark_to_send_unsafe(VariableReference ref,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  void mark_to_checkpoint_unsafe(VariableReference ref,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  void mark_and_signal(VariableReference ref,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  template<typename... Args>
  int set_unsafe_impl(const VariableReference& variable,
      const KnowledgeUpdateSettings& settings, Args&&... args);
 
  template<typename T>
  int set_index_unsafe_impl(const VariableReference& variable, size_t index,
      T&& value,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  std::pair<KnowledgeMap::const_iterator, KnowledgeMap::const_iterator>
  get_prefix_range(const std::string& prefix) const;
 
  std::pair<KnowledgeMap::iterator, KnowledgeMap::iterator> get_prefix_range(
      const std::string& prefix);
 
  madara::knowledge::KnowledgeMap map_;
  mutable MADARA_LOCK_TYPE mutex_;
  mutable MADARA_CONDITION_TYPE changed_;
  std::vector<std::string> expansion_splitters_;
  mutable uint64_t clock_;
  mutable VariableReferenceMap changed_map_;
  mutable VariableReferenceMap local_changed_map_;
 
  FunctionMap functions_;
 
  madara::expression::Interpreter* interpreter_;
 
  mutable logger::Logger* logger_;
 
  std::unique_ptr<BaseStreamer> streamer_ = nullptr;
};
}
}
 
#include "ThreadSafeContext.inl"
 
#endif