KnowledgeBaseImpl.h

Go to the documentation of this file.

#ifndef _MADARA_KNOWLEDGE_BASE_IMPL_H
#define _MADARA_KNOWLEDGE_BASE_IMPL_H
 
#include <string>
#include <map>
 
#include <ostream>
#include <vector>
#include <atomic>
 
#include "madara/knowledge/CompiledExpression.h"
#include "madara/knowledge/WaitSettings.h"
#include "madara/knowledge/KnowledgeUpdateSettings.h"
#include "madara/knowledge/CheckpointSettings.h"
#include "madara/knowledge/KnowledgeRecord.h"
#include "madara/knowledge/VariableReference.h"
#include "madara/MadaraExport.h"
#include "madara/knowledge/ThreadSafeContext.h"
#include "madara/transport/Transport.h"
#include "madara/expression/Interpreter.h"
 
namespace madara
{
namespace knowledge
{
class KnowledgeBaseImpl
{
public:
  KnowledgeBaseImpl();
 
  KnowledgeBaseImpl(const std::string& host, int transport);
 
  KnowledgeBaseImpl(
      const std::string& host, int transport, const std::string& domain);
 
  KnowledgeBaseImpl(const std::string& host,
      const madara::transport::TransportSettings& config);
 
  ~KnowledgeBaseImpl();
 
  void lock(void);
 
  void unlock(void);
 
  void activate_transport(void);
 
  size_t get_num_transports(void);
 
  void close_transport(void);
 
  void copy(const KnowledgeBaseImpl& source, const KnowledgeRequirements& reqs,
      const EvalSettings& settings = EvalSettings());
 
  void copy(const KnowledgeBaseImpl& source,
      const CopySet& copy_set = CopySet(), bool clean_copy = false,
      const EvalSettings& settings = EvalSettings());
 
  madara::knowledge::KnowledgeRecord get(
      const std::string& key, const KnowledgeReferenceSettings& settings =
                                  KnowledgeReferenceSettings());
 
  madara::knowledge::KnowledgeRecord get(const VariableReference& variable,
      const KnowledgeReferenceSettings& settings =
          KnowledgeReferenceSettings());
 
  VariableReference get_ref(
      const std::string& key, const KnowledgeReferenceSettings& settings =
                                  KnowledgeReferenceSettings());
 
  template<typename K>
  std::shared_ptr<const std::string> share_string(
      K&& key, const KnowledgeReferenceSettings& settings =
                   KnowledgeReferenceSettings()) const
  {
    return map_.share_string(std::forward<K>(key), settings);
  }
 
  template<typename K>
  std::shared_ptr<const std::vector<KnowledgeRecord::Integer>> share_integers(
      K&& key, const KnowledgeReferenceSettings& settings =
                   KnowledgeReferenceSettings()) const
  {
    return map_.share_integers(std::forward<K>(key), settings);
  }
 
  template<typename K>
  std::shared_ptr<const std::vector<double>> share_doubles(
      K&& key, const KnowledgeReferenceSettings& settings =
                   KnowledgeReferenceSettings()) const
  {
    return map_.share_doubles(std::forward<K>(key), settings);
  }
 
  template<typename K>
  std::shared_ptr<const std::vector<unsigned char>> share_binary(
      K&& key, const KnowledgeReferenceSettings& settings =
                   KnowledgeReferenceSettings()) const
  {
    return map_.share_binary(std::forward<K>(key), settings);
  }
 
