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 "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/MADARA_export.h"
#include "madara/knowledge/ThreadSafeContext.h"
#include "madara/knowledge/Files.h"
#include "madara/transport/Transport.h"
#include "madara/expression/Interpreter.h"
#include "ace/SOCK_Dgram.h"

// declare ACE class so MADARA user will not have to directly link to ACE
class ACE_SOCK_Acceptor;

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);

      void copy (const KnowledgeBaseImpl & source,
        const CopySet & copy_set = CopySet (),
        bool clean_copy = false);

      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<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<std::string> take_string(K && key,
             const KnowledgeReferenceSettings & settings =
                     KnowledgeReferenceSettings ())
      {
        return map_.share_string(std::forward<K>(key), settings);
      }

      template<typename K>
      std::shared_ptr<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<std::vector<KnowledgeRecord::Integer>> take_integers(K && key,
             const KnowledgeReferenceSettings & settings =
                     KnowledgeReferenceSettings ())
      {
        return map_.share_integers(std::forward<K>(key), settings);
      }

      template<typename K>
      std::shared_ptr<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<std::vector<double>> take_doubles(K && key,
             const KnowledgeReferenceSettings & settings =
                     KnowledgeReferenceSettings ())
      {
        return map_.share_doubles(std::forward<K>(key), settings);
      }

      template<typename K>
      std::shared_ptr<std::vector<unsigned char>> share_binary(K && key,
             const KnowledgeReferenceSettings & settings =
                     KnowledgeReferenceSettings ()) const
      {
        return map_.share_binary(std::forward<K>(key), settings);
      }

      template<typename K>
      std::shared_ptr<std::vector<unsigned char>> take_binary(K && key,
             const KnowledgeReferenceSettings & settings =
                     KnowledgeReferenceSettings ())
      {
        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);

      int read_policy (const std::string & policy_key,
                       const std::string & policy_file);
#ifdef _USE_CID_

      void print_all_redeployment_results (std::ostream & output);

      void run_all (void);

      long start_latency (void);

      void print_my_latencies (std::ostream & output);

      void print_all_latencies (std::ostream & output);

      void print_all_summations (std::ostream & output);

      long vote (void);

#endif // _USE_CID_

      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, 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;

      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));

      void clear_modifieds (void);

      void reset_checkpoint (void) const;

      void add_modifieds (const VariableReferences & modifieds) const;

      VariableReferences save_modifieds (void) const;

      int send_modifieds (
        const std::string & prefix,
        const EvalSettings & settings =
          EvalSettings ());

      void wait_for_change (void);

      std::string setup_unique_hostport (const std::string & host = "");

    private:
      ThreadSafeContext                 map_;
      ACE_SOCK_Dgram                      unique_bind_;
      std::string                         id_;
      transport::QoSTransportSettings   settings_;
      Files                               files_;

      madara::transport::Transports transports_;
    };
  }
}

// include the inline functions
#include "KnowledgeBaseImpl.inl"

#endif  // _MADARA_KNOWLEDGE_BASE_IMPL_H