d2/d62/ExternFunctionVariables_8h_source.html

 #ifndef _MADARA_EXTERNAL_FUNCTION_VARIABLES_H_
 #define _MADARA_EXTERNAL_FUNCTION_VARIABLES_H_

 #include <string>
 #include "madara/MADARA_export.h"
 #include "madara/knowledge/KnowledgeRecord.h"
 #include "madara/knowledge/KnowledgeUpdateSettings.h"
 #include "madara/expression/ExpressionTree.h"
 #include "madara/knowledge/CompiledExpression.h"
 #include "madara/knowledge/VariableReference.h"
 #include "madara/knowledge/FunctionArguments.h"
 #include "madara/knowledge/Functions.h"

 #ifdef _MADARA_PYTHON_CALLBACKS_
 #include "boost/python/object.hpp"
 #endif

 #ifdef _MADARA_JAVA_
   #include <jni.h>
   #include "madara_jni.h"
 #endif

 namespace madara
 {
   namespace expression
   {
     class CompositeFunctionNode;
   }

   namespace knowledge
   {
     class ThreadSafeContext;
     class KnowledgeRecordFilters;

     typedef madara::knowledge::KnowledgeRecord VALUE_TYPE;

     class MADARA_Export Variables
     {
     public:
       friend class madara::expression::CompositeFunctionNode;
       friend class madara::knowledge::KnowledgeRecordFilters;

       Variables ()
         : context_ (0)
       {
       }

       Variables (const Variables & rhs)
         : context_ (rhs.context_)
       {
       }

       void operator= (Variables & rhs);

       ThreadSafeContext * get_context (void);

       knowledge::KnowledgeRecord get (const std::string & key,
         const KnowledgeReferenceSettings & settings =
         knowledge::KnowledgeReferenceSettings (false));

       knowledge::KnowledgeRecord get (const VariableReference & variable,
         const KnowledgeReferenceSettings & settings =
         knowledge::KnowledgeReferenceSettings (false));

       VariableReference get_ref (const std::string & key,
         const KnowledgeReferenceSettings & settings =
         knowledge::KnowledgeReferenceSettings (false));

       int set (const std::string & key,
         madara::knowledge::KnowledgeRecord::Integer value,
         const KnowledgeUpdateSettings & settings =
           knowledge::KnowledgeUpdateSettings (
             false, true, false, false));

       int set (const VariableReference & variable,
         madara::knowledge::KnowledgeRecord::Integer value,
         const KnowledgeUpdateSettings & settings =
           knowledge::KnowledgeUpdateSettings (
             false, true, false, false));

       int set (const std::string & key,
         const madara::knowledge::KnowledgeRecord::Integer * value,
         uint32_t size,
         const KnowledgeUpdateSettings & settings =
           knowledge::KnowledgeUpdateSettings (
             false, true, false, false));

       int set (const VariableReference & variable,
         const madara::knowledge::KnowledgeRecord::Integer * value,
         uint32_t size,
         const KnowledgeUpdateSettings & settings =
           knowledge::KnowledgeUpdateSettings (
             false, true, false, false));

       int set (const std::string & key,
         const std::vector <KnowledgeRecord::Integer> & value,
         const KnowledgeUpdateSettings & settings =
           knowledge::KnowledgeUpdateSettings (
             false, true, false, false));

       int set (const VariableReference & variable,
         const std::vector <KnowledgeRecord::Integer> & value,
         const KnowledgeUpdateSettings & settings =
           knowledge::KnowledgeUpdateSettings (
             false, true, false, false));

       int set (const std::string & key, double value,
         const KnowledgeUpdateSettings & settings =
           knowledge::KnowledgeUpdateSettings (
             false, true, false, false));

       int set (const VariableReference & variable, double value,
         const KnowledgeUpdateSettings & settings =
           knowledge::KnowledgeUpdateSettings (
             false, true, false, false));

       int set (const std::string & key,
         const double * value,
         uint32_t size,
         const KnowledgeUpdateSettings & settings =
           knowledge::KnowledgeUpdateSettings (
             false, true, false, false));

       int set (const VariableReference & variable,
         const double * value,
         uint32_t size,
         const KnowledgeUpdateSettings & settings =
           knowledge::KnowledgeUpdateSettings (
             false, true, false, false));

       int set (const std::string & key,
         const std::vector <double> & value,
         const KnowledgeUpdateSettings & settings =
           knowledge::KnowledgeUpdateSettings (
             false, true, false, false));

       int set (const VariableReference & variable,
         const std::vector <double> & value,
         const KnowledgeUpdateSettings & settings =
           knowledge::KnowledgeUpdateSettings (
             false, true, false, false));

       int set (const std::string & key, const std::string & value,
         const KnowledgeUpdateSettings & settings =
           knowledge::KnowledgeUpdateSettings (
             false, true, false, false));

       int set (const VariableReference & variable, const std::string & value,
         const KnowledgeUpdateSettings & settings =
           knowledge::KnowledgeUpdateSettings (
             false, true, false, false));

       int set (const std::string & key,
         const madara::knowledge::KnowledgeRecord & value,
         const KnowledgeUpdateSettings & settings =
           knowledge::KnowledgeUpdateSettings (
             false, true, false, false));

       int set (const VariableReference & variable,
         const madara::knowledge::KnowledgeRecord & value,
         const KnowledgeUpdateSettings & settings =
           knowledge::KnowledgeUpdateSettings (
             false, true, false, false));

       knowledge::KnowledgeRecord inc (const std::string & key,
         const KnowledgeUpdateSettings & settings =
           knowledge::KnowledgeUpdateSettings (
             false, true, false, false));

       knowledge::KnowledgeRecord inc (const VariableReference & variable,
         const KnowledgeUpdateSettings & settings =
           knowledge::KnowledgeUpdateSettings (
             false, true, false, false));

       knowledge::KnowledgeRecord dec (const std::string & key,
         const KnowledgeUpdateSettings & settings =
           knowledge::KnowledgeUpdateSettings (
             false, true, false, false));

       knowledge::KnowledgeRecord dec (const VariableReference & variable,
         const KnowledgeUpdateSettings & settings =
           knowledge::KnowledgeUpdateSettings (
             false, true, false, false));

       void to_string (std::string & target,
         const std::string & array_delimiter = ",",
         const std::string & record_delimiter = ";\n",
         const std::string & key_val_delimiter = "=") const;

       void print (unsigned int level = 0) const;

       void print (const std::string & statement, unsigned int level = 0) const;

       madara::knowledge::KnowledgeRecord retrieve_index (
              const std::string & key,
              size_t index,
              const KnowledgeReferenceSettings & settings =
                knowledge::KnowledgeReferenceSettings (false));

       madara::knowledge::KnowledgeRecord retrieve_index (
              const VariableReference & variable,
              size_t index,
              const KnowledgeReferenceSettings & settings =
                knowledge::KnowledgeReferenceSettings (false));

       std::string expand_statement (const std::string & statement) const;

       void apply_modified (
         const KnowledgeUpdateSettings & settings =
           knowledge::KnowledgeUpdateSettings ());

       bool exists (const std::string & key,
         const KnowledgeReferenceSettings & settings =
           KnowledgeReferenceSettings (false)) const;

       bool exists (const VariableReference & variable,
         const KnowledgeReferenceSettings & settings =
           KnowledgeReferenceSettings (false)) const;

 #ifndef _MADARA_NO_KARL_

       CompiledExpression
         compile (const std::string & expression);

       madara::knowledge::KnowledgeRecord evaluate (
         const std::string & expression,
         const KnowledgeUpdateSettings & settings =
           knowledge::KnowledgeUpdateSettings ());

       madara::knowledge::KnowledgeRecord evaluate (
         CompiledExpression & expression,
         const KnowledgeUpdateSettings & settings =
           knowledge::KnowledgeUpdateSettings ());

       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_

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

       int64_t save_as_karl (const std::string & filename) const;

       int64_t save_context (const std::string & filename);

       int64_t save_checkpoint (const std::string & filename,
         bool reset_modifieds = true);

       int64_t load_context (const std::string & filename,
         const KnowledgeUpdateSettings & settings =
               KnowledgeUpdateSettings (true, true, true, false));

       ssize_t write_file (const std::string & knowledge_key,
                           const std::string & filename);

     private:
       ThreadSafeContext * context_;
     };
   }
 }

 #endif
