Ocean
Loading...
Searching...
No Matches
Measurement.h
Go to the documentation of this file.
1/*
2 * Copyright (c) Meta Platforms, Inc. and affiliates.
3 *
4 * This source code is licensed under the MIT license found in the
5 * LICENSE file in the root directory of this source tree.
6 */
7
8#ifndef META_OCEAN_DEVICES_MEASUREMENT_H
9#define META_OCEAN_DEVICES_MEASUREMENT_H
10
13
14#include "ocean/base/Callback.h"
15#include "ocean/base/Value.h"
16
17namespace Ocean
18{
19
20namespace Devices
21{
22
23// Forward declaration.
24class Measurement;
25
26/**
27 * Definition of a smart object reference for a measurement.
28 * @see Measurement.
29 * @ingroup devices
30 */
32
33/**
34 * This class implements the base class for all devices providing measurement samples.
35 * Each measurement holds a container holding several most recent samples provided by the device.<br>
36 * Thus, depending on the number of stored samples a specific sample can be requested.<br>
37 * @ingroup devices
38 */
39class OCEAN_DEVICES_EXPORT Measurement : virtual public Device
40{
41 public:
42
43 /**
44 * Definition of an object id.
45 */
46 using ObjectId = unsigned int;
47
48 /**
49 * Definition of a vector holding object ids.
50 */
51 using ObjectIds = std::vector<ObjectId>;
52
53 /**
54 * Definition of an unordered set holding object ids.
55 */
56 using ObjectIdSet = std::unordered_set<ObjectId>;
57
58 /**
59 * Definition of an unordered map mapping keys to values.
60 */
61 using Metadata = std::unordered_map<std::string, Value>;
62
63 /**
64 * Definition of a sample holding a measurement.
65 */
66 class OCEAN_DEVICES_EXPORT Sample
67 {
68 friend class ObjectRef<Sample>;
69
70 public:
71
72 /**
73 * Returns the sample timestamp.
74 * @return The sample's timestamp
75 */
76 inline const Timestamp& timestamp() const;
77
78 /**
79 * Returns the relative timestamp of this sample.
80 * @return The sample's relative timestamp
81 */
82 inline const Timestamp& relativeTimestamp() const;
83
84 /**
85 * Returns the sample object ids specifying possible different measurement units.
86 * @return Object ids
87 */
88 inline const ObjectIds& objectIds() const;
89
90 /**
91 * Returns the metadata of this sample.
92 * @return The sample's meta data
93 */
94 inline const Metadata& metadata() const;
95
96 /**
97 * Sets the relative timestamp of this sample.
98 * @param relativeTimestamp The sample's relative timestamp to set, must be valid
99 */
100 inline void setRelativeTimestamp(const Timestamp& relativeTimestamp);
101
102 protected:
103
104 /**
105 * Creates a new measurement sample.
106 * @param timestamp Sample timestamp
107 * @param objectIds Object ids corresponding to different measurement units of one tracker
108 * @param metadata Optional metadata of the new sample
109 */
110 Sample(const Timestamp& timestamp, const ObjectIds& objectIds, const Metadata& metadata = Metadata());
111
112 /**
113 * Creates a new measurement sample.
114 * @param timestamp Sample timestamp
115 * @param objectIds Object ids corresponding to different measurement units of one tracker
116 * @param metadata Optional metadata of the new sample
117 */
118 Sample(const Timestamp& timestamp, ObjectIds&& objectIds, Metadata&& metadata = Metadata());
119
120 /**
121 * Destructs a sample.
122 */
123 virtual ~Sample();
124
125 protected:
126
127 /// The sample timestamp.
129
130 /// The relative sample timestamp.
132
133 /// Measurement unit object ids.
135
136 /// The metadata of this sample.
138 };
139
140 /**
141 * Definition of an object reference for samples.
142 */
144
145 /**
146 * Definition of a callback function to subscribe for new measurement sample events.
147 * The first parameter is the Measurement object sending the sample
148 * The second parameter is the sample
149 */
151
152 /**
153 * Definition of individual interpolation strategies for samples.
154 */
156 {
157 /// An invalid strategy.
159 /// The sample with nearest/closest timestamp is used.
161 /// The sample is interpolated based on two samples.
162 IS_TIMESTAMP_INTERPOLATE
163 };
164
165 /**
166 * This class manages the lifetime of an event subscription for sample events.
167 */
168 class OCEAN_DEVICES_EXPORT SampleEventSubscription
169 {
170 friend class Measurement;
171
172 public:
173
174 /**
175 * Default constructor for a not active subscription.
176 */
178
179 /**
180 * Move constructor.
181 * @param sampleEventSubscription The object to be moved
182 */
183 inline SampleEventSubscription(SampleEventSubscription&& sampleEventSubscription);
184
185 /**
186 * Destructs the subscription object and unsubscribes the object event.
187 */
189
190 /**
191 * Makes this subscription object weak so that is does not hold a reference to the actual measurement object.
192 */
193 inline void makeWeak();
194
195 /**
196 * Explicitly releases the subscription.
197 */
198 void release();
199
200 /**
201 * Returns whether this subscription object holds an active subscription.
202 * @return True, if so
203 */
204 explicit inline operator bool() const;
205
206 /**
207 * Replaces the current event subscription with a new event subscription.
208 * @param sampleEventSubscription The subscription object to assign
209 * @return Reference to this object
210 */
212
213 protected:
214
215 /**
216 * Creates an active subscription object.
217 * @param measurement The measurement object to which the event subscription belongs
218 * @param subscriptionId The subscription id of the event, must be valid
219 */
220 SampleEventSubscription(const Measurement& measurement, const SubscriptionId subscriptionId);
221
222 /**
223 * Disabled assign operator.
224 * @param sampleEventSubscription The subscription object to assign
225 * @return Reference to this object
226 */
227 SampleEventSubscription& operator=(const SampleEventSubscription& sampleEventSubscription) = delete;
228
229 protected:
230
231 /// The measurement object to which the event subscription belongs.
233
234 /// The pointer to the measurement object to which the event subscription belongs.
235 Measurement* weakMeasurement_ = nullptr;
236
237 /// The subscription id.
238 SubscriptionId subscriptionId_ = invalidSubscriptionId();
239 };
240
241 protected:
242
243 /**
244 * Definition of a map holding the most recent samples
245 */
246 using SampleMap = std::map<Timestamp, SampleRef>;
247
248 /**
249 * This class implements a helper class to simplify the mapping between internal object ids (of the actual tracking implementation) and extern object ids (of the device system).
250 * @tparam TInternalId The data type of the internal object id.
251 */
252 template <typename TInternalId>
254 {
255 protected:
256
257 /**
258 * Definition of an unordered map mapping internal object ids to external object ids.
259 */
260 using InternalObjectIdMap = std::unordered_map<TInternalId, ObjectId>;
261
262 /**
263 * Definition of an unordered map mapping external object ids to internal object ids.
264 */
265 using ExternalObjectIdMap = std::unordered_map<ObjectId, TInternalId>;
266
267 public:
268
269 /**
270 * Default constructor.
271 */
272 explicit inline ObjectMapper(Measurement& owner);
273
274 /**
275 * Returns whether this mapping object holds a specific internal object.
276 * @param internalObjectId The id of the internal object to be checked
277 * @return True, if so
278 */
279 bool hasInternalObject(const TInternalId& internalObjectId) const;
280
281 /**
282 * Returns whether this mapping object holds a specific external object.
283 * @param externalObjectId The id of the external object to be checked, must be valid
284 * @return True, if so
285 */
286 bool hasExternalObject(const Measurement::ObjectId& externalObjectId) const;
287
288 /**
289 * Adds a new internal pattern id.
290 * @param internalObjectId The new internal object id to add
291 * @param description The description of the new pattern
292 * @return The corresponding external object id
293 */
294 ObjectId newInternalObjectId(const TInternalId& internalObjectId, const std::string& description);
295
296 /**
297 * Removes a mapping between internal and external object.
298 * @param internalObjectId The id of the internal object for which the mapping will be removed
299 */
300 void removeInternalObject(const TInternalId& internalObjectId);
301
302 /**
303 * Converts the tracker's internal object id to an external object id.
304 * @param internalObjectId The internal object id to translate
305 * @return The resulting external object id
306 */
307 ObjectId externalObjectIdFromInternalObjectId(const TInternalId& internalObjectId) const;
308
309 /**
310 * Converts an external object id to the tracker tracker's internal object id.
311 * @param externalObjectId The external object id to translate
312 * @param invalidInternalId An invalid internal id
313 * @return The resulting internal object id
314 */
315 TInternalId internalObjectIdFromExternalObjectId(const ObjectId externalObjectId, const TInternalId& invalidInternalId) const;
316
317 protected:
318
319 /**
320 * Disabled copy constructor.
321 * @param objectMapper Object which would be copied
322 */
323 ObjectMapper(const ObjectMapper& objectMapper) = delete;
324
325 /**
326 * Disabled copy operator.
327 * @param objectMapper Object which would be copied
328 * @return Reference to this object
329 */
330 ObjectMapper& operator=(const ObjectMapper& objectMapper) = delete;
331
332 protected:
333
334 /// The owner of this mapper.
336
337 /// The map mapping internal object ids to external object ids.
339
340 /// The map mapping external object ids to internal object ids.
342 };
343
344 /**
345 * Definition of an unordered map mapping descriptions to unique object ids.
346 */
347 using ObjectDescriptionToIdMap = std::unordered_map<std::string, ObjectId>;
348
349 /**
350 * Definition of an unordered map mapping unique object ids to descriptions.
351 */
352 using ObjectIdToDescriptionMap = std::unordered_map<ObjectId, std::string>;
353
354 /**
355 * Definition of a map mapping subscription ids to event sample callback functions.
356 */
357 using SampleSubscriptionMap = std::unordered_map<SubscriptionId, SampleCallback>;
358
359 public:
360
361 /**
362 * Returns the capacity of the internal sample container.
363 * @return The sample container's capacity, with range [2, infinity)
364 * @see setSampleCapacity().
365 */
366 inline size_t sampleCapacity() const;
367
368 /**
369 * Sets the capacity of the internal sample container.
370 * @param capacity The number maximal number of samples to be stored, with range [2, infinity)
371 * @return True, if succeeded
372 */
373 bool setSampleCapacity(const size_t capacity);
374
375 /**
376 * Returns the most recent sample.
377 * @return Most recent sample as object reference
378 */
379 virtual SampleRef sample() const;
380
381 /**
382 * Returns the sample with a specific timestamp.
383 * If no sample exists with the given timestamp the most recent sample is returned.
384 * @param timestamp The timestamp of the sample to be returned
385 * @return Requested sample
386 */
387 virtual SampleRef sample(const Timestamp timestamp) const;
388
389 /**
390 * Returns the sample best matching with a specified timestamp.
391 * In case, the given timestamp does not fit to an existing sample, the resulting sample will be based on the specified interpolation strategy.
392 * @param timestamp The timestamp for which a sample will be determined, must be valid
393 * @param interpolationStrategy The interpolation strategy to be applied in case the timestamp does not fit with an existing sample
394 * @return The resulting sample, invalid if no sample could be determined
395 */
396 virtual SampleRef sample(const Timestamp& timestamp, const InterpolationStrategy interpolationStrategy) const;
397
398 /**
399 * Subscribes a callback event function for new measurement sample events.
400 * Do not subscribe or unsubscribe from inside an event thread.
401 * @param callback The callback function receiving the event calls, must be valid
402 * @return The resulting subscription object, dispose the object to unsubscribe from the event call
403 */
405
406 /**
407 * Returns the object id for an object description.
408 * @param description The description for which the object id will be returned
409 * @return The object id, an invalid id if the description is not known
410 * @see objectDescriptions().
411 */
412 ObjectId objectId(const std::string& description) const;
413
414 /**
415 * Returns descriptions of all objects currently available.
416 * @return All object descriptions
417 * @see objectId().
418 */
420
421 /**
422 * Returns the description of one object of this measurement.
423 * @param objectId The id of the object for which the description will be returned, must be valid
424 * @return The description of the object, empty if the object is unknown
425 */
426 std::string objectDescription(const ObjectId objectId) const;
427
428 /**
429 * Returns an invalid object id.
430 * @return Id of an invalid object
431 */
432 static constexpr ObjectId invalidObjectId();
433
434 protected:
435
436 /**
437 * Creates a new measurement object.
438 * @param name The name of the measurement device
439 * @param type Major and minor device type of the device
440 */
441 Measurement(const std::string& name, const DeviceType type);
442
443 /**
444 * Destructs a measurement object.
445 */
446 ~Measurement() override;
447
448 /**
449 * Posts a new measurement sample.
450 * @param newSample New sample to post
451 */
452 void postNewSample(const SampleRef& newSample);
453
454 /**
455 * Creates a unique object id for a new object (e.g., a tracking object like an image, a marker, or a location).
456 * @param description The description of the new object, must be valid
457 * @return The unique id which is unique across all devices
458 */
459 ObjectId addUniqueObjectId(const std::string& description);
460
461 /**
462 * Unsubscribes a sample event callback function.
463 * @param subscriptionId The id of the event subscription to unsubscribe
464 */
465 void unsubscribeSampleEvent(const SubscriptionId subscriptionId);
466
467 protected:
468
469 /// Sample lock.
471
472 /// Subscription lock.
474
475 private:
476
477 /// The most recent measurement samples.
479
480 /// The maximal number of samples this measurement object can hold.
482
483 /// Map holding all sample event subscriptions.
485
486 /// The subscription id of the next event subscription.
487 SubscriptionId nextSampleSubscriptionId_ = SubscriptionId(invalidSubscriptionId() + 1u);
488
489 /// The map mapping object descriptions to object ids.
491
492 /// The map mapping object ids to descriptions.
494};
495
497{
498 return timestamp_;
499}
500
502{
503 return relativeTimestamp_;
504}
505
507{
508 return objectIds_;
509}
510
512{
513 return metadata_;
514}
515
516inline void Measurement::Sample::setRelativeTimestamp(const Timestamp& relativeTimestamp)
517{
518 ocean_assert(!relativeTimestamp_.isValid());
519 relativeTimestamp_ = relativeTimestamp;
520}
521
522template <typename TInternalId>
524 owner_(owner)
525{
526 // nothing to do here
527}
528
529template <typename TInternalId>
530bool Measurement::ObjectMapper<TInternalId>::hasInternalObject(const TInternalId& internalObjectId) const
531{
532 return internalObjectIdMap_.find(internalObjectId) != internalObjectIdMap_.cend();
533}
534
535template <typename TInternalId>
537{
538 ocean_assert(externalObjectId != invalidObjectId());
539
540 return externalObjectIdMap_.find(externalObjectId) != externalObjectIdMap_.cend();
541}
542
543template <typename TInternalId>
544Measurement::ObjectId Measurement::ObjectMapper<TInternalId>::newInternalObjectId(const TInternalId& internalObjectId, const std::string& description)
545{
546 const ObjectId externalObjectId = owner_.addUniqueObjectId(description);
547
548 internalObjectIdMap_.emplace(internalObjectId, externalObjectId);
549 externalObjectIdMap_.emplace(externalObjectId, internalObjectId);
550
551 return externalObjectId;
552}
553
554template <typename TInternalId>
556{
557 const ObjectId externalObjectId = externalObjectIdFromInternalObjectId(internalObjectId);
558
559 internalObjectIdMap_.erase(internalObjectId);
560 externalObjectIdMap_.erase(externalObjectId);
561}
562
563template <typename TInternalId>
565{
566 const typename InternalObjectIdMap::const_iterator i = internalObjectIdMap_.find(internalObjectId);
567
568 if (i == internalObjectIdMap_.cend())
569 {
570 ocean_assert(false && "This must never happen!");
571 return invalidObjectId();
572 }
573
574 return i->second;
575}
576
577template <typename TInternalId>
578TInternalId Measurement::ObjectMapper<TInternalId>::internalObjectIdFromExternalObjectId(const ObjectId externalObjectId, const TInternalId& invalidInternalId) const
579{
580 const typename ExternalObjectIdMap::const_iterator i = externalObjectIdMap_.find(externalObjectId);
581
582 if (i == externalObjectIdMap_.cend())
583 {
584 ocean_assert(false && "This must never happen!");
585 return invalidInternalId;
586 }
587
588 return i->second;
589}
590
592{
593 *this = std::move(sampleEventSubscription);
594}
595
600
602{
603 measurement_.release();
604}
605
606inline Measurement::SampleEventSubscription::operator bool() const
607{
608 return weakMeasurement_ != nullptr;
609}
610
611inline size_t Measurement::sampleCapacity() const
612{
613 const ScopedLock scopedLock(samplesLock_);
614
615 return sampleCapacity_;
616}
617
619{
620 return ObjectId(-1);
621}
622
623}
624
625}
626
627#endif // META_OCEAN_DEVICES_MEASUREMENT_H
This class implements a container for callback functions.
Definition Callback.h:3456
Definition of a class holding the major and minor device type.
Definition devices/Device.h:62
This class is the base class for all devices of any type.
Definition devices/Device.h:28
unsigned int SubscriptionId
Definition of a subscription id for event callbacks.
Definition devices/Device.h:151
This class implements a helper class to simplify the mapping between internal object ids (of the actu...
Definition Measurement.h:254
InternalObjectIdMap internalObjectIdMap_
The map mapping internal object ids to external object ids.
Definition Measurement.h:338
ObjectMapper & operator=(const ObjectMapper &objectMapper)=delete
Disabled copy operator.
ObjectId newInternalObjectId(const TInternalId &internalObjectId, const std::string &description)
Adds a new internal pattern id.
Definition Measurement.h:544
bool hasExternalObject(const Measurement::ObjectId &externalObjectId) const
Returns whether this mapping object holds a specific external object.
Definition Measurement.h:536
ObjectMapper(Measurement &owner)
Default constructor.
Definition Measurement.h:523
std::unordered_map< TInternalId, ObjectId > InternalObjectIdMap
Definition of an unordered map mapping internal object ids to external object ids.
Definition Measurement.h:260
ObjectMapper(const ObjectMapper &objectMapper)=delete
Disabled copy constructor.
bool hasInternalObject(const TInternalId &internalObjectId) const
Returns whether this mapping object holds a specific internal object.
Definition Measurement.h:530
ObjectId externalObjectIdFromInternalObjectId(const TInternalId &internalObjectId) const
Converts the tracker's internal object id to an external object id.
Definition Measurement.h:564
TInternalId internalObjectIdFromExternalObjectId(const ObjectId externalObjectId, const TInternalId &invalidInternalId) const
Converts an external object id to the tracker tracker's internal object id.
Definition Measurement.h:578
ExternalObjectIdMap externalObjectIdMap_
The map mapping external object ids to internal object ids.
Definition Measurement.h:341
void removeInternalObject(const TInternalId &internalObjectId)
Removes a mapping between internal and external object.
Definition Measurement.h:555
std::unordered_map< ObjectId, TInternalId > ExternalObjectIdMap
Definition of an unordered map mapping external object ids to internal object ids.
Definition Measurement.h:265
Measurement & owner_
The owner of this mapper.
Definition Measurement.h:335
This class manages the lifetime of an event subscription for sample events.
Definition Measurement.h:169
SampleEventSubscription & operator=(const SampleEventSubscription &sampleEventSubscription)=delete
Disabled assign operator.
void release()
Explicitly releases the subscription.
SampleEventSubscription & operator=(SampleEventSubscription &&sampleEventSubscription)
Replaces the current event subscription with a new event subscription.
void makeWeak()
Makes this subscription object weak so that is does not hold a reference to the actual measurement ob...
Definition Measurement.h:601
~SampleEventSubscription()
Destructs the subscription object and unsubscribes the object event.
Definition Measurement.h:596
MeasurementRef measurement_
The measurement object to which the event subscription belongs.
Definition Measurement.h:232
SampleEventSubscription()=default
Default constructor for a not active subscription.
SampleEventSubscription(const Measurement &measurement, const SubscriptionId subscriptionId)
Creates an active subscription object.
Definition of a sample holding a measurement.
Definition Measurement.h:67
virtual ~Sample()
Destructs a sample.
const ObjectIds & objectIds() const
Returns the sample object ids specifying possible different measurement units.
Definition Measurement.h:506
Timestamp relativeTimestamp_
The relative sample timestamp.
Definition Measurement.h:131
ObjectIds objectIds_
Measurement unit object ids.
Definition Measurement.h:134
Metadata metadata_
The metadata of this sample.
Definition Measurement.h:137
void setRelativeTimestamp(const Timestamp &relativeTimestamp)
Sets the relative timestamp of this sample.
Definition Measurement.h:516
const Timestamp & relativeTimestamp() const
Returns the relative timestamp of this sample.
Definition Measurement.h:501
const Metadata & metadata() const
Returns the metadata of this sample.
Definition Measurement.h:511
Sample(const Timestamp &timestamp, ObjectIds &&objectIds, Metadata &&metadata=Metadata())
Creates a new measurement sample.
const Timestamp & timestamp() const
Returns the sample timestamp.
Definition Measurement.h:496
Sample(const Timestamp &timestamp, const ObjectIds &objectIds, const Metadata &metadata=Metadata())
Creates a new measurement sample.
Timestamp timestamp_
The sample timestamp.
Definition Measurement.h:128
This class implements the base class for all devices providing measurement samples.
Definition Measurement.h:40
ObjectId objectId(const std::string &description) const
Returns the object id for an object description.
SampleEventSubscription subscribeSampleEvent(SampleCallback &&callback)
Subscribes a callback event function for new measurement sample events.
void postNewSample(const SampleRef &newSample)
Posts a new measurement sample.
virtual SampleRef sample() const
Returns the most recent sample.
static constexpr ObjectId invalidObjectId()
Returns an invalid object id.
Definition Measurement.h:618
Strings objectDescriptions() const
Returns descriptions of all objects currently available.
ObjectId addUniqueObjectId(const std::string &description)
Creates a unique object id for a new object (e.g., a tracking object like an image,...
SampleSubscriptionMap sampleSubscriptionMap_
Map holding all sample event subscriptions.
Definition Measurement.h:484
std::unordered_map< SubscriptionId, SampleCallback > SampleSubscriptionMap
Definition of a map mapping subscription ids to event sample callback functions.
Definition Measurement.h:357
unsigned int ObjectId
Definition of an object id.
Definition Measurement.h:46
virtual SampleRef sample(const Timestamp timestamp) const
Returns the sample with a specific timestamp.
std::unordered_set< ObjectId > ObjectIdSet
Definition of an unordered set holding object ids.
Definition Measurement.h:56
std::vector< ObjectId > ObjectIds
Definition of a vector holding object ids.
Definition Measurement.h:51
SampleMap sampleMap_
The most recent measurement samples.
Definition Measurement.h:478
InterpolationStrategy
Definition of individual interpolation strategies for samples.
Definition Measurement.h:156
@ IS_INVALID
An invalid strategy.
Definition Measurement.h:158
@ IS_TIMESTAMP_NEAREST
The sample with nearest/closest timestamp is used.
Definition Measurement.h:160
virtual SampleRef sample(const Timestamp &timestamp, const InterpolationStrategy interpolationStrategy) const
Returns the sample best matching with a specified timestamp.
std::unordered_map< std::string, ObjectId > ObjectDescriptionToIdMap
Definition of an unordered map mapping descriptions to unique object ids.
Definition Measurement.h:347
size_t sampleCapacity() const
Returns the capacity of the internal sample container.
Definition Measurement.h:611
std::unordered_map< ObjectId, std::string > ObjectIdToDescriptionMap
Definition of an unordered map mapping unique object ids to descriptions.
Definition Measurement.h:352
ObjectDescriptionToIdMap objectDescriptionToIdMap_
The map mapping object descriptions to object ids.
Definition Measurement.h:490
Lock samplesLock_
Sample lock.
Definition Measurement.h:470
void unsubscribeSampleEvent(const SubscriptionId subscriptionId)
Unsubscribes a sample event callback function.
size_t sampleCapacity_
The maximal number of samples this measurement object can hold.
Definition Measurement.h:481
~Measurement() override
Destructs a measurement object.
bool setSampleCapacity(const size_t capacity)
Sets the capacity of the internal sample container.
std::unordered_map< std::string, Value > Metadata
Definition of an unordered map mapping keys to values.
Definition Measurement.h:61
std::string objectDescription(const ObjectId objectId) const
Returns the description of one object of this measurement.
ObjectIdToDescriptionMap objectIdToDescriptionMap_
The map mapping object ids to descriptions.
Definition Measurement.h:493
Measurement(const std::string &name, const DeviceType type)
Creates a new measurement object.
Lock subscriptionLock_
Subscription lock.
Definition Measurement.h:473
std::map< Timestamp, SampleRef > SampleMap
Definition of a map holding the most recent samples.
Definition Measurement.h:246
This class implements a recursive lock object.
Definition Lock.h:31
This template class implements a object reference with an internal reference counter.
Definition base/ObjectRef.h:58
This class implements a scoped lock object for recursive lock objects.
Definition Lock.h:135
This class implements a timestamp.
Definition Timestamp.h:43
std::vector< std::string > Strings
Definition of a vector holding strings.
Definition Base.h:162
The namespace covering the entire Ocean framework.
Definition Accessor.h:15