MADARA  3.1.8
BaseTracker.h
Go to the documentation of this file.
1 
2 
3 #ifndef INCL_MADARA_RCW_BASE_TRACKER_H
4 #define INCL_MADARA_RCW_BASE_TRACKER_H
5 
14 #include <string>
15 #include <vector>
16 #include <map>
17 #include <list>
18 #include <type_traits>
19 #include <initializer_list>
22 #include "madara/utility/stdint.h"
23 #include "madara/MADARA_export.h"
28 
29 namespace madara { namespace knowledge { namespace rcw
30 {
32  template<typename T>
33  const T &get_value(const T &t)
34  {
35  return t;
36  }
37 
39  template<typename T>
40  void set_value(T &t, const T &v)
41  {
42  t = v;
43  }
44 
46  template<typename T>
47  auto get_value(const std::vector<T> &t, size_t i) ->
48  decltype(get_value(t[i]))
49  {
50  return get_value(t[i]);
51  }
52 
54  template<typename T, typename V>
55  void set_value(std::vector<T> &t, size_t i, V v)
56  {
57  set_value(t[i], v);
58  }
59 
63  {
64  public:
65  virtual ~BaseTracker() {}
66 
67  private:
70 
72  BaseTracker(VariableReference ref) : ref_(ref) {}
73 
75  virtual void pull() = 0;
77  virtual void push(KnowledgeBase &kb) = 0;
79  virtual void force_push(KnowledgeBase &kb) = 0;
81  virtual const char *get_name() const = 0;
83  virtual const void *get_tracked() const = 0;
84 
86  const KnowledgeRecord &get() const
87  {
88  return get(ref_);
89  }
90 
93  {
94  return get_mut(ref_);
95  }
96 
98  static const KnowledgeRecord &get(const VariableReference &ref)
99  {
100  return *ref.record_;
101  }
102 
105  {
106  return *ref.record_;
107  }
108 
110  template<typename T>
111  void set(KnowledgeBase &kb, T&& val)
112  {
113  return set(kb, ref_, std::forward<T>(val));
114  }
115 
117  template<typename T>
118  static void set(KnowledgeBase &kb, const VariableReference &ref, T&& val)
119  {
120  kb.get_context().set_unsafe(ref, std::forward<T>(val), EvalSettings());
121  }
122 
124  template<typename I>
125  auto set_index(KnowledgeBase &kb, size_t idx, I val) ->
126  typename std::enable_if<std::is_integral<I>::value>::type
127  {
128  kb.get_context().set_index_unsafe_impl(ref_, idx, val, EvalSettings());
129  }
130 
132  template<typename I>
133  auto set_index(KnowledgeBase &kb, size_t idx, I val) ->
134  typename std::enable_if<std::is_floating_point<I>::value>::type
135  {
136  kb.get_context().set_index_unsafe_impl(ref_, idx, val, EvalSettings());
137  }
138 
141  {
142  post_set(kb, ref_);
143  }
144 
147  {
149  }
150 
151  friend class Transaction;
152 
153  template<class, class, bool, bool, class>
154  friend class Tracker;
155 
156  template<class, class, bool, bool, class>
157  friend class PrefixTracker;
158  };
159 
166  #define MADARA_MAKE_SUPPORT_TEST(name, var, expr) template <typename T> \
167  struct supports_##name##_impl { \
168  template<typename U> static auto test(U *var) -> decltype((expr), std::true_type()); \
169  template<typename U> static auto test(...) -> std::false_type; \
170  using type = decltype(test<T>(0)); \
171  }; \
172  template <typename T> struct supports_##name : supports_##name##_impl<T>::type {}
173 
176 
179 
182 
184  MADARA_MAKE_SUPPORT_TEST(indexed_is_dirty, p, (is_dirty(*p, 0), clear_dirty(*p, 0)));
185 
188 
190  MADARA_MAKE_SUPPORT_TEST(indexed_get_value, p, (set_value(*p, 0, get_value(*p, 0))));
191 
193  MADARA_MAKE_SUPPORT_TEST(const_iter, p, (p->cbegin(), p->cend()));
194 
196  MADARA_MAKE_SUPPORT_TEST(size, p, (p->size()));
197 
201  knowledge_cast<decltype(get_value(*p))>(
202  std::declval<KnowledgeRecord>())));
203 
205  MADARA_MAKE_SUPPORT_TEST(self_eq, p, (
206  get_value(*p) == get_value(*p),
207  get_value(*p) != get_value(*p)));
208 } } } // end namespace madara::knowledge::rcw
209 
210 #endif // INCL_MADARA_RCW_BASE_TRACKER_H
This class encapsulates an entry in a KnowledgeBase.
utility::ScopedArray< const char > name_
potential string value of the node (size int)
auto set_index(KnowledgeBase &kb, size_t idx, I val) -> typename std::enable_if< std::is_integral< I >::value >::type
Set index in record points to. No locking, so be careful!
Definition: BaseTracker.h:125
bool is_size_dirty(const Tracked< std::vector< T >> &t)
Return size changed dirty flag of Tracked vector.
Definition: Tracked.h:836
Manages a Read-Compute-Write cycle for registered variables.
Definition: Transaction.h:43
VariableReference ref_
Reference to tracked variable.
Definition: BaseTracker.h:69
KnowledgeRecord & get_mut()
Get record points to. No locking, so be careful!
Definition: BaseTracker.h:92
#define MADARA_MAKE_SUPPORT_TEST(name, var, expr)
Macro which generates feature testing traits, to allow enabling features based on what a given type s...
Definition: BaseTracker.h:166
BaseTracker(VariableReference ref)
Constructor from a VariableReference.
Definition: BaseTracker.h:72
Base type for Trackers.
Definition: BaseTracker.h:62
auto set_index(KnowledgeBase &kb, size_t idx, I val) -> typename std::enable_if< std::is_floating_point< I >::value >::type
Set index in record points to. No locking, so be careful!
Definition: BaseTracker.h:133
virtual void force_push(KnowledgeBase &kb)=0
As push, but ignore any modification status tracking.
Optimized reference to a variable within the knowledge base.
bool is_dirty(const Tracked< T > &t)
Returns dirty flag of Tracked types.
Definition: Tracked.h:533
virtual const char * get_name() const =0
Get name of MADARA variable.
O knowledge_cast(const KnowledgeRecord &in)
By default, call constructor of target class; for other semantics, define specializations.
void post_set(KnowledgeBase &kb, const VariableReference &ref)
Call after setting to perform any necessary after-setting logic.
Definition: BaseTracker.h:146
virtual const void * get_tracked() const =0
Get pointer to tracked object.
virtual void push(KnowledgeBase &kb)=0
Override to implement pushing logic (into ref_)
T * get_ptr(void)
get the underlying pointer
Definition: ScopedArray.inl:68
bool is_all_dirty(const Tracked< std::vector< T >> &t)
Return global dirty flag of Tracked vector.
Definition: Tracked.h:829
void clear_dirty(Tracked< T > &t)
Clears dirty flag of Tracked types.
Definition: Tracked.h:540
This class provides a distributed knowledge base to users.
Definition: KnowledgeBase.h:44
Tracker which puts variable values into a single KnowledgeRecord.
Definition: Tracker.h:34
Tracker that puts values into a multiple prefixed KnowledgeRecords.
Definition: PrefixTracker.h:35
const T & get_value(const T &t)
Fallback definition of get_value; simply passes through the value.
Definition: BaseTracker.h:33
ThreadSafeContext & get_context(void)
Returns the ThreadSafeContext associated with this Knowledge Base.
Encapsulates settings for an evaluation statement.
Definition: EvalSettings.h:26
Provides functions and classes for the distributed knowledge base.
static KnowledgeRecord & get_mut(const VariableReference &ref)
Get record points to. No locking, so be careful!
Definition: BaseTracker.h:104
knowledge::KnowledgeRecord * record_
Reference to knowledge record.
void set_value(T &t, const T &v)
Fallback definition of set_value; simply passes through the value.
Definition: BaseTracker.h:40
Copyright (c) 2015 Carnegie Mellon University.
virtual void pull()=0
Override to implement pulling logic (from ref_)
void mark_and_signal(const char *name, knowledge::KnowledgeRecord *record, const KnowledgeUpdateSettings &settings=KnowledgeUpdateSettings())
method for marking a record modified and signaling changes
void post_set(KnowledgeBase &kb)
Call after setting to perform any necessary after-setting logic.
Definition: BaseTracker.h:140