madara::knowledge::KnowledgeRecord
This class encapsulates an entry in a KnowledgeBase.
Definition: KnowledgeRecord.h:60

Functions.h

KnowledgeRecord.h

madara::knowledge::Variables::Variables
Variables()
Constructor.
Definition: ExternFunctionVariables.h:60

madara::knowledge::KnowledgeRecord::Integer
int64_t Integer
Definition: KnowledgeRecord.h:103

madara::knowledge::KnowledgeRecordFilters::context_
ThreadSafeContext * context_
Context used by this filter.
Definition: KnowledgeRecordFilters.h:272

VariableReference.h

madara::knowledge::ThreadSafeContext
This class stores variables and their values for use by any entity needing state information in a thr...
Definition: ThreadSafeContext.h:82

madara::expression::CompositeFunctionNode
A composite node that calls a function.
Definition: CompositeFunctionNode.h:24

madara::knowledge::VariableReference
Optimized reference to a variable within the knowledge base.
Definition: VariableReference.h:35

madara::knowledge::CompiledExpression
Compiled, optimized KaRL logic.
Definition: CompiledExpression.h:35

madara::knowledge::KnowledgeRecordFilters
Provides map of data types to a filter chain to apply to the data.
Definition: KnowledgeRecordFilters.h:50

madara::knowledge::FunctionArguments
std::vector< KnowledgeRecord > FunctionArguments
Definition: FunctionArguments.h:20

