C++ API Reference RNBO: src/RNBO_PatcherState.h Source File
C++ API

C++ Guides

RNBO: src/RNBO_PatcherState.h Source File

1 //
2 // RNBO_PatcherState.h
3 // Created: 27 Jan 2016 1:43:53pm
4 // Author: Stefan Brunner
5 //
6 //
7 
8 #ifndef _RNBO_Patcherstate_H_
9 #define _RNBO_Patcherstate_H_
10 
11 #include <unordered_map>
12 #include <vector>
13 #include <memory>
14 
15 #include "RNBO_Debug.h"
16 #include "RNBO_String.h"
17 #include "RNBO_Types.h"
18 #include "RNBO_ExternalPtr.h"
19 #include "RNBO_PatcherEventTarget.h"
20 #include "RNBO_PatcherStateInterface.h"
21 #include "RNBO_List.h"
22 #include "RNBO_DataRef.h"
23 
24 #include "3rdparty/MPark_variant/variant.hpp"
25 
26 namespace RNBO {
27 
28  class ValueHolder;
29  class PatcherState;
30  using StateMapPtr = std::shared_ptr<PatcherState>;
31  using SubStateMapType = std::unordered_map<Index,std::shared_ptr<ValueHolder> >;
32  using SubStateMapPtr = std::shared_ptr<SubStateMapType>;
33 
37  class ValueHolder {
38  public:
39 
43  enum Type {
44  NONE,
45  FLOAT,
46  DOUBLE,
47  EXTERNAL,
48  SUBSTATE,
49  SUBSTATEMAP,
50  EVENTTARGET,
51  LIST,
52  DATAREF,
53  MULTIREF,
54  SIGNAL,
55  STRING,
56  UINT32,
57  BOOLEAN,
58  INTVALUE,
59  UINT64,
60  BUFFER
61  };
62 
66  ValueHolder(float val);
67 
71  ValueHolder(double val);
72 
76  ValueHolder(Int val);
77 
81  ValueHolder(UInt32 val);
82 
86  ValueHolder(UInt64 val);
87 
91  ValueHolder(bool val);
92 
96  ValueHolder(ExternalPtr& ext);
97 
103  ValueHolder(StateMapPtr substate);
104 
108  ValueHolder(PatcherEventTarget* patcherEventTarget);
109 
113  ValueHolder(const list& theList);
114 
118  ValueHolder(DataRef&& dataRef);
119 
123  ValueHolder(MultiDataRef&& dataRef);
124 
128  ValueHolder(const signal sig);
129 
133  ValueHolder(const char* str);
134 
138  ValueHolder(SerializedBuffer&& data);
139 
143  ValueHolder();
144 
145  ~ValueHolder();
146 
147  //no copy constructor/assign
148  ValueHolder(const ValueHolder&) = delete;
149  ValueHolder& operator=(ValueHolder&) = delete;
150 
151  //default move constructor
152  ValueHolder(ValueHolder&&) = default;
153  //explicit delete move assignment, mpark variant does so it would be implicitly deleted anyway
154  ValueHolder& operator=(ValueHolder&&) = delete;
155 
156  explicit operator float() const;
157  explicit operator double() const;
158  explicit operator Int() const;
159  explicit operator UInt32() const;
160  explicit operator UInt64() const;
161  explicit operator bool() const;
162  explicit operator PatcherEventTarget*();
163  explicit operator signal();
164 
165  operator ExternalPtr();
166  operator const list&() const;
167  operator DataRef&();
168  operator MultiDataRef&();
169  operator const char*() const;
170  operator SerializedBuffer&();
171 
172  operator PatcherState&();
173  PatcherState& operator[](Index i);
174 
175  operator const PatcherState&() const;
176  const PatcherState& operator[](Index i) const;
177 
181  Index getSubStateMapSize() const;
182 
186  Type getType() const;
187 
188  private:
189 
190  void allocateSubState();
191  void allocateSubStateMap();
192 
193  mpark::variant<
194  mpark::monostate,
195  float,
196  double,
197  Int,
198  UInt32,
199  bool,
200  ExternalPtr,
201  StateMapPtr,
202  PatcherEventTarget*,
203  SubStateMapPtr,
204  list,
205  DataRef,
206  MultiDataRef,
207  signal,
208  String,
209  UInt64,
210  SerializedBuffer
211  > _value;
212  };
213 
214  using StateMap = std::unordered_map<String, ValueHolder, StringHasher>;
215 
219  class PatcherState : public PatcherStateInterface {
220  public:
221 
222  PatcherState() {}
223 
224  PatcherState (const PatcherState&) = delete;
225  PatcherState& operator= (const PatcherState&) = delete;
226 
227  using Iterator = typename StateMap::iterator;
228  using ConstIterator = typename StateMap::const_iterator;
229 
230  Iterator begin()
231  {
232  return _map.begin();
233  }
234 
235  Iterator end()
236  {
237  return _map.end();
238  }
239 
240  ConstIterator begin() const
241  {
242  return _map.begin();
243  }
244 
245  ConstIterator end() const
246  {
247  return _map.end();
248  }
249 
256  PatcherState& getSubState(const char* key) override;
257 
265  PatcherState& getSubStateAt(const char* key, Index i) override;
266 
267  StateHelper<PatcherState> operator[](const char* key) {
268  StateHelper<PatcherState> helper(key, *this);
269  return helper;
270  }
271 
272  virtual bool isDummy() const { return false; }
273 
274  private:
275 
276  friend class StateHelper<PatcherState>;
277 
278  void add(const char* key, float val) override;
279  void add(const char* key, double val) override;
280  void add(const char* key, Int val) override;
281  void add(const char* key, UInt32 val) override;
282  void add(const char* key, UInt64 val) override;
283  void add(const char* key, bool val) override;
284  void add(const char* key, ExternalPtr& ext) override;
285  void add(const char* key, PatcherEventTarget* patcherEventTarget) override;
286  void add(const char* key, const list& theList) override;
287  void add(const char* key, DataRef& dataRef) override;
288  void add(const char* key, MultiDataRef& dataRef) override;
289  void add(const char* key, signal sig) override;
290  void add(const char* key, const char* str) override;
291  void add(const char* key, SerializedBuffer& data) override;
292 
293  float getFloat(const char* key) override;
294  double getDouble(const char* key) override;
295  Int getInt(const char* key) override;
296  UInt32 getUInt32(const char* key) override;
297  UInt64 getUInt64(const char* key) override;
298  bool getBool(const char* key) override;
299  ExternalPtr getExternalPtr(const char* key) override;
300  PatcherEventTarget* getEventTarget(const char* key) override;
301  const PatcherState& getSubState(const char* key) const override;
302  const PatcherState& getSubStateAt(const char* key, Index i) const override;
303  bool isEmpty() const override;
304  list getList(const char* key) override;
305  DataRef& getDataRef(const char *key) override;
306  MultiDataRef& getMultiDataRef(const char *key) override;
307  signal getSignal(const char *key) override;
308  const char* getString(const char *key) override;
309  SerializedBuffer& getBuffer(const char *key) override;
310 
311  bool containsValue(const char* key) const override;
312 
313  StateMap _map;
314  };
315 
316 }
317 
318 #endif // _RNBO_Patcherstate_H_