  void mark_modified(const VariableReference& variable,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  void mark_modified(const std::string& name,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings());
 
  madara::knowledge::KnowledgeRecord retrieve_index(const std::string& key,
      size_t index,
      const KnowledgeReferenceSettings& settings =
          KnowledgeReferenceSettings());
 
  madara::knowledge::KnowledgeRecord retrieve_index(
      const VariableReference& variable, size_t index,
      const KnowledgeReferenceSettings& settings =
          KnowledgeReferenceSettings());
 
  std::string expand_statement(const std::string& statement) const;
 
  std::string debug_modifieds(void) const;
 
  int get_log_level(void);
 
  void attach_logger(logger::Logger& logger) const;
 
  logger::Logger& get_logger(void) const;
 
  void set_log_level(int level);
 
#ifndef _MADARA_NO_KARL_
 
  CompiledExpression compile(const std::string& expression);
 
  madara::knowledge::KnowledgeRecord evaluate(const std::string& expression);
 
  madara::knowledge::KnowledgeRecord evaluate(
      const std::string& expression, const EvalSettings& settings);
 
  madara::knowledge::KnowledgeRecord evaluate(
      CompiledExpression& expression, const EvalSettings& settings);
 
  madara::knowledge::KnowledgeRecord evaluate(expression::ComponentNode* root,
      const EvalSettings& settings = EvalSettings());
 
  madara::knowledge::KnowledgeRecord wait(const std::string& expression);
 
  madara::knowledge::KnowledgeRecord wait(
      const std::string& expression, const WaitSettings& settings);
 
  madara::knowledge::KnowledgeRecord wait(
      CompiledExpression& expression, const WaitSettings& settings);
 
  void define_function(const std::string& name,
      knowledge::KnowledgeRecord (*func)(FunctionArguments&, Variables&));
 
  void define_function(
      const std::string& name, knowledge::KnowledgeRecord (*func)(const char*,
                                   FunctionArguments&, Variables&));
 
#ifdef _MADARA_JAVA_
  void define_function(const std::string& name, jobject callable);
#endif
 
#ifdef _MADARA_PYTHON_CALLBACKS_
  void define_function(const std::string& name, boost::python::object callable);
#endif
 
  void define_function(const std::string& name, const std::string& expression);
 
  void define_function(
      const std::string& name, const CompiledExpression& expression);
 
#endif  // _MADARA_NO_KARL_
 
  int read_file(const std::string& knowledge_key, const std::string& filename,
      const EvalSettings& settings = EvalSettings());
 
  ssize_t write_file(
      const std::string& knowledge_key, const std::string& filename);
 
  template<typename K, typename V>
  int set(K&& key, V&& val, const EvalSettings& settings)
  {
    int result = map_.set(std::forward<K>(key), std::forward<V>(val), settings);
 
    send_modifieds("KnowledgeBaseImpl:set", settings);
 
    return result;
  }
 
  template<typename K, typename V>
  int set_index(K&& key, size_t i, V&& val, const EvalSettings& settings)
  {
    int result =
        map_.set_index(std::forward<K>(key), i, std::forward<V>(val), settings);
 
    send_modifieds("KnowledgeBaseImpl:set_index", settings);
 
    return result;
  }
 
  template<typename K, typename V>
  int set(K&& key, const V* arr, size_t size, const EvalSettings& settings)
  {
    int result = map_.set(std::forward<K>(key), arr, (uint32_t)size, settings);
 
    send_modifieds("KnowledgeBaseImpl:set", settings);
 
    return result;
  }
 
  int read_file(const VariableReference& variable, const std::string& filename,
      const EvalSettings& settings = EvalSettings());
 
  int set_text(const VariableReference& variable, const char* value,
      size_t size, const EvalSettings& settings = EvalSettings());
 
  int set_file(const VariableReference& variable, const unsigned char* value,
      size_t size, const EvalSettings& settings = EvalSettings());
 
  int set_jpeg(const VariableReference& variable, const unsigned char* value,
      size_t size, const EvalSettings& settings = EvalSettings());
 
  int set_xml(const VariableReference& variable, const char* value, size_t size,
      const EvalSettings& settings = EvalSettings());
 
  madara::transport::TransportSettings& transport_settings(void);
 
  int apply_modified(const EvalSettings& settings = EvalSettings());
 
  bool exists(
      const std::string& key, const KnowledgeReferenceSettings& settings =
                                  KnowledgeReferenceSettings()) const;
 
  bool exists(const VariableReference& variable,
      const KnowledgeReferenceSettings& settings = KnowledgeReferenceSettings(
          false)) const;
 
  void set_quality(const std::string& key, uint32_t quality,
      const KnowledgeReferenceSettings& settings =
          KnowledgeReferenceSettings());
 
  void print(unsigned int level) const;
 
  void print(const std::string& statement, unsigned int level) const;
 
  void to_string(std::string& target, const std::string& array_delimiter = ",",
      const std::string& record_delimiter = ";\n",
      const std::string& key_val_delimiter = "=") const;
 
  bool clear(
      const std::string& key, const KnowledgeReferenceSettings& settings =
                                  KnowledgeReferenceSettings());
 
  void clear(bool erase = false);
 
  void clear_map(void);
 
  void clear_rules(void);
 
  void acquire(void);
 
  void release(void);
 
  size_t attach_transport(madara::transport::Base* transport);
 
  size_t attach_transport(
      const std::string& id, transport::TransportSettings& settings);
 
  size_t remove_transport(size_t index);
 
  ThreadSafeContext& get_context(void);
 
  std::string get_id(void);
 
  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);
 
  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;
 