madara::utility::write_file
MADARA_Export ssize_t write_file(const std::string &filename, void *buffer, size_t size)
Writes a file with provided contents.
Definition: Utility.cpp:779

KnowledgeUpdateSettings.h

ExpressionTree.h

madara::knowledge::Variables::context_
ThreadSafeContext * context_
Variables context that is directly used by the KaRL engine.
Definition: ExternFunctionVariables.h:674

madara::knowledge::VALUE_TYPE
madara::knowledge::KnowledgeRecord VALUE_TYPE
Definition: ExternFunctionVariables.h:42

madara::knowledge::tags::string
static constexpr struct madara::knowledge::tags::string_t string

madara::knowledge::VariableReferences
std::vector< VariableReference > VariableReferences
a vector of variable references
Definition: VariableReference.h:109

madara::transport::exists
MADARA_Export bool exists(const char *originator, uint64_t clock, uint32_t update_number, OriginatorFragmentMap &map)
Checks if a fragment already exists within a fragment map.
Definition: Fragmentation.cpp:678

madara::knowledge
Provides functions and classes for the distributed knowledge base.
Definition: AggregateFilter.h:32

madara::knowledge::KnowledgeRecordFilters::operator=
void operator=(const KnowledgeRecordFilters &rhs)
Assignment operator.
Definition: KnowledgeRecordFilters.cpp:41

madara::knowledge::KnowledgeUpdateSettings
Settings for applying knowledge updates.
Definition: KnowledgeUpdateSettings.h:23

madara
Copyright (c) 2015 Carnegie Mellon University.
Definition: AggregateFilter.h:30

FunctionArguments.h

CompiledExpression.h

madara::knowledge::KnowledgeReferenceSettings
Settings for applying knowledge updates.
Definition: KnowledgeReferenceSettings.h:22

madara::knowledge::Variables
Provides an interface for external functions into the MADARA KaRL variable settings.
Definition: ExternFunctionVariables.h:51

madara::knowledge::Variables::Variables
Variables(const Variables &rhs)
Constructor.
Definition: ExternFunctionVariables.h:68