KnowledgeBaseImpl.inl

Go to the documentation of this file.

#ifndef _MADARA_KNOWLEDGE_BASE_IMPL_INL_
#define _MADARA_KNOWLEDGE_BASE_IMPL_INL_

#include "madara/utility/Utility.h"
#include "madara/knowledge/KnowledgeBaseImpl.h"
#include "madara/knowledge/KnowledgeRecord.h"
#include "madara/expression/Interpreter.h"
#include "madara/expression/ExpressionTree.h"


namespace madara { namespace knowledge {

inline KnowledgeBaseImpl::KnowledgeBaseImpl ()
  : settings_ (), files_ (map_)
{
  //activate_transport ();
  // no hope of transporting, so don't setup uniquehostport
}

inline KnowledgeBaseImpl::KnowledgeBaseImpl (
  const std::string & host, int transport)
  : settings_ (), files_ (map_)
{
  // override default settings for the arguments
  settings_.type = transport;

  id_ = setup_unique_hostport (host);
  activate_transport ();
}

inline KnowledgeBaseImpl::KnowledgeBaseImpl (
  const std::string & host, int transport,
  const std::string & knowledge_domain)
  : settings_ (), files_ (map_)
{
  // override default settings for the arguments
  settings_.type = transport;
  settings_.write_domain = knowledge_domain;

  id_ = setup_unique_hostport (host);
  activate_transport ();
}

inline KnowledgeBaseImpl::KnowledgeBaseImpl (
  const std::string & host, const madara::transport::TransportSettings & config)
  : settings_ (config), files_ (map_)
{
  id_ = setup_unique_hostport (host);
  if (!settings_.delay_launch)
    activate_transport ();
}

inline KnowledgeBaseImpl::~KnowledgeBaseImpl ()
{
  close_transport ();
  unique_bind_.close ();
}
inline KnowledgeRecord
KnowledgeBaseImpl::get (
  const std::string & t_key,
  const KnowledgeReferenceSettings & settings)
{
  return map_.get (t_key, settings);
}

inline KnowledgeRecord
KnowledgeBaseImpl::get (
  const VariableReference & variable,
  const KnowledgeReferenceSettings & settings)
{
  return map_.get (variable, settings);
}

inline VariableReference
KnowledgeBaseImpl::get_ref (
  const std::string & t_key,
  const KnowledgeReferenceSettings & settings)
{
  return map_.get_ref (t_key, settings);
}

inline int
KnowledgeBaseImpl::get_log_level (void)
{
  return map_.get_log_level ();
}

inline std::string
KnowledgeBaseImpl::debug_modifieds (void) const
{
  return map_.debug_modifieds ();
}

inline madara::logger::Logger &
KnowledgeBaseImpl::get_logger (void) const
{
  return map_.get_logger ();
}

inline void
KnowledgeBaseImpl::attach_logger (
  logger::Logger & logger) const
{
  map_.attach_logger (logger);
}

inline void
KnowledgeBaseImpl::set_log_level (int level)
{
  map_.set_log_level (level);
}

inline KnowledgeRecord
KnowledgeBaseImpl::retrieve_index (
  const std::string & t_key,
  size_t index,
  const KnowledgeReferenceSettings & settings)
{
  return map_.retrieve_index (t_key, index, settings);
}

inline KnowledgeRecord
KnowledgeBaseImpl::retrieve_index (
  const VariableReference & variable,
  size_t index,
  const KnowledgeReferenceSettings & settings)
{
  return map_.retrieve_index (variable, index, settings);
}

inline bool
KnowledgeBaseImpl::exists (
  const std::string & key,
  const KnowledgeReferenceSettings & settings) const
{
  return map_.exists (key, settings);
}

inline bool
KnowledgeBaseImpl::exists (
  const VariableReference & variable,
  const KnowledgeReferenceSettings & settings) const
{
  return map_.exists (variable, settings);
}

inline int
KnowledgeBaseImpl::apply_modified (
const EvalSettings & settings)
{
  // lock the context and apply modified flags and current clock to
  // all global variables
  map_.lock ();
  map_.apply_modified ();

  int ret = 0;

  send_modifieds ("KnowledgeBaseImpl:apply_modified", settings);

  map_.unlock ();

  return ret;
}

inline void
KnowledgeBaseImpl::mark_modified (
  const VariableReference & variable,
  const KnowledgeUpdateSettings & settings)
{
  map_.mark_modified (variable, settings);
}

inline void
KnowledgeBaseImpl::mark_modified (
  const std::string & name,
  const KnowledgeUpdateSettings & settings)
{
  map_.mark_modified (name, settings);
}

inline int
KnowledgeBaseImpl::read_file (
const std::string & key, const std::string & filename,
const EvalSettings & settings)
{
  if (key == "")
    return -1;

  int result = map_.read_file (key, filename, settings);

  send_modifieds ("KnowledgeBaseImpl:read_file", settings);

  return result;
}

inline int
KnowledgeBaseImpl::set_file (
const VariableReference & variable,
const unsigned char * value, size_t size,
const EvalSettings & settings)
{
  int result = map_.set_file (variable, value, size, settings);

  send_modifieds ("KnowledgeBaseImpl:set_file", settings);

  return result;
}

inline int
KnowledgeBaseImpl::set_jpeg (
const VariableReference & variable,
const unsigned char * value, size_t size,
const EvalSettings & settings)
{
  int result = map_.set_jpeg (variable, value, size, settings);

  send_modifieds ("KnowledgeBaseImpl:set_jpeg", settings);

  return result;
}

inline int
KnowledgeBaseImpl::read_file (
const VariableReference & variable,
const std::string & filename,
const EvalSettings & settings)
{
  int result = map_.read_file (variable, filename, settings);

  send_modifieds ("KnowledgeBaseImpl:read_file", settings);

  return result;
}

inline void
KnowledgeBaseImpl::activate_transport (void)
{
  if (transports_.size () == 0)
  {
    attach_transport (id_, settings_);
  }
  else
  {
    madara_logger_log (map_.get_logger (), logger::LOG_MAJOR,
      "KnowledgeBaseImpl::activate_transport:" \
      " transport already activated. If you need" \
      " a new type, close transport first\n");
  }
}

inline void
KnowledgeBaseImpl::copy (
const KnowledgeBaseImpl & source,
const KnowledgeRequirements & reqs)
{
  map_.copy (source.map_, reqs);
}

inline void
KnowledgeBaseImpl::copy (
const KnowledgeBaseImpl & source,
const CopySet & copy_set,
bool clean_copy)
{
  map_.copy (source.map_, copy_set, clean_copy);
}

inline void
KnowledgeBaseImpl::lock (void)
{
  map_.lock ();
}

inline void
KnowledgeBaseImpl::unlock (void)
{
  map_.unlock ();
}


inline std::string
KnowledgeBaseImpl::expand_statement (
  const std::string & statement) const
{
  return map_.expand_statement (statement);
}

inline int
KnowledgeBaseImpl::read_policy (
  const std::string & knowledge_key, const std::string & filename)
{
  return files_.read_policy (knowledge_key, filename);
}

inline ssize_t
KnowledgeBaseImpl::write_file (
  const std::string & knowledge_key, const std::string & filename)
{
  return map_.get_record (knowledge_key)->to_file (filename);
}

inline void
KnowledgeBaseImpl::set_quality (
  const std::string & t_key, uint32_t quality,
  const KnowledgeReferenceSettings & settings)
{
  map_.set_write_quality (t_key, quality, settings);
}

#ifdef _USE_CID_

inline void
KnowledgeBaseImpl::print_all_redeployment_results (
  std::ostream & output)
{
  settings_.print_all_results (output);
}

inline void
KnowledgeBaseImpl::run_all (void)
{
  settings_.run_all ();
}

inline void
KnowledgeBaseImpl::print_my_latencies (
  std::ostream & output)
{
  settings_.print_my_latencies (output);
}

inline void
KnowledgeBaseImpl::print_all_latencies (
  std::ostream & output)
{
  settings_.print_all_latencies (output);
}

inline void
KnowledgeBaseImpl::print_all_summations (
  std::ostream & output)
{
  settings_.print_all_summations (output);
}

inline long
KnowledgeBaseImpl::start_latency (void)
{
  if (transport_)
    return transport_->start_latency ();
  else
    return -1;
}

inline long
KnowledgeBaseImpl::vote (void)
{
  if (transport_)
    return transport_->vote ();
  else
    return -1;
}

#endif // _USE_CID_

inline madara::transport::TransportSettings &
KnowledgeBaseImpl::transport_settings (void)
{
  return settings_;
}

inline void
KnowledgeBaseImpl::print (
  unsigned int level) const
{
  map_.print (
    "\nKnowledge in Knowledge Base:\n", logger::LOG_ALWAYS);

  map_.print (level);
}

inline void
KnowledgeBaseImpl::to_string (
  std::string & target,
  const std::string & array_delimiter,
  const std::string & record_delimiter,
  const std::string & key_val_delimiter) const
{
  map_.to_string (target,
    array_delimiter, record_delimiter, key_val_delimiter);
}

inline void
KnowledgeBaseImpl::print (
  const std::string & statement, unsigned int level) const
{
  map_.print (statement, level);
}

inline bool
KnowledgeBaseImpl::clear (const std::string & key,
  const KnowledgeReferenceSettings & settings)
{
  return map_.clear (key, settings);
}

inline void
KnowledgeBaseImpl::clear (bool erase)
{
  map_.clear (erase);
}

inline void
KnowledgeBaseImpl::clear_map (void)
{
  map_.clear ();
}

inline void KnowledgeBaseImpl::acquire (void)
{
  map_.lock ();
}

inline void KnowledgeBaseImpl::release (void)
{
  map_.unlock ();
}

#ifndef _MADARA_NO_KARL_

// Defines a function
inline void
KnowledgeBaseImpl::define_function (
  const std::string & name, KnowledgeRecord (*func) (FunctionArguments &, Variables &))
{
  map_.define_function (name, func);
}

// Defines a function
inline void
KnowledgeBaseImpl::define_function (
  const std::string & name,
    KnowledgeRecord (*func) (const char *, FunctionArguments &, Variables &))
{
  map_.define_function (name, func);
}

#ifdef _MADARA_JAVA_
inline void
KnowledgeBaseImpl::define_function (
  const std::string & name, jobject callable)
{
  map_.define_function (name, callable);
}
#endif

#ifdef _MADARA_PYTHON_CALLBACKS_

inline void
KnowledgeBaseImpl::define_function (
  const std::string & name, boost::python::object callable)
{
  map_.define_function (name, callable);
}

#endif

inline void
KnowledgeBaseImpl::define_function (const std::string & name,
  const std::string & expression)
{
  map_.define_function (name, expression);
}


inline void
KnowledgeBaseImpl::define_function (
  const std::string & name,
  const CompiledExpression & expression)
{
  map_.define_function (name, expression);
}

inline KnowledgeRecord
KnowledgeBaseImpl::wait (
  const std::string & expression)
{
  CompiledExpression compiled = compile (expression);
  WaitSettings settings;
  return wait (compiled, settings);
}

inline KnowledgeRecord
KnowledgeBaseImpl::evaluate (
  const std::string & expression)
{
  CompiledExpression compiled = compile (expression);
  EvalSettings settings;
  return evaluate (compiled, settings);
}

#endif // _MADARA_NO_KARL_

inline size_t
KnowledgeBaseImpl::attach_transport (
  madara::transport::Base * transport)
{
  transports_.push_back (transport);
  return transports_.size ();
}

inline size_t
KnowledgeBaseImpl::get_num_transports (void)
{
  return transports_.size ();
}

inline size_t
KnowledgeBaseImpl::remove_transport (size_t index)
{
  return transports_.erase (index);
}

inline ThreadSafeContext &
KnowledgeBaseImpl::get_context (void)
{
  return map_;
}


inline std::string
KnowledgeBaseImpl::get_id (void)
{
  if (id_ == "")
  {
    id_ = setup_unique_hostport ();
  }

  return id_;
}

inline size_t
KnowledgeBaseImpl::to_vector (
                              const std::string & subject,
                              unsigned int start,
                              unsigned int end,
                              std::vector <KnowledgeRecord> & target)
{
  return map_.to_vector (subject, start, end, target);
}

inline void
KnowledgeBaseImpl::get_matches (
      const std::string & prefix,
      const std::string & suffix,
      VariableReferences & matches)
{
  map_.get_matches (prefix, suffix, matches);
}

inline size_t
KnowledgeBaseImpl::to_map (
  const std::string & expression,
  std::map <std::string, KnowledgeRecord> & target)
{
  return map_.to_map (expression, target);
}

inline size_t
KnowledgeBaseImpl::to_map (
  const std::string & prefix,
  const std::string & delimiter,
  const std::string & suffix,
  std::vector <std::string> & next_keys,
  std::map <std::string, KnowledgeRecord> & result,
  bool just_keys)
{
  return map_.to_map (
    prefix, delimiter, suffix, next_keys, result, just_keys);
}

inline KnowledgeMap
KnowledgeBaseImpl::to_map (
  const std::string & prefix) const
{
  return map_.to_map (prefix);
}

inline KnowledgeMap
KnowledgeBaseImpl::to_map_stripped (
  const std::string & prefix) const
{
  return map_.to_map_stripped (prefix);
}


inline int64_t
KnowledgeBaseImpl::save_context (
  const std::string & filename) const
{
  return map_.save_context (filename, id_);
}

inline int64_t
KnowledgeBaseImpl::save_context (
  CheckpointSettings & settings) const
{
  settings.originator = id_;
  return map_.save_context (settings);
}

inline int64_t
KnowledgeBaseImpl::save_as_json (
const std::string & filename) const
{
  return map_.save_as_json (filename);
}

inline int64_t
KnowledgeBaseImpl::save_as_json (
const CheckpointSettings & settings) const
{
  return map_.save_as_json (settings);
}

inline int64_t
KnowledgeBaseImpl::save_as_karl (
const std::string & filename) const
{
  return map_.save_as_karl (filename);
}

inline int64_t
KnowledgeBaseImpl::save_as_karl (
const CheckpointSettings & settings) const
{
  return map_.save_as_karl (settings);
}

inline void
KnowledgeBaseImpl::clear_modifieds (
  void)
{
  map_.reset_modified ();
}

inline void
madara::knowledge::KnowledgeBaseImpl::reset_checkpoint (
  void) const
{
  map_.reset_checkpoint ();
}

inline int64_t
KnowledgeBaseImpl::save_checkpoint (
  const std::string & filename,
  bool reset_modifieds)
{
  int64_t total_written = map_.save_checkpoint (filename, id_);

  if (reset_modifieds)
    map_.reset_checkpoint ();

  return total_written;
}

inline int64_t
KnowledgeBaseImpl::save_checkpoint (
  CheckpointSettings & settings) const
{
  settings.originator = id_;
  return map_.save_checkpoint (settings);
}

inline int64_t
  KnowledgeBaseImpl::load_context (
  const std::string & filename,
  bool  use_id,
  const KnowledgeUpdateSettings & settings)
{
  int64_t result = 0;

  if (use_id)
    result = map_.load_context (filename, id_, settings);
  else
  {
    std::string id;
    result = map_.load_context (filename, id, settings);
  }

  return result;
}

inline int64_t
KnowledgeBaseImpl::load_context (
const std::string & filename,
FileHeader & meta,
bool  use_id,
const KnowledgeUpdateSettings & settings)
{
  int64_t result = 0;

  if (use_id)
  {
    result = map_.load_context (filename, meta, settings);
    id_ = meta.originator;
  }
  else
  {
    result = map_.load_context (filename, meta, settings);
  }

  return result;
}

inline int64_t
KnowledgeBaseImpl::load_context (
CheckpointSettings & checkpoint_settings,
const KnowledgeUpdateSettings & update_settings)
{
  int64_t result = 0;

  if (checkpoint_settings.originator == "")
  {
    result = map_.load_context (checkpoint_settings, update_settings);

    if (checkpoint_settings.originator != "")
      id_ = checkpoint_settings.originator;
  }
  else
  {
    result = map_.load_context (checkpoint_settings, update_settings);
  }

  return result;
}

inline void
KnowledgeBaseImpl::add_modifieds (
  const VariableReferences & modifieds) const
{
  map_.add_modifieds (modifieds);
}

inline VariableReferences
KnowledgeBaseImpl::save_modifieds (void) const
{
  return map_.save_modifieds ();
}

#ifndef _MADARA_NO_KARL_

inline void
KnowledgeBaseImpl::wait_for_change (void)
{
  map_.wait_for_change ();
}

inline KnowledgeRecord
KnowledgeBaseImpl::evaluate (
const std::string & expression,
const EvalSettings & settings)
{
  CompiledExpression compiled = compile (expression);
  return evaluate (compiled, settings);
}

#endif // _MADARA_NO_KARL_

} }


#endif  // _MADARA_KNOWLEDGE_BASE_IMPL_INL_