Fast RTPS  Version 2.14.5
Fast RTPS
TypesBase.h
1 // Copyright 2018 Proyectos y Sistemas de Mantenimiento SL (eProsima).
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14 
15 #ifndef TYPES_BASE_H
16 #define TYPES_BASE_H
17 
18 #include <algorithm>
19 #include <bitset>
20 #include <cctype>
21 #include <map>
22 #include <memory>
23 #include <string>
24 #include <type_traits>
25 #include <vector>
26 
27 #include <fastdds/rtps/common/Types.h>
28 
29 namespace eprosima {
30 namespace fastdds {
31 namespace dds {
32 using DomainId_t = uint32_t;
33 } // dds
34 } // namespace fastdds
35 
36 namespace fastcdr {
37 class Cdr;
38 } // namespace fastcdr
39 namespace fastrtps {
40 namespace types {
41 
43 constexpr uint32_t BOUND_UNLIMITED = 0;
44 
45 using eprosima::fastrtps::rtps::octet;
46 
47 using OctetSeq = std::vector<octet>;
48 
50  OctetSeq&);
51 
53  OctetSeq&,
54  int);
55 
56 size_t to_size_t(
57  const OctetSeq&);
58 
59 const std::string CONST_TRUE = "true";
60 const std::string CONST_FALSE = "false";
61 
62 const std::string ANNOTATION_KEY_ID = "key";
63 const std::string ANNOTATION_EPKEY_ID = "Key";
64 const std::string ANNOTATION_TOPIC_ID = "Topic";
65 const std::string ANNOTATION_EXTENSIBILITY_ID = "extensibility";
66 const std::string ANNOTATION_FINAL_ID = "final";
67 const std::string ANNOTATION_APPENDABLE_ID = "appendable";
68 const std::string ANNOTATION_MUTABLE_ID = "mutable";
69 const std::string ANNOTATION_NESTED_ID = "nested";
70 const std::string ANNOTATION_OPTIONAL_ID = "optional";
71 const std::string ANNOTATION_MUST_UNDERSTAND_ID = "must_understand";
72 const std::string ANNOTATION_NON_SERIALIZED_ID = "non_serialized";
73 const std::string ANNOTATION_BIT_BOUND_ID = "bit_bound";
74 const std::string ANNOTATION_DEFAULT_ID = "default";
75 const std::string ANNOTATION_DEFAULT_LITERAL_ID = "default_literal";
76 const std::string ANNOTATION_VALUE_ID = "value";
77 const std::string ANNOTATION_POSITION_ID = "position";
78 
79 const std::string EXTENSIBILITY_FINAL = "FINAL";
80 const std::string EXTENSIBILITY_APPENDABLE = "APPENDABLE";
81 const std::string EXTENSIBILITY_MUTABLE = "MUTABLE";
82 
83 const std::string TKNAME_BOOLEAN = "bool";
84 const std::string TKNAME_INT16 = "int16_t";
85 const std::string TKNAME_UINT16 = "uint16_t";
86 const std::string TKNAME_INT32 = "int32_t";
87 const std::string TKNAME_UINT32 = "uint32_t";
88 const std::string TKNAME_INT64 = "int64_t";
89 const std::string TKNAME_UINT64 = "uint64_t";
90 const std::string TKNAME_CHAR8 = "char";
91 const std::string TKNAME_BYTE = "octet";
92 const std::string TKNAME_INT8 = "int8_t";
93 const std::string TKNAME_UINT8 = "uint8_t";
94 const std::string TKNAME_CHAR16 = "wchar";
95 const std::string TKNAME_CHAR16T = "wchar_t";
96 const std::string TKNAME_FLOAT32 = "float";
97 const std::string TKNAME_FLOAT64 = "double";
98 const std::string TKNAME_FLOAT128 = "longdouble";
99 
100 const std::string TKNAME_STRING8 = "string";
101 const std::string TKNAME_STRING16 = "wstring";
102 const std::string TKNAME_ALIAS = "alias";
103 const std::string TKNAME_ENUM = "enum";
104 const std::string TKNAME_BITMASK = "bitmask";
105 const std::string TKNAME_ANNOTATION = "annotation";
106 const std::string TKNAME_STRUCTURE = "structure";
107 const std::string TKNAME_UNION = "union";
108 const std::string TKNAME_BITSET = "bitset";
109 const std::string TKNAME_SEQUENCE = "sequence";
110 const std::string TKNAME_ARRAY = "array";
111 const std::string TKNAME_MAP = "map";
112 
113 // ---------- Equivalence Kinds ------------------
114 typedef octet EquivalenceKind;
115 const octet EK_MINIMAL = 0xF1; // 0x1111 0001
116 const octet EK_COMPLETE = 0xF2; // 0x1111 0010
117 const octet EK_BOTH = 0xF3; // 0x1111 0011
118 
119 // ---------- TypeKinds (begin) ------------------
120 typedef octet TypeKind; // Primitive TKs
121 
122 const octet TK_NONE = 0x00;
123 const octet TK_BOOLEAN = 0x01;
124 const octet TK_BYTE = 0x02;
125 const octet TK_INT16 = 0x03;
126 const octet TK_INT32 = 0x04;
127 const octet TK_INT64 = 0x05;
128 const octet TK_UINT16 = 0x06;
129 const octet TK_UINT32 = 0x07;
130 const octet TK_UINT64 = 0x08;
131 const octet TK_FLOAT32 = 0x09;
132 const octet TK_FLOAT64 = 0x0A;
133 const octet TK_FLOAT128 = 0x0B;
134 const octet TK_CHAR8 = 0x10;
135 const octet TK_CHAR16 = 0x11;
136 
137 // String TKs
138 const octet TK_STRING8 = 0x20;
139 const octet TK_STRING16 = 0x21;
140 
141 
142 // Constructed/Named types
143 const octet TK_ALIAS = 0x30;
144 
145 // Enumerated TKs
146 const octet TK_ENUM = 0x40;
147 const octet TK_BITMASK = 0x41;
148 
149 // Structured TKs
150 const octet TK_ANNOTATION = 0x50;
151 const octet TK_STRUCTURE = 0x51;
152 const octet TK_UNION = 0x52;
153 const octet TK_BITSET = 0x53;
154 
155 // Collection TKs
156 const octet TK_SEQUENCE = 0x60;
157 const octet TK_ARRAY = 0x61;
158 const octet TK_MAP = 0x62;
159 
160 // ---------- TypeKinds (end) ------------------
161 
162 // The name of some element (e.g. type, type member, module)
163 // Valid characters are alphanumeric plus the "_" cannot start with digit
164 
165 const int32_t MEMBER_NAME_MAX_LENGTH = 256;
166 typedef std::string MemberName;
167 
168 // Qualified type name includes the name of containing modules
169 // using "::" as separator. No leading "::". E.g. "MyModule::MyType"
170 const int32_t TYPE_NAME_MAX_LENGTH = 256;
171 typedef std::string QualifiedTypeName;
172 
173 // Every type has an ID. Those of the primitive types are pre-defined.
174 typedef octet PrimitiveTypeId;
175 
176 // First 4 bytes of MD5 of of a member name converted to bytes
177 // using UTF-8 encoding and without a 'nul' terminator.
178 // Example: the member name "color" has NameHash {0x70, 0xDD, 0xA5, 0xDF}
179 typedef std::array<uint8_t, 4> NameHash;
180 
181 // Mask used to remove the flags that do no affect assignability
182 // Selects T1, T2, O, M, K, D
183 const uint16_t MemberFlagMinimalMask = 0x003f;
184 
189 class RTPS_DllAPI ReturnCode_t
190 {
191  uint32_t value_;
192 
193 public:
194 
196  {
197  RETCODE_OK = 0,
198  RETCODE_ERROR = 1,
199  RETCODE_UNSUPPORTED = 2,
200  RETCODE_BAD_PARAMETER = 3,
201  RETCODE_PRECONDITION_NOT_MET = 4,
202  RETCODE_OUT_OF_RESOURCES = 5,
203  RETCODE_NOT_ENABLED = 6,
204  RETCODE_IMMUTABLE_POLICY = 7,
205  RETCODE_INCONSISTENT_POLICY = 8,
206  RETCODE_ALREADY_DELETED = 9,
207  RETCODE_TIMEOUT = 10,
208  RETCODE_NO_DATA = 11,
209  RETCODE_ILLEGAL_OPERATION = 12,
210  RETCODE_NOT_ALLOWED_BY_SECURITY = 13
211  };
212 
214  : value_(RETCODE_OK)
215  {
216  }
217 
219  uint32_t e)
220  {
221  value_ = e;
222  }
223 
225  const ReturnCode_t& c) const
226  {
227  return value_ == c.value_;
228  }
229 
231  const ReturnCode_t& c) const
232  {
233  return value_ != c.value_;
234  }
235 
236  explicit operator bool() = delete;
237 
238  uint32_t operator ()() const
239  {
240  return value_;
241  }
242 
243  bool operator !() const
244  {
245  return value_ != 0;
246  }
247 
248 };
249 
250 RTPS_DllAPI inline bool operator ==(
252  const ReturnCode_t& b)
253 {
254  return b.operator ==(
255  a);
256 }
257 
258 RTPS_DllAPI inline bool operator !=(
260  const ReturnCode_t& b)
261 {
262  return b.operator !=(
263  a);
264 }
265 
266 RTPS_DllAPI inline bool operator ==(
267  uint32_t a,
268  const ReturnCode_t& b)
269 {
270  return b.operator ==(
271  a);
272 }
273 
274 RTPS_DllAPI inline bool operator !=(
275  uint32_t a,
276  const ReturnCode_t& b)
277 {
278  return b.operator !=(
279  a);
280 }
281 
282 // TODO Remove this alias when Fast-RTPS reaches version 2
284 
285 typedef uint32_t MemberId;
286 constexpr uint32_t MEMBER_ID_INVALID {0X0FFFFFFF};
287 #define INDEX_INVALID UINT32_MAX
288 
289 const int32_t MAX_BITMASK_LENGTH = 64;
290 const int32_t MAX_ELEMENTS_COUNT = 100;
291 const int32_t MAX_STRING_LENGTH = 255;
292 
293 // Long Bound of a collection type
294 typedef uint32_t LBound;
295 typedef std::vector<LBound> LBoundSeq;
297 
298 // Short Bound of a collection type
299 typedef octet SBound;
300 typedef std::vector<SBound> SBoundSeq;
302 
303 // Auxiliar function to compare sequences (std::vector)
304 template<class T>
306  const std::vector<T>& a,
307  const std::vector<T>& b)
308 {
309  if (a.size() == b.size())
310  {
311  auto aIt = a.begin();
312  auto bIt = b.begin();
313  while (aIt != a.end() && bIt != b.end())
314  {
315  if (*aIt == *bIt)
316  {
317  ++aIt;
318  ++bIt;
319  }
320  else
321  {
322  return false;
323  }
324  }
325  return true;
326  }
327  return false;
328 }
329 
330 // Flags that apply to struct/union/collection/enum/bitmask/bitset
331 // members/elements and DO affect type assignability
332 // Depending on the flag it may not apply to members of all types
333 
334 // When not all, the applicable member types are listed
336 {
337 private:
338 
339  std::bitset<16> m_MemberFlag;
340 
341 public:
342 
344  {
345  }
346 
348  const MemberFlag& x)
349  : m_MemberFlag(x.m_MemberFlag)
350  {
351  }
352 
354  MemberFlag&& x)
355  : m_MemberFlag(std::move(x.m_MemberFlag))
356  {
357  }
358 
360  const MemberFlag& x)
361  {
362  m_MemberFlag = x.m_MemberFlag;
363  return *this;
364  }
365 
367  MemberFlag&& x)
368  {
369  m_MemberFlag = std::move(x.m_MemberFlag);
370  return *this;
371  }
372 
373  // T1 | 00 = INVALID, 01 = DISCARD
374  bool TRY_CONSTRUCT1() const
375  {
376  return m_MemberFlag.test(0);
377  }
378 
380  bool b)
381  {
382  b ? m_MemberFlag.set(0) : m_MemberFlag.reset(0);
383  }
384 
385  // T2 | 10 = USE_DEFAULT, 11 = TRIM
386  bool TRY_CONSTRUCT2() const
387  {
388  return m_MemberFlag.test(1);
389  }
390 
392  bool b)
393  {
394  b ? m_MemberFlag.set(1) : m_MemberFlag.reset(1);
395  }
396 
397  // X StructMember, UnionMember,
398  // CollectionElement
399  bool IS_EXTERNAL() const
400  {
401  return m_MemberFlag.test(2);
402  }
403 
405  bool b)
406  {
407  b ? m_MemberFlag.set(2) : m_MemberFlag.reset(2);
408  }
409 
410  // O StructMember
411  bool IS_OPTIONAL() const
412  {
413  return m_MemberFlag.test(3);
414  }
415 
417  bool b)
418  {
419  b ? m_MemberFlag.set(3) : m_MemberFlag.reset(3);
420  }
421 
422  // M StructMember
423  bool IS_MUST_UNDERSTAND() const
424  {
425  return m_MemberFlag.test(4);
426  }
427 
429  bool b)
430  {
431  b ? m_MemberFlag.set(4) : m_MemberFlag.reset(4);
432  }
433 
434  // K StructMember, UnionDiscriminator
435  bool IS_KEY() const
436  {
437  return m_MemberFlag.test(5);
438  }
439 
440  void IS_KEY(
441  bool b)
442  {
443  b ? m_MemberFlag.set(5) : m_MemberFlag.reset(5);
444  }
445 
446  // D UnionMember, EnumerationLiteral
447  bool IS_DEFAULT() const
448  {
449  return m_MemberFlag.test(6);
450  }
451 
453  bool b)
454  {
455  b ? m_MemberFlag.set(6) : m_MemberFlag.reset(6);
456  }
457 
459  const MemberFlag& other) const
460  {
461  return m_MemberFlag == other.m_MemberFlag;
462  }
463 
464  std::bitset<16> bitset() const
465  {
466  std::string str_value;
467 
468  str_value = m_MemberFlag.to_string() + str_value;
469 
470  return std::bitset<16>(str_value);
471  }
472 
473  void bitset(
474  const std::bitset<16>& bitset)
475  {
476  std::string str_value {bitset.to_string()};
477  size_t base_diff {0};
478  size_t last_post {std::string::npos};
479 
480  base_diff += 16;
481  m_MemberFlag = std::bitset<16>(str_value.substr(str_value.length() - base_diff, last_post));
482  }
483 
484 };
485 
486 typedef MemberFlag CollectionElementFlag; // T1, T2, X
487 typedef MemberFlag StructMemberFlag; // T1, T2, O, M, K, X
488 typedef MemberFlag UnionMemberFlag; // T1, T2, D, X
489 typedef MemberFlag UnionDiscriminatorFlag; // T1, T2, K
491 typedef MemberFlag AnnotationParameterFlag; // Unused. No flags apply
492 typedef MemberFlag AliasMemberFlag; // Unused. No flags apply
493 typedef MemberFlag BitflagFlag; // Unused. No flags apply
494 typedef MemberFlag BitsetMemberFlag; // Unused. No flags apply
495 
496 // Flags that apply to type declarationa and DO affect assignability
497 // Depending on the flag it may not apply to all types
498 // When not all, the applicable types are listed
499 class TypeFlag
500 {
501 private:
502 
503  std::bitset<16> m_TypeFlag;
504 
505 public:
506 
508  {
509  }
510 
512  const TypeFlag& x)
513  : m_TypeFlag(x.m_TypeFlag)
514  {
515  }
516 
518  TypeFlag&& x)
519  : m_TypeFlag(std::move(x.m_TypeFlag))
520  {
521  }
522 
524  const TypeFlag& x)
525  {
526  m_TypeFlag = x.m_TypeFlag;
527  return *this;
528  }
529 
531  TypeFlag&& x)
532  {
533  m_TypeFlag = std::move(x.m_TypeFlag);
534  return *this;
535  }
536 
537  // F |
538  bool IS_FINAL() const
539  {
540  return m_TypeFlag.test(0);
541  }
542 
543  void IS_FINAL(
544  bool b)
545  {
546  b ? m_TypeFlag.set(0) : m_TypeFlag.reset(0);
547  }
548 
549  // A |- Struct, Union
550  bool IS_APPENDABLE() const
551  {
552  return m_TypeFlag.test(1);
553  }
554 
556  bool b)
557  {
558  b ? m_TypeFlag.set(1) : m_TypeFlag.reset(1);
559  }
560 
561  // M | (exactly one flag)
562  bool IS_MUTABLE() const
563  {
564  return m_TypeFlag.test(2);
565  }
566 
568  bool b)
569  {
570  b ? m_TypeFlag.set(2) : m_TypeFlag.reset(2);
571  }
572 
573  // N Struct, Union
574  bool IS_NESTED() const
575  {
576  return m_TypeFlag.test(3);
577  }
578 
579  void IS_NESTED(
580  bool b)
581  {
582  b ? m_TypeFlag.set(3) : m_TypeFlag.reset(3);
583  }
584 
585  // H Struct
586  bool IS_AUTOID_HASH() const
587  {
588  return m_TypeFlag.test(4);
589  }
590 
592  bool b)
593  {
594  b ? m_TypeFlag.set(4) : m_TypeFlag.reset(4);
595  }
596 
598  const TypeFlag& other) const
599  {
600  return m_TypeFlag == other.m_TypeFlag;
601  }
602 
603  std::bitset<16> bitset() const
604  {
605  std::string str_value;
606 
607  str_value = m_TypeFlag.to_string() + str_value;
608 
609  return std::bitset<16>(str_value);
610  }
611 
612  void bitset(
613  const std::bitset<16>& bitset)
614  {
615  std::string str_value {bitset.to_string()};
616  size_t base_diff {0};
617  size_t last_post {std::string::npos};
618 
619  base_diff += 16;
620  m_TypeFlag = std::bitset<16>(str_value.substr(str_value.length() - base_diff, last_post));
621  }
622 
623 };
624 
625 typedef TypeFlag StructTypeFlag; // All flags apply
626 typedef TypeFlag UnionTypeFlag; // All flags apply
627 typedef TypeFlag CollectionTypeFlag; // Unused. No flags apply
628 typedef TypeFlag AnnotationTypeFlag; // Unused. No flags apply
629 typedef TypeFlag AliasTypeFlag; // Unused. No flags apply
630 typedef TypeFlag EnumTypeFlag; // Unused. No flags apply
631 typedef TypeFlag BitmaskTypeFlag; // Unused. No flags apply
632 typedef TypeFlag BitsetTypeFlag; // Unused. No flags apply
633 
634 // Mask used to remove the flags that do no affect assignability
635 const uint16_t TypeFlagMinimalMask = 0x0007; // Selects M, A, F
636 
637 // --- Annotation usage: ----------------------------------------------
638 
639 // ID of a type member
640 const uint32_t ANNOTATION_STR_VALUE_MAX_LEN = 128;
642 
643 } // namespace types
644 } // namespace fastrtps
645 } // namespace eprosima
646 
647 #endif // TYPES_BASE_H
Definition: TypesBase.h:336
bool IS_OPTIONAL() const
Definition: TypesBase.h:411
MemberFlag(MemberFlag &&x)
Definition: TypesBase.h:353
void TRY_CONSTRUCT1(bool b)
Definition: TypesBase.h:379
bool IS_MUST_UNDERSTAND() const
Definition: TypesBase.h:423
MemberFlag & operator=(const MemberFlag &x)
Definition: TypesBase.h:359
void bitset(const std::bitset< 16 > &bitset)
Definition: TypesBase.h:473
void IS_OPTIONAL(bool b)
Definition: TypesBase.h:416
bool IS_DEFAULT() const
Definition: TypesBase.h:447
std::bitset< 16 > bitset() const
Definition: TypesBase.h:464
bool TRY_CONSTRUCT2() const
Definition: TypesBase.h:386
void TRY_CONSTRUCT2(bool b)
Definition: TypesBase.h:391
bool IS_KEY() const
Definition: TypesBase.h:435
bool IS_EXTERNAL() const
Definition: TypesBase.h:399
MemberFlag()
Definition: TypesBase.h:343
bool operator==(const MemberFlag &other) const
Definition: TypesBase.h:458
void IS_EXTERNAL(bool b)
Definition: TypesBase.h:404
void IS_DEFAULT(bool b)
Definition: TypesBase.h:452
bool TRY_CONSTRUCT1() const
Definition: TypesBase.h:374
MemberFlag(const MemberFlag &x)
Definition: TypesBase.h:347
void IS_MUST_UNDERSTAND(bool b)
Definition: TypesBase.h:428
void IS_KEY(bool b)
Definition: TypesBase.h:440
This class represents the enumeration ReturnCode_t.
Definition: TypesBase.h:190
ReturnCode_t(uint32_t e)
Definition: TypesBase.h:218
ReturnCode_t()
Definition: TypesBase.h:213
ReturnCodeValue
Definition: TypesBase.h:196
Definition: TypesBase.h:500
void IS_MUTABLE(bool b)
Definition: TypesBase.h:567
bool IS_NESTED() const
Definition: TypesBase.h:574
TypeFlag & operator=(const TypeFlag &x)
Definition: TypesBase.h:523
TypeFlag()
Definition: TypesBase.h:507
void IS_APPENDABLE(bool b)
Definition: TypesBase.h:555
void bitset(const std::bitset< 16 > &bitset)
Definition: TypesBase.h:612
bool IS_APPENDABLE() const
Definition: TypesBase.h:550
TypeFlag(TypeFlag &&x)
Definition: TypesBase.h:517
std::bitset< 16 > bitset() const
Definition: TypesBase.h:603
void IS_FINAL(bool b)
Definition: TypesBase.h:543
bool operator==(const TypeFlag &other) const
Definition: TypesBase.h:597
void IS_NESTED(bool b)
Definition: TypesBase.h:579
bool IS_MUTABLE() const
Definition: TypesBase.h:562
TypeFlag(const TypeFlag &x)
Definition: TypesBase.h:511
void IS_AUTOID_HASH(bool b)
Definition: TypesBase.h:591
bool IS_FINAL() const
Definition: TypesBase.h:538
bool IS_AUTOID_HASH() const
Definition: TypesBase.h:586
uint32_t DomainId_t
Definition: TypesBase.h:32
const octet TK_FLOAT32
Definition: TypesBase.h:131
MemberFlag BitsetMemberFlag
Definition: TypesBase.h:494
uint32_t MemberId
Definition: TypesBase.h:285
TypeFlag BitsetTypeFlag
Definition: TypesBase.h:632
const octet TK_BYTE
Definition: TypesBase.h:124
const std::string ANNOTATION_DEFAULT_LITERAL_ID
Definition: TypesBase.h:75
TypeFlag StructTypeFlag
Definition: TypesBase.h:625
const octet TK_UINT64
Definition: TypesBase.h:130
octet PrimitiveTypeId
Definition: TypesBase.h:174
const std::string TKNAME_MAP
Definition: TypesBase.h:111
const octet TK_BITSET
Definition: TypesBase.h:153
const std::string ANNOTATION_TOPIC_ID
Definition: TypesBase.h:64
octet EquivalenceKind
Definition: TypesBase.h:114
const octet TK_UNION
Definition: TypesBase.h:152
const std::string CONST_FALSE
Definition: TypesBase.h:60
TypeFlag AliasTypeFlag
Definition: TypesBase.h:629
const octet TK_FLOAT64
Definition: TypesBase.h:132
MemberFlag BitflagFlag
Definition: TypesBase.h:493
const std::string ANNOTATION_VALUE_ID
Definition: TypesBase.h:76
const std::string EXTENSIBILITY_MUTABLE
Definition: TypesBase.h:81
const uint16_t MemberFlagMinimalMask
Definition: TypesBase.h:183
MemberFlag StructMemberFlag
Definition: TypesBase.h:487
const octet TK_STRING16
Definition: TypesBase.h:139
const std::string TKNAME_BITMASK
Definition: TypesBase.h:104
octet SBound
Definition: TypesBase.h:299
const std::string TKNAME_STRING8
Definition: TypesBase.h:100
uint32_t LBound
Definition: TypesBase.h:294
TypeFlag CollectionTypeFlag
Definition: TypesBase.h:627
const std::string TKNAME_CHAR16
Definition: TypesBase.h:94
const std::string TKNAME_UINT64
Definition: TypesBase.h:89
const uint16_t TypeFlagMinimalMask
Definition: TypesBase.h:635
const std::string ANNOTATION_MUTABLE_ID
Definition: TypesBase.h:68
const octet TK_INT32
Definition: TypesBase.h:126
const octet TK_ANNOTATION
Definition: TypesBase.h:150
const std::string TKNAME_SEQUENCE
Definition: TypesBase.h:109
const std::string ANNOTATION_APPENDABLE_ID
Definition: TypesBase.h:67
const std::string ANNOTATION_OPTIONAL_ID
Definition: TypesBase.h:70
const std::string TKNAME_FLOAT64
Definition: TypesBase.h:97
const std::string ANNOTATION_POSITION_ID
Definition: TypesBase.h:77
MemberFlag EnumeratedLiteralFlag
Definition: TypesBase.h:490
const octet TK_MAP
Definition: TypesBase.h:158
const std::string ANNOTATION_EPKEY_ID
Definition: TypesBase.h:63
const octet EK_COMPLETE
Definition: TypesBase.h:116
RTPS_DllAPI bool operator==(ReturnCode_t::ReturnCodeValue a, const ReturnCode_t &b)
Definition: TypesBase.h:250
std::vector< SBound > SBoundSeq
Definition: TypesBase.h:300
std::string MemberName
Definition: TypesBase.h:166
const octet TK_UINT16
Definition: TypesBase.h:128
const std::string TKNAME_FLOAT128
Definition: TypesBase.h:98
constexpr uint32_t BOUND_UNLIMITED
A special value indicating an unlimited quantity.
Definition: TypesBase.h:43
const std::string TKNAME_STRING16
Definition: TypesBase.h:101
const octet TK_CHAR8
Definition: TypesBase.h:134
const std::string TKNAME_BITSET
Definition: TypesBase.h:108
const std::string TKNAME_UNION
Definition: TypesBase.h:107
TypeFlag AnnotationTypeFlag
Definition: TypesBase.h:628
std::vector< octet > OctetSeq
Definition: TypesBase.h:47
const std::string EXTENSIBILITY_APPENDABLE
Definition: TypesBase.h:80
TypeFlag UnionTypeFlag
Definition: TypesBase.h:626
const std::string TKNAME_UINT32
Definition: TypesBase.h:87
const octet EK_BOTH
Definition: TypesBase.h:117
const std::string TKNAME_INT32
Definition: TypesBase.h:86
const std::string TKNAME_INT8
Definition: TypesBase.h:92
TypeFlag EnumTypeFlag
Definition: TypesBase.h:630
const octet TK_CHAR16
Definition: TypesBase.h:135
const std::string CONST_TRUE
Definition: TypesBase.h:59
const std::string TKNAME_ANNOTATION
Definition: TypesBase.h:105
const int32_t MAX_ELEMENTS_COUNT
Definition: TypesBase.h:290
const octet EK_MINIMAL
Definition: TypesBase.h:115
const octet TK_ALIAS
Definition: TypesBase.h:143
const std::string EXTENSIBILITY_FINAL
Definition: TypesBase.h:79
const octet TK_INT16
Definition: TypesBase.h:125
MemberFlag UnionMemberFlag
Definition: TypesBase.h:488
const octet TK_BOOLEAN
Definition: TypesBase.h:123
const uint32_t ANNOTATION_OCTETSEC_VALUE_MAX_LEN
Definition: TypesBase.h:641
const octet TK_FLOAT128
Definition: TypesBase.h:133
const std::string TKNAME_ALIAS
Definition: TypesBase.h:102
constexpr uint32_t MEMBER_ID_INVALID
Definition: TypesBase.h:286
const std::string TKNAME_BOOLEAN
Definition: TypesBase.h:83
std::string QualifiedTypeName
Definition: TypesBase.h:171
const octet TK_BITMASK
Definition: TypesBase.h:147
const std::string TKNAME_FLOAT32
Definition: TypesBase.h:96
bool compareSequence(const std::vector< T > &a, const std::vector< T > &b)
Definition: TypesBase.h:305
const LBound INVALID_LBOUND
Definition: TypesBase.h:296
const SBound INVALID_SBOUND
Definition: TypesBase.h:301
TypeFlag BitmaskTypeFlag
Definition: TypesBase.h:631
size_t to_size_t(const OctetSeq &)
const std::string ANNOTATION_DEFAULT_ID
Definition: TypesBase.h:74
const uint32_t ANNOTATION_STR_VALUE_MAX_LEN
Definition: TypesBase.h:640
const octet TK_ENUM
Definition: TypesBase.h:146
const std::string TKNAME_UINT16
Definition: TypesBase.h:85
OctetSeq & operator++(OctetSeq &)
const std::string TKNAME_UINT8
Definition: TypesBase.h:93
const std::string ANNOTATION_NON_SERIALIZED_ID
Definition: TypesBase.h:72
const std::string TKNAME_INT64
Definition: TypesBase.h:88
const int32_t MAX_BITMASK_LENGTH
Definition: TypesBase.h:289
const octet TK_STRUCTURE
Definition: TypesBase.h:151
std::vector< LBound > LBoundSeq
Definition: TypesBase.h:295
const octet TK_ARRAY
Definition: TypesBase.h:157
const octet TK_SEQUENCE
Definition: TypesBase.h:156
MemberFlag AliasMemberFlag
Definition: TypesBase.h:492
MemberFlag AnnotationParameterFlag
Definition: TypesBase.h:491
MemberFlag UnionDiscriminatorFlag
Definition: TypesBase.h:489
const std::string TKNAME_CHAR16T
Definition: TypesBase.h:95
const octet TK_INT64
Definition: TypesBase.h:127
RTPS_DllAPI bool operator!=(ReturnCode_t::ReturnCodeValue a, const ReturnCode_t &b)
Definition: TypesBase.h:258
const std::string TKNAME_CHAR8
Definition: TypesBase.h:90
const octet TK_NONE
Definition: TypesBase.h:122
const std::string ANNOTATION_FINAL_ID
Definition: TypesBase.h:66
const octet TK_STRING8
Definition: TypesBase.h:138
const octet TK_UINT32
Definition: TypesBase.h:129
const std::string TKNAME_ENUM
Definition: TypesBase.h:103
octet TypeKind
Definition: TypesBase.h:120
const std::string TKNAME_ARRAY
Definition: TypesBase.h:110
const std::string TKNAME_STRUCTURE
Definition: TypesBase.h:106
const std::string ANNOTATION_BIT_BOUND_ID
Definition: TypesBase.h:73
const int32_t TYPE_NAME_MAX_LENGTH
Definition: TypesBase.h:170
const int32_t MEMBER_NAME_MAX_LENGTH
Definition: TypesBase.h:165
const int32_t MAX_STRING_LENGTH
Definition: TypesBase.h:291
std::array< uint8_t, 4 > NameHash
Definition: TypesBase.h:179
const std::string ANNOTATION_NESTED_ID
Definition: TypesBase.h:69
MemberFlag CollectionElementFlag
Definition: TypesBase.h:486
const std::string ANNOTATION_EXTENSIBILITY_ID
Definition: TypesBase.h:65
const std::string ANNOTATION_MUST_UNDERSTAND_ID
Definition: TypesBase.h:71
const std::string TKNAME_BYTE
Definition: TypesBase.h:91
const std::string ANNOTATION_KEY_ID
Definition: TypesBase.h:62
const std::string TKNAME_INT16
Definition: TypesBase.h:84
eProsima namespace.
Definition: LibrarySettingsAttributes.h:23