Fast RTPS  Version 2.14.1
Fast RTPS
Loading...
Searching...
No Matches
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
29namespace eprosima {
30namespace fastdds {
31namespace dds {
32using DomainId_t = uint32_t;
33} // dds
34} // namespace fastdds
35
36namespace fastcdr {
37class Cdr;
38} // namespace fastcdr
39namespace fastrtps {
40namespace types {
41
43constexpr uint32_t BOUND_UNLIMITED = 0;
44
45using eprosima::fastrtps::rtps::octet;
46
47using OctetSeq = std::vector<octet>;
48
50 OctetSeq&);
51
53 OctetSeq&,
54 int);
55
56size_t to_size_t(
57 const OctetSeq&);
58
59const std::string CONST_TRUE = "true";
60const std::string CONST_FALSE = "false";
61
62const std::string ANNOTATION_KEY_ID = "key";
63const std::string ANNOTATION_EPKEY_ID = "Key";
64const std::string ANNOTATION_TOPIC_ID = "Topic";
65const std::string ANNOTATION_EXTENSIBILITY_ID = "extensibility";
66const std::string ANNOTATION_FINAL_ID = "final";
67const std::string ANNOTATION_APPENDABLE_ID = "appendable";
68const std::string ANNOTATION_MUTABLE_ID = "mutable";
69const std::string ANNOTATION_NESTED_ID = "nested";
70const std::string ANNOTATION_OPTIONAL_ID = "optional";
71const std::string ANNOTATION_MUST_UNDERSTAND_ID = "must_understand";
72const std::string ANNOTATION_NON_SERIALIZED_ID = "non_serialized";
73const std::string ANNOTATION_BIT_BOUND_ID = "bit_bound";
74const std::string ANNOTATION_DEFAULT_ID = "default";
75const std::string ANNOTATION_DEFAULT_LITERAL_ID = "default_literal";
76const std::string ANNOTATION_VALUE_ID = "value";
77const std::string ANNOTATION_POSITION_ID = "position";
78
79const std::string EXTENSIBILITY_FINAL = "FINAL";
80const std::string EXTENSIBILITY_APPENDABLE = "APPENDABLE";
81const std::string EXTENSIBILITY_MUTABLE = "MUTABLE";
82
83const std::string TKNAME_BOOLEAN = "bool";
84const std::string TKNAME_INT16 = "int16_t";
85const std::string TKNAME_UINT16 = "uint16_t";
86const std::string TKNAME_INT32 = "int32_t";
87const std::string TKNAME_UINT32 = "uint32_t";
88const std::string TKNAME_INT64 = "int64_t";
89const std::string TKNAME_UINT64 = "uint64_t";
90const std::string TKNAME_CHAR8 = "char";
91const std::string TKNAME_BYTE = "octet";
92const std::string TKNAME_INT8 = "int8_t";
93const std::string TKNAME_UINT8 = "uint8_t";
94const std::string TKNAME_CHAR16 = "wchar";
95const std::string TKNAME_CHAR16T = "wchar_t";
96const std::string TKNAME_FLOAT32 = "float";
97const std::string TKNAME_FLOAT64 = "double";
98const std::string TKNAME_FLOAT128 = "longdouble";
99
100const std::string TKNAME_STRING8 = "string";
101const std::string TKNAME_STRING16 = "wstring";
102const std::string TKNAME_ALIAS = "alias";
103const std::string TKNAME_ENUM = "enum";
104const std::string TKNAME_BITMASK = "bitmask";
105const std::string TKNAME_ANNOTATION = "annotation";
106const std::string TKNAME_STRUCTURE = "structure";
107const std::string TKNAME_UNION = "union";
108const std::string TKNAME_BITSET = "bitset";
109const std::string TKNAME_SEQUENCE = "sequence";
110const std::string TKNAME_ARRAY = "array";
111const std::string TKNAME_MAP = "map";
112
113// ---------- Equivalence Kinds ------------------
114typedef octet EquivalenceKind;
115const octet EK_MINIMAL = 0xF1; // 0x1111 0001
116const octet EK_COMPLETE = 0xF2; // 0x1111 0010
117const octet EK_BOTH = 0xF3; // 0x1111 0011
118
119// ---------- TypeKinds (begin) ------------------
120typedef octet TypeKind; // Primitive TKs
121
122const octet TK_NONE = 0x00;
123const octet TK_BOOLEAN = 0x01;
124const octet TK_BYTE = 0x02;
125const octet TK_INT16 = 0x03;
126const octet TK_INT32 = 0x04;
127const octet TK_INT64 = 0x05;
128const octet TK_UINT16 = 0x06;
129const octet TK_UINT32 = 0x07;
130const octet TK_UINT64 = 0x08;
131const octet TK_FLOAT32 = 0x09;
132const octet TK_FLOAT64 = 0x0A;
133const octet TK_FLOAT128 = 0x0B;
134const octet TK_CHAR8 = 0x10;
135const octet TK_CHAR16 = 0x11;
136
137// String TKs
138const octet TK_STRING8 = 0x20;
139const octet TK_STRING16 = 0x21;
140
141
142// Constructed/Named types
143const octet TK_ALIAS = 0x30;
144
145// Enumerated TKs
146const octet TK_ENUM = 0x40;
147const octet TK_BITMASK = 0x41;
148
149// Structured TKs
150const octet TK_ANNOTATION = 0x50;
151const octet TK_STRUCTURE = 0x51;
152const octet TK_UNION = 0x52;
153const octet TK_BITSET = 0x53;
154
155// Collection TKs
156const octet TK_SEQUENCE = 0x60;
157const octet TK_ARRAY = 0x61;
158const 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
165const int32_t MEMBER_NAME_MAX_LENGTH = 256;
166typedef std::string MemberName;
167
168// Qualified type name includes the name of containing modules
169// using "::" as separator. No leading "::". E.g. "MyModule::MyType"
170const int32_t TYPE_NAME_MAX_LENGTH = 256;
171typedef std::string QualifiedTypeName;
172
173// Every type has an ID. Those of the primitive types are pre-defined.
174typedef 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}
179typedef 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
183const uint16_t MemberFlagMinimalMask = 0x003f;
184
189class RTPS_DllAPI ReturnCode_t
190{
191 uint32_t value_;
192
193public:
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
224 bool operator ==(
225 const ReturnCode_t& c) const
226 {
227 return value_ == c.value_;
228 }
229
230 bool operator !=(
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
250RTPS_DllAPI inline bool operator ==(
252 const ReturnCode_t& b)
253{
254 return b.operator ==(
255 a);
256}
257
258RTPS_DllAPI inline bool operator !=(
260 const ReturnCode_t& b)
261{
262 return b.operator !=(
263 a);
264}
265
266RTPS_DllAPI inline bool operator ==(
267 uint32_t a,
268 const ReturnCode_t& b)
269{
270 return b.operator ==(
271 a);
272}
273
274RTPS_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
285typedef uint32_t MemberId;
286constexpr uint32_t MEMBER_ID_INVALID {0X0FFFFFFF};
287#define INDEX_INVALID UINT32_MAX
288
289const int32_t MAX_BITMASK_LENGTH = 64;
290const int32_t MAX_ELEMENTS_COUNT = 100;
291const int32_t MAX_STRING_LENGTH = 255;
292
293// Long Bound of a collection type
294typedef uint32_t LBound;
295typedef std::vector<LBound> LBoundSeq;
297
298// Short Bound of a collection type
299typedef octet SBound;
300typedef std::vector<SBound> SBoundSeq;
302
303// Auxiliar function to compare sequences (std::vector)
304template<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{
337private:
338
339 std::bitset<16> m_MemberFlag;
340
341public:
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
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
487typedef MemberFlag StructMemberFlag; // T1, T2, O, M, K, X
488typedef MemberFlag UnionMemberFlag; // T1, T2, D, X
491typedef MemberFlag AnnotationParameterFlag; // Unused. No flags apply
492typedef MemberFlag AliasMemberFlag; // Unused. No flags apply
493typedef MemberFlag BitflagFlag; // Unused. No flags apply
494typedef 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
500{
501private:
502
503 std::bitset<16> m_TypeFlag;
504
505public:
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
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
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
625typedef TypeFlag StructTypeFlag; // All flags apply
626typedef TypeFlag UnionTypeFlag; // All flags apply
627typedef TypeFlag CollectionTypeFlag; // Unused. No flags apply
628typedef TypeFlag AnnotationTypeFlag; // Unused. No flags apply
629typedef TypeFlag AliasTypeFlag; // Unused. No flags apply
630typedef TypeFlag EnumTypeFlag; // Unused. No flags apply
631typedef TypeFlag BitmaskTypeFlag; // Unused. No flags apply
632typedef TypeFlag BitsetTypeFlag; // Unused. No flags apply
633
634// Mask used to remove the flags that do no affect assignability
635const uint16_t TypeFlagMinimalMask = 0x0007; // Selects M, A, F
636
637// --- Annotation usage: ----------------------------------------------
638
639// ID of a type member
640const 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
void bitset(const std::bitset< 16 > &bitset)
Definition TypesBase.h:473
void IS_OPTIONAL(bool b)
Definition TypesBase.h:416
MemberFlag & operator=(const MemberFlag &x)
Definition TypesBase.h:359
bool IS_DEFAULT() const
Definition TypesBase.h:447
bool TRY_CONSTRUCT2() const
Definition TypesBase.h:386
void TRY_CONSTRUCT2(bool b)
Definition TypesBase.h:391
std::bitset< 16 > bitset() const
Definition TypesBase.h:464
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()
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
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
std::bitset< 16 > bitset() const
Definition TypesBase.h:603
TypeFlag(const TypeFlag &x)
Definition TypesBase.h:511
TypeFlag & operator=(const TypeFlag &x)
Definition TypesBase.h:523
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
OctetSeq & operator++(OctetSeq &)
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
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
size_t to_size_t(const OctetSeq &)
const std::string CONST_TRUE
Definition TypesBase.h:59
const std::string TKNAME_ANNOTATION
Definition TypesBase.h:105
bool compareSequence(const std::vector< T > &a, const std::vector< T > &b)
Definition TypesBase.h:305
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
RTPS_DllAPI bool operator!=(ReturnCode_t::ReturnCodeValue a, const ReturnCode_t &b)
Definition TypesBase.h:258
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
const LBound INVALID_LBOUND
Definition TypesBase.h:296
const SBound INVALID_SBOUND
Definition TypesBase.h:301
TypeFlag BitmaskTypeFlag
Definition TypesBase.h:631
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
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
RTPS_DllAPI bool operator==(ReturnCode_t::ReturnCodeValue a, const ReturnCode_t &b)
Definition TypesBase.h:250
MemberFlag UnionDiscriminatorFlag
Definition TypesBase.h:489
const std::string TKNAME_CHAR16T
Definition TypesBase.h:95
const octet TK_INT64
Definition TypesBase.h:127
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