  int64_t save_context(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 save_checkpoint(
      const std::string& filename, bool reset_modifieds = true);
 
  int64_t save_checkpoint(CheckpointSettings& settings) const;
 
  std::unique_ptr<BaseStreamer> attach_streamer(
      std::unique_ptr<BaseStreamer> streamer)
  {
    return map_.attach_streamer(std::move(streamer));
  }
 
  int64_t load_context(const std::string& filename, bool use_id,
      const KnowledgeUpdateSettings& settings = KnowledgeUpdateSettings(
          true, true, true, false));
 
  int64_t load_context(const std::string& filename, FileHeader& meta,
      bool use_id = true,
      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);
 
  void clear_modifieds(void);
 
  void reset_checkpoint(void) const;
 
  void add_modifieds(const VariableReferences& modifieds) const;
 
  VariableReferences save_modifieds(void) const;
 
  MADARA_EXPORT int send_modifieds(const std::string& prefix,
      const EvalSettings& settings = EvalSettings::SEND);
 
  void wait_for_change(void);
 
  std::string setup_unique_hostport(std::string host = "");
 
private:
  struct ModifiedsSender
  {
    KnowledgeBaseImpl* self;
    const char* func;
    const EvalSettings* settings;
 
    ~ModifiedsSender()
    {
      self->send_modifieds(func, *settings);
    }
  };
 
public:
  
  template<typename Callable>
  auto invoke(const std::string& key, Callable&& callable,
      const EvalSettings& settings = EvalSettings())
      -> decltype(utility::invoke_(
          std::forward<Callable>(callable), std::declval<KnowledgeRecord&>()))
  {
    ModifiedsSender sender = {this, "KnowledgeBase::invoke", &settings};
    return map_.invoke(key, std::forward<Callable>(callable), settings);
  }
 
  template<typename Callable>
  auto invoke(const VariableReference& key, Callable&& callable,
      const EvalSettings& settings = EvalSettings())
      -> decltype(utility::invoke_(
          std::forward<Callable>(callable), std::declval<KnowledgeRecord&>()))
  {
    ModifiedsSender sender = {this, "KnowledgeBase::invoke", &settings};
    return map_.invoke(key, std::forward<Callable>(callable), settings);
  }
 
  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&>()))
  {
    return map_.invoke(key, std::forward<Callable>(callable), settings);
  }
 
  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&>()))
  {
    return map_.invoke(key, std::forward<Callable>(callable), settings);
  }
 
  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 map_.cinvoke(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 map_.cinvoke(key, std::forward<Callable>(callable), settings);
  }
 
  template<typename Func>
  void for_each(Func&& func) const
  {
    map_.for_each(std::forward<Func>(func));
  }
 
private:
  ThreadSafeContext map_;
  std::string id_;
  transport::QoSTransportSettings settings_;
  
  mutable MADARA_LOCK_TYPE transport_mutex_;
  mutable MADARA_LOCK_TYPE send_mutex_;
  mutable MADARA_LOCK_TYPE done_sending_mutex_;
 
  std::vector<std::shared_ptr<transport::Base>> transports_;
 
  std::vector<std::shared_ptr<transport::Base>> get_transports()
  {
    MADARA_GUARD_TYPE transport_guard(transport_mutex_);
    return transports_;
  }
 
  bool done_sending_ = false;
};
}
}
 
// include the inline functions
#include "KnowledgeBaseImpl.inl"
 
#endif  // _MADARA_KNOWLEDGE_BASE_IMPL_H