Fast RTPS  Version 2.9.1
Fast RTPS
AnnotationParameterValue.h
1// Copyright 2016 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
22#ifndef _ANNOTATIONPARAMETERVALUE_H_
23#define _ANNOTATIONPARAMETERVALUE_H_
24
25#if _MSC_VER
26
27#if defined(max)
28#pragma push_macro("max")
29#undef max
30#define FASTDDS_RESTORE_MAX
31#endif // defined(max)
32
33#if defined(min)
34#pragma push_macro("min")
35#undef min
36#define FASTDDS_RESTORE_MIN
37#endif // defined(min)
38
39#endif // if _MSC_VER
40
41#include <fastrtps/types/TypesBase.h>
42#include <fastrtps/types/TypeIdentifier.h>
43#include <fastrtps/utils/string_convert.hpp>
44#include <fastrtps/fastrtps_dll.h>
45#include <stdint.h>
46#include <array>
47#include <vector>
48
49namespace eprosima {
50namespace fastcdr {
51class Cdr;
52} // namespace fastcdr
53} // namespace eprosima
54namespace eprosima {
55namespace fastrtps {
56
57namespace types {
58
64{
65public:
66
71
76
83
90
97
104
111 RTPS_DllAPI static size_t getCdrSerializedSize(
113 size_t current_alignment = 0);
114
115
120 RTPS_DllAPI void serialize(
121 eprosima::fastcdr::Cdr& cdr) const;
122
127 RTPS_DllAPI void deserialize(
128 eprosima::fastcdr::Cdr& cdr);
129
130
131
138 RTPS_DllAPI static size_t getKeyMaxCdrSerializedSize(
139 size_t current_alignment = 0);
140
144 RTPS_DllAPI static bool isKeyDefined();
145
150 RTPS_DllAPI void serializeKey(
151 eprosima::fastcdr::Cdr& cdr) const;
152
153 RTPS_DllAPI bool operator ==(
155 {
156 return true;
157 }
158
159private:
160};
166{
167public:
168
173
178
184 const AnnotationParameterValue& x);
185
192
198 const AnnotationParameterValue& x);
199
206
212 RTPS_DllAPI void _d(
213 char __d);
214
219 RTPS_DllAPI char _d() const;
220
225 RTPS_DllAPI char& _d();
226
231 RTPS_DllAPI void boolean_value(
232 bool _boolean_value);
233
239 RTPS_DllAPI bool boolean_value() const;
240
246 RTPS_DllAPI bool& boolean_value();
251 RTPS_DllAPI void byte_value(
252 uint8_t _byte_value);
253
259 RTPS_DllAPI uint8_t byte_value() const;
260
266 RTPS_DllAPI uint8_t& byte_value();
271 RTPS_DllAPI void int16_value(
272 int16_t _int16_value);
273
279 RTPS_DllAPI int16_t int16_value() const;
280
286 RTPS_DllAPI int16_t& int16_value();
291 RTPS_DllAPI void uint_16_value(
292 uint16_t _uint_16_value);
293
299 RTPS_DllAPI uint16_t uint_16_value() const;
300
306 RTPS_DllAPI uint16_t& uint_16_value();
311 RTPS_DllAPI void int32_value(
312 int32_t _int32_value);
313
319 RTPS_DllAPI int32_t int32_value() const;
320
326 RTPS_DllAPI int32_t& int32_value();
331 RTPS_DllAPI void uint32_value(
332 uint32_t _uint32_value);
333
339 RTPS_DllAPI uint32_t uint32_value() const;
340
346 RTPS_DllAPI uint32_t& uint32_value();
351 RTPS_DllAPI void int64_value(
352 int64_t _int64_value);
353
359 RTPS_DllAPI int64_t int64_value() const;
360
366 RTPS_DllAPI int64_t& int64_value();
367
372 RTPS_DllAPI void uint64_value(
373 uint64_t _uint64_value);
374
380 RTPS_DllAPI uint64_t uint64_value() const;
381
387 RTPS_DllAPI uint64_t& uint64_value();
392 RTPS_DllAPI void float32_value(
393 float _float32_value);
394
400 RTPS_DllAPI float float32_value() const;
401
407 RTPS_DllAPI float& float32_value();
412 RTPS_DllAPI void float64_value(
413 double _float64_value);
414
420 RTPS_DllAPI double float64_value() const;
421
427 RTPS_DllAPI double& float64_value();
428
433 RTPS_DllAPI void float128_value(
434 long double _float128_value);
435
441 RTPS_DllAPI long double float128_value() const;
442
448 RTPS_DllAPI long double& float128_value();
453 RTPS_DllAPI void char_value(
454 char _char_value);
455
461 RTPS_DllAPI char char_value() const;
462
468 RTPS_DllAPI char& char_value();
473 RTPS_DllAPI void wchar_value(
474 wchar_t _wchar_value);
475
481 RTPS_DllAPI wchar_t wchar_value() const;
482
488 RTPS_DllAPI wchar_t& wchar_value();
493 RTPS_DllAPI void enumerated_value(
494 int32_t _enumerated_value);
495
501 RTPS_DllAPI int32_t enumerated_value() const;
502
508 RTPS_DllAPI int32_t& enumerated_value();
513 RTPS_DllAPI void string8_value(
514 const std::string& _string8_value);
515
520 RTPS_DllAPI void string8_value(
521 std::string&& _string8_value);
522
528 RTPS_DllAPI const std::string& string8_value() const;
529
535 RTPS_DllAPI std::string& string8_value();
540 RTPS_DllAPI void string16_value(
541 const std::wstring& _string16_value);
542
547 RTPS_DllAPI void string16_value(
548 std::wstring&& _string16_value);
549
555 RTPS_DllAPI const std::wstring& string16_value() const;
556
562 RTPS_DllAPI std::wstring& string16_value();
563
568 RTPS_DllAPI void extended_value(
569 const ExtendedAnnotationParameterValue& _extended_value);
570
575 RTPS_DllAPI void extended_value(
576 ExtendedAnnotationParameterValue&& _extended_value);
577
584
591
598 RTPS_DllAPI static size_t getCdrSerializedSize(
599 const AnnotationParameterValue& data,
600 size_t current_alignment = 0);
601
602
607 RTPS_DllAPI void serialize(
608 eprosima::fastcdr::Cdr& cdr) const;
609
614 RTPS_DllAPI void deserialize(
615 eprosima::fastcdr::Cdr& cdr);
616
617
618
625 RTPS_DllAPI static size_t getKeyMaxCdrSerializedSize(
626 size_t current_alignment = 0);
627
631 RTPS_DllAPI static bool isKeyDefined();
632
637 RTPS_DllAPI void serializeKey(
638 eprosima::fastcdr::Cdr& cdr) const;
639
640 RTPS_DllAPI bool operator ==(
641 const AnnotationParameterValue& other) const;
642
646 RTPS_DllAPI std::string to_string() const
647 {
648 switch (m__d)
649 {
650 case TK_BOOLEAN:
651 return (m_boolean_value) ? "true" : "false";
652 case TK_BYTE:
653 return std::to_string(m_byte_value);
654 case TK_INT16:
655 return std::to_string(m_int16_value);
656 case TK_UINT16:
657 return std::to_string(m_uint_16_value);
658 case TK_INT32:
659 return std::to_string(m_int32_value);
660 case TK_UINT32:
661 return std::to_string(m_uint32_value);
662 case TK_INT64:
663 return std::to_string(m_int64_value);
664 case TK_UINT64:
665 return std::to_string(m_uint64_value);
666 case TK_FLOAT32:
667 return std::to_string(m_float32_value);
668 case TK_FLOAT64:
669 return std::to_string(m_float64_value);
670 case TK_FLOAT128:
671 return std::to_string(m_float128_value);
672 case TK_CHAR8:
673 return std::to_string(m_char_value);
674 case TK_CHAR16:
675 return std::to_string(m_wchar_value);
676 case TK_ENUM:
677 return std::to_string(m_enumerated_value);
678 case TK_STRING16:
679 {
680 return wstring_to_bytes(m_string16_value);
681 }
682 case TK_STRING8:
683 case TK_NONE: // Cheat!
684 return m_string8_value;
685 default:
686 return "";
687 }
688 }
689
693 RTPS_DllAPI void from_string(
694 const std::string& value)
695 {
696 switch (m__d)
697 {
698 case TK_BOOLEAN:
699 {
700 std::string val_ = value;
701 std::transform(val_.begin(), val_.end(), val_.begin(),
702 [](unsigned char c)
703 {
704 return static_cast<char>(std::tolower(c));
705 });
706 boolean_value(val_.compare("0") != 0 || val_.compare(CONST_TRUE) == 0);
707 }
708 break;
709 case TK_BYTE:
710 {
711 byte_value(static_cast<uint8_t>(std::stoul(value)));
712 }
713 break;
714 case TK_INT16:
715 {
716 int16_value(static_cast<int16_t>(std::stoi(value)));
717 }
718 break;
719 case TK_INT32:
720 {
721 int32_value(static_cast<int32_t>(std::stoi(value)));
722 }
723 break;
724 case TK_INT64:
725 {
726 int64_value(static_cast<int64_t>(std::stoll(value)));
727 }
728 break;
729 case TK_UINT16:
730 {
731 uint_16_value(static_cast<uint16_t>(std::stoul(value)));
732 }
733 break;
734 case TK_UINT32:
735 {
736 uint32_value(static_cast<uint32_t>(std::stoul(value)));
737 }
738 break;
739 case TK_UINT64:
740 {
741 uint64_value(static_cast<uint64_t>(std::stoull(value)));
742 }
743 break;
744 case TK_FLOAT32:
745 {
746 float32_value(std::stof(value));
747 }
748 break;
749 case TK_FLOAT64:
750 {
751 float64_value(std::stod(value));
752 }
753 break;
754 case TK_FLOAT128:
755 {
756 float128_value(std::stold(value));
757 }
758 break;
759 case TK_CHAR8:
760 {
761 char_value(value.c_str()[0]);
762 }
763 break;
764 case TK_CHAR16:
765 {
766 wchar_value(wstring_from_bytes(value).c_str()[0]);
767 }
768 break;
769 case TK_STRING8:
770 case TK_NONE: // Cheat!
771 {
772 string8_value(value);
773 }
774 break;
775 case TK_STRING16:
776 {
778 }
779 break;
780 case TK_ENUM:
781 {
782 // TODO Translate from enum value name to integer value
783 enumerated_value(static_cast<int32_t>(std::stoul(value)));
784 }
785 break;
786 default:
787 break;
788 }
789 }
790
791private:
792
793 char m__d;
794
795 bool m_boolean_value;
796 uint8_t m_byte_value;
797 int16_t m_int16_value;
798 uint16_t m_uint_16_value;
799 int32_t m_int32_value;
800 uint32_t m_uint32_value;
801 int64_t m_int64_value;
802 uint64_t m_uint64_value;
803 float m_float32_value;
804 double m_float64_value;
805 long double m_float128_value;
806 char m_char_value;
807 wchar_t m_wchar_value;
808 int32_t m_enumerated_value;
809 std::string m_string8_value;
810 std::wstring m_string16_value;
811 ExtendedAnnotationParameterValue m_extended_value;
812};
813
819{
820public:
821
826
831
838
845
852
859
864 inline void paramname_hash(
865 const NameHash& _paramname_hash)
866 {
867 m_paramname_hash = _paramname_hash;
868 }
869
874 inline void paramname_hash(
875 NameHash&& _paramname_hash)
876 {
877 m_paramname_hash = std::move(_paramname_hash);
878 }
879
884 inline const NameHash& paramname_hash() const
885 {
886 return m_paramname_hash;
887 }
888
894 {
895 return m_paramname_hash;
896 }
897
902 inline void value(
903 const AnnotationParameterValue& _value)
904 {
905 m_value = _value;
906 }
907
912 inline void value(
914 {
915 m_value = std::move(_value);
916 }
917
922 inline const AnnotationParameterValue& value() const
923 {
924 return m_value;
925 }
926
932 {
933 return m_value;
934 }
935
942 RTPS_DllAPI static size_t getCdrSerializedSize(
943 const AppliedAnnotationParameter& data,
944 size_t current_alignment = 0);
945
946
951 RTPS_DllAPI void serialize(
952 eprosima::fastcdr::Cdr& cdr) const;
953
958 RTPS_DllAPI void deserialize(
959 eprosima::fastcdr::Cdr& cdr);
960
961
962
969 RTPS_DllAPI static size_t getKeyMaxCdrSerializedSize(
970 size_t current_alignment = 0);
971
975 RTPS_DllAPI static bool isKeyDefined();
976
981 RTPS_DllAPI void serializeKey(
982 eprosima::fastcdr::Cdr& cdr) const;
983
984 RTPS_DllAPI bool operator ==(
985 const AppliedAnnotationParameter& other) const;
986
987private:
988
989 NameHash m_paramname_hash;
991};
992
993
994// The application of an annotation to some type or type member
995/*struct AppliedAnnotationParameter {
996 NameHash paramname_hash;
997 AnnotationParameterValue value;
998 };*/
999/*
1000 class AppliedAnnotationParameter
1001 {
1002 public:
1003 AppliedAnnotationParameter();
1004 ~AppliedAnnotationParameter();
1005 AppliedAnnotationParameter(const AppliedAnnotationParameter &x);
1006 AppliedAnnotationParameter(AppliedAnnotationParameter &&x);
1007 AppliedAnnotationParameter& operator=(const AppliedAnnotationParameter &x);
1008 AppliedAnnotationParameter& operator=(AppliedAnnotationParameter &&x);
1009
1010 inline void paramname_hash(const NameHash &_paramname_hash) { m_paramname_hash = _paramname_hash; }
1011 inline void paramname_hash(NameHash &&_paramname_hash) { m_paramname_hash = std::move(_paramname_hash); }
1012 inline const NameHash& paramname_hash() const { return m_paramname_hash; }
1013 inline NameHash& paramname_hash() { return m_paramname_hash; }
1014
1015 inline void value(const AnnotationParameterValue &_value) { m_value = _value; }
1016 inline void value(AnnotationParameterValue &&_value) { m_value = std::move(_value); }
1017 inline const AnnotationParameterValue& value() const { return m_value; }
1018 inline AnnotationParameterValue& value() { return m_value; }
1019
1020 static size_t getCdrSerializedSize(const AppliedAnnotationParameter& data, size_t current_alignment = 0);
1021 void serialize(eprosima::fastcdr::Cdr &cdr) const;
1022 void deserialize(eprosima::fastcdr::Cdr &cdr);
1023 static size_t getKeyMaxCdrSerializedSize(size_t current_alignment = 0);
1024 static bool isKeyDefined();
1025 void serializeKey(eprosima::fastcdr::Cdr &cdr) const;
1026
1027 private:
1028 NameHash m_paramname_hash;
1029 AnnotationParameterValue m_value;
1030 };
1031 */
1032// Sorted by AppliedAnnotationParameter.paramname_hash
1033typedef std::vector<AppliedAnnotationParameter> AppliedAnnotationParameterSeq;
1034
1035/*struct AppliedAnnotation {
1036 TypeIdentifier annotation_typeid;
1037 AppliedAnnotationParameterSeq param_seq; // @Optional
1038 };*/
1040{
1041public:
1042
1043 RTPS_DllAPI AppliedAnnotation();
1044
1045 RTPS_DllAPI ~AppliedAnnotation();
1046
1048 const AppliedAnnotation& x);
1049
1051 AppliedAnnotation&& x);
1053 const AppliedAnnotation& x);
1055 AppliedAnnotation&& x);
1056
1058 const TypeIdentifier& _annotation_typeid)
1059 {
1060 m_annotation_typeid = _annotation_typeid;
1061 }
1062
1064 TypeIdentifier&& _annotation_typeid)
1065 {
1066 m_annotation_typeid = std::move(_annotation_typeid);
1067 }
1068
1069 inline const TypeIdentifier& annotation_typeid() const
1070 {
1071 return m_annotation_typeid;
1072 }
1073
1075 {
1076 return m_annotation_typeid;
1077 }
1078
1079 inline void param_seq(
1080 const AppliedAnnotationParameterSeq& _param_seq)
1081 {
1082 m_param_seq = _param_seq;
1083 }
1084
1085 inline void param_seq(
1086 AppliedAnnotationParameterSeq&& _param_seq)
1087 {
1088 m_param_seq = std::move(_param_seq);
1089 }
1090
1092 {
1093 return m_param_seq;
1094 }
1095
1097 {
1098 return m_param_seq;
1099 }
1100
1101 RTPS_DllAPI static size_t getCdrSerializedSize(
1102 const AppliedAnnotation& data,
1103 size_t current_alignment = 0);
1104 RTPS_DllAPI void serialize(
1105 eprosima::fastcdr::Cdr& cdr) const;
1106 RTPS_DllAPI void deserialize(
1107 eprosima::fastcdr::Cdr& cdr);
1108 RTPS_DllAPI static size_t getKeyMaxCdrSerializedSize(
1109 size_t current_alignment = 0);
1110 RTPS_DllAPI static bool isKeyDefined();
1111 RTPS_DllAPI void serializeKey(
1112 eprosima::fastcdr::Cdr& cdr) const;
1113
1114 RTPS_DllAPI bool operator ==(
1115 const AppliedAnnotation& other) const;
1116
1117private:
1118
1119 TypeIdentifier m_annotation_typeid;
1121};
1122
1123// Sorted by AppliedAnnotation.annotation_typeid
1124typedef std::vector<AppliedAnnotation> AppliedAnnotationSeq;
1125
1126// @verbatim(placement="<placement>", language="<lang>", text="<text>")
1127/*struct AppliedVerbatimAnnotation {
1128 std::string placement; // 32
1129 std::string language; // 32
1130 std::string text;
1131 };*/
1133{
1134public:
1135
1137
1139
1141 const AppliedVerbatimAnnotation& x);
1142
1145
1147 const AppliedVerbatimAnnotation& x);
1148
1151
1152 inline void placement(
1153 const std::string& _placement)
1154 {
1155 m_placement = _placement;
1156 }
1157
1158 inline void placement(
1159 std::string&& _placement)
1160 {
1161 m_placement = std::move(_placement);
1162 }
1163
1164 inline const std::string& placement() const
1165 {
1166 return m_placement;
1167 }
1168
1169 inline std::string& placement()
1170 {
1171 return m_placement;
1172 }
1173
1174 inline void language(
1175 const std::string& _language)
1176 {
1177 m_language = _language;
1178 }
1179
1180 inline void language(
1181 std::string&& _language)
1182 {
1183 m_language = std::move(_language);
1184 }
1185
1186 inline const std::string& language() const
1187 {
1188 return m_language;
1189 }
1190
1191 inline std::string& language()
1192 {
1193 return m_language;
1194 }
1195
1196 inline void text(
1197 const std::string& _text)
1198 {
1199 m_text = _text;
1200 }
1201
1202 inline void text(
1203 std::string&& _text)
1204 {
1205 m_text = std::move(_text);
1206 }
1207
1208 inline const std::string& text() const
1209 {
1210 return m_text;
1211 }
1212
1213 inline std::string& text()
1214 {
1215 return m_text;
1216 }
1217
1218 RTPS_DllAPI static size_t getCdrSerializedSize(
1219 const AppliedVerbatimAnnotation& data,
1220 size_t current_alignment = 0);
1221
1222 RTPS_DllAPI void serialize(
1223 eprosima::fastcdr::Cdr& cdr) const;
1224
1225 RTPS_DllAPI void deserialize(
1226 eprosima::fastcdr::Cdr& cdr);
1227
1228 RTPS_DllAPI static size_t getKeyMaxCdrSerializedSize(
1229 size_t current_alignment = 0);
1230
1231 RTPS_DllAPI static bool isKeyDefined();
1232
1233 RTPS_DllAPI void serializeKey(
1234 eprosima::fastcdr::Cdr& cdr) const;
1235
1236 RTPS_DllAPI bool operator ==(
1237 const AppliedVerbatimAnnotation& other) const;
1238
1239private:
1240
1241 std::string m_placement;
1242 std::string m_language;
1243 std::string m_text;
1244};
1245
1246// --- Aggregate types: -----------------------------------------------
1247/*struct AppliedBuiltinMemberAnnotations {
1248 std::string unit; // @unit("<unit>") // @Optional
1249 AnnotationParameterValue min; // @min , @range // @Optional
1250 AnnotationParameterValue max; // @max , @range // @Optional
1251 std::string hash_id; // @hash_id("<membername>") // @Optional
1252 };
1253 */
1255{
1256public:
1257
1259
1261
1264
1267
1270
1273
1274 inline void unit(
1275 const std::string& _unit)
1276 {
1277 m_unit = _unit;
1278 }
1279
1280 inline void unit(
1281 std::string&& _unit)
1282 {
1283 m_unit = std::move(_unit);
1284 }
1285
1286 inline const std::string& unit() const
1287 {
1288 return m_unit;
1289 }
1290
1291 inline std::string& unit()
1292 {
1293 return m_unit;
1294 }
1295
1296 inline void min(
1297 const AnnotationParameterValue& _min)
1298 {
1299 m_min = _min;
1300 }
1301
1302 inline void min(
1304 {
1305 m_min = std::move(_min);
1306 }
1307
1308 inline const AnnotationParameterValue& min() const
1309 {
1310 return m_min;
1311 }
1312
1314 {
1315 return m_min;
1316 }
1317
1318 inline void max(
1319 const AnnotationParameterValue& _max)
1320 {
1321 m_max = _max;
1322 }
1323
1324 inline void max(
1326 {
1327 m_max = std::move(_max);
1328 }
1329
1330 inline const AnnotationParameterValue& max() const
1331 {
1332 return m_max;
1333 }
1334
1336 {
1337 return m_max;
1338 }
1339
1340 inline void hash_id(
1341 const std::string& _hash_id)
1342 {
1343 m_hash_id = _hash_id;
1344 }
1345
1346 inline void hash_id(
1347 std::string&& _hash_id)
1348 {
1349 m_hash_id = std::move(_hash_id);
1350 }
1351
1352 inline const std::string& hash_id() const
1353 {
1354 return m_hash_id;
1355 }
1356
1357 inline std::string& hash_id()
1358 {
1359 return m_hash_id;
1360 }
1361
1362 RTPS_DllAPI static size_t getCdrSerializedSize(
1364 size_t current_alignment = 0);
1365
1366 RTPS_DllAPI void serialize(
1367 eprosima::fastcdr::Cdr& cdr) const;
1368
1369 RTPS_DllAPI void deserialize(
1370 eprosima::fastcdr::Cdr& cdr);
1371
1372 RTPS_DllAPI static size_t getKeyMaxCdrSerializedSize(
1373 size_t current_alignment = 0);
1374
1375 RTPS_DllAPI static bool isKeyDefined();
1376
1377 RTPS_DllAPI void serializeKey(
1378 eprosima::fastcdr::Cdr& cdr) const;
1379
1380 RTPS_DllAPI bool operator ==(
1381 const AppliedBuiltinMemberAnnotations& other) const;
1382
1383private:
1384
1385 std::string m_unit;
1388 std::string m_hash_id;
1389};
1390
1391
1392} // namespace types
1393} // namespace fastrtps
1394} // namespace eprosima
1395
1396#if _MSC_VER
1397
1398#if defined(FASTDDS_RESTORE_MIN)
1399#pragma pop_macro("min")
1400#undef FASTDDS_RESTORE_MIN
1401#endif // defined(FASTDDS_RESTORE_MIN)
1402
1403#if defined(FASTDDS_RESTORE_MAX)
1404#pragma pop_macro("max")
1405#undef FASTDDS_RESTORE_MAX
1406#endif // defined(FASTDDS_RESTORE_MAX)
1407
1408#endif // if _MSC_VER
1409
1410#endif // _ANNOTATIONPARAMETERVALUE_H_
This class represents the union AnnotationParameterValue defined by the user in the IDL file.
Definition: AnnotationParameterValue.h:166
RTPS_DllAPI void int16_value(int16_t _int16_value)
This function sets a value in member int16_value.
RTPS_DllAPI const std::string & string8_value() const
This function returns a constant reference to member string8_value.
RTPS_DllAPI wchar_t & wchar_value()
This function returns a reference to member wchar_value.
RTPS_DllAPI long double & float128_value()
This function returns a reference to member float128_value.
RTPS_DllAPI void wchar_value(wchar_t _wchar_value)
This function sets a value in member wchar_value.
RTPS_DllAPI double & float64_value()
This function returns a reference to member float64_value.
RTPS_DllAPI uint32_t & uint32_value()
This function returns a reference to member uint32_value.
RTPS_DllAPI int32_t int32_value() const
This function returns the value of member int32_value.
RTPS_DllAPI AnnotationParameterValue(const AnnotationParameterValue &x)
Copy constructor.
RTPS_DllAPI void byte_value(uint8_t _byte_value)
This function sets a value in member byte_value.
RTPS_DllAPI uint64_t & uint64_value()
This function returns a reference to member uint64_value.
RTPS_DllAPI char & char_value()
This function returns a reference to member char_value.
RTPS_DllAPI void from_string(const std::string &value)
Aux method to set value from its string representation.
Definition: AnnotationParameterValue.h:693
RTPS_DllAPI std::wstring & string16_value()
This function returns a reference to member string16_value.
RTPS_DllAPI void extended_value(const ExtendedAnnotationParameterValue &_extended_value)
This function copies the value in member extended_value.
RTPS_DllAPI long double float128_value() const
This function returns the value of member float128_value.
RTPS_DllAPI void string16_value(std::wstring &&_string16_value)
This function moves the value in member string16_value.
RTPS_DllAPI uint32_t uint32_value() const
This function returns the value of member uint32_value.
RTPS_DllAPI void string8_value(std::string &&_string8_value)
This function moves the value in member string8_value.
RTPS_DllAPI const std::wstring & string16_value() const
This function returns a constant reference to member string16_value.
RTPS_DllAPI uint8_t byte_value() const
This function returns the value of member byte_value.
static RTPS_DllAPI size_t getKeyMaxCdrSerializedSize(size_t current_alignment=0)
This function returns the maximum serialized size of the Key of an object depending on the buffer ali...
RTPS_DllAPI std::string to_string() const
Aux method to return value as its string representation.
Definition: AnnotationParameterValue.h:646
RTPS_DllAPI const ExtendedAnnotationParameterValue & extended_value() const
This function returns a constant reference to member extended_value.
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
This function deserializes an object using CDR serialization.
RTPS_DllAPI bool boolean_value() const
This function returns the value of member boolean_value.
RTPS_DllAPI int16_t int16_value() const
This function returns the value of member int16_value.
RTPS_DllAPI float float32_value() const
This function returns the value of member float32_value.
RTPS_DllAPI void enumerated_value(int32_t _enumerated_value)
This function sets a value in member enumerated_value.
RTPS_DllAPI int32_t enumerated_value() const
This function returns the value of member enumerated_value.
RTPS_DllAPI uint8_t & byte_value()
This function returns a reference to member byte_value.
RTPS_DllAPI void uint32_value(uint32_t _uint32_value)
This function sets a value in member uint32_value.
RTPS_DllAPI int32_t & int32_value()
This function returns a reference to member int32_value.
RTPS_DllAPI bool & boolean_value()
This function returns a reference to member boolean_value.
RTPS_DllAPI int64_t int64_value() const
This function returns the value of member int64_value.
RTPS_DllAPI std::string & string8_value()
This function returns a reference to member string8_value.
static RTPS_DllAPI bool isKeyDefined()
This function tells you if the Key has been defined for this type.
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
This function serializes an object using CDR serialization.
RTPS_DllAPI void int32_value(int32_t _int32_value)
This function sets a value in member int32_value.
RTPS_DllAPI char _d() const
This function returns the value of the discriminator.
RTPS_DllAPI int16_t & int16_value()
This function returns a reference to member int16_value.
RTPS_DllAPI AnnotationParameterValue(AnnotationParameterValue &&x)
Move constructor.
RTPS_DllAPI wchar_t wchar_value() const
This function returns the value of member wchar_value.
RTPS_DllAPI uint64_t uint64_value() const
This function returns the value of member uint64_value.
RTPS_DllAPI void string16_value(const std::wstring &_string16_value)
This function copies the value in member string16_value.
RTPS_DllAPI void extended_value(ExtendedAnnotationParameterValue &&_extended_value)
This function moves the value in member extended_value.
RTPS_DllAPI void float32_value(float _float32_value)
This function sets a value in member float32_value.
RTPS_DllAPI void int64_value(int64_t _int64_value)
This function sets a value in member int64_value.
RTPS_DllAPI void float128_value(long double _float128_value)
This function sets a value in member float128_value.
RTPS_DllAPI int64_t & int64_value()
This function returns a reference to member int64_value.
RTPS_DllAPI void char_value(char _char_value)
This function sets a value in member char_value.
RTPS_DllAPI double float64_value() const
This function returns the value of member float64_value.
RTPS_DllAPI AnnotationParameterValue & operator=(const AnnotationParameterValue &x)
Copy assignment.
RTPS_DllAPI void uint_16_value(uint16_t _uint_16_value)
This function sets a value in member uint_16_value.
RTPS_DllAPI ~AnnotationParameterValue()
Default destructor.
RTPS_DllAPI float & float32_value()
This function returns a reference to member float32_value.
RTPS_DllAPI AnnotationParameterValue()
Default constructor.
RTPS_DllAPI uint16_t & uint_16_value()
This function returns a reference to member uint_16_value.
RTPS_DllAPI void serializeKey(eprosima::fastcdr::Cdr &cdr) const
This function serializes the key members of an object using CDR serialization.
RTPS_DllAPI int32_t & enumerated_value()
This function returns a reference to member enumerated_value.
RTPS_DllAPI bool operator==(const AnnotationParameterValue &other) const
RTPS_DllAPI void string8_value(const std::string &_string8_value)
This function copies the value in member string8_value.
RTPS_DllAPI void _d(char __d)
This function sets the discriminator value.
RTPS_DllAPI uint16_t uint_16_value() const
This function returns the value of member uint_16_value.
RTPS_DllAPI void uint64_value(uint64_t _uint64_value)
This function sets a value in member uint64_value.
RTPS_DllAPI void boolean_value(bool _boolean_value)
This function sets a value in member boolean_value.
static RTPS_DllAPI size_t getCdrSerializedSize(const AnnotationParameterValue &data, size_t current_alignment=0)
This function returns the serialized size of a data depending on the buffer alignment.
RTPS_DllAPI char char_value() const
This function returns the value of member char_value.
RTPS_DllAPI char & _d()
This function returns a reference to the discriminator.
RTPS_DllAPI ExtendedAnnotationParameterValue & extended_value()
This function returns a reference to member extended_value.
RTPS_DllAPI void float64_value(double _float64_value)
This function sets a value in member float64_value.
Definition: AnnotationParameterValue.h:1040
RTPS_DllAPI bool operator==(const AppliedAnnotation &other) const
void param_seq(const AppliedAnnotationParameterSeq &_param_seq)
Definition: AnnotationParameterValue.h:1079
const TypeIdentifier & annotation_typeid() const
Definition: AnnotationParameterValue.h:1069
void annotation_typeid(const TypeIdentifier &_annotation_typeid)
Definition: AnnotationParameterValue.h:1057
TypeIdentifier & annotation_typeid()
Definition: AnnotationParameterValue.h:1074
static RTPS_DllAPI size_t getKeyMaxCdrSerializedSize(size_t current_alignment=0)
const AppliedAnnotationParameterSeq & param_seq() const
Definition: AnnotationParameterValue.h:1091
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
void param_seq(AppliedAnnotationParameterSeq &&_param_seq)
Definition: AnnotationParameterValue.h:1085
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
static RTPS_DllAPI size_t getCdrSerializedSize(const AppliedAnnotation &data, size_t current_alignment=0)
RTPS_DllAPI AppliedAnnotation(AppliedAnnotation &&x)
RTPS_DllAPI AppliedAnnotation & operator=(const AppliedAnnotation &x)
AppliedAnnotationParameterSeq & param_seq()
Definition: AnnotationParameterValue.h:1096
RTPS_DllAPI void serializeKey(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI AppliedAnnotation(const AppliedAnnotation &x)
void annotation_typeid(TypeIdentifier &&_annotation_typeid)
Definition: AnnotationParameterValue.h:1063
This class represents the structure AppliedAnnotationParameter defined by the user in the IDL file.
Definition: AnnotationParameterValue.h:819
RTPS_DllAPI AppliedAnnotationParameter()
Default constructor.
const NameHash & paramname_hash() const
This function returns a constant reference to member paramname_hash.
Definition: AnnotationParameterValue.h:884
RTPS_DllAPI bool operator==(const AppliedAnnotationParameter &other) const
RTPS_DllAPI AppliedAnnotationParameter(const AppliedAnnotationParameter &x)
Copy constructor.
void value(const AnnotationParameterValue &_value)
This function copies the value in member value.
Definition: AnnotationParameterValue.h:902
AnnotationParameterValue & value()
This function returns a reference to member value.
Definition: AnnotationParameterValue.h:931
void value(AnnotationParameterValue &&_value)
This function moves the value in member value.
Definition: AnnotationParameterValue.h:912
const AnnotationParameterValue & value() const
This function returns a constant reference to member value.
Definition: AnnotationParameterValue.h:922
static RTPS_DllAPI size_t getKeyMaxCdrSerializedSize(size_t current_alignment=0)
This function returns the maximum serialized size of the Key of an object depending on the buffer ali...
NameHash & paramname_hash()
This function returns a reference to member paramname_hash.
Definition: AnnotationParameterValue.h:893
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
This function deserializes an object using CDR serialization.
void paramname_hash(const NameHash &_paramname_hash)
This function copies the value in member paramname_hash.
Definition: AnnotationParameterValue.h:864
RTPS_DllAPI AppliedAnnotationParameter & operator=(const AppliedAnnotationParameter &x)
Copy assignment.
static RTPS_DllAPI bool isKeyDefined()
This function tells you if the Key has been defined for this type.
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
This function serializes an object using CDR serialization.
RTPS_DllAPI AppliedAnnotationParameter(AppliedAnnotationParameter &&x)
Move constructor.
void paramname_hash(NameHash &&_paramname_hash)
This function moves the value in member paramname_hash.
Definition: AnnotationParameterValue.h:874
static RTPS_DllAPI size_t getCdrSerializedSize(const AppliedAnnotationParameter &data, size_t current_alignment=0)
This function returns the serialized size of a data depending on the buffer alignment.
RTPS_DllAPI void serializeKey(eprosima::fastcdr::Cdr &cdr) const
This function serializes the key members of an object using CDR serialization.
RTPS_DllAPI ~AppliedAnnotationParameter()
Default destructor.
Definition: AnnotationParameterValue.h:1255
void max(const AnnotationParameterValue &_max)
Definition: AnnotationParameterValue.h:1318
void min(AnnotationParameterValue &&_min)
Definition: AnnotationParameterValue.h:1302
AnnotationParameterValue & max()
Definition: AnnotationParameterValue.h:1335
AnnotationParameterValue & min()
Definition: AnnotationParameterValue.h:1313
static RTPS_DllAPI size_t getCdrSerializedSize(const AppliedBuiltinMemberAnnotations &data, size_t current_alignment=0)
std::string & unit()
Definition: AnnotationParameterValue.h:1291
void hash_id(std::string &&_hash_id)
Definition: AnnotationParameterValue.h:1346
void unit(std::string &&_unit)
Definition: AnnotationParameterValue.h:1280
void max(AnnotationParameterValue &&_max)
Definition: AnnotationParameterValue.h:1324
static RTPS_DllAPI size_t getKeyMaxCdrSerializedSize(size_t current_alignment=0)
const AnnotationParameterValue & min() const
Definition: AnnotationParameterValue.h:1308
RTPS_DllAPI AppliedBuiltinMemberAnnotations(AppliedBuiltinMemberAnnotations &&x)
std::string & hash_id()
Definition: AnnotationParameterValue.h:1357
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
const AnnotationParameterValue & max() const
Definition: AnnotationParameterValue.h:1330
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI AppliedBuiltinMemberAnnotations(const AppliedBuiltinMemberAnnotations &x)
RTPS_DllAPI AppliedBuiltinMemberAnnotations & operator=(const AppliedBuiltinMemberAnnotations &x)
const std::string & unit() const
Definition: AnnotationParameterValue.h:1286
void unit(const std::string &_unit)
Definition: AnnotationParameterValue.h:1274
RTPS_DllAPI void serializeKey(eprosima::fastcdr::Cdr &cdr) const
void hash_id(const std::string &_hash_id)
Definition: AnnotationParameterValue.h:1340
void min(const AnnotationParameterValue &_min)
Definition: AnnotationParameterValue.h:1296
RTPS_DllAPI bool operator==(const AppliedBuiltinMemberAnnotations &other) const
const std::string & hash_id() const
Definition: AnnotationParameterValue.h:1352
Definition: AnnotationParameterValue.h:1133
void text(const std::string &_text)
Definition: AnnotationParameterValue.h:1196
void text(std::string &&_text)
Definition: AnnotationParameterValue.h:1202
const std::string & language() const
Definition: AnnotationParameterValue.h:1186
static RTPS_DllAPI size_t getKeyMaxCdrSerializedSize(size_t current_alignment=0)
void placement(std::string &&_placement)
Definition: AnnotationParameterValue.h:1158
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI AppliedVerbatimAnnotation(const AppliedVerbatimAnnotation &x)
const std::string & placement() const
Definition: AnnotationParameterValue.h:1164
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
static RTPS_DllAPI size_t getCdrSerializedSize(const AppliedVerbatimAnnotation &data, size_t current_alignment=0)
RTPS_DllAPI bool operator==(const AppliedVerbatimAnnotation &other) const
void placement(const std::string &_placement)
Definition: AnnotationParameterValue.h:1152
RTPS_DllAPI AppliedVerbatimAnnotation(AppliedVerbatimAnnotation &&x)
void language(const std::string &_language)
Definition: AnnotationParameterValue.h:1174
void language(std::string &&_language)
Definition: AnnotationParameterValue.h:1180
std::string & language()
Definition: AnnotationParameterValue.h:1191
const std::string & text() const
Definition: AnnotationParameterValue.h:1208
RTPS_DllAPI void serializeKey(eprosima::fastcdr::Cdr &cdr) const
std::string & text()
Definition: AnnotationParameterValue.h:1213
std::string & placement()
Definition: AnnotationParameterValue.h:1169
RTPS_DllAPI AppliedVerbatimAnnotation & operator=(const AppliedVerbatimAnnotation &x)
This class represents the structure ExtendedAnnotationParameterValue defined by the user in the IDL f...
Definition: AnnotationParameterValue.h:64
RTPS_DllAPI ExtendedAnnotationParameterValue & operator=(const ExtendedAnnotationParameterValue &x)
Copy assignment.
static RTPS_DllAPI size_t getKeyMaxCdrSerializedSize(size_t current_alignment=0)
This function returns the maximum serialized size of the Key of an object depending on the buffer ali...
RTPS_DllAPI ExtendedAnnotationParameterValue(ExtendedAnnotationParameterValue &&x)
Move constructor.
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
This function deserializes an object using CDR serialization.
RTPS_DllAPI ExtendedAnnotationParameterValue(const ExtendedAnnotationParameterValue &x)
Copy constructor.
RTPS_DllAPI ExtendedAnnotationParameterValue()
Default constructor.
static RTPS_DllAPI bool isKeyDefined()
This function tells you if the Key has been defined for this type.
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
This function serializes an object using CDR serialization.
RTPS_DllAPI bool operator==(const ExtendedAnnotationParameterValue &) const
Definition: AnnotationParameterValue.h:153
RTPS_DllAPI ~ExtendedAnnotationParameterValue()
Default destructor.
static RTPS_DllAPI size_t getCdrSerializedSize(const ExtendedAnnotationParameterValue &data, size_t current_alignment=0)
This function returns the serialized size of a data depending on the buffer alignment.
RTPS_DllAPI void serializeKey(eprosima::fastcdr::Cdr &cdr) const
This function serializes the key members of an object using CDR serialization.
Definition: TypeIdentifier.h:81
const octet TK_FLOAT32
Definition: TypesBase.h:130
const octet TK_BYTE
Definition: TypesBase.h:123
const octet TK_UINT64
Definition: TypesBase.h:129
const octet TK_FLOAT64
Definition: TypesBase.h:131
const octet TK_STRING16
Definition: TypesBase.h:138
const octet TK_INT32
Definition: TypesBase.h:125
const octet TK_UINT16
Definition: TypesBase.h:127
const octet TK_CHAR8
Definition: TypesBase.h:133
std::vector< AppliedAnnotationParameter > AppliedAnnotationParameterSeq
Definition: AnnotationParameterValue.h:1033
const octet TK_CHAR16
Definition: TypesBase.h:134
const std::string CONST_TRUE
Definition: TypesBase.h:58
const octet TK_INT16
Definition: TypesBase.h:124
const octet TK_BOOLEAN
Definition: TypesBase.h:122
const octet TK_FLOAT128
Definition: TypesBase.h:132
const octet TK_ENUM
Definition: TypesBase.h:145
std::vector< AppliedAnnotation > AppliedAnnotationSeq
Definition: AnnotationParameterValue.h:1124
const octet TK_INT64
Definition: TypesBase.h:126
const octet TK_NONE
Definition: TypesBase.h:121
const octet TK_STRING8
Definition: TypesBase.h:137
const octet TK_UINT32
Definition: TypesBase.h:128
std::array< uint8_t, 4 > NameHash
Definition: TypesBase.h:178
std::string wstring_to_bytes(const std::wstring &str)
std::wstring wstring_from_bytes(const std::string &str)
eProsima namespace.
Definition: LibrarySettingsAttributes.h:23