MIRA
Tape.h
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2012 by
3  * MetraLabs GmbH (MLAB), GERMANY
4  * and
5  * Neuroinformatics and Cognitive Robotics Labs (NICR) at TU Ilmenau, GERMANY
6  * All rights reserved.
7  *
8  * Contact: info@mira-project.org
9  *
10  * Commercial Usage:
11  * Licensees holding valid commercial licenses may use this file in
12  * accordance with the commercial license agreement provided with the
13  * software or, alternatively, in accordance with the terms contained in
14  * a written agreement between you and MLAB or NICR.
15  *
16  * GNU General Public License Usage:
17  * Alternatively, this file may be used under the terms of the GNU
18  * General Public License version 3.0 as published by the Free Software
19  * Foundation and appearing in the file LICENSE.GPL3 included in the
20  * packaging of this file. Please review the following information to
21  * ensure the GNU General Public License version 3.0 requirements will be
22  * met: http://www.gnu.org/copyleft/gpl.html.
23  * Alternatively you may (at your option) use any later version of the GNU
24  * General Public License if such license has been publicly approved by
25  * MLAB and NICR (or its successors, if any).
26  *
27  * IN NO EVENT SHALL "MLAB" OR "NICR" BE LIABLE TO ANY PARTY FOR DIRECT,
28  * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF
29  * THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF "MLAB" OR
30  * "NICR" HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31  *
32  * "MLAB" AND "NICR" SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING,
33  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
34  * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
35  * ON AN "AS IS" BASIS, AND "MLAB" AND "NICR" HAVE NO OBLIGATION TO
36  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS OR MODIFICATIONS.
37  */
38 
47 #ifndef _MIRA_TAPE_H_
48 #define _MIRA_TAPE_H_
49 
50 #ifndef Q_MOC_RUN
51 #include <boost/optional.hpp>
52 #endif
53 
54 #include <utils/Path.h>
55 #include <fw/Framework.h>
56 
57 #include <platform/Platform.h>
58 
59 namespace mira {
60 
62 
143 {
144 public:
146  static const uint32 sHeaderSize;
147  // size of a message block packet
148  static const uint32 sMessageBlockSize;
149 
151  enum OpenMode
152  {
156  };
160 
163  {
164  MESSAGEBLOCK = 0x0A,
165  CHANNELINFO = 0x0B,
166  MESSAGE = 0x0C,
167  INDEX = 0x0D
168  };
169 
171  struct Header
172  {
173  char type;
174  uint32 size;
175  };
176 
179  {
180  uint64 block;
181  uint64 offset;
183  };
184 
186  struct ChannelInfo
187  {
188  typedef std::vector<MessageIndex> MessageVector;
189  uint64 offset;
193  std::string name;
194  std::string type;
198  uint64 dataSize;
199  };
200 
202  struct FileInfo
203  {
204  std::fstream file;
207  std::string filename;
208  uint32 version;
209  uint32 nrBlocks;
210  uint32 nrChannels;
212  };
213 
216  {
217  uint64 offset;
218  uint32 nrMessages;
219  uint32 size;
223  };
224 
226  struct Message
227  {
228  bool compressed;
229  std::string name;
230  std::string frameID;
231  uint32 sequenceID;
234  };
235 
237  typedef std::map<std::string, ChannelInfo> ChannelMap;
239  typedef std::map<uint64, MessageBlock> MessageBlockMap;
241  typedef std::multimap<Duration, Message> MessageMap;
242 
243  Tape() :
244  mIsOpen(false),
245  mWaitForAlteredStartTime(false),
246  mMaxMessageBlockSize(64 * 1024* 1024),
247  mSortWindowSize(Duration::seconds(2))
248  {}
249 
250  ~Tape();
251 
257  void open(const Path& file, OpenMode mode);
258 
262  void close();
263 
271  void repair(const Path& file, const Path& outFile, bool displayProgress = false);
272 
284  void waitForAlteredStartTime();
285 
294  void alterStartTime(const Time& startTime);
295 
306  template <typename T>
307  MIRA_DEPRECATED("Please use int compressionLevel(=0/-1) instead of bool compress(=false/true)",
308  std::size_t write(ChannelRead<T> value, bool compress,
309  TypeMetaPtr meta = TypeMetaPtr(),
310  const MetaTypeDatabase& metaDB = MetaTypeDatabase()))
311  {
312  if (!mIsOpen || mMode != WRITE)
313  MIRA_THROW(XIO, "Tape is not opened in write mode");
314  return write(value.getChannelID(), value.getTypename(),
315  value->timestamp, value.readSerialized(),
316  (compress ? -1 : 0), meta, metaDB);
317  }
318 
330  template <typename T>
331  std::size_t write(ChannelRead<T> value, int compressionLevel = 0,
332  TypeMetaPtr meta = TypeMetaPtr(),
333  const MetaTypeDatabase& metaDB = MetaTypeDatabase())
334  {
335  if (!mIsOpen || mMode != WRITE)
336  MIRA_THROW(XIO, "Tape is not opened in write mode");
337  return write(value.getChannelID(), value.getTypename(),
338  value->timestamp, value.readSerialized(),
339  compressionLevel, meta, metaDB);
340  }
341 
354  template <typename T>
355  MIRA_DEPRECATED("Please use int compressionLevel(=0/-1) instead of bool compress(=false/true)",
356  std::size_t write(ChannelRead<T> value,
357  std::list<BinarySerializerCodecPtr>& codecs,
358  bool compress, TypeMetaPtr meta = TypeMetaPtr(),
359  const MetaTypeDatabase& metaDB = MetaTypeDatabase()))
360  {
361  if (!mIsOpen || mMode != WRITE)
362  MIRA_THROW(XIO, "Tape is not opened in write mode");
363  return write(value.getChannelID(), value.getTypename(),
364  value->timestamp, value.readSerialized(codecs),
365  (compress ? -1 : 0), meta, metaDB);
366  }
367 
381  template <typename T>
382  std::size_t write(ChannelRead<T> value,
383  std::list<BinarySerializerCodecPtr>& codecs,
384  int compressionLevel = 0, TypeMetaPtr meta = TypeMetaPtr(),
385  const MetaTypeDatabase& metaDB = MetaTypeDatabase())
386  {
387  if (!mIsOpen || mMode != WRITE)
388  MIRA_THROW(XIO, "Tape is not opened in write mode");
389  return write(value.getChannelID(), value.getTypename(),
390  value->timestamp, value.readSerialized(codecs),
391  compressionLevel, meta, metaDB);
392  }
393 
406  template <typename T>
407  MIRA_DEPRECATED("Please use int compressionLevel(=0/-1) instead of bool compress(=false/true)",
408  std::size_t write(const std::string& channelID, const Stamped<T>& value,
409  bool compress, TypeMetaPtr meta = TypeMetaPtr(),
410  const MetaTypeDatabase& metaDB = MetaTypeDatabase()))
411  {
412  Buffer<uint8> buffer;
413  BinaryBufferSerializer s(&buffer);
414  s.serialize(value.value(),false);
415  return write(channelID, typeName<T>(), value.timestamp,
416  value.frameID, value.sequenceID,
417  buffer, (compress ? -1 : 0), meta, metaDB);
418  }
419 
433  template <typename T>
434  std::size_t write(const std::string& channelID, const Stamped<T>& value,
435  int compressionLevel = 0, TypeMetaPtr meta = TypeMetaPtr(),
436  const MetaTypeDatabase& metaDB = MetaTypeDatabase())
437  {
438  Buffer<uint8> buffer;
439  BinaryBufferSerializer s(&buffer);
440  s.serialize(value.value(),false);
441  return write(channelID, typeName<T>(), value.timestamp,
442  value.frameID, value.sequenceID,
443  buffer, compressionLevel, meta, metaDB);
444  }
445 
460  MIRA_DEPRECATED("Please use int compressionLevel(=0/-1) instead of bool compress(=false/true)",
461  std::size_t write(const std::string& channelID, const std::string& typeName,
462  const StampedHeader& header,
463  const Buffer<uint8>& data, bool compress,
464  TypeMetaPtr meta = TypeMetaPtr(),
465  const MetaTypeDatabase& metaDB = MetaTypeDatabase()))
466  {
467  return write(channelID, typeName, header.timestamp, header.frameID,
468  header.sequenceID, data, (compress ? -1 : 0), meta, metaDB);
469  }
470 
486  std::size_t write(const std::string& channelID, const std::string& typeName,
487  const StampedHeader& header,
488  const Buffer<uint8>& data, int compressionLevel = 0,
489  TypeMetaPtr meta = TypeMetaPtr(),
490  const MetaTypeDatabase& metaDB = MetaTypeDatabase())
491  {
492  return write(channelID, typeName, header.timestamp, header.frameID,
493  header.sequenceID, data, compressionLevel, meta, metaDB);
494  }
495 
511  MIRA_DEPRECATED("Please use int compressionLevel(=0/-1) instead of bool compress(=false/true)",
512  std::size_t write(const std::string& channelID, const std::string& typeName,
513  const Time& time, const std::string& frameID, uint32 sequenceID,
514  const Buffer<uint8>& data, bool compress,
515  TypeMetaPtr meta = TypeMetaPtr(),
516  const MetaTypeDatabase& metaDB = MetaTypeDatabase()))
517  {
518  return write(channelID, typeName, time, frameID, sequenceID,
519  data, (compress ? -1 : 0), meta, metaDB);
520  }
521 
538  std::size_t write(const std::string& channelID, const std::string& typeName,
539  const Time& time, const std::string& frameID, uint32 sequenceID,
540  const Buffer<uint8>& data, int compressionLevel = 0,
541  TypeMetaPtr meta = TypeMetaPtr(),
542  const MetaTypeDatabase& metaDB = MetaTypeDatabase());
543 
548  void setMaxMessageBlockSize(uint32 size)
549  {
550  mMaxMessageBlockSize = size;
551  }
552 
560  void setSortWindowSize(const Duration& interval)
561  {
562  mSortWindowSize = interval;
563  }
564 
571  void setStartTime(Time time)
572  {
573  mFile.start = time;
574  mFile.timezoneOffset = mFile.start.toLocal() - mFile.start;
575  }
576 
583  {
584  if (!mIsOpen)
585  MIRA_THROW(XIO, "Tape is not opened.");
586  return mFile.start;
587  }
588 
595  {
596  if (!mIsOpen)
597  MIRA_THROW(XIO, "Tape is not opened.");
598  return mFile.start + mFile.timezoneOffset;
599  }
600 
606  Time getEndTime() const
607  {
608  if (!mIsOpen)
609  MIRA_THROW(XIO, "Tape is not opened.");
610  if (mMessageBlocks.size()==0)
611  return Time::unixEpoch();
612  return mFile.start + mMessageBlocks.rbegin()->second.lastMessageOffset;
613  }
614 
624  {
625  if (!mIsOpen)
626  MIRA_THROW(XIO, "Tape is not opened.");
627  return mFile.timezoneOffset;
628  }
629 
636  {
637  if (!mIsOpen)
638  MIRA_THROW(XIO, "Tape is not opened.");
639  return mChannels;
640  }
641 
648  {
649  if (!mIsOpen)
650  MIRA_THROW(XIO, "Tape is not opened.");
651  return mMessageBlocks;
652  }
653 
659  uint32 getVersion() const
660  {
661  if (!mIsOpen)
662  MIRA_THROW(XIO, "Tape is not opened.");
663  return mFile.version;
664  }
665 
672  static uint32 getCurrentVersion();
673 
687  void readMessage(const MessageIndex& index, std::string& frameID,
688  uint32& sequenceID, Buffer<uint8>& oData, Duration& oTime);
689 
695  void readMessage(const MessageIndex& index, std::string& frameID,
696  uint32& sequenceID, Buffer<uint8>& oData, Duration& oTime,
697  bool& oCompressed);
698 
699 
700 protected:
701 
702  uint64 getFileHeaderSize() const;
703  void openInfo(const Path& file);
704  void openRead(const Path& file);
705  void closeRead();
706  void openWrite(const Path& file);
707  void closeWrite();
708  void openRepair(const Path& file);
709 
710  void write(Duration time, const Message& message);
711 
712  void readFileHeader();
713  void readChannelInfo();
714  void readMessageBlocks();
715  void readMessageBlock(uint64 offset);
716  void writeFileHeader();
717  Tape::Header readHeader();
718  void writeHeader(HeaderType type, uint32 size);
719  void writeChannelInfo(ChannelInfo& info);
720  void startMessageBlock(Duration time);
721  void finishMessageBlock();
722 
723 protected:
724 
725  bool mIsOpen;
729  std::set<std::string> mWrittenChannels;
730  boost::optional<MessageBlock> mCurrentMessageBlock;
731  boost::mutex mMutex;
732  boost::mutex mMessageMutex;
735  uint64 mLastInfo;
737 
740 };
741 
743 
744 }
745 
746 #endif
MessageBlockMap mMessageBlocks
Pairs of offset - message block.
Definition: Tape.h:733
A tape is a binary file that contains recorded/serialized data of one or multiple channels...
Definition: Tape.h:142
static const uint32 sHeaderSize
size of the header packet
Definition: Tape.h:146
Database that stores all meta type information and provides additional functions for accessing the da...
Definition: MetaSerializer.h:509
Duration timezoneOffset
Offset of the timezone on the recording machine to UTC.
Definition: Tape.h:206
Definition: BinarySerializer.h:324
std::size_t write(const std::string &channelID, const std::string &typeName, const StampedHeader &header, const Buffer< uint8 > &data, int compressionLevel=0, TypeMetaPtr meta=TypeMetaPtr(), const MetaTypeDatabase &metaDB=MetaTypeDatabase())
Write the serialized data into the tape.
Definition: Tape.h:486
uint32 nrBlocks
Nr of message data blocks.
Definition: Tape.h:209
T & value()
Returns a read-write reference to the underlying data.
Definition: Stamped.h:202
Duration timeOffset
Time offset of the message relative to start time of tape.
Definition: Tape.h:182
HeaderType
The type of the header specifying the following packet.
Definition: Tape.h:162
std::vector< MessageIndex > MessageVector
Definition: Tape.h:188
boost::mutex mMutex
Definition: Tape.h:731
uint32 getVersion() const
Get the version of the tape.
Definition: Tape.h:659
Buffer< uint8 > buffer
Buffer for the block data.
Definition: Tape.h:222
PropertyHint file(const std::string &filters=std::string(), bool save=false)
Tells the property editor that the path is for a file, and that it should show a "File Open"/"File Sa...
Definition: Path.h:247
Time toLocal() const
Converts to local time zone based on the settings of the machine.
Definition: Time.h:557
Time timestamp
The time stamp when the data was obtained.
Definition: Stamped.h:104
MetaTypeDatabase metaDB
Database of meta information needed by this type.
Definition: Tape.h:196
specialize cv::DataType for our ImgPixel and inherit from cv::DataType<Vec>
Definition: IOService.h:67
uint64 offsetToIndexTable
Offset in bytes of the index table for the channel.
Definition: Tape.h:190
boost::filesystem::path Path
Typedef of a Path (shorter version for boost::filesystem::path)
Definition: Path.h:69
bool mIsOpen
Definition: Tape.h:725
Duration firstMessageOffset
Time offset of the first message in the channel.
Definition: Tape.h:191
bool mWaitForAlteredStartTime
Definition: Tape.h:726
Time getStartTime() const
Get the time when the recording started.
Definition: Tape.h:582
Duration mSortWindowSize
Size of the window used for sorting messages in a tape.
Definition: Tape.h:739
TypeMetaPtr meta
Type meta information.
Definition: Tape.h:195
const Tape::ChannelMap & getChannels() const
Get a list of channels in the tape.
Definition: Tape.h:635
Definition: Tape.h:154
static const uint32 sMessageBlockSize
Definition: Tape.h:148
Duration lastMessageOffset
Time offset of the last message in the block.
Definition: Tape.h:221
OpenMode
The open mode for a tape.
Definition: Tape.h:151
static Time unixEpoch()
Returns the unix epoch 1.1.1970 0:0:0.000.
Definition: Time.h:511
Time getLocalStartTime() const
Get the time when the recording started in the local timezone of the machine the recording took place...
Definition: Tape.h:594
std::string name
Name of the messages channel.
Definition: Tape.h:229
Time start
Start recording time.
Definition: Tape.h:205
Definition: Tape.h:153
An object that allows read access to data of a channel.
Definition: ChannelReadWrite.h:494
std::size_t write(ChannelRead< T > value, int compressionLevel=0, TypeMetaPtr meta=TypeMetaPtr(), const MetaTypeDatabase &metaDB=MetaTypeDatabase())
Write the content of a channel into the tape.
Definition: Tape.h:331
#define MIRA_THROW(ex, msg)
Macro for throwing an exception.
Definition: Exception.h:82
void serialize(const T &value, bool enableTypeCheck=true)
Provides a special serialize interface for the BinarySerializer.
Definition: BinarySerializer.h:598
uint32 nrChannels
Nr of channels.
Definition: Tape.h:210
Information about a channel in a tape.
Definition: Tape.h:186
std::string filename
Name of the tape.
Definition: Tape.h:207
const Tape::MessageBlockMap & getMessageBlocks() const
Get a list of the tapes message blocks.
Definition: Tape.h:647
Wrapper class for boost::posix_time::ptime for adding more functionality to it.
Definition: Time.h:418
uint32 sequenceID
Sequence id of the message.
Definition: Tape.h:231
Duration getTZOffset() const
Get the time zone offset.
Definition: Tape.h:623
ChannelMap mChannels
Definition: Tape.h:728
uint32 size
Size of the block.
Definition: Tape.h:219
Definition: Tape.h:155
std::string type
Typename of the channel.
Definition: Tape.h:194
MIRA_BASE_EXPORT void write(const Value &value, std::ostream &ioStream, bool formatted=false, int precision=-1)
Writes a json::Value into a given stream using the JSON format.
std::map< uint64, MessageBlock > MessageBlockMap
maps a message block to an offset
Definition: Tape.h:239
std::string frameID
Frame id of the message.
Definition: Tape.h:230
std::size_t write(ChannelRead< T > value, std::list< BinarySerializerCodecPtr > &codecs, int compressionLevel=0, TypeMetaPtr meta=TypeMetaPtr(), const MetaTypeDatabase &metaDB=MetaTypeDatabase())
Write the content of a channel into the tape.
Definition: Tape.h:382
MIRA_DEPRECATED("Please use int compressionLevel(=0/-1) instead of bool compress(=false/true)", std::size_t write(const std::string &channelID, const std::string &typeName, const StampedHeader &header, const Buffer< uint8 > &data, bool compress, TypeMetaPtr meta=TypeMetaPtr(), const MetaTypeDatabase &metaDB=MetaTypeDatabase()))
Write the serialized data into the tape.
Definition: Tape.h:460
FileInfo mFile
File informations.
Definition: Tape.h:734
uint64 offsetToFirstInfo
Offset to the first channel info packet.
Definition: Tape.h:211
#define MIRA_FRAMEWORK_EXPORT
Definition: FrameworkExports.h:61
MessageVector messages
Messages.
Definition: Tape.h:197
PropertyHint type(const std::string &t)
Sets the attribute "type" to the specified value.
Definition: PropertyHint.h:295
bool compressed
Is message compressed.
Definition: Tape.h:228
void setMaxMessageBlockSize(uint32 size)
Set the maximum size of the chunks.
Definition: Tape.h:548
Use this class to represent time durations.
Definition: Time.h:106
The common header for all stamped data.
Definition: Stamped.h:62
void setStartTime(Time time)
Set an alternative start time for recording.
Definition: Tape.h:571
boost::optional< MessageBlock > mCurrentMessageBlock
Definition: Tape.h:730
std::size_t write(const std::string &channelID, const Stamped< T > &value, int compressionLevel=0, TypeMetaPtr meta=TypeMetaPtr(), const MetaTypeDatabase &metaDB=MetaTypeDatabase())
Write the stamped data into the tape.
Definition: Tape.h:434
uint64 offset
Offset in bytes of the info packet in the tape.
Definition: Tape.h:189
uint64 mLastInfo
Offset to the last written info field.
Definition: Tape.h:735
boost::mutex mMessageMutex
Definition: Tape.h:732
MessageMap mMessages
Messages we have not yet written to file (in the sort window)
Definition: Tape.h:738
MIRA_DEPRECATED("Please use int compressionLevel(=0/-1) instead of bool compress(=false/true)", std::size_t write(ChannelRead< T > value, std::list< BinarySerializerCodecPtr > &codecs, bool compress, TypeMetaPtr meta=TypeMetaPtr(), const MetaTypeDatabase &metaDB=MetaTypeDatabase()))
Write the content of a channel into the tape.
Definition: Tape.h:355
MIRA_DEPRECATED("Please use int compressionLevel(=0/-1) instead of bool compress(=false/true)", std::size_t write(const std::string &channelID, const Stamped< T > &value, bool compress, TypeMetaPtr meta=TypeMetaPtr(), const MetaTypeDatabase &metaDB=MetaTypeDatabase()))
Write the stamped data into the tape.
Definition: Tape.h:407
const std::string & getChannelID()
Definition: ChannelReadWrite.h:245
Mix in for adding a time stamp, an optional frame id and an optional sequence id to data types like P...
Definition: Stamped.h:149
boost::shared_ptr< TypeMeta > TypeMetaPtr
Definition: MetaSerializer.h:309
uint32 size
Size of the packet.
Definition: Tape.h:174
OpenMode mMode
Definition: Tape.h:727
uint64 dataSize
Size of all messages in bytes.
Definition: Tape.h:198
Header containing type and size of the following packet.
Definition: Tape.h:171
uint64 block
Offset in bytes of the containing block in the tape.
Definition: Tape.h:180
Time getEndTime() const
Get the time of the last entry.
Definition: Tape.h:606
uint32 mMaxMessageBlockSize
Maximum size of a message block.
Definition: Tape.h:736
MIRA_DEPRECATED("Please use int compressionLevel(=0/-1) instead of bool compress(=false/true)", std::size_t write(const std::string &channelID, const std::string &typeName, const Time &time, const std::string &frameID, uint32 sequenceID, const Buffer< uint8 > &data, bool compress, TypeMetaPtr meta=TypeMetaPtr(), const MetaTypeDatabase &metaDB=MetaTypeDatabase()))
Low level write method to write serialized binary data to the tape.
Definition: Tape.h:511
uint32 version
Tape version.
Definition: Tape.h:208
std::string getTypename() const
Definition: ChannelReadWrite.h:250
uint64 offset
Offset in bytes of the message in the containing block.
Definition: Tape.h:181
Functions for modifying file system paths.
std::multimap< Duration, Message > MessageMap
maps a message to an time offset
Definition: Tape.h:241
Struct for a message block in a tape.
Definition: Tape.h:215
Buffer< uint8 > data
Buffer for the message data.
Definition: Tape.h:232
void setSortWindowSize(const Duration &interval)
Messages get sorted before they are written to a tape to guarantee a correct temporal order...
Definition: Tape.h:560
Duration lastMessageOffset
Time offset of the last message in the channel.
Definition: Tape.h:192
uint64 offset
Offset in bytes of the block in the tape.
Definition: Tape.h:217
std::map< std::string, ChannelInfo > ChannelMap
maps channel information to a channel names
Definition: Tape.h:237
std::set< std::string > mWrittenChannels
Definition: Tape.h:729
std::fstream file
The file stream.
Definition: Tape.h:204
Duration firstMessageOffset
Time offset of the first message in the block.
Definition: Tape.h:220
char type
Type of the packet (see HeaderType)
Definition: Tape.h:173
Index entry for a message in the tape.
Definition: Tape.h:178
uint32 uncompressedSize
Uncompressed size of the message.
Definition: Tape.h:233
Information about a tape file.
Definition: Tape.h:202
MIRA_DEPRECATED("Please use int compressionLevel(=0/-1) instead of bool compress(=false/true)", std::size_t write(ChannelRead< T > value, bool compress, TypeMetaPtr meta=TypeMetaPtr(), const MetaTypeDatabase &metaDB=MetaTypeDatabase()))
Write the content of a channel into the tape.
Definition: Tape.h:307
uint32 sequenceID
A user defined sequence ID.
Definition: Stamped.h:111
The framework that holds all manager classes and provides startup and shutdown of all framework relat...
Struct for message data in a tape.
Definition: Tape.h:226
Typename typeName(bool cvqualify=true)
Returns a compiler and platform independent typename of T.
Definition: Typename.h:103
std::string frameID
The unique id of the transform frame that this data is assigned to (if any, otherwise empty) ...
Definition: Stamped.h:108
std::string name
Name of the channel.
Definition: Tape.h:193
Tape()
Definition: Tape.h:243
Platform dependent defines and macros.
uint32 nrMessages
Nr of contained messages.
Definition: Tape.h:218