ThreadSafeContext.h

Go to the documentation of this file.

#ifndef MADARA_THREADSAFECONTEXT_H
#define MADARA_THREADSAFECONTEXT_H

#include "ace/Guard_T.h"
#include "ace/Recursive_Thread_Mutex.h"
#include "ace/Condition_Recursive_Thread_Mutex.h"
#include "ace/Synch.h"
#include "madara/knowledge/FileHeader.h"
#include "madara/logger/Logger.h"

#ifndef ACE_LACKS_PRAGMA_ONCE
# pragma once
#endif /* ACE_LACKS_PRAGMA_ONCE */

#include <string>
#include <map>
#include "madara/utility/inttypes.h"

#include "madara/MADARA_export.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"

#ifdef _MADARA_JAVA_
#include "madara_jni.h"
#endif

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

namespace madara
{
  namespace expression
  {
    class Interpreter;
    class CompositeArrayReference;
    class VariableNode;
  }

  namespace knowledge
  {
    namespace rcw
    {
      class BaseTracker;
    }

    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;
      friend class rcw::BaseTracker;

      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;

    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<std::string> share_string(const std::string & key,
             const KnowledgeReferenceSettings & settings =
                     KnowledgeReferenceSettings ()) const
      {
        return get_shared<std::string, &KnowledgeRecord::share_string>(key, settings);
      }

      std::shared_ptr<std::string> share_string(const VariableReference & key,
             const KnowledgeReferenceSettings & settings =
                     KnowledgeReferenceSettings ()) const
      {
        return get_shared<std::string, &KnowledgeRecord::share_string>(key, settings);
      }

      std::shared_ptr<std::string> take_string(const std::string & key,
             const KnowledgeReferenceSettings & settings =
                     KnowledgeReferenceSettings ())
      {
        return get_shared<std::string, &KnowledgeRecord::take_string>(key, settings);
      }

      std::shared_ptr<std::string> take_string(const VariableReference & key,
             const KnowledgeReferenceSettings & settings =
                     KnowledgeReferenceSettings ())
      {
        return get_shared<std::string, &KnowledgeRecord::take_string>(key, settings);
      }

      std::shared_ptr<std::vector<KnowledgeRecord::Integer>>
        share_integers(const std::string & key,
             const KnowledgeReferenceSettings & settings =
                     KnowledgeReferenceSettings ()) const
      {
        return get_shared<std::vector<KnowledgeRecord::Integer>,
                 &KnowledgeRecord::share_integers>(key, settings);
      }

      std::shared_ptr<std::vector<KnowledgeRecord::Integer>>
        share_integers(const VariableReference & key,
             const KnowledgeReferenceSettings & settings =
                     KnowledgeReferenceSettings ()) const
      {
        return get_shared<std::vector<KnowledgeRecord::Integer>,
                 &KnowledgeRecord::share_integers>(key, settings);
      }

      std::shared_ptr<std::vector<KnowledgeRecord::Integer>>
        take_integers(const std::string & key,
             const KnowledgeReferenceSettings & settings =
                     KnowledgeReferenceSettings ())
      {
        return get_shared<std::vector<KnowledgeRecord::Integer>,
                 &KnowledgeRecord::take_integers>(key, settings);
      }

      std::shared_ptr<std::vector<KnowledgeRecord::Integer>>
        take_integers(const VariableReference & key,
             const KnowledgeReferenceSettings & settings =
                     KnowledgeReferenceSettings ())
      {
        return get_shared<std::vector<KnowledgeRecord::Integer>,
                 &KnowledgeRecord::take_integers>(key, settings);
      }

      std::shared_ptr<std::vector<double>>
        share_doubles(const std::string & key,
             const KnowledgeReferenceSettings & settings =
                     KnowledgeReferenceSettings ()) const
      {
        return get_shared<std::vector<double>,
                 &KnowledgeRecord::share_doubles>(key, settings);
      }

      std::shared_ptr<std::vector<double>>
        share_doubles(const VariableReference & key,
             const KnowledgeReferenceSettings & settings =
                     KnowledgeReferenceSettings ()) const
      {
        return get_shared<std::vector<double>,
                 &KnowledgeRecord::share_doubles>(key, settings);
      }

      std::shared_ptr<std::vector<double>>
        take_doubles(const std::string & key,
             const KnowledgeReferenceSettings & settings =
                     KnowledgeReferenceSettings ())
      {
        return get_shared<std::vector<double>,
                 &KnowledgeRecord::take_doubles>(key, settings);
      }

      std::shared_ptr<std::vector<double>>
        take_doubles(const VariableReference & key,
             const KnowledgeReferenceSettings & settings =
                     KnowledgeReferenceSettings ())
      {
        return get_shared<std::vector<double>,
                 &KnowledgeRecord::take_doubles>(key, settings);
      }

      std::shared_ptr<std::vector<unsigned char>>
        share_binary(const std::string & key,
             const KnowledgeReferenceSettings & settings =
                     KnowledgeReferenceSettings ()) const
      {
        return get_shared<std::vector<unsigned char>,
                 &KnowledgeRecord::share_binary>(key, settings);
      }

      std::shared_ptr<std::vector<unsigned char>>
        share_binary(const VariableReference & key,
             const KnowledgeReferenceSettings & settings =
                     KnowledgeReferenceSettings ()) const
      {
        return get_shared<std::vector<unsigned char>,
                 &KnowledgeRecord::share_binary>(key, settings);
      }

      std::shared_ptr<std::vector<unsigned char>>
        take_binary(const std::string & key,
             const KnowledgeReferenceSettings & settings =
                     KnowledgeReferenceSettings ())
      {
        return get_shared<std::vector<unsigned char>,
                 &KnowledgeRecord::take_binary>(key, settings);
      }

      std::shared_ptr<std::vector<unsigned char>>
        take_binary(const VariableReference & key,
             const KnowledgeReferenceSettings & settings =
                     KnowledgeReferenceSettings ())
      {
        return get_shared<std::vector<unsigned char>,
                 &KnowledgeRecord::take_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 knowledge::KnowledgeRecords & get_modifieds (void) const;

      void add_modifieds (const VariableReferences & modifieds) const;

      VariableReferences save_modifieds (void) const;

      std::string debug_modifieds (void) const;

      const knowledge::KnowledgeRecords & 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 delete_variable (const std::string & key,
             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;

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


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


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

      int64_t save_checkpoint (const std::string & filename,
        const std::string & id = "") const;

      int64_t save_checkpoint (
        const CheckpointSettings & settings) const;

      KnowledgeMap &get_map_unsafe (void) { return map_; }

      const KnowledgeMap &get_map_unsafe (void) const { return map_; }

    protected:
    private:
      void mark_to_send_unsafe (const std::string & key,
        madara::knowledge::KnowledgeRecord & record,
        const KnowledgeUpdateSettings & settings = KnowledgeUpdateSettings ());

      void mark_to_checkpoint_unsafe (const std::string & key,
        madara::knowledge::KnowledgeRecord & record,
        const KnowledgeUpdateSettings & settings = KnowledgeUpdateSettings ());

      void mark_and_signal (const char * name,
        knowledge::KnowledgeRecord * record,
        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 knowledge::KnowledgeRecords changed_map_;
      mutable knowledge::KnowledgeRecords local_changed_map_;

      FunctionMap functions_;

      madara::expression::Interpreter  *   interpreter_;

      mutable logger::Logger * logger_;
    };
  }
}

#include "ThreadSafeContext.inl"

#endif