Line data Source code
1 : /*
2 : * Distributed under the OpenDDS License.
3 : * See: http://www.opendds.org/license.html
4 : */
5 :
6 : #include "DCPS/DdsDcps_pch.h" //Only the _pch include should start with DCPS/
7 : #include "TypeObject.h"
8 :
9 :
10 : #include "dds/DCPS/debug.h"
11 : #include "dds/DCPS/Hash.h"
12 : #include "dds/DCPS/Message_Block_Ptr.h"
13 : #include "dds/DCPS/SafetyProfileStreams.h"
14 :
15 : #include <ace/OS_NS_string.h>
16 :
17 : #include <cstring>
18 :
19 : OPENDDS_BEGIN_VERSIONED_NAMESPACE_DECL
20 :
21 : namespace OpenDDS {
22 : namespace XTypes {
23 :
24 : using DCPS::Encoding;
25 : using DCPS::serialized_size;
26 :
27 862 : const Encoding& get_typeobject_encoding()
28 : {
29 862 : static const Encoding encoding(Encoding::KIND_XCDR2, DCPS::ENDIAN_LITTLE);
30 862 : return encoding;
31 : }
32 :
33 0 : DCPS::String equivalence_hash_to_string(const EquivalenceHash& equivalence_hash)
34 : {
35 0 : return DCPS::to_dds_string(&equivalence_hash[0], sizeof equivalence_hash);
36 : }
37 :
38 216 : MinimalMemberDetail::MinimalMemberDetail(const OPENDDS_STRING& name)
39 : {
40 : unsigned char result[16];
41 216 : DCPS::MD5Hash(result, name.c_str(), name.size());
42 :
43 216 : std::memcpy(name_hash, result, sizeof name_hash);
44 216 : }
45 :
46 : #ifdef min
47 : #undef min
48 : #endif
49 :
50 : #ifdef max
51 : #undef max
52 : #endif
53 :
54 0 : AppliedBuiltinMemberAnnotations::AppliedBuiltinMemberAnnotations(const Optional<DCPS::String>& a_unit,
55 : const Optional<AnnotationParameterValue>& a_min,
56 : const Optional<AnnotationParameterValue>& a_max,
57 0 : const Optional<DCPS::String>& a_hash_id)
58 0 : : unit(a_unit)
59 0 : , min(a_min)
60 0 : , max(a_max)
61 0 : , hash_id(a_hash_id)
62 0 : {}
63 :
64 42930 : TypeIdentifier::TypeIdentifier(ACE_CDR::Octet kind)
65 42930 : : kind_(kind)
66 42930 : , active_(0)
67 : {
68 42930 : activate();
69 42930 : }
70 :
71 162710 : void TypeIdentifier::activate(const TypeIdentifier* other)
72 : {
73 : #define OPENDDS_BRANCH_ACTIVATE(T, N) \
74 : active_ = new(N ## _) T(); \
75 : if (other) N() = other->N(); \
76 : break
77 :
78 162710 : switch (kind_) {
79 1903 : case TI_STRING8_SMALL:
80 : case TI_STRING16_SMALL:
81 3806 : OPENDDS_BRANCH_ACTIVATE(StringSTypeDefn, string_sdefn);
82 459 : case TI_STRING8_LARGE:
83 : case TI_STRING16_LARGE:
84 918 : OPENDDS_BRANCH_ACTIVATE(StringLTypeDefn, string_ldefn);
85 2681 : case TI_PLAIN_SEQUENCE_SMALL:
86 5362 : OPENDDS_BRANCH_ACTIVATE(PlainSequenceSElemDefn, seq_sdefn);
87 48 : case TI_PLAIN_SEQUENCE_LARGE:
88 96 : OPENDDS_BRANCH_ACTIVATE(PlainSequenceLElemDefn, seq_ldefn);
89 1350 : case TI_PLAIN_ARRAY_SMALL:
90 2700 : OPENDDS_BRANCH_ACTIVATE(PlainArraySElemDefn, array_sdefn);
91 30 : case TI_PLAIN_ARRAY_LARGE:
92 60 : OPENDDS_BRANCH_ACTIVATE(PlainArrayLElemDefn, array_ldefn);
93 26 : case TI_PLAIN_MAP_SMALL:
94 52 : OPENDDS_BRANCH_ACTIVATE(PlainMapSTypeDefn, map_sdefn);
95 74 : case TI_PLAIN_MAP_LARGE:
96 148 : OPENDDS_BRANCH_ACTIVATE(PlainMapLTypeDefn, map_ldefn);
97 883 : case TI_STRONGLY_CONNECTED_COMPONENT:
98 1766 : OPENDDS_BRANCH_ACTIVATE(StronglyConnectedComponentId, sc_component_id);
99 22039 : case EK_COMPLETE:
100 : case EK_MINIMAL:
101 22039 : active_ = equivalence_hash_;
102 22039 : if (other) {
103 21022 : std::memcpy(equivalence_hash(), other->equivalence_hash(), sizeof(EquivalenceHash));
104 : }
105 22039 : break;
106 133217 : case TK_NONE:
107 : case TK_BOOLEAN:
108 : case TK_BYTE:
109 : case TK_INT16:
110 : case TK_INT32:
111 : case TK_INT64:
112 : case TK_UINT16:
113 : case TK_UINT32:
114 : case TK_UINT64:
115 : case TK_FLOAT32:
116 : case TK_FLOAT64:
117 : case TK_FLOAT128:
118 : case TK_INT8:
119 : case TK_UINT8:
120 : case TK_CHAR8:
121 : case TK_CHAR16:
122 133217 : break; // no-op, no member selected
123 0 : default:
124 0 : OPENDDS_BRANCH_ACTIVATE(ExtendedTypeDefn, extended_defn);
125 : }
126 162710 : }
127 :
128 111610 : TypeIdentifier::TypeIdentifier(const TypeIdentifier& other)
129 111610 : : kind_(other.kind_)
130 111610 : , active_(0)
131 : {
132 111610 : activate(&other);
133 111610 : }
134 :
135 162710 : void TypeIdentifier::reset()
136 : {
137 162710 : if (!active_) {
138 133169 : return;
139 : }
140 : #define OPENDDS_BRANCH_RESET(T) static_cast<T*>(active_)->~T(); break
141 29541 : switch (kind_) {
142 1903 : case TI_STRING8_SMALL:
143 : case TI_STRING16_SMALL:
144 1903 : OPENDDS_BRANCH_RESET(StringSTypeDefn);
145 459 : case TI_STRING8_LARGE:
146 : case TI_STRING16_LARGE:
147 459 : OPENDDS_BRANCH_RESET(StringLTypeDefn);
148 2681 : case TI_PLAIN_SEQUENCE_SMALL:
149 2681 : OPENDDS_BRANCH_RESET(PlainSequenceSElemDefn);
150 48 : case TI_PLAIN_SEQUENCE_LARGE:
151 48 : OPENDDS_BRANCH_RESET(PlainSequenceLElemDefn);
152 1350 : case TI_PLAIN_ARRAY_SMALL:
153 1350 : OPENDDS_BRANCH_RESET(PlainArraySElemDefn);
154 30 : case TI_PLAIN_ARRAY_LARGE:
155 30 : OPENDDS_BRANCH_RESET(PlainArrayLElemDefn);
156 26 : case TI_PLAIN_MAP_SMALL:
157 26 : OPENDDS_BRANCH_RESET(PlainMapSTypeDefn);
158 74 : case TI_PLAIN_MAP_LARGE:
159 74 : OPENDDS_BRANCH_RESET(PlainMapLTypeDefn);
160 883 : case TI_STRONGLY_CONNECTED_COMPONENT:
161 883 : OPENDDS_BRANCH_RESET(StronglyConnectedComponentId);
162 22039 : case EK_COMPLETE:
163 : case EK_MINIMAL:
164 22039 : break; // no-op, data is just an array of octets
165 48 : case TK_NONE:
166 : case TK_BOOLEAN:
167 : case TK_BYTE:
168 : case TK_INT16:
169 : case TK_INT32:
170 : case TK_INT64:
171 : case TK_UINT16:
172 : case TK_UINT32:
173 : case TK_UINT64:
174 : case TK_FLOAT32:
175 : case TK_FLOAT64:
176 : case TK_FLOAT128:
177 : case TK_INT8:
178 : case TK_UINT8:
179 : case TK_CHAR8:
180 : case TK_CHAR16:
181 48 : break; // no-op, no member selected
182 0 : default:
183 0 : OPENDDS_BRANCH_RESET(ExtendedTypeDefn);
184 : }
185 : }
186 :
187 7717 : TypeIdentifier& TypeIdentifier::operator=(const TypeIdentifier& other)
188 : {
189 7717 : if (&other == this) {
190 0 : return *this;
191 : }
192 7717 : reset();
193 7717 : kind_ = other.kind_;
194 7717 : activate(&other);
195 7717 : return *this;
196 : }
197 :
198 0 : TypeIdentifier::TypeIdentifier(ACE_CDR::Octet k, const StringSTypeDefn& sdefn)
199 0 : : kind_(k)
200 : {
201 0 : activate();
202 0 : string_sdefn() = sdefn;
203 0 : }
204 :
205 0 : TypeIdentifier::TypeIdentifier(ACE_CDR::Octet k, const StringLTypeDefn& ldefn)
206 0 : : kind_(k)
207 : {
208 0 : activate();
209 0 : string_ldefn() = ldefn;
210 0 : }
211 :
212 0 : TypeIdentifier::TypeIdentifier(ACE_CDR::Octet k, const PlainSequenceSElemDefn& sdefn)
213 0 : : kind_(k)
214 : {
215 0 : activate();
216 0 : seq_sdefn() = sdefn;
217 0 : }
218 :
219 0 : TypeIdentifier::TypeIdentifier(ACE_CDR::Octet k, const PlainSequenceLElemDefn& ldefn)
220 0 : : kind_(k)
221 : {
222 0 : activate();
223 0 : seq_ldefn() = ldefn;
224 0 : }
225 :
226 0 : TypeIdentifier::TypeIdentifier(ACE_CDR::Octet k, const PlainArraySElemDefn& sdefn)
227 0 : : kind_(k)
228 : {
229 0 : activate();
230 0 : array_sdefn() = sdefn;
231 0 : }
232 :
233 0 : TypeIdentifier::TypeIdentifier(ACE_CDR::Octet k, const PlainArrayLElemDefn& ldefn)
234 0 : : kind_(k)
235 : {
236 0 : activate();
237 0 : array_ldefn() = ldefn;
238 0 : }
239 :
240 422 : TypeIdentifier::TypeIdentifier(ACE_CDR::Octet k, const EquivalenceHashWrapper& eh)
241 422 : : kind_(k)
242 : {
243 422 : activate();
244 422 : std::memcpy(equivalence_hash(), eh.eh_, sizeof eh.eh_);
245 422 : }
246 :
247 31 : TypeIdentifier::TypeIdentifier(ACE_CDR::Octet k, const StronglyConnectedComponentId& id)
248 31 : : kind_(k)
249 : {
250 31 : activate();
251 31 : sc_component_id() = id;
252 31 : }
253 :
254 2 : TypeIdentifier makeTypeIdentifier(const TypeObject& type_object, const DCPS::Encoding* encoding_option)
255 : {
256 2 : OPENDDS_ASSERT(type_object.kind == EK_MINIMAL || type_object.kind == EK_COMPLETE);
257 :
258 2 : const Encoding& encoding = encoding_option ? *encoding_option : get_typeobject_encoding();
259 2 : size_t size = serialized_size(encoding, type_object);
260 2 : ACE_Message_Block buff(size);
261 2 : DCPS::Serializer ser(&buff, encoding);
262 2 : ser << type_object;
263 :
264 : unsigned char result[16];
265 2 : DCPS::MD5Hash(result, buff.rd_ptr(), buff.length());
266 :
267 : // First 14 bytes of MD5 of the serialized TypeObject using XCDR
268 : // version 2 with Little Endian encoding
269 2 : TypeIdentifier ti(type_object.kind);
270 2 : std::memcpy(ti.equivalence_hash(), result, sizeof(EquivalenceHash));
271 :
272 4 : return ti;
273 2 : }
274 :
275 93 : AnnotationParameterValue::AnnotationParameterValue(ACE_CDR::Octet kind)
276 93 : : kind_(kind)
277 93 : , active_(0)
278 : {
279 93 : activate();
280 93 : }
281 :
282 0 : AnnotationParameterValue::AnnotationParameterValue(const AnnotationParameterValue& other)
283 0 : : kind_(other.kind_)
284 0 : , active_(0)
285 : {
286 0 : activate(&other);
287 0 : }
288 :
289 6 : AnnotationParameterValue& AnnotationParameterValue::operator=(const AnnotationParameterValue& other)
290 : {
291 6 : if (&other == this) {
292 0 : return *this;
293 : }
294 6 : reset();
295 6 : kind_ = other.kind_;
296 6 : activate(&other);
297 6 : return *this;
298 : }
299 :
300 99 : void AnnotationParameterValue::activate(const AnnotationParameterValue* other)
301 : {
302 : #define OPENDDS_BRANCH_ACTIVATE(T, N) \
303 : active_ = new(N ## _) T(); \
304 : if (other) N() = other->N(); \
305 : break
306 :
307 99 : switch (kind_) {
308 12 : case TK_NONE:
309 12 : break; // no-op, no member selected
310 17 : case TK_BOOLEAN:
311 17 : OPENDDS_BRANCH_ACTIVATE(ACE_CDR::Boolean, boolean_value);
312 4 : case TK_BYTE:
313 4 : OPENDDS_BRANCH_ACTIVATE(ACE_CDR::Octet, byte_value);
314 4 : case TK_INT8:
315 4 : OPENDDS_BRANCH_ACTIVATE(ACE_CDR::Char, int8_value);
316 4 : case TK_UINT8:
317 4 : OPENDDS_BRANCH_ACTIVATE(ACE_CDR::Octet, uint8_value);
318 4 : case TK_INT16:
319 4 : OPENDDS_BRANCH_ACTIVATE(ACE_CDR::Short, int16_value);
320 4 : case TK_UINT16:
321 4 : OPENDDS_BRANCH_ACTIVATE(ACE_CDR::UShort, uint16_value);
322 4 : case TK_INT32:
323 4 : OPENDDS_BRANCH_ACTIVATE(ACE_CDR::Long, int32_value);
324 4 : case TK_UINT32:
325 4 : OPENDDS_BRANCH_ACTIVATE(ACE_CDR::ULong, uint32_value);
326 4 : case TK_INT64:
327 4 : OPENDDS_BRANCH_ACTIVATE(ACE_CDR::LongLong, int64_value);
328 4 : case TK_UINT64:
329 4 : OPENDDS_BRANCH_ACTIVATE(ACE_CDR::ULongLong, uint64_value);
330 4 : case TK_FLOAT32:
331 4 : OPENDDS_BRANCH_ACTIVATE(ACE_CDR::Float, float32_value);
332 4 : case TK_FLOAT64:
333 4 : OPENDDS_BRANCH_ACTIVATE(ACE_CDR::Double, float64_value);
334 4 : case TK_FLOAT128:
335 4 : OPENDDS_BRANCH_ACTIVATE(ACE_CDR::LongDouble, float128_value);
336 4 : case TK_CHAR8:
337 4 : OPENDDS_BRANCH_ACTIVATE(ACE_CDR::Char, char_value);
338 4 : case TK_CHAR16:
339 4 : OPENDDS_BRANCH_ACTIVATE(ACE_CDR::WChar, wchar_value);
340 4 : case TK_ENUM:
341 4 : OPENDDS_BRANCH_ACTIVATE(ACE_CDR::Long, enumerated_value);
342 4 : case TK_STRING8:
343 8 : OPENDDS_BRANCH_ACTIVATE(OPENDDS_STRING, string8_value);
344 6 : case TK_STRING16:
345 12 : OPENDDS_BRANCH_ACTIVATE(OPENDDS_WSTRING, string16_value);
346 0 : default:
347 0 : OPENDDS_BRANCH_ACTIVATE(ExtendedAnnotationParameterValue, extended_value);
348 : }
349 99 : }
350 :
351 99 : void AnnotationParameterValue::reset()
352 : {
353 : using DCPS::String;
354 : using DCPS::WString;
355 :
356 99 : if (!active_) {
357 12 : return;
358 : }
359 : #define OPENDDS_BRANCH_RESET(T) static_cast<T*>(active_)->~T(); break
360 87 : switch (kind_) {
361 0 : case TK_NONE:
362 0 : break; // no-op, no member selected
363 77 : case TK_BOOLEAN:
364 : case TK_BYTE:
365 : case TK_INT8:
366 : case TK_UINT8:
367 : case TK_INT16:
368 : case TK_UINT16:
369 : case TK_INT32:
370 : case TK_UINT32:
371 : case TK_INT64:
372 : case TK_UINT64:
373 : case TK_FLOAT32:
374 : case TK_FLOAT64:
375 : case TK_FLOAT128:
376 : case TK_CHAR8:
377 : case TK_CHAR16:
378 : case TK_ENUM:
379 77 : break; // primitive type, no destructor.
380 4 : case TK_STRING8:
381 4 : OPENDDS_BRANCH_RESET(String);
382 6 : case TK_STRING16:
383 6 : OPENDDS_BRANCH_RESET(WString);
384 0 : default:
385 0 : OPENDDS_BRANCH_RESET(ExtendedAnnotationParameterValue);
386 : }
387 : }
388 :
389 0 : ACE_CDR::ULong hash_member_name_to_id(const OPENDDS_STRING& name)
390 : {
391 : ACE_CDR::ULong name_hash;
392 :
393 : unsigned char result[16];
394 0 : DCPS::MD5Hash(result, name.c_str(), name.size());
395 :
396 0 : std::memcpy(&name_hash, result, sizeof name_hash);
397 0 : return name_hash & DCPS::Serializer::MEMBER_ID_MASK;
398 : }
399 :
400 5 : void hash_member_name(NameHash& name_hash, const OPENDDS_STRING& name)
401 : {
402 : unsigned char result[16];
403 5 : DCPS::MD5Hash(result, name.c_str(), name.size());
404 :
405 5 : std::memcpy(&name_hash, result, sizeof name_hash);
406 5 : }
407 :
408 618 : bool is_fully_descriptive(const TypeIdentifier& ti)
409 : {
410 618 : switch (ti.kind()) {
411 349 : case TK_BOOLEAN:
412 : case TK_BYTE:
413 : case TK_INT16:
414 : case TK_INT32:
415 : case TK_INT64:
416 : case TK_UINT16:
417 : case TK_UINT32:
418 : case TK_UINT64:
419 : case TK_FLOAT32:
420 : case TK_FLOAT64:
421 : case TK_FLOAT128:
422 : case TK_INT8:
423 : case TK_UINT8:
424 : case TK_CHAR8:
425 : case TK_CHAR16:
426 : case TI_STRING8_SMALL:
427 : case TI_STRING8_LARGE:
428 : case TI_STRING16_SMALL:
429 : case TI_STRING16_LARGE:
430 349 : return true;
431 65 : case TI_PLAIN_SEQUENCE_SMALL:
432 65 : return ti.seq_sdefn().header.equiv_kind == EK_BOTH;
433 0 : case TI_PLAIN_SEQUENCE_LARGE:
434 0 : return ti.seq_ldefn().header.equiv_kind == EK_BOTH;
435 73 : case TI_PLAIN_ARRAY_SMALL:
436 73 : return ti.array_sdefn().header.equiv_kind == EK_BOTH;
437 0 : case TI_PLAIN_ARRAY_LARGE:
438 0 : return ti.array_ldefn().header.equiv_kind == EK_BOTH;
439 0 : case TI_PLAIN_MAP_SMALL:
440 0 : return ti.map_sdefn().header.equiv_kind == EK_BOTH;
441 0 : case TI_PLAIN_MAP_LARGE:
442 0 : return ti.map_ldefn().header.equiv_kind == EK_BOTH;
443 : }
444 131 : return false;
445 : }
446 :
447 145 : bool is_plain_collection(const TypeIdentifier& ti)
448 : {
449 145 : switch (ti.kind()) {
450 14 : case TI_PLAIN_SEQUENCE_SMALL:
451 : case TI_PLAIN_SEQUENCE_LARGE:
452 : case TI_PLAIN_ARRAY_SMALL:
453 : case TI_PLAIN_ARRAY_LARGE:
454 : case TI_PLAIN_MAP_SMALL:
455 : case TI_PLAIN_MAP_LARGE:
456 14 : return true;
457 : }
458 131 : return false;
459 : }
460 :
461 612 : bool has_type_object(const TypeIdentifier& ti)
462 : {
463 742 : return !is_fully_descriptive(ti) && !is_plain_collection(ti) &&
464 742 : ti.kind() != TK_NONE;
465 : }
466 :
467 : namespace {
468 : template <typename T>
469 : void compute_dependencies(const TypeMap& type_map,
470 : const Sequence<T>& type,
471 : OPENDDS_SET(TypeIdentifier)& dependencies);
472 :
473 98 : void compute_dependencies(const TypeMap& type_map,
474 : const CommonAliasBody& type,
475 : OPENDDS_SET(TypeIdentifier)& dependencies)
476 : {
477 98 : compute_dependencies(type_map, type.related_type, dependencies);
478 98 : }
479 :
480 49 : void compute_dependencies(const TypeMap& type_map,
481 : const MinimalAliasBody& type,
482 : OPENDDS_SET(TypeIdentifier)& dependencies)
483 : {
484 49 : compute_dependencies(type_map, type.common, dependencies);
485 49 : }
486 :
487 49 : void compute_dependencies(const TypeMap& type_map,
488 : const MinimalAliasType& type,
489 : OPENDDS_SET(TypeIdentifier)& dependencies)
490 : {
491 49 : compute_dependencies(type_map, type.body, dependencies);
492 49 : }
493 :
494 0 : void compute_dependencies(const TypeMap& type_map,
495 : const AppliedAnnotation& ann,
496 : OPENDDS_SET(TypeIdentifier)& dependencies)
497 : {
498 0 : compute_dependencies(type_map, ann.annotation_typeid, dependencies);
499 0 : }
500 :
501 737 : void compute_dependencies(const TypeMap& type_map,
502 : const Optional<AppliedAnnotationSeq>& ann_seq,
503 : OPENDDS_SET(TypeIdentifier)& dependencies)
504 : {
505 737 : if (ann_seq) {
506 0 : compute_dependencies(type_map, ann_seq.value(), dependencies);
507 : }
508 737 : }
509 :
510 207 : void compute_dependencies(const TypeMap& type_map,
511 : const CompleteTypeDetail& type_detail,
512 : OPENDDS_SET(TypeIdentifier)& dependencies)
513 : {
514 207 : compute_dependencies(type_map, type_detail.ann_custom, dependencies);
515 207 : }
516 :
517 49 : void compute_dependencies(const TypeMap& type_map,
518 : const CompleteAliasHeader& header,
519 : OPENDDS_SET(TypeIdentifier)& dependencies)
520 : {
521 49 : compute_dependencies(type_map, header.detail, dependencies);
522 49 : }
523 :
524 49 : void compute_dependencies(const TypeMap& type_map,
525 : const CompleteAliasBody& body,
526 : OPENDDS_SET(TypeIdentifier)& dependencies)
527 : {
528 49 : compute_dependencies(type_map, body.common, dependencies);
529 49 : compute_dependencies(type_map, body.ann_custom, dependencies);
530 49 : }
531 :
532 49 : void compute_dependencies(const TypeMap& type_map,
533 : const CompleteAliasType& type,
534 : OPENDDS_SET(TypeIdentifier)& dependencies)
535 : {
536 49 : compute_dependencies(type_map, type.header, dependencies);
537 49 : compute_dependencies(type_map, type.body, dependencies);
538 49 : }
539 :
540 0 : void compute_dependencies(const TypeMap& type_map,
541 : const CommonAnnotationParameter& type,
542 : OPENDDS_SET(TypeIdentifier)& dependencies)
543 : {
544 0 : compute_dependencies(type_map, type.member_type_id, dependencies);
545 0 : }
546 :
547 0 : void compute_dependencies(const TypeMap& type_map,
548 : const MinimalAnnotationParameter& type,
549 : OPENDDS_SET(TypeIdentifier)& dependencies)
550 : {
551 0 : compute_dependencies(type_map, type.common, dependencies);
552 0 : }
553 :
554 0 : void compute_dependencies(const TypeMap& type_map,
555 : const MinimalAnnotationType& type,
556 : OPENDDS_SET(TypeIdentifier)& dependencies)
557 : {
558 0 : compute_dependencies(type_map, type.member_seq, dependencies);
559 0 : }
560 :
561 0 : void compute_dependencies(const TypeMap& type_map,
562 : const CompleteAnnotationParameter& type,
563 : OPENDDS_SET(TypeIdentifier)& dependencies)
564 : {
565 0 : compute_dependencies(type_map, type.common, dependencies);
566 0 : }
567 :
568 0 : void compute_dependencies(const TypeMap& type_map,
569 : const CompleteAnnotationType& type,
570 : OPENDDS_SET(TypeIdentifier)& dependencies)
571 : {
572 0 : compute_dependencies(type_map, type.member_seq, dependencies);
573 0 : }
574 :
575 110 : void compute_dependencies(const TypeMap& type_map,
576 : const MinimalStructHeader& type,
577 : OPENDDS_SET(TypeIdentifier)& dependencies)
578 : {
579 110 : compute_dependencies(type_map, type.base_type, dependencies);
580 110 : }
581 :
582 566 : void compute_dependencies(const TypeMap& type_map,
583 : const CommonStructMember& type,
584 : OPENDDS_SET(TypeIdentifier)& dependencies)
585 : {
586 566 : compute_dependencies(type_map, type.member_type_id, dependencies);
587 566 : }
588 :
589 283 : void compute_dependencies(const TypeMap& type_map,
590 : const MinimalStructMember& type,
591 : OPENDDS_SET(TypeIdentifier)& dependencies)
592 : {
593 283 : compute_dependencies(type_map, type.common, dependencies);
594 283 : }
595 :
596 110 : void compute_dependencies(const TypeMap& type_map,
597 : const MinimalStructType& type,
598 : OPENDDS_SET(TypeIdentifier)& dependencies)
599 : {
600 110 : compute_dependencies(type_map, type.header, dependencies);
601 110 : compute_dependencies(type_map, type.member_seq, dependencies);
602 110 : }
603 :
604 110 : void compute_dependencies(const TypeMap& type_map,
605 : const CompleteStructHeader& header,
606 : OPENDDS_SET(TypeIdentifier)& dependencies)
607 : {
608 110 : compute_dependencies(type_map, header.base_type, dependencies);
609 110 : compute_dependencies(type_map, header.detail, dependencies);
610 110 : }
611 :
612 447 : void compute_dependencies(const TypeMap& type_map,
613 : const CompleteMemberDetail& detail,
614 : OPENDDS_SET(TypeIdentifier)& dependencies)
615 : {
616 447 : compute_dependencies(type_map, detail.ann_custom, dependencies);
617 447 : }
618 :
619 283 : void compute_dependencies(const TypeMap& type_map,
620 : const CompleteStructMember& member,
621 : OPENDDS_SET(TypeIdentifier)& dependencies)
622 : {
623 283 : compute_dependencies(type_map, member.common, dependencies);
624 283 : compute_dependencies(type_map, member.detail, dependencies);
625 283 : }
626 :
627 110 : void compute_dependencies(const TypeMap& type_map,
628 : const CompleteStructType& type,
629 : OPENDDS_SET(TypeIdentifier)& dependencies)
630 : {
631 110 : compute_dependencies(type_map, type.header, dependencies);
632 110 : compute_dependencies(type_map, type.member_seq, dependencies);
633 110 : }
634 :
635 68 : void compute_dependencies(const TypeMap& type_map,
636 : const CommonDiscriminatorMember& type,
637 : OPENDDS_SET(TypeIdentifier)& dependencies)
638 : {
639 68 : compute_dependencies(type_map, type.type_id, dependencies);
640 68 : }
641 :
642 34 : void compute_dependencies(const TypeMap& type_map,
643 : const MinimalDiscriminatorMember& type,
644 : OPENDDS_SET(TypeIdentifier)& dependencies)
645 : {
646 34 : compute_dependencies(type_map, type.common, dependencies);
647 34 : }
648 :
649 198 : void compute_dependencies(const TypeMap& type_map,
650 : const CommonUnionMember& type,
651 : OPENDDS_SET(TypeIdentifier)& dependencies)
652 : {
653 198 : compute_dependencies(type_map, type.type_id, dependencies);
654 198 : }
655 :
656 99 : void compute_dependencies(const TypeMap& type_map,
657 : const MinimalUnionMember& type,
658 : OPENDDS_SET(TypeIdentifier)& dependencies)
659 : {
660 99 : compute_dependencies(type_map, type.common, dependencies);
661 99 : }
662 :
663 34 : void compute_dependencies(const TypeMap& type_map,
664 : const MinimalUnionType& type,
665 : OPENDDS_SET(TypeIdentifier)& dependencies)
666 : {
667 34 : compute_dependencies(type_map, type.discriminator, dependencies);
668 34 : compute_dependencies(type_map, type.member_seq, dependencies);
669 34 : }
670 :
671 34 : void compute_dependencies(const TypeMap& type_map,
672 : const CompleteUnionHeader& header,
673 : OPENDDS_SET(TypeIdentifier)& dependencies)
674 : {
675 34 : compute_dependencies(type_map, header.detail, dependencies);
676 34 : }
677 :
678 34 : void compute_dependencies(const TypeMap& type_map,
679 : const CompleteDiscriminatorMember& type,
680 : OPENDDS_SET(TypeIdentifier)& dependencies)
681 : {
682 34 : compute_dependencies(type_map, type.common, dependencies);
683 34 : compute_dependencies(type_map, type.ann_custom, dependencies);
684 34 : }
685 :
686 99 : void compute_dependencies(const TypeMap& type_map,
687 : const CompleteUnionMember& type,
688 : OPENDDS_SET(TypeIdentifier)& dependencies)
689 : {
690 99 : compute_dependencies(type_map, type.common, dependencies);
691 99 : compute_dependencies(type_map, type.detail, dependencies);
692 99 : }
693 :
694 34 : void compute_dependencies(const TypeMap& type_map,
695 : const CompleteUnionType& type,
696 : OPENDDS_SET(TypeIdentifier)& dependencies)
697 : {
698 34 : compute_dependencies(type_map, type.header, dependencies);
699 34 : compute_dependencies(type_map, type.discriminator, dependencies);
700 34 : compute_dependencies(type_map, type.member_seq, dependencies);
701 34 : }
702 :
703 0 : void compute_dependencies(const TypeMap&,
704 : const MinimalBitsetType&,
705 : OPENDDS_SET(TypeIdentifier)&)
706 : {
707 : // Doesn't have any dependencies.
708 0 : }
709 :
710 0 : void compute_dependencies(const TypeMap& type_map,
711 : const CompleteBitsetHeader& header,
712 : OPENDDS_SET(TypeIdentifier)& dependencies)
713 : {
714 0 : compute_dependencies(type_map, header.detail, dependencies);
715 0 : }
716 :
717 0 : void compute_dependencies(const TypeMap& type_map,
718 : const CompleteBitfield& field,
719 : OPENDDS_SET(TypeIdentifier)& dependencies)
720 : {
721 0 : compute_dependencies(type_map, field.detail, dependencies);
722 0 : }
723 :
724 0 : void compute_dependencies(const TypeMap& type_map,
725 : const CompleteBitsetType& type,
726 : OPENDDS_SET(TypeIdentifier)& dependencies)
727 : {
728 0 : compute_dependencies(type_map, type.header, dependencies);
729 0 : compute_dependencies(type_map, type.field_seq, dependencies);
730 0 : }
731 :
732 0 : void compute_dependencies(const TypeMap& type_map,
733 : const CommonCollectionElement& type,
734 : OPENDDS_SET(TypeIdentifier)& dependencies)
735 : {
736 0 : compute_dependencies(type_map, type.type, dependencies);
737 0 : }
738 :
739 0 : void compute_dependencies(const TypeMap& type_map,
740 : const MinimalCollectionElement& type,
741 : OPENDDS_SET(TypeIdentifier)& dependencies)
742 : {
743 0 : compute_dependencies(type_map, type.common, dependencies);
744 0 : }
745 :
746 0 : void compute_dependencies(const TypeMap& type_map,
747 : const MinimalSequenceType& type,
748 : OPENDDS_SET(TypeIdentifier)& dependencies)
749 : {
750 0 : compute_dependencies(type_map, type.element, dependencies);
751 0 : }
752 :
753 0 : void compute_dependencies(const TypeMap& type_map,
754 : const CompleteCollectionHeader& header,
755 : OPENDDS_SET(TypeIdentifier)& dependencies)
756 : {
757 0 : if (header.detail) {
758 0 : compute_dependencies(type_map, header.detail.value(), dependencies);
759 : }
760 0 : }
761 :
762 0 : void compute_dependencies(const TypeMap& type_map,
763 : const CompleteElementDetail& detail,
764 : OPENDDS_SET(TypeIdentifier)& dependencies)
765 : {
766 0 : compute_dependencies(type_map, detail.ann_custom, dependencies);
767 0 : }
768 :
769 0 : void compute_dependencies(const TypeMap& type_map,
770 : const CompleteCollectionElement& element,
771 : OPENDDS_SET(TypeIdentifier)& dependencies)
772 : {
773 0 : compute_dependencies(type_map, element.common, dependencies);
774 0 : compute_dependencies(type_map, element.detail, dependencies);
775 0 : }
776 :
777 0 : void compute_dependencies(const TypeMap& type_map,
778 : const CompleteSequenceType& type,
779 : OPENDDS_SET(TypeIdentifier)& dependencies)
780 : {
781 0 : compute_dependencies(type_map, type.header, dependencies);
782 0 : compute_dependencies(type_map, type.element, dependencies);
783 0 : }
784 :
785 0 : void compute_dependencies(const TypeMap& type_map,
786 : const MinimalArrayType& type,
787 : OPENDDS_SET(TypeIdentifier)& dependencies)
788 : {
789 0 : compute_dependencies(type_map, type.element, dependencies);
790 0 : }
791 :
792 0 : void compute_dependencies(const TypeMap& type_map,
793 : const CompleteArrayHeader& header,
794 : OPENDDS_SET(TypeIdentifier)& dependencies)
795 : {
796 0 : compute_dependencies(type_map, header.detail, dependencies);
797 0 : }
798 :
799 0 : void compute_dependencies(const TypeMap& type_map,
800 : const CompleteArrayType& type,
801 : OPENDDS_SET(TypeIdentifier)& dependencies)
802 : {
803 0 : compute_dependencies(type_map, type.header, dependencies);
804 0 : compute_dependencies(type_map, type.element, dependencies);
805 0 : }
806 :
807 0 : void compute_dependencies(const TypeMap& type_map,
808 : const MinimalMapType& type,
809 : OPENDDS_SET(TypeIdentifier)& dependencies)
810 : {
811 0 : compute_dependencies(type_map, type.key, dependencies);
812 0 : compute_dependencies(type_map, type.element, dependencies);
813 0 : }
814 :
815 0 : void compute_dependencies(const TypeMap& type_map,
816 : const CompleteMapType& type,
817 : OPENDDS_SET(TypeIdentifier)& dependencies)
818 : {
819 0 : compute_dependencies(type_map, type.header, dependencies);
820 0 : compute_dependencies(type_map, type.key, dependencies);
821 0 : compute_dependencies(type_map, type.element, dependencies);
822 0 : }
823 :
824 14 : void compute_dependencies(const TypeMap&,
825 : const MinimalEnumeratedType&,
826 : OPENDDS_SET(TypeIdentifier)&)
827 : {
828 : // Doesn't have any dependencies.
829 14 : }
830 :
831 14 : void compute_dependencies(const TypeMap& type_map,
832 : const CompleteEnumeratedHeader& header,
833 : OPENDDS_SET(TypeIdentifier)& dependencies)
834 : {
835 14 : compute_dependencies(type_map, header.detail, dependencies);
836 14 : }
837 :
838 65 : void compute_dependencies(const TypeMap& type_map,
839 : const CompleteEnumeratedLiteral& literal,
840 : OPENDDS_SET(TypeIdentifier)& dependencies)
841 : {
842 65 : compute_dependencies(type_map, literal.detail, dependencies);
843 65 : }
844 :
845 14 : void compute_dependencies(const TypeMap& type_map,
846 : const CompleteEnumeratedType& type,
847 : OPENDDS_SET(TypeIdentifier)& dependencies)
848 : {
849 14 : compute_dependencies(type_map, type.header, dependencies);
850 14 : compute_dependencies(type_map, type.literal_seq, dependencies);
851 14 : }
852 :
853 0 : void compute_dependencies(const TypeMap&,
854 : const MinimalBitmaskType&,
855 : OPENDDS_SET(TypeIdentifier)&)
856 : {
857 : // Doesn't have any dependencies.
858 0 : }
859 :
860 0 : void compute_dependencies(const TypeMap& type_map,
861 : const CompleteBitflag& bitflag,
862 : OPENDDS_SET(TypeIdentifier)& dependencies)
863 : {
864 0 : compute_dependencies(type_map, bitflag.detail, dependencies);
865 0 : }
866 :
867 0 : void compute_dependencies(const TypeMap& type_map,
868 : const CompleteBitmaskType& type,
869 : OPENDDS_SET(TypeIdentifier)& dependencies)
870 : {
871 0 : compute_dependencies(type_map, type.header, dependencies);
872 0 : compute_dependencies(type_map, type.flag_seq, dependencies);
873 0 : }
874 :
875 207 : void compute_dependencies(const TypeMap& type_map,
876 : const MinimalTypeObject& type_object,
877 : OPENDDS_SET(TypeIdentifier)& dependencies)
878 : {
879 207 : switch (type_object.kind) {
880 49 : case TK_ALIAS:
881 49 : compute_dependencies(type_map, type_object.alias_type, dependencies);
882 49 : break;
883 0 : case TK_ANNOTATION:
884 0 : compute_dependencies(type_map, type_object.annotation_type, dependencies);
885 0 : break;
886 110 : case TK_STRUCTURE:
887 110 : compute_dependencies(type_map, type_object.struct_type, dependencies);
888 110 : break;
889 34 : case TK_UNION:
890 34 : compute_dependencies(type_map, type_object.union_type, dependencies);
891 34 : break;
892 0 : case TK_BITSET:
893 0 : compute_dependencies(type_map, type_object.bitset_type, dependencies);
894 0 : break;
895 0 : case TK_SEQUENCE:
896 0 : compute_dependencies(type_map, type_object.sequence_type, dependencies);
897 0 : break;
898 0 : case TK_ARRAY:
899 0 : compute_dependencies(type_map, type_object.array_type, dependencies);
900 0 : break;
901 0 : case TK_MAP:
902 0 : compute_dependencies(type_map, type_object.map_type, dependencies);
903 0 : break;
904 14 : case TK_ENUM:
905 14 : compute_dependencies(type_map, type_object.enumerated_type, dependencies);
906 14 : break;
907 0 : case TK_BITMASK:
908 0 : compute_dependencies(type_map, type_object.bitmask_type, dependencies);
909 0 : break;
910 : }
911 207 : }
912 :
913 207 : void compute_dependencies(const TypeMap& type_map,
914 : const CompleteTypeObject& type_object,
915 : OPENDDS_SET(TypeIdentifier)& dependencies)
916 : {
917 207 : switch (type_object.kind) {
918 49 : case TK_ALIAS:
919 49 : compute_dependencies(type_map, type_object.alias_type, dependencies);
920 49 : break;
921 0 : case TK_ANNOTATION:
922 0 : compute_dependencies(type_map, type_object.annotation_type, dependencies);
923 0 : break;
924 110 : case TK_STRUCTURE:
925 110 : compute_dependencies(type_map, type_object.struct_type, dependencies);
926 110 : break;
927 34 : case TK_UNION:
928 34 : compute_dependencies(type_map, type_object.union_type, dependencies);
929 34 : break;
930 0 : case TK_BITSET:
931 0 : compute_dependencies(type_map, type_object.bitset_type, dependencies);
932 0 : break;
933 0 : case TK_SEQUENCE:
934 0 : compute_dependencies(type_map, type_object.sequence_type, dependencies);
935 0 : break;
936 0 : case TK_ARRAY:
937 0 : compute_dependencies(type_map, type_object.array_type, dependencies);
938 0 : break;
939 0 : case TK_MAP:
940 0 : compute_dependencies(type_map, type_object.map_type, dependencies);
941 0 : break;
942 14 : case TK_ENUM:
943 14 : compute_dependencies(type_map, type_object.enumerated_type, dependencies);
944 14 : break;
945 0 : case TK_BITMASK:
946 0 : compute_dependencies(type_map, type_object.bitmask_type, dependencies);
947 0 : break;
948 : }
949 207 : }
950 :
951 414 : void compute_dependencies(const TypeMap& type_map,
952 : const TypeObject& type_object,
953 : OPENDDS_SET(TypeIdentifier)& dependencies)
954 : {
955 414 : switch (type_object.kind) {
956 207 : case EK_COMPLETE:
957 207 : compute_dependencies(type_map, type_object.complete, dependencies);
958 207 : break;
959 207 : case EK_MINIMAL:
960 207 : compute_dependencies(type_map, type_object.minimal, dependencies);
961 207 : break;
962 : }
963 414 : }
964 :
965 12 : void compute_dependencies(const TypeMap&,
966 : const StringSTypeDefn&,
967 : OPENDDS_SET(TypeIdentifier)&)
968 : {
969 : // Do nothing.
970 12 : }
971 :
972 0 : void compute_dependencies(const TypeMap&,
973 : const StringLTypeDefn&,
974 : OPENDDS_SET(TypeIdentifier)&)
975 : {
976 : // Do nothing.
977 0 : }
978 :
979 136 : void compute_dependencies(const TypeMap&,
980 : const PlainCollectionHeader&,
981 : OPENDDS_SET(TypeIdentifier)&)
982 : {
983 : // Do nothing.
984 136 : }
985 :
986 64 : void compute_dependencies(const TypeMap& type_map,
987 : const PlainSequenceSElemDefn& type,
988 : OPENDDS_SET(TypeIdentifier)& dependencies)
989 : {
990 64 : compute_dependencies(type_map, type.header, dependencies);
991 64 : compute_dependencies(type_map, *type.element_identifier, dependencies);
992 64 : }
993 :
994 0 : void compute_dependencies(const TypeMap& type_map,
995 : const PlainSequenceLElemDefn& type,
996 : OPENDDS_SET(TypeIdentifier)& dependencies)
997 : {
998 0 : compute_dependencies(type_map, type.header, dependencies);
999 0 : compute_dependencies(type_map, *type.element_identifier, dependencies);
1000 0 : }
1001 :
1002 72 : void compute_dependencies(const TypeMap& type_map,
1003 : const PlainArraySElemDefn& type,
1004 : OPENDDS_SET(TypeIdentifier)& dependencies)
1005 : {
1006 72 : compute_dependencies(type_map, type.header, dependencies);
1007 72 : compute_dependencies(type_map, *type.element_identifier, dependencies);
1008 72 : }
1009 :
1010 0 : void compute_dependencies(const TypeMap& type_map,
1011 : const PlainArrayLElemDefn& type,
1012 : OPENDDS_SET(TypeIdentifier)& dependencies)
1013 : {
1014 0 : compute_dependencies(type_map, type.header, dependencies);
1015 0 : compute_dependencies(type_map, *type.element_identifier, dependencies);
1016 0 : }
1017 :
1018 0 : void compute_dependencies(const TypeMap& type_map,
1019 : const PlainMapSTypeDefn& type,
1020 : OPENDDS_SET(TypeIdentifier)& dependencies)
1021 : {
1022 0 : compute_dependencies(type_map, type.header, dependencies);
1023 0 : compute_dependencies(type_map, *type.element_identifier, dependencies);
1024 0 : compute_dependencies(type_map, *type.key_identifier, dependencies);
1025 0 : }
1026 :
1027 0 : void compute_dependencies(const TypeMap& type_map,
1028 : const PlainMapLTypeDefn& type,
1029 : OPENDDS_SET(TypeIdentifier)& dependencies)
1030 : {
1031 0 : compute_dependencies(type_map, type.header, dependencies);
1032 0 : compute_dependencies(type_map, *type.element_identifier, dependencies);
1033 0 : compute_dependencies(type_map, *type.key_identifier, dependencies);
1034 0 : }
1035 :
1036 0 : void compute_dependencies(const TypeMap&,
1037 : const StronglyConnectedComponentId&,
1038 : OPENDDS_SET(TypeIdentifier)&)
1039 : {
1040 : // Do nothing.
1041 0 : }
1042 :
1043 : template <typename T>
1044 302 : void compute_dependencies(const TypeMap& type_map,
1045 : const Sequence<T>& type,
1046 : OPENDDS_SET(TypeIdentifier)& dependencies)
1047 : {
1048 1131 : for (typename Sequence<T>::const_iterator pos = type.begin(), limit = type.end(); pos != limit; ++pos) {
1049 829 : compute_dependencies(type_map, *pos, dependencies);
1050 : }
1051 302 : }
1052 :
1053 : }
1054 :
1055 1446 : void compute_dependencies(const TypeMap& type_map,
1056 : const TypeIdentifier& type_identifier,
1057 : OPENDDS_SET(TypeIdentifier)& dependencies)
1058 : {
1059 1446 : if (dependencies.count(type_identifier) != 0) {
1060 420 : return;
1061 : }
1062 :
1063 1026 : dependencies.insert(type_identifier);
1064 :
1065 1026 : switch (type_identifier.kind()) {
1066 12 : case TI_STRING8_SMALL:
1067 : case TI_STRING16_SMALL:
1068 12 : compute_dependencies(type_map, type_identifier.string_sdefn(), dependencies);
1069 12 : break;
1070 0 : case TI_STRING8_LARGE:
1071 : case TI_STRING16_LARGE:
1072 0 : compute_dependencies(type_map, type_identifier.string_ldefn(), dependencies);
1073 0 : break;
1074 64 : case TI_PLAIN_SEQUENCE_SMALL:
1075 64 : compute_dependencies(type_map, type_identifier.seq_sdefn(), dependencies);
1076 64 : break;
1077 0 : case TI_PLAIN_SEQUENCE_LARGE:
1078 0 : compute_dependencies(type_map, type_identifier.seq_ldefn(), dependencies);
1079 0 : break;
1080 72 : case TI_PLAIN_ARRAY_SMALL:
1081 72 : compute_dependencies(type_map, type_identifier.array_sdefn(), dependencies);
1082 72 : break;
1083 0 : case TI_PLAIN_ARRAY_LARGE:
1084 0 : compute_dependencies(type_map, type_identifier.array_ldefn(), dependencies);
1085 0 : break;
1086 0 : case TI_PLAIN_MAP_SMALL:
1087 0 : compute_dependencies(type_map, type_identifier.map_sdefn(), dependencies);
1088 0 : break;
1089 0 : case TI_PLAIN_MAP_LARGE:
1090 0 : compute_dependencies(type_map, type_identifier.map_ldefn(), dependencies);
1091 0 : break;
1092 0 : case TI_STRONGLY_CONNECTED_COMPONENT:
1093 0 : compute_dependencies(type_map, type_identifier.sc_component_id(), dependencies);
1094 0 : break;
1095 414 : case EK_COMPLETE:
1096 : case EK_MINIMAL:
1097 : {
1098 414 : TypeMap::const_iterator pos = type_map.find(type_identifier);
1099 414 : if (pos != type_map.end()) {
1100 414 : compute_dependencies(type_map, pos->second, dependencies);
1101 : }
1102 414 : break;
1103 : }
1104 : }
1105 : }
1106 :
1107 0 : bool write_empty_xcdr2_nonfinal(DCPS::Serializer& strm)
1108 : {
1109 0 : size_t size = 0;
1110 0 : serialized_size_delimiter(strm.encoding(), size);
1111 0 : return strm.write_delimiter(size);
1112 : }
1113 :
1114 54 : bool read_empty_xcdr2_nonfinal(DCPS::Serializer& strm)
1115 : {
1116 54 : size_t total_size = 0;
1117 54 : if (!strm.read_delimiter(total_size)) {
1118 0 : return false;
1119 : }
1120 54 : return strm.skip(total_size);
1121 : }
1122 :
1123 84 : const char* typekind_to_string(TypeKind tk)
1124 : {
1125 84 : switch (tk) {
1126 0 : case TK_NONE:
1127 0 : return "none";
1128 0 : case TK_BOOLEAN:
1129 0 : return "boolean";
1130 0 : case TK_BYTE:
1131 0 : return "byte";
1132 0 : case TK_INT16:
1133 0 : return "int16";
1134 0 : case TK_INT32:
1135 0 : return "int32";
1136 0 : case TK_INT64:
1137 0 : return "int64";
1138 0 : case TK_UINT16:
1139 0 : return "uint16";
1140 0 : case TK_UINT32:
1141 0 : return "uint32";
1142 0 : case TK_UINT64:
1143 0 : return "uint64";
1144 0 : case TK_FLOAT32:
1145 0 : return "float32";
1146 0 : case TK_FLOAT64:
1147 0 : return "float64";
1148 0 : case TK_FLOAT128:
1149 0 : return "float128";
1150 0 : case TK_INT8:
1151 0 : return "int8";
1152 0 : case TK_UINT8:
1153 0 : return "uint8";
1154 0 : case TK_CHAR8:
1155 0 : return "char8";
1156 0 : case TK_CHAR16:
1157 0 : return "char16";
1158 0 : case TK_STRING8:
1159 0 : return "string";
1160 0 : case TK_STRING16:
1161 0 : return "wstring";
1162 0 : case TK_ALIAS:
1163 0 : return "alias";
1164 0 : case TK_ENUM:
1165 0 : return "enum";
1166 0 : case TK_BITMASK:
1167 0 : return "bitmask";
1168 0 : case TK_ANNOTATION:
1169 0 : return "annotation";
1170 0 : case TK_STRUCTURE:
1171 0 : return "structure";
1172 0 : case TK_UNION:
1173 0 : return "union";
1174 0 : case TK_BITSET:
1175 0 : return "bitset";
1176 84 : case TK_SEQUENCE:
1177 84 : return "sequence";
1178 0 : case TK_ARRAY:
1179 0 : return "array";
1180 0 : case TK_MAP:
1181 0 : return "map";
1182 0 : default:
1183 0 : if (DCPS::log_level >= DCPS::LogLevel::Warning) {
1184 0 : ACE_ERROR((LM_WARNING, "(%P|%t) WARNING: typekind_to_string: "
1185 : "passed unknown TypeKind %u\n", tk));
1186 : }
1187 0 : return "unknown";
1188 : }
1189 : }
1190 :
1191 10218 : bool is_primitive(TypeKind tk)
1192 : {
1193 10218 : switch (tk) {
1194 6360 : case TK_BOOLEAN:
1195 : case TK_BYTE:
1196 : case TK_INT8:
1197 : case TK_UINT8:
1198 : case TK_INT16:
1199 : case TK_UINT16:
1200 : case TK_INT32:
1201 : case TK_UINT32:
1202 : case TK_INT64:
1203 : case TK_UINT64:
1204 : case TK_FLOAT32:
1205 : case TK_FLOAT64:
1206 : case TK_FLOAT128:
1207 : case TK_CHAR8:
1208 : case TK_CHAR16:
1209 6360 : return true;
1210 3858 : default:
1211 3858 : return false;
1212 : }
1213 : }
1214 :
1215 2466 : bool is_scalar(TypeKind tk)
1216 : {
1217 2466 : return is_primitive(tk) || tk == TK_ENUM;
1218 : }
1219 :
1220 7108 : bool is_basic(TypeKind tk)
1221 : {
1222 7108 : return is_primitive(tk) || tk == TK_STRING8 || tk == TK_STRING16;
1223 : }
1224 :
1225 210 : bool is_complex(TypeKind tk)
1226 : {
1227 210 : switch (tk) {
1228 210 : case TK_ARRAY:
1229 : case TK_SEQUENCE:
1230 : case TK_MAP:
1231 : case TK_STRUCTURE:
1232 : case TK_UNION:
1233 : case TK_BITSET:
1234 210 : return true;
1235 0 : default:
1236 0 : return false;
1237 : }
1238 : }
1239 :
1240 3369 : bool is_sequence_like(TypeKind tk)
1241 : {
1242 3369 : switch (tk) {
1243 903 : case TK_SEQUENCE:
1244 : case TK_ARRAY:
1245 : case TK_STRING8:
1246 : case TK_STRING16:
1247 903 : return true;
1248 2466 : default:
1249 2466 : return false;
1250 : }
1251 : }
1252 :
1253 : } // namespace XTypes
1254 :
1255 : namespace DCPS {
1256 :
1257 : // Serialization support for TypeObject and its components
1258 :
1259 : using XTypes::TYPE_NAME_MAX_LENGTH;
1260 : using XTypes::MEMBER_NAME_MAX_LENGTH;
1261 :
1262 2189 : void serialized_size(const Encoding& encoding, size_t& size,
1263 : const XTypes::TypeIdentifier& uni)
1264 : {
1265 2189 : primitive_serialized_size_octet(encoding, size);
1266 :
1267 2189 : switch (uni.kind()) {
1268 28 : case XTypes::TI_STRING8_SMALL:
1269 : case XTypes::TI_STRING16_SMALL:
1270 28 : serialized_size(encoding, size, uni.string_sdefn());
1271 28 : break;
1272 0 : case XTypes::TI_STRING8_LARGE:
1273 : case XTypes::TI_STRING16_LARGE:
1274 0 : serialized_size(encoding, size, uni.string_ldefn());
1275 0 : break;
1276 104 : case XTypes::TI_PLAIN_SEQUENCE_SMALL:
1277 104 : serialized_size(encoding, size, uni.seq_sdefn());
1278 104 : break;
1279 0 : case XTypes::TI_PLAIN_SEQUENCE_LARGE:
1280 0 : serialized_size(encoding, size, uni.seq_ldefn());
1281 0 : break;
1282 112 : case XTypes::TI_PLAIN_ARRAY_SMALL:
1283 112 : serialized_size(encoding, size, uni.array_sdefn());
1284 112 : break;
1285 0 : case XTypes::TI_PLAIN_ARRAY_LARGE:
1286 0 : serialized_size(encoding, size, uni.array_ldefn());
1287 0 : break;
1288 0 : case XTypes::TI_PLAIN_MAP_SMALL:
1289 0 : serialized_size(encoding, size, uni.map_sdefn());
1290 0 : break;
1291 0 : case XTypes::TI_PLAIN_MAP_LARGE:
1292 0 : serialized_size(encoding, size, uni.map_ldefn());
1293 0 : break;
1294 0 : case XTypes::TI_STRONGLY_CONNECTED_COMPONENT:
1295 0 : serialized_size(encoding, size, uni.sc_component_id());
1296 0 : break;
1297 290 : case XTypes::EK_COMPLETE:
1298 : case XTypes::EK_MINIMAL:
1299 : {
1300 290 : XTypes::EquivalenceHash_forany uni_equivalence_hash(const_cast<XTypes::EquivalenceHash_slice*>(uni.equivalence_hash()));
1301 290 : serialized_size(encoding, size, uni_equivalence_hash);
1302 290 : break;
1303 : }
1304 1655 : case XTypes::TK_NONE:
1305 : case XTypes::TK_BOOLEAN:
1306 : case XTypes::TK_BYTE:
1307 : case XTypes::TK_INT16:
1308 : case XTypes::TK_INT32:
1309 : case XTypes::TK_INT64:
1310 : case XTypes::TK_UINT16:
1311 : case XTypes::TK_UINT32:
1312 : case XTypes::TK_UINT64:
1313 : case XTypes::TK_FLOAT32:
1314 : case XTypes::TK_FLOAT64:
1315 : case XTypes::TK_FLOAT128:
1316 : case XTypes::TK_INT8:
1317 : case XTypes::TK_UINT8:
1318 : case XTypes::TK_CHAR8:
1319 : case XTypes::TK_CHAR16:
1320 1655 : break; // no-op, no member selected
1321 0 : default:
1322 0 : serialized_size(encoding, size, uni.extended_defn());
1323 : }
1324 2189 : }
1325 :
1326 0 : void serialized_size(const Encoding& encoding, size_t& size,
1327 : const NestedKeyOnly<const XTypes::TypeIdentifier>& uni)
1328 : {
1329 0 : serialized_size(encoding, size, uni.value);
1330 0 : }
1331 :
1332 166 : bool operator<<(Serializer& strm, const XTypes::TypeIdentifier& uni)
1333 : {
1334 166 : if (!(strm << ACE_OutputCDR::from_octet(uni.kind()))) {
1335 0 : return false;
1336 : }
1337 :
1338 166 : switch (uni.kind()) {
1339 0 : case XTypes::TI_STRING8_SMALL:
1340 : case XTypes::TI_STRING16_SMALL:
1341 0 : return (strm << uni.string_sdefn());
1342 0 : case XTypes::TI_STRING8_LARGE:
1343 : case XTypes::TI_STRING16_LARGE:
1344 0 : return (strm << uni.string_ldefn());
1345 0 : case XTypes::TI_PLAIN_SEQUENCE_SMALL:
1346 0 : return (strm << uni.seq_sdefn());
1347 0 : case XTypes::TI_PLAIN_SEQUENCE_LARGE:
1348 0 : return (strm << uni.seq_ldefn());
1349 0 : case XTypes::TI_PLAIN_ARRAY_SMALL:
1350 0 : return (strm << uni.array_sdefn());
1351 0 : case XTypes::TI_PLAIN_ARRAY_LARGE:
1352 0 : return (strm << uni.array_ldefn());
1353 0 : case XTypes::TI_PLAIN_MAP_SMALL:
1354 0 : return (strm << uni.map_sdefn());
1355 0 : case XTypes::TI_PLAIN_MAP_LARGE:
1356 0 : return (strm << uni.map_ldefn());
1357 0 : case XTypes::TI_STRONGLY_CONNECTED_COMPONENT:
1358 0 : return (strm << uni.sc_component_id());
1359 0 : case XTypes::EK_COMPLETE:
1360 : case XTypes::EK_MINIMAL:
1361 : {
1362 0 : XTypes::EquivalenceHash_forany uni_equivalence_hash(const_cast<XTypes::EquivalenceHash_slice*>(uni.equivalence_hash()));
1363 0 : return (strm << uni_equivalence_hash);
1364 : }
1365 166 : case XTypes::TK_NONE:
1366 : case XTypes::TK_BOOLEAN:
1367 : case XTypes::TK_BYTE:
1368 : case XTypes::TK_INT16:
1369 : case XTypes::TK_INT32:
1370 : case XTypes::TK_INT64:
1371 : case XTypes::TK_UINT16:
1372 : case XTypes::TK_UINT32:
1373 : case XTypes::TK_UINT64:
1374 : case XTypes::TK_FLOAT32:
1375 : case XTypes::TK_FLOAT64:
1376 : case XTypes::TK_FLOAT128:
1377 : case XTypes::TK_INT8:
1378 : case XTypes::TK_UINT8:
1379 : case XTypes::TK_CHAR8:
1380 : case XTypes::TK_CHAR16:
1381 166 : return true; // no-op, no member selected
1382 0 : default:
1383 0 : return (strm << uni.extended_defn());
1384 : }
1385 : }
1386 :
1387 0 : bool operator<<(Serializer& strm, const NestedKeyOnly<const XTypes::TypeIdentifier>& uni)
1388 : {
1389 0 : return (strm << uni.value);
1390 : }
1391 :
1392 1616 : bool operator>>(Serializer& strm, XTypes::TypeIdentifier& uni)
1393 : {
1394 : ACE_CDR::Octet k;
1395 1616 : if (!(strm >> ACE_InputCDR::to_octet(k))) {
1396 0 : return false;
1397 : }
1398 1616 : uni = XTypes::TypeIdentifier(k);
1399 :
1400 1616 : switch (k) {
1401 56 : case XTypes::TI_STRING8_SMALL:
1402 : case XTypes::TI_STRING16_SMALL:
1403 56 : return (strm >> uni.string_sdefn());
1404 0 : case XTypes::TI_STRING8_LARGE:
1405 : case XTypes::TI_STRING16_LARGE:
1406 0 : return (strm >> uni.string_ldefn());
1407 127 : case XTypes::TI_PLAIN_SEQUENCE_SMALL:
1408 127 : return (strm >> uni.seq_sdefn());
1409 0 : case XTypes::TI_PLAIN_SEQUENCE_LARGE:
1410 0 : return (strm >> uni.seq_ldefn());
1411 113 : case XTypes::TI_PLAIN_ARRAY_SMALL:
1412 113 : return (strm >> uni.array_sdefn());
1413 0 : case XTypes::TI_PLAIN_ARRAY_LARGE:
1414 0 : return (strm >> uni.array_ldefn());
1415 0 : case XTypes::TI_PLAIN_MAP_SMALL:
1416 0 : return (strm >> uni.map_sdefn());
1417 0 : case XTypes::TI_PLAIN_MAP_LARGE:
1418 0 : return (strm >> uni.map_ldefn());
1419 26 : case XTypes::TI_STRONGLY_CONNECTED_COMPONENT:
1420 26 : return (strm >> uni.sc_component_id());
1421 486 : case XTypes::EK_COMPLETE:
1422 : case XTypes::EK_MINIMAL:
1423 : {
1424 486 : XTypes::EquivalenceHash_forany uni_equivalence_hash(uni.equivalence_hash());
1425 486 : return (strm >> uni_equivalence_hash);
1426 : }
1427 808 : case XTypes::TK_NONE:
1428 : case XTypes::TK_BOOLEAN:
1429 : case XTypes::TK_BYTE:
1430 : case XTypes::TK_INT16:
1431 : case XTypes::TK_INT32:
1432 : case XTypes::TK_INT64:
1433 : case XTypes::TK_UINT16:
1434 : case XTypes::TK_UINT32:
1435 : case XTypes::TK_UINT64:
1436 : case XTypes::TK_FLOAT32:
1437 : case XTypes::TK_FLOAT64:
1438 : case XTypes::TK_FLOAT128:
1439 : case XTypes::TK_INT8:
1440 : case XTypes::TK_UINT8:
1441 : case XTypes::TK_CHAR8:
1442 : case XTypes::TK_CHAR16:
1443 808 : return true; // no-op, no member selected
1444 0 : default:
1445 0 : return (strm >> uni.extended_defn());
1446 : }
1447 : }
1448 :
1449 0 : bool operator>>(Serializer& strm, NestedKeyOnly<XTypes::TypeIdentifier>& uni)
1450 : {
1451 0 : return (strm >> uni.value);
1452 : }
1453 :
1454 2 : void serialized_size(const Encoding& encoding, size_t& size,
1455 : const XTypes::LBoundSeq& seq)
1456 : {
1457 2 : DCPS::primitive_serialized_size_ulong(encoding, size);
1458 2 : if (seq.length() == 0) {
1459 2 : return;
1460 : }
1461 0 : primitive_serialized_size(encoding, size, ACE_CDR::ULong(), seq.length());
1462 : }
1463 :
1464 2 : bool operator<<(Serializer& strm, const XTypes::LBoundSeq& seq)
1465 : {
1466 2 : const ACE_CDR::ULong length = seq.length();
1467 2 : if (!(strm << length)) {
1468 0 : return false;
1469 : }
1470 2 : if (length == 0) {
1471 2 : return true;
1472 : }
1473 0 : return strm.write_ulong_array(seq.get_buffer(), length);
1474 : }
1475 :
1476 4 : bool operator>>(Serializer& strm, XTypes::LBoundSeq& seq)
1477 : {
1478 : ACE_CDR::ULong length;
1479 4 : if (!(strm >> length)) {
1480 0 : return false;
1481 : }
1482 4 : seq.length(length);
1483 4 : if (length == 0) {
1484 2 : return true;
1485 : }
1486 2 : return strm.read_ulong_array(seq.get_buffer(), length);
1487 : }
1488 :
1489 :
1490 112 : void serialized_size(const Encoding& encoding, size_t& size,
1491 : const XTypes::SBoundSeq& seq)
1492 : {
1493 112 : DCPS::primitive_serialized_size_ulong(encoding, size);
1494 112 : if (seq.length() == 0) {
1495 0 : return;
1496 : }
1497 112 : primitive_serialized_size_octet(encoding, size, seq.length());
1498 : }
1499 :
1500 0 : bool operator<<(Serializer& strm, const XTypes::SBoundSeq& seq)
1501 : {
1502 0 : const ACE_CDR::ULong length = seq.length();
1503 0 : if (!(strm << length)) {
1504 0 : return false;
1505 : }
1506 0 : if (length == 0) {
1507 0 : return true;
1508 : }
1509 0 : return strm.write_octet_array(seq.get_buffer(), length);
1510 : }
1511 :
1512 113 : bool operator>>(Serializer& strm, XTypes::SBoundSeq& seq)
1513 : {
1514 : ACE_CDR::ULong length;
1515 113 : if (!(strm >> length)) {
1516 0 : return false;
1517 : }
1518 113 : seq.length(length);
1519 113 : if (length == 0) {
1520 0 : return true;
1521 : }
1522 113 : return strm.read_octet_array(seq.get_buffer(), length);
1523 : }
1524 :
1525 :
1526 198 : void serialized_size(const Encoding& encoding, size_t& size,
1527 : const XTypes::UnionCaseLabelSeq& seq)
1528 : {
1529 198 : DCPS::primitive_serialized_size_ulong(encoding, size);
1530 198 : if (seq.length() == 0) {
1531 34 : return;
1532 : }
1533 164 : primitive_serialized_size(encoding, size, ACE_CDR::Long(), seq.length());
1534 : }
1535 :
1536 0 : bool operator<<(Serializer& strm, const XTypes::UnionCaseLabelSeq& seq)
1537 : {
1538 0 : const ACE_CDR::ULong length = seq.length();
1539 0 : if (!(strm << length)) {
1540 0 : return false;
1541 : }
1542 0 : if (length == 0) {
1543 0 : return true;
1544 : }
1545 0 : return strm.write_long_array(seq.get_buffer(), length);
1546 : }
1547 :
1548 303 : bool operator>>(Serializer& strm, XTypes::UnionCaseLabelSeq& seq)
1549 : {
1550 : ACE_CDR::ULong length;
1551 303 : if (!(strm >> length)) {
1552 0 : return false;
1553 : }
1554 303 : seq.length(length);
1555 303 : if (length == 0) {
1556 12 : return true;
1557 : }
1558 291 : return strm.read_long_array(seq.get_buffer(), length);
1559 : }
1560 :
1561 :
1562 0 : void serialized_size(const Encoding& encoding, size_t& size,
1563 : const XTypes::ExtendedAnnotationParameterValue&)
1564 : {
1565 0 : serialized_size_delimiter(encoding, size);
1566 0 : }
1567 :
1568 0 : bool operator<<(Serializer& strm, const XTypes::ExtendedAnnotationParameterValue&)
1569 : {
1570 0 : return XTypes::write_empty_xcdr2_nonfinal(strm);
1571 : }
1572 :
1573 0 : bool operator>>(Serializer& strm, XTypes::ExtendedAnnotationParameterValue&)
1574 : {
1575 0 : return XTypes::read_empty_xcdr2_nonfinal(strm);
1576 : }
1577 :
1578 :
1579 454 : void serialized_size(const Encoding& encoding, size_t& size,
1580 : const XTypes::NameHash_forany&)
1581 : {
1582 454 : primitive_serialized_size_octet(encoding, size, 4);
1583 454 : }
1584 :
1585 2 : bool operator<<(Serializer& strm, const XTypes::NameHash_forany& arr)
1586 : {
1587 2 : return strm.write_octet_array(arr.in(), 4);
1588 : }
1589 :
1590 255 : bool operator>>(Serializer& strm, XTypes::NameHash_forany& arr)
1591 : {
1592 255 : return strm.read_octet_array(arr.out(), 4);
1593 : }
1594 :
1595 :
1596 290 : void serialized_size(const Encoding& encoding, size_t& size,
1597 : const XTypes::EquivalenceHash_forany&)
1598 : {
1599 290 : primitive_serialized_size_octet(encoding, size, 14);
1600 290 : }
1601 :
1602 0 : bool operator<<(Serializer& strm, const XTypes::EquivalenceHash_forany& arr)
1603 : {
1604 0 : return strm.write_octet_array(arr.in(), 14);
1605 : }
1606 :
1607 512 : bool operator>>(Serializer& strm, XTypes::EquivalenceHash_forany& arr)
1608 : {
1609 512 : return strm.read_octet_array(arr.out(), 14);
1610 : }
1611 :
1612 :
1613 207 : void serialized_size(const Encoding& encoding, size_t& size,
1614 : const XTypes::CompleteTypeDetail& stru)
1615 : {
1616 207 : serialized_size(encoding, size, stru.ann_builtin);
1617 207 : serialized_size(encoding, size, stru.ann_custom);
1618 207 : DCPS::primitive_serialized_size_ulong(encoding, size);
1619 207 : size += stru.type_name.size() + 1;
1620 207 : }
1621 :
1622 0 : bool operator<<(Serializer& strm, const XTypes::CompleteTypeDetail& stru)
1623 : {
1624 0 : return (strm << stru.ann_builtin)
1625 0 : && (strm << stru.ann_custom)
1626 0 : && (strm << Serializer::FromBoundedString<char>(stru.type_name, TYPE_NAME_MAX_LENGTH));
1627 : }
1628 :
1629 209 : bool operator>>(Serializer& strm, XTypes::CompleteTypeDetail& stru)
1630 : {
1631 209 : return (strm >> stru.ann_builtin)
1632 209 : && (strm >> stru.ann_custom)
1633 418 : && (strm >> Serializer::ToBoundedString<char>(stru.type_name, TYPE_NAME_MAX_LENGTH));
1634 : }
1635 :
1636 :
1637 110 : void serialized_size(const Encoding& encoding, size_t& size,
1638 : const XTypes::CompleteStructHeader& stru)
1639 : {
1640 110 : serialized_size_delimiter(encoding, size);
1641 110 : serialized_size(encoding, size, stru.base_type);
1642 110 : serialized_size(encoding, size, stru.detail);
1643 110 : }
1644 :
1645 0 : bool operator<<(Serializer& strm, const XTypes::CompleteStructHeader& stru)
1646 : {
1647 0 : size_t total_size = 0;
1648 0 : serialized_size(strm.encoding(), total_size, stru);
1649 0 : if (!strm.write_delimiter(total_size)) {
1650 0 : return false;
1651 : }
1652 :
1653 0 : return (strm << stru.base_type)
1654 0 : && (strm << stru.detail);
1655 : }
1656 :
1657 79 : bool operator>>(Serializer& strm, XTypes::CompleteStructHeader& stru)
1658 : {
1659 79 : size_t total_size = 0;
1660 79 : if (!strm.read_delimiter(total_size)) {
1661 0 : return false;
1662 : }
1663 :
1664 79 : const size_t start_pos = strm.rpos();
1665 :
1666 79 : const bool ret = (strm >> stru.base_type)
1667 79 : && (strm >> stru.detail);
1668 :
1669 79 : if (ret && strm.rpos() - start_pos < total_size) {
1670 0 : strm.skip(total_size - strm.rpos() + start_pos);
1671 : }
1672 79 : return ret;
1673 : }
1674 :
1675 :
1676 116 : void serialized_size(const Encoding& encoding, size_t& size,
1677 : const XTypes::MinimalStructHeader& stru)
1678 : {
1679 116 : serialized_size_delimiter(encoding, size);
1680 116 : serialized_size(encoding, size, stru.base_type);
1681 116 : serialized_size(encoding, size, stru.detail);
1682 116 : }
1683 :
1684 2 : bool operator<<(Serializer& strm, const XTypes::MinimalStructHeader& stru)
1685 : {
1686 2 : size_t total_size = 0;
1687 2 : serialized_size(strm.encoding(), total_size, stru);
1688 2 : if (!strm.write_delimiter(total_size)) {
1689 0 : return false;
1690 : }
1691 :
1692 2 : return (strm << stru.base_type)
1693 2 : && (strm << stru.detail);
1694 : }
1695 :
1696 39 : bool operator>>(Serializer& strm, XTypes::MinimalStructHeader& stru)
1697 : {
1698 39 : size_t total_size = 0;
1699 39 : if (!strm.read_delimiter(total_size)) {
1700 0 : return false;
1701 : }
1702 :
1703 39 : const size_t start_pos = strm.rpos();
1704 :
1705 39 : const bool ret = (strm >> stru.base_type)
1706 39 : && (strm >> stru.detail);
1707 :
1708 39 : if (ret && strm.rpos() - start_pos < total_size) {
1709 0 : strm.skip(total_size - strm.rpos() + start_pos);
1710 : }
1711 39 : return ret;
1712 : }
1713 :
1714 110 : void serialized_size(const Encoding& encoding, size_t& size,
1715 : const XTypes::CompleteStructType& stru)
1716 : {
1717 110 : primitive_serialized_size(encoding, size, stru.struct_flags);
1718 110 : serialized_size(encoding, size, stru.header);
1719 110 : serialized_size(encoding, size, stru.member_seq);
1720 110 : }
1721 :
1722 0 : bool operator<<(Serializer& strm, const XTypes::CompleteStructType& stru)
1723 : {
1724 0 : return (strm << stru.struct_flags)
1725 0 : && (strm << stru.header)
1726 0 : && (strm << stru.member_seq);
1727 : }
1728 :
1729 79 : bool operator>>(Serializer& strm, XTypes::CompleteStructType& stru)
1730 : {
1731 79 : return (strm >> stru.struct_flags)
1732 79 : && (strm >> stru.header)
1733 158 : && (strm >> stru.member_seq);
1734 : }
1735 :
1736 :
1737 114 : void serialized_size(const Encoding& encoding, size_t& size,
1738 : const XTypes::MinimalStructType& stru)
1739 : {
1740 114 : primitive_serialized_size(encoding, size, stru.struct_flags);
1741 114 : serialized_size(encoding, size, stru.header);
1742 114 : serialized_size(encoding, size, stru.member_seq);
1743 114 : }
1744 :
1745 2 : bool operator<<(Serializer& strm, const XTypes::MinimalStructType& stru)
1746 : {
1747 2 : return (strm << stru.struct_flags)
1748 2 : && (strm << stru.header)
1749 4 : && (strm << stru.member_seq);
1750 : }
1751 :
1752 39 : bool operator>>(Serializer& strm, XTypes::MinimalStructType& stru)
1753 : {
1754 39 : return (strm >> stru.struct_flags)
1755 39 : && (strm >> stru.header)
1756 78 : && (strm >> stru.member_seq);
1757 : }
1758 :
1759 :
1760 34 : void serialized_size(const Encoding& encoding, size_t& size,
1761 : const XTypes::CompleteUnionType& stru)
1762 : {
1763 34 : primitive_serialized_size(encoding, size, stru.union_flags);
1764 34 : serialized_size(encoding, size, stru.header);
1765 34 : serialized_size(encoding, size, stru.discriminator);
1766 34 : serialized_size(encoding, size, stru.member_seq);
1767 34 : }
1768 :
1769 0 : bool operator<<(Serializer& strm, const XTypes::CompleteUnionType& stru)
1770 : {
1771 0 : return (strm << stru.union_flags)
1772 0 : && (strm << stru.header)
1773 0 : && (strm << stru.discriminator)
1774 0 : && (strm << stru.member_seq);
1775 : }
1776 :
1777 29 : bool operator>>(Serializer& strm, XTypes::CompleteUnionType& stru)
1778 : {
1779 29 : return (strm >> stru.union_flags)
1780 29 : && (strm >> stru.header)
1781 29 : && (strm >> stru.discriminator)
1782 58 : && (strm >> stru.member_seq);
1783 : }
1784 :
1785 :
1786 34 : void serialized_size(const Encoding& encoding, size_t& size,
1787 : const XTypes::MinimalUnionType& stru)
1788 : {
1789 34 : primitive_serialized_size(encoding, size, stru.union_flags);
1790 34 : serialized_size(encoding, size, stru.header);
1791 34 : serialized_size(encoding, size, stru.discriminator);
1792 34 : serialized_size(encoding, size, stru.member_seq);
1793 34 : }
1794 :
1795 0 : bool operator<<(Serializer& strm, const XTypes::MinimalUnionType& stru)
1796 : {
1797 0 : return (strm << stru.union_flags)
1798 0 : && (strm << stru.header)
1799 0 : && (strm << stru.discriminator)
1800 0 : && (strm << stru.member_seq);
1801 : }
1802 :
1803 10 : bool operator>>(Serializer& strm, XTypes::MinimalUnionType& stru)
1804 : {
1805 10 : return (strm >> stru.union_flags)
1806 10 : && (strm >> stru.header)
1807 10 : && (strm >> stru.discriminator)
1808 20 : && (strm >> stru.member_seq);
1809 : }
1810 :
1811 :
1812 0 : void serialized_size(const Encoding& encoding, size_t& size,
1813 : const XTypes::CompleteAnnotationType& stru)
1814 : {
1815 0 : primitive_serialized_size(encoding, size, stru.annotation_flag);
1816 0 : serialized_size(encoding, size, stru.header);
1817 0 : serialized_size(encoding, size, stru.member_seq);
1818 0 : }
1819 :
1820 0 : bool operator<<(Serializer& strm, const XTypes::CompleteAnnotationType& stru)
1821 : {
1822 0 : return (strm << stru.annotation_flag)
1823 0 : && (strm << stru.header)
1824 0 : && (strm << stru.member_seq);
1825 : }
1826 :
1827 0 : bool operator>>(Serializer& strm, XTypes::CompleteAnnotationType& stru)
1828 : {
1829 0 : return (strm >> stru.annotation_flag)
1830 0 : && (strm >> stru.header)
1831 0 : && (strm >> stru.member_seq);
1832 : }
1833 :
1834 :
1835 0 : void serialized_size(const Encoding& encoding, size_t& size,
1836 : const XTypes::MinimalAnnotationType& stru)
1837 : {
1838 0 : primitive_serialized_size(encoding, size, stru.annotation_flag);
1839 0 : serialized_size(encoding, size, stru.header);
1840 0 : serialized_size(encoding, size, stru.member_seq);
1841 0 : }
1842 :
1843 0 : bool operator<<(Serializer& strm, const XTypes::MinimalAnnotationType& stru)
1844 : {
1845 0 : return (strm << stru.annotation_flag)
1846 0 : && (strm << stru.header)
1847 0 : && (strm << stru.member_seq);
1848 : }
1849 :
1850 0 : bool operator>>(Serializer& strm, XTypes::MinimalAnnotationType& stru)
1851 : {
1852 0 : return (strm >> stru.annotation_flag)
1853 0 : && (strm >> stru.header)
1854 0 : && (strm >> stru.member_seq);
1855 : }
1856 :
1857 :
1858 49 : void serialized_size(const Encoding& encoding, size_t& size,
1859 : const XTypes::CompleteAliasType& stru)
1860 : {
1861 49 : primitive_serialized_size(encoding, size, stru.alias_flags);
1862 49 : serialized_size(encoding, size, stru.header);
1863 49 : serialized_size(encoding, size, stru.body);
1864 49 : }
1865 :
1866 0 : bool operator<<(Serializer& strm, const XTypes::CompleteAliasType& stru)
1867 : {
1868 0 : return (strm << stru.alias_flags)
1869 0 : && (strm << stru.header)
1870 0 : && (strm << stru.body);
1871 : }
1872 :
1873 94 : bool operator>>(Serializer& strm, XTypes::CompleteAliasType& stru)
1874 : {
1875 94 : return (strm >> stru.alias_flags)
1876 94 : && (strm >> stru.header)
1877 188 : && (strm >> stru.body);
1878 : }
1879 :
1880 :
1881 49 : void serialized_size(const Encoding& encoding, size_t& size,
1882 : const XTypes::MinimalAliasType& stru)
1883 : {
1884 49 : primitive_serialized_size(encoding, size, stru.alias_flags);
1885 49 : serialized_size(encoding, size, stru.header);
1886 49 : serialized_size(encoding, size, stru.body);
1887 49 : }
1888 :
1889 0 : bool operator<<(Serializer& strm, const XTypes::MinimalAliasType& stru)
1890 : {
1891 0 : return (strm << stru.alias_flags)
1892 0 : && (strm << stru.header)
1893 0 : && (strm << stru.body);
1894 : }
1895 :
1896 54 : bool operator>>(Serializer& strm, XTypes::MinimalAliasType& stru)
1897 : {
1898 54 : return (strm >> stru.alias_flags)
1899 54 : && (strm >> stru.header)
1900 108 : && (strm >> stru.body);
1901 : }
1902 :
1903 :
1904 0 : void serialized_size(const Encoding& encoding, size_t& size,
1905 : const XTypes::CompleteSequenceType& stru)
1906 : {
1907 0 : primitive_serialized_size(encoding, size, stru.collection_flag);
1908 0 : serialized_size(encoding, size, stru.header);
1909 0 : serialized_size(encoding, size, stru.element);
1910 0 : }
1911 :
1912 0 : bool operator<<(Serializer& strm, const XTypes::CompleteSequenceType& stru)
1913 : {
1914 0 : return (strm << stru.collection_flag)
1915 0 : && (strm << stru.header)
1916 0 : && (strm << stru.element);
1917 : }
1918 :
1919 6 : bool operator>>(Serializer& strm, XTypes::CompleteSequenceType& stru)
1920 : {
1921 6 : return (strm >> stru.collection_flag)
1922 6 : && (strm >> stru.header)
1923 12 : && (strm >> stru.element);
1924 : }
1925 :
1926 :
1927 0 : void serialized_size(const Encoding& encoding, size_t& size,
1928 : const XTypes::MinimalSequenceType& stru)
1929 : {
1930 0 : primitive_serialized_size(encoding, size, stru.collection_flag);
1931 0 : serialized_size(encoding, size, stru.header);
1932 0 : serialized_size(encoding, size, stru.element);
1933 0 : }
1934 :
1935 0 : bool operator<<(Serializer& strm, const XTypes::MinimalSequenceType& stru)
1936 : {
1937 0 : return (strm << stru.collection_flag)
1938 0 : && (strm << stru.header)
1939 0 : && (strm << stru.element);
1940 : }
1941 :
1942 4 : bool operator>>(Serializer& strm, XTypes::MinimalSequenceType& stru)
1943 : {
1944 4 : return (strm >> stru.collection_flag)
1945 4 : && (strm >> stru.header)
1946 8 : && (strm >> stru.element);
1947 : }
1948 :
1949 :
1950 0 : void serialized_size(const Encoding& encoding, size_t& size,
1951 : const XTypes::CompleteArrayType& stru)
1952 : {
1953 0 : serialized_size_delimiter(encoding, size);
1954 0 : primitive_serialized_size(encoding, size, stru.collection_flag);
1955 0 : serialized_size(encoding, size, stru.header);
1956 0 : serialized_size(encoding, size, stru.element);
1957 0 : }
1958 :
1959 0 : bool operator<<(Serializer& strm, const XTypes::CompleteArrayType& stru)
1960 : {
1961 0 : size_t total_size = 0;
1962 0 : serialized_size(strm.encoding(), total_size, stru);
1963 0 : if (!strm.write_delimiter(total_size)) {
1964 0 : return false;
1965 : }
1966 :
1967 0 : return (strm << stru.collection_flag)
1968 0 : && (strm << stru.header)
1969 0 : && (strm << stru.element);
1970 : }
1971 :
1972 1 : bool operator>>(Serializer& strm, XTypes::CompleteArrayType& stru)
1973 : {
1974 1 : size_t total_size = 0;
1975 1 : if (!strm.read_delimiter(total_size)) {
1976 0 : return false;
1977 : }
1978 :
1979 1 : const size_t start_pos = strm.rpos();
1980 :
1981 1 : const bool ret = (strm >> stru.collection_flag)
1982 1 : && (strm >> stru.header)
1983 2 : && (strm >> stru.element);
1984 :
1985 1 : if (ret && strm.rpos() - start_pos < total_size) {
1986 0 : strm.skip(total_size - strm.rpos() + start_pos);
1987 : }
1988 1 : return ret;
1989 : }
1990 :
1991 :
1992 0 : void serialized_size(const Encoding& encoding, size_t& size,
1993 : const XTypes::MinimalArrayType& stru)
1994 : {
1995 0 : primitive_serialized_size(encoding, size, stru.collection_flag);
1996 0 : serialized_size(encoding, size, stru.header);
1997 0 : serialized_size(encoding, size, stru.element);
1998 0 : }
1999 :
2000 0 : bool operator<<(Serializer& strm, const XTypes::MinimalArrayType& stru)
2001 : {
2002 0 : return (strm << stru.collection_flag)
2003 0 : && (strm << stru.header)
2004 0 : && (strm << stru.element);
2005 : }
2006 :
2007 1 : bool operator>>(Serializer& strm, XTypes::MinimalArrayType& stru)
2008 : {
2009 1 : return (strm >> stru.collection_flag)
2010 1 : && (strm >> stru.header)
2011 2 : && (strm >> stru.element);
2012 : }
2013 :
2014 :
2015 0 : void serialized_size(const Encoding& encoding, size_t& size,
2016 : const XTypes::CompleteMapType& stru)
2017 : {
2018 0 : primitive_serialized_size(encoding, size, stru.collection_flag);
2019 0 : serialized_size(encoding, size, stru.header);
2020 0 : serialized_size(encoding, size, stru.key);
2021 0 : serialized_size(encoding, size, stru.element);
2022 0 : }
2023 :
2024 0 : bool operator<<(Serializer& strm, const XTypes::CompleteMapType& stru)
2025 : {
2026 0 : return (strm << stru.collection_flag)
2027 0 : && (strm << stru.header)
2028 0 : && (strm << stru.key)
2029 0 : && (strm << stru.element);
2030 : }
2031 :
2032 0 : bool operator>>(Serializer& strm, XTypes::CompleteMapType& stru)
2033 : {
2034 0 : return (strm >> stru.collection_flag)
2035 0 : && (strm >> stru.header)
2036 0 : && (strm >> stru.key)
2037 0 : && (strm >> stru.element);
2038 : }
2039 :
2040 :
2041 0 : void serialized_size(const Encoding& encoding, size_t& size,
2042 : const XTypes::MinimalMapType& stru)
2043 : {
2044 0 : primitive_serialized_size(encoding, size, stru.collection_flag);
2045 0 : serialized_size(encoding, size, stru.header);
2046 0 : serialized_size(encoding, size, stru.key);
2047 0 : serialized_size(encoding, size, stru.element);
2048 0 : }
2049 :
2050 0 : bool operator<<(Serializer& strm, const XTypes::MinimalMapType& stru)
2051 : {
2052 0 : return (strm << stru.collection_flag)
2053 0 : && (strm << stru.header)
2054 0 : && (strm << stru.key)
2055 0 : && (strm << stru.element);
2056 : }
2057 :
2058 0 : bool operator>>(Serializer& strm, XTypes::MinimalMapType& stru)
2059 : {
2060 0 : return (strm >> stru.collection_flag)
2061 0 : && (strm >> stru.header)
2062 0 : && (strm >> stru.key)
2063 0 : && (strm >> stru.element);
2064 : }
2065 :
2066 :
2067 14 : void serialized_size(const Encoding& encoding, size_t& size,
2068 : const XTypes::CompleteEnumeratedHeader& stru)
2069 : {
2070 14 : serialized_size_delimiter(encoding, size);
2071 14 : serialized_size(encoding, size, stru.common);
2072 14 : serialized_size(encoding, size, stru.detail);
2073 14 : }
2074 :
2075 0 : bool operator<<(Serializer& strm, const XTypes::CompleteEnumeratedHeader& stru)
2076 : {
2077 0 : size_t total_size = 0;
2078 0 : serialized_size(strm.encoding(), total_size, stru);
2079 0 : if (!strm.write_delimiter(total_size)) {
2080 0 : return false;
2081 : }
2082 :
2083 0 : return (strm << stru.common)
2084 0 : && (strm << stru.detail);
2085 : }
2086 :
2087 6 : bool operator>>(Serializer& strm, XTypes::CompleteEnumeratedHeader& stru)
2088 : {
2089 6 : size_t total_size = 0;
2090 6 : if (!strm.read_delimiter(total_size)) {
2091 0 : return false;
2092 : }
2093 :
2094 6 : const size_t start_pos = strm.rpos();
2095 :
2096 6 : const bool ret = (strm >> stru.common)
2097 6 : && (strm >> stru.detail);
2098 :
2099 6 : if (ret && strm.rpos() - start_pos < total_size) {
2100 0 : strm.skip(total_size - strm.rpos() + start_pos);
2101 : }
2102 6 : return ret;
2103 : }
2104 :
2105 14 : void serialized_size(const Encoding& encoding, size_t& size,
2106 : const XTypes::MinimalEnumeratedHeader& stru)
2107 : {
2108 14 : serialized_size_delimiter(encoding, size);
2109 14 : serialized_size(encoding, size, stru.common);
2110 14 : }
2111 :
2112 0 : bool operator<<(Serializer& strm, const XTypes::MinimalEnumeratedHeader& stru)
2113 : {
2114 0 : size_t total_size = 0;
2115 0 : serialized_size(strm.encoding(), total_size, stru);
2116 0 : if (!strm.write_delimiter(total_size)) {
2117 0 : return false;
2118 : }
2119 :
2120 0 : return (strm << stru.common);
2121 : }
2122 :
2123 4 : bool operator>>(Serializer& strm, XTypes::MinimalEnumeratedHeader& stru)
2124 : {
2125 4 : size_t total_size = 0;
2126 4 : if (!strm.read_delimiter(total_size)) {
2127 0 : return false;
2128 : }
2129 :
2130 4 : const size_t start_pos = strm.rpos();
2131 :
2132 4 : const bool ret = (strm >> stru.common);
2133 :
2134 4 : if (ret && strm.rpos() - start_pos < total_size) {
2135 0 : strm.skip(total_size - strm.rpos() + start_pos);
2136 : }
2137 4 : return ret;
2138 : }
2139 :
2140 :
2141 14 : void serialized_size(const Encoding& encoding, size_t& size,
2142 : const XTypes::CompleteEnumeratedType& stru)
2143 : {
2144 14 : primitive_serialized_size(encoding, size, stru.enum_flags);
2145 14 : serialized_size(encoding, size, stru.header);
2146 14 : serialized_size(encoding, size, stru.literal_seq);
2147 14 : }
2148 :
2149 0 : bool operator<<(Serializer& strm, const XTypes::CompleteEnumeratedType& stru)
2150 : {
2151 0 : return (strm << stru.enum_flags)
2152 0 : && (strm << stru.header)
2153 0 : && (strm << stru.literal_seq);
2154 : }
2155 :
2156 6 : bool operator>>(Serializer& strm, XTypes::CompleteEnumeratedType& stru)
2157 : {
2158 6 : return (strm >> stru.enum_flags)
2159 6 : && (strm >> stru.header)
2160 12 : && (strm >> stru.literal_seq);
2161 : }
2162 :
2163 :
2164 14 : void serialized_size(const Encoding& encoding, size_t& size,
2165 : const XTypes::MinimalEnumeratedType& stru)
2166 : {
2167 14 : primitive_serialized_size(encoding, size, stru.enum_flags);
2168 14 : serialized_size(encoding, size, stru.header);
2169 14 : serialized_size(encoding, size, stru.literal_seq);
2170 14 : }
2171 :
2172 0 : bool operator<<(Serializer& strm, const XTypes::MinimalEnumeratedType& stru)
2173 : {
2174 0 : return (strm << stru.enum_flags)
2175 0 : && (strm << stru.header)
2176 0 : && (strm << stru.literal_seq);
2177 : }
2178 :
2179 4 : bool operator>>(Serializer& strm, XTypes::MinimalEnumeratedType& stru)
2180 : {
2181 4 : return (strm >> stru.enum_flags)
2182 4 : && (strm >> stru.header)
2183 8 : && (strm >> stru.literal_seq);
2184 : }
2185 :
2186 :
2187 0 : void serialized_size(const Encoding& encoding, size_t& size,
2188 : const XTypes::CompleteBitmaskType& stru)
2189 : {
2190 0 : serialized_size_delimiter(encoding, size);
2191 0 : primitive_serialized_size(encoding, size, stru.bitmask_flags);
2192 0 : serialized_size(encoding, size, stru.header);
2193 0 : serialized_size(encoding, size, stru.flag_seq);
2194 0 : }
2195 :
2196 0 : bool operator<<(Serializer& strm, const XTypes::CompleteBitmaskType& stru)
2197 : {
2198 0 : size_t total_size = 0;
2199 0 : serialized_size(strm.encoding(), total_size, stru);
2200 0 : if (!strm.write_delimiter(total_size)) {
2201 0 : return false;
2202 : }
2203 :
2204 0 : return (strm << stru.bitmask_flags)
2205 0 : && (strm << stru.header)
2206 0 : && (strm << stru.flag_seq);
2207 : }
2208 :
2209 0 : bool operator>>(Serializer& strm, XTypes::CompleteBitmaskType& stru)
2210 : {
2211 0 : size_t total_size = 0;
2212 0 : if (!strm.read_delimiter(total_size)) {
2213 0 : return false;
2214 : }
2215 :
2216 0 : const size_t start_pos = strm.rpos();
2217 :
2218 0 : const bool ret = (strm >> stru.bitmask_flags)
2219 0 : && (strm >> stru.header)
2220 0 : && (strm >> stru.flag_seq);
2221 :
2222 0 : if (ret && strm.rpos() - start_pos < total_size) {
2223 0 : strm.skip(total_size - strm.rpos() + start_pos);
2224 : }
2225 0 : return ret;
2226 : }
2227 :
2228 :
2229 0 : void serialized_size(const Encoding& encoding, size_t& size,
2230 : const XTypes::MinimalBitmaskType& stru)
2231 : {
2232 0 : serialized_size_delimiter(encoding, size);
2233 0 : primitive_serialized_size(encoding, size, stru.bitmask_flags);
2234 0 : serialized_size(encoding, size, stru.header);
2235 0 : serialized_size(encoding, size, stru.flag_seq);
2236 0 : }
2237 :
2238 0 : bool operator<<(Serializer& strm, const XTypes::MinimalBitmaskType& stru)
2239 : {
2240 0 : size_t total_size = 0;
2241 0 : serialized_size(strm.encoding(), total_size, stru);
2242 0 : if (!strm.write_delimiter(total_size)) {
2243 0 : return false;
2244 : }
2245 :
2246 0 : return (strm << stru.bitmask_flags)
2247 0 : && (strm << stru.header)
2248 0 : && (strm << stru.flag_seq);
2249 : }
2250 :
2251 0 : bool operator>>(Serializer& strm, XTypes::MinimalBitmaskType& stru)
2252 : {
2253 0 : size_t total_size = 0;
2254 0 : if (!strm.read_delimiter(total_size)) {
2255 0 : return false;
2256 : }
2257 :
2258 0 : const size_t start_pos = strm.rpos();
2259 :
2260 0 : const bool ret = (strm >> stru.bitmask_flags)
2261 0 : && (strm >> stru.header)
2262 0 : && (strm >> stru.flag_seq);
2263 :
2264 0 : if (ret && strm.rpos() - start_pos < total_size) {
2265 0 : strm.skip(total_size - strm.rpos() + start_pos);
2266 : }
2267 0 : return ret;
2268 : }
2269 :
2270 :
2271 0 : void serialized_size(const Encoding& encoding, size_t& size,
2272 : const XTypes::CompleteBitsetType& stru)
2273 : {
2274 0 : serialized_size_delimiter(encoding, size);
2275 0 : primitive_serialized_size(encoding, size, stru.bitset_flags);
2276 0 : serialized_size(encoding, size, stru.header);
2277 0 : serialized_size(encoding, size, stru.field_seq);
2278 0 : }
2279 :
2280 0 : bool operator<<(Serializer& strm, const XTypes::CompleteBitsetType& stru)
2281 : {
2282 0 : size_t total_size = 0;
2283 0 : serialized_size(strm.encoding(), total_size, stru);
2284 0 : if (!strm.write_delimiter(total_size)) {
2285 0 : return false;
2286 : }
2287 :
2288 0 : return (strm << stru.bitset_flags)
2289 0 : && (strm << stru.header)
2290 0 : && (strm << stru.field_seq);
2291 : }
2292 :
2293 0 : bool operator>>(Serializer& strm, XTypes::CompleteBitsetType& stru)
2294 : {
2295 0 : size_t total_size = 0;
2296 0 : if (!strm.read_delimiter(total_size)) {
2297 0 : return false;
2298 : }
2299 :
2300 0 : const size_t start_pos = strm.rpos();
2301 :
2302 0 : const bool ret = (strm >> stru.bitset_flags)
2303 0 : && (strm >> stru.header)
2304 0 : && (strm >> stru.field_seq);
2305 :
2306 0 : if (ret && strm.rpos() - start_pos < total_size) {
2307 0 : strm.skip(total_size - strm.rpos() + start_pos);
2308 : }
2309 0 : return ret;
2310 : }
2311 :
2312 :
2313 0 : void serialized_size(const Encoding& encoding, size_t& size,
2314 : const XTypes::MinimalBitsetType& stru)
2315 : {
2316 0 : serialized_size_delimiter(encoding, size);
2317 0 : primitive_serialized_size(encoding, size, stru.bitset_flags);
2318 0 : serialized_size(encoding, size, stru.header);
2319 0 : serialized_size(encoding, size, stru.field_seq);
2320 0 : }
2321 :
2322 0 : bool operator<<(Serializer& strm, const XTypes::MinimalBitsetType& stru)
2323 : {
2324 0 : size_t total_size = 0;
2325 0 : serialized_size(strm.encoding(), total_size, stru);
2326 0 : if (!strm.write_delimiter(total_size)) {
2327 0 : return false;
2328 : }
2329 :
2330 0 : return (strm << stru.bitset_flags)
2331 0 : && (strm << stru.header)
2332 0 : && (strm << stru.field_seq);
2333 : }
2334 :
2335 0 : bool operator>>(Serializer& strm, XTypes::MinimalBitsetType& stru)
2336 : {
2337 0 : size_t total_size = 0;
2338 0 : if (!strm.read_delimiter(total_size)) {
2339 0 : return false;
2340 : }
2341 :
2342 0 : const size_t start_pos = strm.rpos();
2343 :
2344 0 : const bool ret = (strm >> stru.bitset_flags)
2345 0 : && (strm >> stru.header)
2346 0 : && (strm >> stru.field_seq);
2347 :
2348 0 : if (ret && strm.rpos() - start_pos < total_size) {
2349 0 : strm.skip(total_size - strm.rpos() + start_pos);
2350 : }
2351 0 : return ret;
2352 : }
2353 :
2354 :
2355 0 : void serialized_size(const Encoding& encoding, size_t& size,
2356 : const XTypes::CompleteExtendedType&)
2357 : {
2358 0 : serialized_size_delimiter(encoding, size);
2359 0 : }
2360 :
2361 0 : bool operator<<(Serializer& strm, const XTypes::CompleteExtendedType&)
2362 : {
2363 0 : return XTypes::write_empty_xcdr2_nonfinal(strm);
2364 : }
2365 :
2366 0 : bool operator>>(Serializer& strm, XTypes::CompleteExtendedType&)
2367 : {
2368 0 : return XTypes::read_empty_xcdr2_nonfinal(strm);
2369 : }
2370 :
2371 :
2372 810 : void serialized_size(const Encoding& encoding, size_t& size,
2373 : const XTypes::TypeIdentifierWithSize& stru)
2374 : {
2375 810 : serialized_size_delimiter(encoding, size);
2376 810 : serialized_size(encoding, size, stru.type_id);
2377 810 : primitive_serialized_size(encoding, size, stru.typeobject_serialized_size);
2378 810 : }
2379 :
2380 0 : void serialized_size(const Encoding& encoding, size_t& size,
2381 : const NestedKeyOnly<const XTypes::TypeIdentifierWithSize>& stru)
2382 : {
2383 0 : serialized_size(encoding, size, stru.value);
2384 0 : }
2385 :
2386 162 : bool operator<<(Serializer& strm, const XTypes::TypeIdentifierWithSize& stru)
2387 : {
2388 162 : size_t total_size = 0;
2389 162 : serialized_size(strm.encoding(), total_size, stru);
2390 162 : if (!strm.write_delimiter(total_size)) {
2391 0 : return false;
2392 : }
2393 :
2394 162 : return (strm << stru.type_id)
2395 162 : && (strm << stru.typeobject_serialized_size);
2396 : }
2397 :
2398 0 : bool operator<<(Serializer& strm, const NestedKeyOnly<const XTypes::TypeIdentifierWithSize>& stru)
2399 : {
2400 0 : return (strm << stru.value);
2401 : }
2402 :
2403 78 : bool operator>>(Serializer& strm, XTypes::TypeIdentifierWithSize& stru)
2404 : {
2405 78 : size_t total_size = 0;
2406 78 : if (!strm.read_delimiter(total_size)) {
2407 0 : return false;
2408 : }
2409 :
2410 78 : const size_t start_pos = strm.rpos();
2411 :
2412 78 : const bool ret = (strm >> stru.type_id)
2413 78 : && (strm >> stru.typeobject_serialized_size);
2414 :
2415 78 : if (ret && strm.rpos() - start_pos < total_size) {
2416 0 : strm.skip(total_size - strm.rpos() + start_pos);
2417 : }
2418 78 : return ret;
2419 : }
2420 :
2421 0 : bool operator>>(Serializer& strm, NestedKeyOnly<XTypes::TypeIdentifierWithSize>& stru)
2422 : {
2423 0 : return (strm >> stru.value);
2424 : }
2425 :
2426 648 : void serialized_size(const Encoding& encoding, size_t& size,
2427 : const XTypes::TypeIdentifierWithDependencies& stru)
2428 : {
2429 648 : serialized_size_delimiter(encoding, size);
2430 648 : serialized_size(encoding, size, stru.typeid_with_size);
2431 648 : primitive_serialized_size(encoding, size, stru.dependent_typeid_count);
2432 648 : serialized_size(encoding, size, stru.dependent_typeids);
2433 648 : }
2434 :
2435 162 : bool operator<<(Serializer& strm, const XTypes::TypeIdentifierWithDependencies& stru)
2436 : {
2437 162 : size_t total_size = 0;
2438 162 : serialized_size(strm.encoding(), total_size, stru);
2439 162 : if (!strm.write_delimiter(total_size)) {
2440 0 : return false;
2441 : }
2442 :
2443 162 : return (strm << stru.typeid_with_size)
2444 162 : && (strm << stru.dependent_typeid_count)
2445 324 : && (strm << stru.dependent_typeids);
2446 : }
2447 :
2448 78 : bool operator>>(Serializer& strm, XTypes::TypeIdentifierWithDependencies& stru)
2449 : {
2450 78 : size_t total_size = 0;
2451 78 : if (!strm.read_delimiter(total_size)) {
2452 0 : return false;
2453 : }
2454 :
2455 78 : const size_t start_pos = strm.rpos();
2456 :
2457 78 : const bool ret = (strm >> stru.typeid_with_size)
2458 78 : && (strm >> stru.dependent_typeid_count)
2459 156 : && (strm >> stru.dependent_typeids);
2460 :
2461 78 : if (ret && strm.rpos() - start_pos < total_size) {
2462 0 : strm.skip(total_size - strm.rpos() + start_pos);
2463 : }
2464 78 : return ret;
2465 : }
2466 :
2467 :
2468 0 : void serialized_size(const Encoding& encoding, size_t& size,
2469 : const XTypes::AppliedAnnotation& stru)
2470 : {
2471 0 : serialized_size_delimiter(encoding, size);
2472 0 : serialized_size(encoding, size, stru.annotation_typeid);
2473 0 : serialized_size(encoding, size, stru.param_seq);
2474 0 : }
2475 :
2476 0 : bool operator<<(Serializer& strm, const XTypes::AppliedAnnotation& stru)
2477 : {
2478 0 : size_t total_size = 0;
2479 0 : serialized_size(strm.encoding(), total_size, stru);
2480 0 : if (!strm.write_delimiter(total_size)) {
2481 0 : return false;
2482 : }
2483 :
2484 0 : return (strm << stru.annotation_typeid)
2485 0 : && (strm << stru.param_seq);
2486 : }
2487 :
2488 0 : bool operator>>(Serializer& strm, XTypes::AppliedAnnotation& stru)
2489 : {
2490 0 : size_t total_size = 0;
2491 0 : if (!strm.read_delimiter(total_size)) {
2492 0 : return false;
2493 : }
2494 :
2495 0 : const size_t start_pos = strm.rpos();
2496 0 : const bool ret = (strm >> stru.annotation_typeid)
2497 0 : && (strm >> stru.param_seq);
2498 :
2499 0 : if (ret && strm.rpos() - start_pos < total_size) {
2500 0 : strm.skip(total_size - strm.rpos() + start_pos);
2501 : }
2502 0 : return ret;
2503 : }
2504 :
2505 :
2506 0 : void serialized_size(const Encoding& encoding, size_t& size,
2507 : const XTypes::AppliedBuiltinTypeAnnotations& stru)
2508 : {
2509 0 : serialized_size_delimiter(encoding, size);
2510 0 : serialized_size(encoding, size, stru.verbatim);
2511 0 : }
2512 :
2513 0 : bool operator<<(Serializer& strm, const XTypes::AppliedBuiltinTypeAnnotations& stru)
2514 : {
2515 0 : size_t total_size = 0;
2516 0 : serialized_size(strm.encoding(), total_size, stru);
2517 0 : if (!strm.write_delimiter(total_size)) {
2518 0 : return false;
2519 : }
2520 :
2521 0 : return (strm << stru.verbatim);
2522 : }
2523 :
2524 0 : bool operator>>(Serializer& strm, XTypes::AppliedBuiltinTypeAnnotations& stru)
2525 : {
2526 0 : size_t total_size = 0;
2527 0 : if (!strm.read_delimiter(total_size)) {
2528 0 : return false;
2529 : }
2530 :
2531 0 : const size_t start_pos = strm.rpos();
2532 :
2533 0 : const bool ret = (strm >> stru.verbatim);
2534 :
2535 0 : if (ret && strm.rpos() - start_pos < total_size) {
2536 0 : strm.skip(total_size - strm.rpos() + start_pos);
2537 : }
2538 0 : return ret;
2539 : }
2540 :
2541 :
2542 49 : void serialized_size(const Encoding& encoding, size_t& size,
2543 : const XTypes::CompleteAliasBody& stru)
2544 : {
2545 49 : serialized_size_delimiter(encoding, size);
2546 49 : serialized_size(encoding, size, stru.common);
2547 49 : serialized_size(encoding, size, stru.ann_builtin);
2548 49 : serialized_size(encoding, size, stru.ann_custom);
2549 49 : }
2550 :
2551 0 : bool operator<<(Serializer& strm, const XTypes::CompleteAliasBody& stru)
2552 : {
2553 0 : size_t total_size = 0;
2554 0 : serialized_size(strm.encoding(), total_size, stru);
2555 0 : if (!strm.write_delimiter(total_size)) {
2556 0 : return false;
2557 : }
2558 :
2559 0 : return (strm << stru.common)
2560 0 : && (strm << stru.ann_builtin)
2561 0 : && (strm << stru.ann_custom);
2562 : }
2563 :
2564 94 : bool operator>>(Serializer& strm, XTypes::CompleteAliasBody& stru)
2565 : {
2566 94 : size_t total_size = 0;
2567 94 : if (!strm.read_delimiter(total_size)) {
2568 0 : return false;
2569 : }
2570 :
2571 94 : const size_t start_pos = strm.rpos();
2572 :
2573 94 : const bool ret = (strm >> stru.common)
2574 94 : && (strm >> stru.ann_builtin)
2575 188 : && (strm >> stru.ann_custom);
2576 :
2577 94 : if (ret && strm.rpos() - start_pos < total_size) {
2578 0 : strm.skip(total_size - strm.rpos() + start_pos);
2579 : }
2580 94 : return ret;
2581 : }
2582 :
2583 :
2584 49 : void serialized_size(const Encoding& encoding, size_t& size,
2585 : const XTypes::CompleteAliasHeader& stru)
2586 : {
2587 49 : serialized_size_delimiter(encoding, size);
2588 49 : serialized_size(encoding, size, stru.detail);
2589 49 : }
2590 :
2591 0 : bool operator<<(Serializer& strm, const XTypes::CompleteAliasHeader& stru)
2592 : {
2593 0 : size_t total_size = 0;
2594 0 : serialized_size(strm.encoding(), total_size, stru);
2595 0 : if (!strm.write_delimiter(total_size)) {
2596 0 : return false;
2597 : }
2598 :
2599 0 : return (strm << stru.detail);
2600 : }
2601 :
2602 94 : bool operator>>(Serializer& strm, XTypes::CompleteAliasHeader& stru)
2603 : {
2604 94 : size_t total_size = 0;
2605 94 : if (!strm.read_delimiter(total_size)) {
2606 0 : return false;
2607 : }
2608 :
2609 94 : const size_t start_pos = strm.rpos();
2610 :
2611 94 : const bool ret = (strm >> stru.detail);
2612 :
2613 94 : if (ret && strm.rpos() - start_pos < total_size) {
2614 0 : strm.skip(total_size - strm.rpos() + start_pos);
2615 : }
2616 94 : return ret;
2617 : }
2618 :
2619 :
2620 0 : void serialized_size(const Encoding& encoding, size_t& size,
2621 : const XTypes::CompleteAnnotationHeader& stru)
2622 : {
2623 0 : serialized_size_delimiter(encoding, size);
2624 0 : DCPS::primitive_serialized_size_ulong(encoding, size);
2625 0 : size += ACE_OS::strlen(stru.annotation_name.c_str()) + 1;
2626 0 : }
2627 :
2628 0 : bool operator<<(Serializer& strm, const XTypes::CompleteAnnotationHeader& stru)
2629 : {
2630 0 : size_t total_size = 0;
2631 0 : serialized_size(strm.encoding(), total_size, stru);
2632 0 : if (!strm.write_delimiter(total_size)) {
2633 0 : return false;
2634 : }
2635 :
2636 0 : return (strm << Serializer::FromBoundedString<char>(stru.annotation_name, TYPE_NAME_MAX_LENGTH));
2637 : }
2638 :
2639 0 : bool operator>>(Serializer& strm, XTypes::CompleteAnnotationHeader& stru)
2640 : {
2641 0 : size_t total_size = 0;
2642 0 : if (!strm.read_delimiter(total_size)) {
2643 0 : return false;
2644 : }
2645 :
2646 0 : const size_t start_pos = strm.rpos();
2647 :
2648 0 : const bool ret = (strm >> Serializer::ToBoundedString<char>(stru.annotation_name, TYPE_NAME_MAX_LENGTH));
2649 :
2650 0 : if (ret && strm.rpos() - start_pos < total_size) {
2651 0 : strm.skip(total_size - strm.rpos() + start_pos);
2652 : }
2653 0 : return ret;
2654 : }
2655 :
2656 :
2657 0 : void serialized_size(const Encoding& encoding, size_t& size,
2658 : const XTypes::CompleteAnnotationParameter& stru)
2659 : {
2660 0 : serialized_size_delimiter(encoding, size);
2661 0 : serialized_size(encoding, size, stru.common);
2662 0 : primitive_serialized_size_ulong(encoding, size);
2663 0 : size += ACE_OS::strlen(stru.name.c_str()) + 1;
2664 0 : serialized_size(encoding, size, stru.default_value);
2665 0 : }
2666 :
2667 0 : bool operator<<(Serializer& strm, const XTypes::CompleteAnnotationParameter& stru)
2668 : {
2669 0 : size_t total_size = 0;
2670 0 : serialized_size(strm.encoding(), total_size, stru);
2671 0 : if (!strm.write_delimiter(total_size)) {
2672 0 : return false;
2673 : }
2674 :
2675 0 : return (strm << stru.common)
2676 0 : && (strm << Serializer::FromBoundedString<char>(stru.name, MEMBER_NAME_MAX_LENGTH))
2677 0 : && (strm << stru.default_value);
2678 : }
2679 :
2680 0 : bool operator>>(Serializer& strm, XTypes::CompleteAnnotationParameter& stru)
2681 : {
2682 0 : size_t total_size = 0;
2683 0 : if (!strm.read_delimiter(total_size)) {
2684 0 : return false;
2685 : }
2686 :
2687 0 : const size_t start_pos = strm.rpos();
2688 :
2689 0 : const bool ret = (strm >> stru.common)
2690 0 : && (strm >> Serializer::ToBoundedString<char>(stru.name, MEMBER_NAME_MAX_LENGTH))
2691 0 : && (strm >> stru.default_value);
2692 :
2693 0 : if (ret && strm.rpos() - start_pos < total_size) {
2694 0 : strm.skip(total_size - strm.rpos() + start_pos);
2695 : }
2696 0 : return ret;
2697 : }
2698 :
2699 :
2700 0 : void serialized_size(const Encoding& encoding, size_t& size,
2701 : const XTypes::CompleteArrayHeader& stru)
2702 : {
2703 0 : serialized_size_delimiter(encoding, size);
2704 0 : serialized_size(encoding, size, stru.common);
2705 0 : serialized_size(encoding, size, stru.detail);
2706 0 : }
2707 :
2708 0 : bool operator<<(Serializer& strm, const XTypes::CompleteArrayHeader& stru)
2709 : {
2710 0 : size_t total_size = 0;
2711 0 : serialized_size(strm.encoding(), total_size, stru);
2712 0 : if (!strm.write_delimiter(total_size)) {
2713 0 : return false;
2714 : }
2715 :
2716 0 : return (strm << stru.common)
2717 0 : && (strm << stru.detail);
2718 : }
2719 :
2720 1 : bool operator>>(Serializer& strm, XTypes::CompleteArrayHeader& stru)
2721 : {
2722 1 : size_t total_size = 0;
2723 1 : if (!strm.read_delimiter(total_size)) {
2724 0 : return false;
2725 : }
2726 :
2727 1 : const size_t start_pos = strm.rpos();
2728 :
2729 1 : const bool ret = (strm >> stru.common)
2730 1 : && (strm >> stru.detail);
2731 :
2732 1 : if (ret && strm.rpos() - start_pos < total_size) {
2733 0 : strm.skip(total_size - strm.rpos() + start_pos);
2734 : }
2735 1 : return ret;
2736 : }
2737 :
2738 :
2739 0 : void serialized_size(const Encoding& encoding, size_t& size,
2740 : const XTypes::CompleteBitfield& stru)
2741 : {
2742 0 : serialized_size_delimiter(encoding, size);
2743 0 : serialized_size(encoding, size, stru.common);
2744 0 : serialized_size(encoding, size, stru.detail);
2745 0 : }
2746 :
2747 0 : bool operator<<(Serializer& strm, const XTypes::CompleteBitfield& stru)
2748 : {
2749 0 : size_t total_size = 0;
2750 0 : serialized_size(strm.encoding(), total_size, stru);
2751 0 : if (!strm.write_delimiter(total_size)) {
2752 0 : return false;
2753 : }
2754 :
2755 0 : return (strm << stru.common)
2756 0 : && (strm << stru.detail);
2757 : }
2758 :
2759 0 : bool operator>>(Serializer& strm, XTypes::CompleteBitfield& stru)
2760 : {
2761 0 : size_t total_size = 0;
2762 0 : if (!strm.read_delimiter(total_size)) {
2763 0 : return false;
2764 : }
2765 :
2766 0 : const size_t start_pos = strm.rpos();
2767 :
2768 0 : const bool ret = (strm >> stru.common)
2769 0 : && (strm >> stru.detail);
2770 :
2771 0 : if (ret && strm.rpos() - start_pos < total_size) {
2772 0 : strm.skip(total_size - strm.rpos() + start_pos);
2773 : }
2774 0 : return ret;
2775 : }
2776 :
2777 :
2778 0 : void serialized_size(const Encoding& encoding, size_t& size,
2779 : const XTypes::CompleteBitflag& stru)
2780 : {
2781 0 : serialized_size_delimiter(encoding, size);
2782 0 : serialized_size(encoding, size, stru.common);
2783 0 : serialized_size(encoding, size, stru.detail);
2784 0 : }
2785 :
2786 0 : bool operator<<(Serializer& strm, const XTypes::CompleteBitflag& stru)
2787 : {
2788 0 : size_t total_size = 0;
2789 0 : serialized_size(strm.encoding(), total_size, stru);
2790 0 : if (!strm.write_delimiter(total_size)) {
2791 0 : return false;
2792 : }
2793 :
2794 0 : return (strm << stru.common)
2795 0 : && (strm << stru.detail);
2796 : }
2797 :
2798 0 : bool operator>>(Serializer& strm, XTypes::CompleteBitflag& stru)
2799 : {
2800 0 : size_t total_size = 0;
2801 0 : if (!strm.read_delimiter(total_size)) {
2802 0 : return false;
2803 : }
2804 :
2805 0 : const size_t start_pos = strm.rpos();
2806 :
2807 0 : const bool ret = (strm >> stru.common)
2808 0 : && (strm >> stru.detail);
2809 :
2810 0 : if (ret && strm.rpos() - start_pos < total_size) {
2811 0 : strm.skip(total_size - strm.rpos() + start_pos);
2812 : }
2813 0 : return ret;
2814 : }
2815 :
2816 :
2817 0 : void serialized_size(const Encoding& encoding, size_t& size,
2818 : const XTypes::CompleteBitsetHeader& stru)
2819 : {
2820 0 : serialized_size_delimiter(encoding, size);
2821 0 : serialized_size(encoding, size, stru.detail);
2822 0 : }
2823 :
2824 0 : bool operator<<(Serializer& strm, const XTypes::CompleteBitsetHeader& stru)
2825 : {
2826 0 : size_t total_size = 0;
2827 0 : serialized_size(strm.encoding(), total_size, stru);
2828 0 : if (!strm.write_delimiter(total_size)) {
2829 0 : return false;
2830 : }
2831 :
2832 0 : return (strm << stru.detail);
2833 : }
2834 :
2835 0 : bool operator>>(Serializer& strm, XTypes::CompleteBitsetHeader& stru)
2836 : {
2837 0 : size_t total_size = 0;
2838 0 : if (!strm.read_delimiter(total_size)) {
2839 0 : return false;
2840 : }
2841 :
2842 0 : const size_t start_pos = strm.rpos();
2843 :
2844 0 : const bool ret = (strm >> stru.detail);
2845 :
2846 0 : if (ret && strm.rpos() - start_pos < total_size) {
2847 0 : strm.skip(total_size - strm.rpos() + start_pos);
2848 : }
2849 0 : return ret;
2850 : }
2851 :
2852 :
2853 0 : void serialized_size(const Encoding& encoding, size_t& size,
2854 : const XTypes::CompleteCollectionElement& stru)
2855 : {
2856 0 : serialized_size_delimiter(encoding, size);
2857 0 : serialized_size(encoding, size, stru.common);
2858 0 : serialized_size(encoding, size, stru.detail);
2859 0 : }
2860 :
2861 0 : bool operator<<(Serializer& strm, const XTypes::CompleteCollectionElement& stru)
2862 : {
2863 0 : size_t total_size = 0;
2864 0 : serialized_size(strm.encoding(), total_size, stru);
2865 0 : if (!strm.write_delimiter(total_size)) {
2866 0 : return false;
2867 : }
2868 :
2869 0 : return (strm << stru.common)
2870 0 : && (strm << stru.detail);
2871 : }
2872 :
2873 7 : bool operator>>(Serializer& strm, XTypes::CompleteCollectionElement& stru)
2874 : {
2875 7 : size_t total_size = 0;
2876 7 : if (!strm.read_delimiter(total_size)) {
2877 0 : return false;
2878 : }
2879 :
2880 7 : const size_t start_pos = strm.rpos();
2881 :
2882 7 : const bool ret = (strm >> stru.common)
2883 7 : && (strm >> stru.detail);
2884 :
2885 7 : if (ret && strm.rpos() - start_pos < total_size) {
2886 0 : strm.skip(total_size - strm.rpos() + start_pos);
2887 : }
2888 7 : return ret;
2889 : }
2890 :
2891 :
2892 0 : void serialized_size(const Encoding& encoding, size_t& size,
2893 : const XTypes::CompleteCollectionHeader& stru)
2894 : {
2895 0 : serialized_size_delimiter(encoding, size);
2896 0 : serialized_size(encoding, size, stru.common);
2897 0 : serialized_size(encoding, size, stru.detail);
2898 0 : }
2899 :
2900 0 : bool operator<<(Serializer& strm, const XTypes::CompleteCollectionHeader& stru)
2901 : {
2902 0 : size_t total_size = 0;
2903 0 : serialized_size(strm.encoding(), total_size, stru);
2904 0 : if (!strm.write_delimiter(total_size)) {
2905 0 : return false;
2906 : }
2907 :
2908 0 : return (strm << stru.common)
2909 0 : && (strm << stru.detail);
2910 : }
2911 :
2912 6 : bool operator>>(Serializer& strm, XTypes::CompleteCollectionHeader& stru)
2913 : {
2914 6 : size_t total_size = 0;
2915 6 : if (!strm.read_delimiter(total_size)) {
2916 0 : return false;
2917 : }
2918 :
2919 6 : const size_t start_pos = strm.rpos();
2920 :
2921 6 : const bool ret = (strm >> stru.common)
2922 6 : && (strm >> stru.detail);
2923 :
2924 6 : if (ret && strm.rpos() - start_pos < total_size) {
2925 0 : strm.skip(total_size - strm.rpos() + start_pos);
2926 : }
2927 6 : return ret;
2928 : }
2929 :
2930 :
2931 34 : void serialized_size(const Encoding& encoding, size_t& size,
2932 : const XTypes::CompleteDiscriminatorMember& stru)
2933 : {
2934 34 : serialized_size_delimiter(encoding, size);
2935 34 : serialized_size(encoding, size, stru.common);
2936 34 : serialized_size(encoding, size, stru.ann_builtin);
2937 34 : serialized_size(encoding, size, stru.ann_custom);
2938 34 : }
2939 :
2940 0 : bool operator<<(Serializer& strm, const XTypes::CompleteDiscriminatorMember& stru)
2941 : {
2942 0 : size_t total_size = 0;
2943 0 : serialized_size(strm.encoding(), total_size, stru);
2944 0 : if (!strm.write_delimiter(total_size)) {
2945 0 : return false;
2946 : }
2947 :
2948 0 : return (strm << stru.common)
2949 0 : && (strm << stru.ann_builtin)
2950 0 : && (strm << stru.ann_custom);
2951 : }
2952 :
2953 29 : bool operator>>(Serializer& strm, XTypes::CompleteDiscriminatorMember& stru)
2954 : {
2955 29 : size_t total_size = 0;
2956 29 : if (!strm.read_delimiter(total_size)) {
2957 0 : return false;
2958 : }
2959 :
2960 29 : const size_t start_pos = strm.rpos();
2961 :
2962 29 : const bool ret = (strm >> stru.common)
2963 29 : && (strm >> stru.ann_builtin)
2964 58 : && (strm >> stru.ann_custom);
2965 :
2966 29 : if (ret && strm.rpos() - start_pos < total_size) {
2967 0 : strm.skip(total_size - strm.rpos() + start_pos);
2968 : }
2969 29 : return ret;
2970 : }
2971 :
2972 :
2973 65 : void serialized_size(const Encoding& encoding, size_t& size,
2974 : const XTypes::CompleteEnumeratedLiteral& stru)
2975 : {
2976 65 : serialized_size_delimiter(encoding, size);
2977 65 : serialized_size(encoding, size, stru.common);
2978 65 : serialized_size(encoding, size, stru.detail);
2979 65 : }
2980 :
2981 0 : bool operator<<(Serializer& strm, const XTypes::CompleteEnumeratedLiteral& stru)
2982 : {
2983 0 : size_t total_size = 0;
2984 0 : serialized_size(strm.encoding(), total_size, stru);
2985 0 : if (!strm.write_delimiter(total_size)) {
2986 0 : return false;
2987 : }
2988 :
2989 0 : return (strm << stru.common)
2990 0 : && (strm << stru.detail);
2991 : }
2992 :
2993 61 : bool operator>>(Serializer& strm, XTypes::CompleteEnumeratedLiteral& stru)
2994 : {
2995 61 : size_t total_size = 0;
2996 61 : if (!strm.read_delimiter(total_size)) {
2997 0 : return false;
2998 : }
2999 :
3000 61 : const size_t start_pos = strm.rpos();
3001 :
3002 61 : const bool ret = (strm >> stru.common)
3003 61 : && (strm >> stru.detail);
3004 :
3005 61 : if (ret && strm.rpos() - start_pos < total_size) {
3006 0 : strm.skip(total_size - strm.rpos() + start_pos);
3007 : }
3008 61 : return ret;
3009 : }
3010 :
3011 :
3012 283 : void serialized_size(const Encoding& encoding, size_t& size,
3013 : const XTypes::CompleteStructMember& stru)
3014 : {
3015 283 : serialized_size_delimiter(encoding, size);
3016 283 : serialized_size(encoding, size, stru.common);
3017 283 : serialized_size(encoding, size, stru.detail);
3018 283 : }
3019 :
3020 0 : bool operator<<(Serializer& strm, const XTypes::CompleteStructMember& stru)
3021 : {
3022 0 : size_t total_size = 0;
3023 0 : serialized_size(strm.encoding(), total_size, stru);
3024 0 : if (!strm.write_delimiter(total_size)) {
3025 0 : return false;
3026 : }
3027 :
3028 0 : return (strm << stru.common)
3029 0 : && (strm << stru.detail);
3030 : }
3031 :
3032 490 : bool operator>>(Serializer& strm, XTypes::CompleteStructMember& stru)
3033 : {
3034 490 : size_t total_size = 0;
3035 490 : if (!strm.read_delimiter(total_size)) {
3036 0 : return false;
3037 : }
3038 :
3039 490 : const size_t start_pos = strm.rpos();
3040 :
3041 490 : const bool ret = (strm >> stru.common)
3042 490 : && (strm >> stru.detail);
3043 :
3044 490 : if (ret && strm.rpos() - start_pos < total_size) {
3045 0 : strm.skip(total_size - strm.rpos() + start_pos);
3046 : }
3047 :
3048 490 : return ret;
3049 : }
3050 :
3051 :
3052 34 : void serialized_size(const Encoding& encoding, size_t& size,
3053 : const XTypes::CompleteUnionHeader& stru)
3054 : {
3055 34 : serialized_size_delimiter(encoding, size);
3056 34 : serialized_size(encoding, size, stru.detail);
3057 34 : }
3058 :
3059 0 : bool operator<<(Serializer& strm, const XTypes::CompleteUnionHeader& stru)
3060 : {
3061 0 : size_t total_size = 0;
3062 0 : serialized_size(strm.encoding(), total_size, stru);
3063 0 : if (!strm.write_delimiter(total_size)) {
3064 0 : return false;
3065 : }
3066 :
3067 0 : return (strm << stru.detail);
3068 : }
3069 :
3070 29 : bool operator>>(Serializer& strm, XTypes::CompleteUnionHeader& stru)
3071 : {
3072 29 : size_t total_size = 0;
3073 29 : if (!strm.read_delimiter(total_size)) {
3074 0 : return false;
3075 : }
3076 :
3077 29 : const size_t start_pos = strm.rpos();
3078 :
3079 29 : const bool ret = (strm >> stru.detail);
3080 :
3081 29 : if (ret && strm.rpos() - start_pos < total_size) {
3082 0 : strm.skip(total_size - strm.rpos() + start_pos);
3083 : }
3084 29 : return ret;
3085 : }
3086 :
3087 :
3088 99 : void serialized_size(const Encoding& encoding, size_t& size,
3089 : const XTypes::CompleteUnionMember& stru)
3090 : {
3091 99 : serialized_size_delimiter(encoding, size);
3092 99 : serialized_size(encoding, size, stru.common);
3093 99 : serialized_size(encoding, size, stru.detail);
3094 99 : }
3095 :
3096 0 : bool operator<<(Serializer& strm, const XTypes::CompleteUnionMember& stru)
3097 : {
3098 0 : size_t total_size = 0;
3099 0 : serialized_size(strm.encoding(), total_size, stru);
3100 0 : if (!strm.write_delimiter(total_size)) {
3101 0 : return false;
3102 : }
3103 :
3104 0 : return (strm << stru.common)
3105 0 : && (strm << stru.detail);
3106 : }
3107 :
3108 263 : bool operator>>(Serializer& strm, XTypes::CompleteUnionMember& stru)
3109 : {
3110 263 : size_t total_size = 0;
3111 263 : if (!strm.read_delimiter(total_size)) {
3112 0 : return false;
3113 : }
3114 :
3115 263 : const size_t start_pos = strm.rpos();
3116 :
3117 263 : const bool ret = (strm >> stru.common)
3118 263 : && (strm >> stru.detail);
3119 :
3120 263 : if (ret && strm.rpos() - start_pos < total_size) {
3121 0 : strm.skip(total_size - strm.rpos() + start_pos);
3122 : }
3123 263 : return ret;
3124 : }
3125 :
3126 :
3127 49 : void serialized_size(const Encoding& encoding, size_t& size,
3128 : const XTypes::MinimalAliasBody& stru)
3129 : {
3130 49 : serialized_size_delimiter(encoding, size);
3131 49 : serialized_size(encoding, size, stru.common);
3132 49 : }
3133 :
3134 0 : bool operator<<(Serializer& strm, const XTypes::MinimalAliasBody& stru)
3135 : {
3136 0 : size_t total_size = 0;
3137 0 : serialized_size(strm.encoding(), total_size, stru);
3138 0 : if (!strm.write_delimiter(total_size)) {
3139 0 : return false;
3140 : }
3141 :
3142 0 : return (strm << stru.common);
3143 : }
3144 :
3145 54 : bool operator>>(Serializer& strm, XTypes::MinimalAliasBody& stru)
3146 : {
3147 54 : size_t total_size = 0;
3148 54 : if (!strm.read_delimiter(total_size)) {
3149 0 : return false;
3150 : }
3151 :
3152 54 : const size_t start_pos = strm.rpos();
3153 :
3154 54 : const bool ret = (strm >> stru.common);
3155 :
3156 54 : if (ret && strm.rpos() - start_pos < total_size) {
3157 0 : strm.skip(total_size - strm.rpos() + start_pos);
3158 : }
3159 54 : return ret;
3160 : }
3161 :
3162 :
3163 49 : void serialized_size(const Encoding& encoding, size_t& size,
3164 : const XTypes::MinimalAliasHeader&)
3165 : {
3166 49 : serialized_size_delimiter(encoding, size);
3167 49 : }
3168 :
3169 0 : bool operator<<(Serializer& strm, const XTypes::MinimalAliasHeader&)
3170 : {
3171 0 : return XTypes::write_empty_xcdr2_nonfinal(strm);
3172 : }
3173 :
3174 54 : bool operator>>(Serializer& strm, XTypes::MinimalAliasHeader&)
3175 : {
3176 54 : return XTypes::read_empty_xcdr2_nonfinal(strm);
3177 : }
3178 :
3179 :
3180 0 : void serialized_size(const Encoding& encoding, size_t& size,
3181 : const XTypes::MinimalAnnotationHeader&)
3182 : {
3183 0 : serialized_size_delimiter(encoding, size);
3184 0 : }
3185 :
3186 0 : bool operator<<(Serializer& strm, const XTypes::MinimalAnnotationHeader&)
3187 : {
3188 0 : return XTypes::write_empty_xcdr2_nonfinal(strm);
3189 : }
3190 :
3191 0 : bool operator>>(Serializer& strm, XTypes::MinimalAnnotationHeader&)
3192 : {
3193 0 : return XTypes::read_empty_xcdr2_nonfinal(strm);
3194 : }
3195 :
3196 :
3197 0 : void serialized_size(const Encoding& encoding, size_t& size,
3198 : const XTypes::MinimalAnnotationParameter& stru)
3199 : {
3200 0 : serialized_size_delimiter(encoding, size);
3201 0 : XTypes::NameHash_forany stru_name_hash(const_cast<XTypes::NameHash_slice*>(stru.name_hash));
3202 0 : serialized_size(encoding, size, stru.common);
3203 0 : serialized_size(encoding, size, stru_name_hash);
3204 0 : serialized_size(encoding, size, stru.default_value);
3205 0 : }
3206 :
3207 0 : bool operator<<(Serializer& strm, const XTypes::MinimalAnnotationParameter& stru)
3208 : {
3209 0 : size_t total_size = 0;
3210 0 : serialized_size(strm.encoding(), total_size, stru);
3211 0 : if (!strm.write_delimiter(total_size)) {
3212 0 : return false;
3213 : }
3214 :
3215 0 : XTypes::NameHash_forany stru_name_hash(const_cast<XTypes::NameHash_slice*>(stru.name_hash));
3216 0 : return (strm << stru.common)
3217 0 : && (strm << stru_name_hash)
3218 0 : && (strm << stru.default_value);
3219 : }
3220 :
3221 0 : bool operator>>(Serializer& strm, XTypes::MinimalAnnotationParameter& stru)
3222 : {
3223 0 : XTypes::NameHash_forany stru_name_hash(const_cast<XTypes::NameHash_slice*>(stru.name_hash));
3224 0 : size_t total_size = 0;
3225 0 : if (!strm.read_delimiter(total_size)) {
3226 0 : return false;
3227 : }
3228 :
3229 0 : const size_t start_pos = strm.rpos();
3230 :
3231 0 : const bool ret = (strm >> stru.common)
3232 0 : && (strm >> stru_name_hash)
3233 0 : && (strm >> stru.default_value);
3234 :
3235 0 : if (ret && strm.rpos() - start_pos < total_size) {
3236 0 : strm.skip(total_size - strm.rpos() + start_pos);
3237 : }
3238 0 : return ret;
3239 : }
3240 :
3241 :
3242 0 : void serialized_size(const Encoding& encoding, size_t& size,
3243 : const XTypes::MinimalArrayHeader& stru)
3244 : {
3245 0 : serialized_size_delimiter(encoding, size);
3246 0 : serialized_size(encoding, size, stru.common);
3247 0 : }
3248 :
3249 0 : bool operator<<(Serializer& strm, const XTypes::MinimalArrayHeader& stru)
3250 : {
3251 0 : size_t total_size = 0;
3252 0 : serialized_size(strm.encoding(), total_size, stru);
3253 0 : if (!strm.write_delimiter(total_size)) {
3254 0 : return false;
3255 : }
3256 :
3257 0 : return (strm << stru.common);
3258 : }
3259 :
3260 1 : bool operator>>(Serializer& strm, XTypes::MinimalArrayHeader& stru)
3261 : {
3262 1 : size_t total_size = 0;
3263 1 : if (!strm.read_delimiter(total_size)) {
3264 0 : return false;
3265 : }
3266 :
3267 1 : const size_t start_pos = strm.rpos();
3268 :
3269 1 : const bool ret = (strm >> stru.common);
3270 :
3271 1 : if (ret && strm.rpos() - start_pos < total_size) {
3272 0 : strm.skip(total_size - strm.rpos() + start_pos);
3273 : }
3274 1 : return ret;
3275 : }
3276 :
3277 :
3278 0 : void serialized_size(const Encoding& encoding, size_t& size,
3279 : const XTypes::MinimalBitfield& stru)
3280 : {
3281 0 : serialized_size_delimiter(encoding, size);
3282 0 : XTypes::NameHash_forany stru_name_hash(const_cast<XTypes::NameHash_slice*>(stru.name_hash));
3283 0 : serialized_size(encoding, size, stru.common);
3284 0 : serialized_size(encoding, size, stru_name_hash);
3285 0 : }
3286 :
3287 0 : bool operator<<(Serializer& strm, const XTypes::MinimalBitfield& stru)
3288 : {
3289 0 : size_t total_size = 0;
3290 0 : serialized_size(strm.encoding(), total_size, stru);
3291 0 : if (!strm.write_delimiter(total_size)) {
3292 0 : return false;
3293 : }
3294 :
3295 0 : XTypes::NameHash_forany stru_name_hash(const_cast<XTypes::NameHash_slice*>(stru.name_hash));
3296 0 : return (strm << stru.common)
3297 0 : && (strm << stru_name_hash);
3298 : }
3299 :
3300 0 : bool operator>>(Serializer& strm, XTypes::MinimalBitfield& stru)
3301 : {
3302 0 : XTypes::NameHash_forany stru_name_hash(const_cast<XTypes::NameHash_slice*>(stru.name_hash));
3303 0 : size_t total_size = 0;
3304 0 : if (!strm.read_delimiter(total_size)) {
3305 0 : return false;
3306 : }
3307 :
3308 0 : const size_t start_pos = strm.rpos();
3309 :
3310 0 : const bool ret = (strm >> stru.common)
3311 0 : && (strm >> stru_name_hash);
3312 :
3313 0 : if (ret && strm.rpos() - start_pos < total_size) {
3314 0 : strm.skip(total_size - strm.rpos() + start_pos);
3315 : }
3316 0 : return ret;
3317 : }
3318 :
3319 :
3320 0 : void serialized_size(const Encoding& encoding, size_t& size,
3321 : const XTypes::MinimalBitflag& stru)
3322 : {
3323 0 : serialized_size_delimiter(encoding, size);
3324 0 : serialized_size(encoding, size, stru.common);
3325 0 : serialized_size(encoding, size, stru.detail);
3326 0 : }
3327 :
3328 0 : bool operator<<(Serializer& strm, const XTypes::MinimalBitflag& stru)
3329 : {
3330 0 : size_t total_size = 0;
3331 0 : serialized_size(strm.encoding(), total_size, stru);
3332 0 : if (!strm.write_delimiter(total_size)) {
3333 0 : return false;
3334 : }
3335 :
3336 0 : return (strm << stru.common)
3337 0 : && (strm << stru.detail);
3338 : }
3339 :
3340 0 : bool operator>>(Serializer& strm, XTypes::MinimalBitflag& stru)
3341 : {
3342 0 : size_t total_size = 0;
3343 0 : if (!strm.read_delimiter(total_size)) {
3344 0 : return false;
3345 : }
3346 :
3347 0 : const size_t start_pos = strm.rpos();
3348 :
3349 0 : const bool ret = (strm >> stru.common)
3350 0 : && (strm >> stru.detail);
3351 :
3352 0 : if (ret && strm.rpos() - start_pos < total_size) {
3353 0 : strm.skip(total_size - strm.rpos() + start_pos);
3354 : }
3355 0 : return ret;
3356 : }
3357 :
3358 :
3359 0 : void serialized_size(const Encoding& encoding, size_t& size,
3360 : const XTypes::MinimalBitsetHeader&)
3361 : {
3362 0 : serialized_size_delimiter(encoding, size);
3363 0 : }
3364 :
3365 0 : bool operator<<(Serializer& strm, const XTypes::MinimalBitsetHeader&)
3366 : {
3367 0 : return XTypes::write_empty_xcdr2_nonfinal(strm);
3368 : }
3369 :
3370 0 : bool operator>>(Serializer& strm, XTypes::MinimalBitsetHeader&)
3371 : {
3372 0 : return XTypes::read_empty_xcdr2_nonfinal(strm);
3373 : }
3374 :
3375 :
3376 0 : void serialized_size(const Encoding& encoding, size_t& size,
3377 : const XTypes::MinimalCollectionElement& stru)
3378 : {
3379 0 : serialized_size_delimiter(encoding, size);
3380 0 : serialized_size(encoding, size, stru.common);
3381 0 : }
3382 :
3383 0 : bool operator<<(Serializer& strm, const XTypes::MinimalCollectionElement& stru)
3384 : {
3385 0 : size_t total_size = 0;
3386 0 : serialized_size(strm.encoding(), total_size, stru);
3387 0 : if (!strm.write_delimiter(total_size)) {
3388 0 : return false;
3389 : }
3390 :
3391 0 : return (strm << stru.common);
3392 : }
3393 :
3394 5 : bool operator>>(Serializer& strm, XTypes::MinimalCollectionElement& stru)
3395 : {
3396 5 : size_t total_size = 0;
3397 5 : if (!strm.read_delimiter(total_size)) {
3398 0 : return false;
3399 : }
3400 :
3401 5 : const size_t start_pos = strm.rpos();
3402 :
3403 5 : const bool ret = (strm >> stru.common);
3404 :
3405 5 : if (ret && strm.rpos() - start_pos < total_size) {
3406 0 : strm.skip(total_size - strm.rpos() + start_pos);
3407 : }
3408 5 : return ret;
3409 : }
3410 :
3411 :
3412 0 : void serialized_size(const Encoding& encoding, size_t& size,
3413 : const XTypes::MinimalCollectionHeader& stru)
3414 : {
3415 0 : serialized_size_delimiter(encoding, size);
3416 0 : serialized_size(encoding, size, stru.common);
3417 0 : }
3418 :
3419 0 : bool operator<<(Serializer& strm, const XTypes::MinimalCollectionHeader& stru)
3420 : {
3421 0 : size_t total_size = 0;
3422 0 : serialized_size(strm.encoding(), total_size, stru);
3423 0 : if (!strm.write_delimiter(total_size)) {
3424 0 : return false;
3425 : }
3426 :
3427 0 : return (strm << stru.common);
3428 : }
3429 :
3430 4 : bool operator>>(Serializer& strm, XTypes::MinimalCollectionHeader& stru)
3431 : {
3432 4 : size_t total_size = 0;
3433 4 : if (!strm.read_delimiter(total_size)) {
3434 0 : return false;
3435 : }
3436 :
3437 4 : const size_t start_pos = strm.rpos();
3438 :
3439 4 : const bool ret = (strm >> stru.common);
3440 :
3441 4 : if (ret && strm.rpos() - start_pos < total_size) {
3442 0 : strm.skip(total_size - strm.rpos() + start_pos);
3443 : }
3444 4 : return ret;
3445 : }
3446 :
3447 :
3448 34 : void serialized_size(const Encoding& encoding, size_t& size,
3449 : const XTypes::MinimalDiscriminatorMember& stru)
3450 : {
3451 34 : serialized_size_delimiter(encoding, size);
3452 34 : serialized_size(encoding, size, stru.common);
3453 34 : }
3454 :
3455 0 : bool operator<<(Serializer& strm, const XTypes::MinimalDiscriminatorMember& stru)
3456 : {
3457 0 : size_t total_size = 0;
3458 0 : serialized_size(strm.encoding(), total_size, stru);
3459 0 : if (!strm.write_delimiter(total_size)) {
3460 0 : return false;
3461 : }
3462 :
3463 0 : return (strm << stru.common);
3464 : }
3465 :
3466 10 : bool operator>>(Serializer& strm, XTypes::MinimalDiscriminatorMember& stru)
3467 : {
3468 10 : size_t total_size = 0;
3469 10 : if (!strm.read_delimiter(total_size)) {
3470 0 : return false;
3471 : }
3472 :
3473 10 : const size_t start_pos = strm.rpos();
3474 :
3475 10 : const bool ret = (strm >> stru.common);
3476 :
3477 10 : if (ret && strm.rpos() - start_pos < total_size) {
3478 0 : strm.skip(total_size - strm.rpos() + start_pos);
3479 : }
3480 10 : return ret;
3481 : }
3482 :
3483 :
3484 65 : void serialized_size(const Encoding& encoding, size_t& size,
3485 : const XTypes::MinimalEnumeratedLiteral& stru)
3486 : {
3487 65 : serialized_size_delimiter(encoding, size);
3488 65 : serialized_size(encoding, size, stru.common);
3489 65 : serialized_size(encoding, size, stru.detail);
3490 65 : }
3491 :
3492 0 : bool operator<<(Serializer& strm, const XTypes::MinimalEnumeratedLiteral& stru)
3493 : {
3494 0 : size_t total_size = 0;
3495 0 : serialized_size(strm.encoding(), total_size, stru);
3496 0 : if (!strm.write_delimiter(total_size)) {
3497 0 : return false;
3498 : }
3499 :
3500 0 : return (strm << stru.common)
3501 0 : && (strm << stru.detail);
3502 : }
3503 :
3504 27 : bool operator>>(Serializer& strm, XTypes::MinimalEnumeratedLiteral& stru)
3505 : {
3506 27 : size_t total_size = 0;
3507 27 : if (!strm.read_delimiter(total_size)) {
3508 0 : return false;
3509 : }
3510 :
3511 27 : const size_t start_pos = strm.rpos();
3512 :
3513 27 : const bool ret = (strm >> stru.common)
3514 27 : && (strm >> stru.detail);
3515 :
3516 27 : if (ret && strm.rpos() - start_pos < total_size) {
3517 0 : strm.skip(total_size - strm.rpos() + start_pos);
3518 : }
3519 27 : return ret;
3520 : }
3521 :
3522 :
3523 290 : void serialized_size(const Encoding& encoding, size_t& size,
3524 : const XTypes::MinimalStructMember& stru)
3525 : {
3526 290 : serialized_size_delimiter(encoding, size);
3527 290 : serialized_size(encoding, size, stru.common);
3528 290 : serialized_size(encoding, size, stru.detail);
3529 290 : }
3530 :
3531 2 : bool operator<<(Serializer& strm, const XTypes::MinimalStructMember& stru)
3532 : {
3533 2 : size_t total_size = 0;
3534 2 : serialized_size(strm.encoding(), total_size, stru);
3535 2 : if (!strm.write_delimiter(total_size)) {
3536 0 : return false;
3537 : }
3538 :
3539 2 : return (strm << stru.common)
3540 2 : && (strm << stru.detail);
3541 : }
3542 :
3543 188 : bool operator>>(Serializer& strm, XTypes::MinimalStructMember& stru)
3544 : {
3545 188 : size_t total_size = 0;
3546 188 : if (!strm.read_delimiter(total_size)) {
3547 0 : return false;
3548 : }
3549 :
3550 188 : const size_t start_pos = strm.rpos();
3551 :
3552 188 : const bool ret = (strm >> stru.common)
3553 188 : && (strm >> stru.detail);
3554 :
3555 188 : if (ret && strm.rpos() - start_pos < total_size) {
3556 0 : strm.skip(total_size - strm.rpos() + start_pos);
3557 : }
3558 188 : return ret;
3559 : }
3560 :
3561 :
3562 34 : void serialized_size(const Encoding& encoding, size_t& size,
3563 : const XTypes::MinimalUnionHeader& stru)
3564 : {
3565 34 : serialized_size_delimiter(encoding, size);
3566 34 : serialized_size(encoding, size, stru.detail);
3567 34 : }
3568 :
3569 0 : bool operator<<(Serializer& strm, const XTypes::MinimalUnionHeader& stru)
3570 : {
3571 0 : size_t total_size = 0;
3572 0 : serialized_size(strm.encoding(), total_size, stru);
3573 0 : if (!strm.write_delimiter(total_size)) {
3574 0 : return false;
3575 : }
3576 :
3577 0 : return (strm << stru.detail);
3578 : }
3579 :
3580 10 : bool operator>>(Serializer& strm, XTypes::MinimalUnionHeader& stru)
3581 : {
3582 10 : size_t total_size = 0;
3583 10 : if (!strm.read_delimiter(total_size)) {
3584 0 : return false;
3585 : }
3586 :
3587 10 : const size_t start_pos = strm.rpos();
3588 :
3589 10 : const bool ret = (strm >> stru.detail);
3590 :
3591 10 : if (ret && strm.rpos() - start_pos < total_size) {
3592 0 : strm.skip(total_size - strm.rpos() + start_pos);
3593 : }
3594 10 : return ret;
3595 : }
3596 :
3597 :
3598 99 : void serialized_size(const Encoding& encoding, size_t& size,
3599 : const XTypes::MinimalUnionMember& stru)
3600 : {
3601 99 : serialized_size_delimiter(encoding, size);
3602 99 : serialized_size(encoding, size, stru.common);
3603 99 : serialized_size(encoding, size, stru.detail);
3604 99 : }
3605 :
3606 0 : bool operator<<(Serializer& strm, const XTypes::MinimalUnionMember& stru)
3607 : {
3608 0 : size_t total_size = 0;
3609 0 : serialized_size(strm.encoding(), total_size, stru);
3610 0 : if (!strm.write_delimiter(total_size)) {
3611 0 : return false;
3612 : }
3613 :
3614 0 : return (strm << stru.common)
3615 0 : && (strm << stru.detail);
3616 : }
3617 :
3618 40 : bool operator>>(Serializer& strm, XTypes::MinimalUnionMember& stru)
3619 : {
3620 40 : size_t total_size = 0;
3621 40 : if (!strm.read_delimiter(total_size)) {
3622 0 : return false;
3623 : }
3624 :
3625 40 : const size_t start_pos = strm.rpos();
3626 :
3627 40 : const bool ret = (strm >> stru.common)
3628 40 : && (strm >> stru.detail);
3629 :
3630 40 : if (ret && strm.rpos() - start_pos < total_size) {
3631 0 : strm.skip(total_size - strm.rpos() + start_pos);
3632 : }
3633 40 : return ret;
3634 : }
3635 :
3636 :
3637 0 : void serialized_size(const Encoding& encoding, size_t& size,
3638 : const XTypes::AnnotationParameterValue& uni)
3639 : {
3640 0 : primitive_serialized_size(encoding, size, ACE_OutputCDR::from_octet(uni.kind()));
3641 0 : switch (uni.kind()) {
3642 0 : case XTypes::TK_BOOLEAN: {
3643 0 : primitive_serialized_size(encoding, size, ACE_OutputCDR::from_boolean(uni.boolean_value()));
3644 0 : break;
3645 : }
3646 0 : case XTypes::TK_BYTE: {
3647 0 : primitive_serialized_size(encoding, size, ACE_OutputCDR::from_octet(uni.byte_value()));
3648 0 : break;
3649 : }
3650 0 : case XTypes::TK_INT16: {
3651 0 : primitive_serialized_size(encoding, size, uni.int16_value());
3652 0 : break;
3653 : }
3654 0 : case XTypes::TK_UINT16: {
3655 0 : primitive_serialized_size(encoding, size, uni.uint16_value());
3656 0 : break;
3657 : }
3658 0 : case XTypes::TK_INT32: {
3659 0 : primitive_serialized_size(encoding, size, uni.int32_value());
3660 0 : break;
3661 : }
3662 0 : case XTypes::TK_UINT32: {
3663 0 : primitive_serialized_size(encoding, size, uni.uint32_value());
3664 0 : break;
3665 : }
3666 0 : case XTypes::TK_INT64: {
3667 0 : primitive_serialized_size(encoding, size, uni.int64_value());
3668 0 : break;
3669 : }
3670 0 : case XTypes::TK_UINT64: {
3671 0 : primitive_serialized_size(encoding, size, uni.uint64_value());
3672 0 : break;
3673 : }
3674 0 : case XTypes::TK_FLOAT32: {
3675 0 : primitive_serialized_size(encoding, size, uni.float32_value());
3676 0 : break;
3677 : }
3678 0 : case XTypes::TK_FLOAT64: {
3679 0 : primitive_serialized_size(encoding, size, uni.float64_value());
3680 0 : break;
3681 : }
3682 0 : case XTypes::TK_FLOAT128: {
3683 0 : primitive_serialized_size(encoding, size, uni.float128_value());
3684 0 : break;
3685 : }
3686 0 : case XTypes::TK_CHAR8: {
3687 0 : primitive_serialized_size(encoding, size, ACE_OutputCDR::from_char(uni.char_value()));
3688 0 : break;
3689 : }
3690 0 : case XTypes::TK_CHAR16: {
3691 0 : primitive_serialized_size(encoding, size, ACE_OutputCDR::from_wchar(uni.wchar_value()));
3692 0 : break;
3693 : }
3694 0 : case XTypes::TK_ENUM: {
3695 0 : primitive_serialized_size(encoding, size, uni.enumerated_value());
3696 0 : break;
3697 : }
3698 0 : case XTypes::TK_STRING8: {
3699 0 : DCPS::primitive_serialized_size_ulong(encoding, size);
3700 0 : size += ACE_OS::strlen(uni.string8_value().c_str()) + 1;
3701 0 : break;
3702 : }
3703 0 : case XTypes::TK_STRING16: {
3704 : #ifdef DDS_HAS_WCHAR
3705 0 : DCPS::primitive_serialized_size_ulong(encoding, size);
3706 0 : size += ACE_OS::strlen(uni.string16_value().c_str()) * DCPS::char16_cdr_size;
3707 : #endif
3708 0 : break;
3709 : }
3710 0 : default: {
3711 0 : serialized_size(encoding, size, uni.extended_value());
3712 0 : break;
3713 : }
3714 : }
3715 0 : }
3716 :
3717 0 : bool operator<<(Serializer& strm, const XTypes::AnnotationParameterValue& uni)
3718 : {
3719 0 : if (!(strm << ACE_OutputCDR::from_octet(uni.kind()))) {
3720 0 : return false;
3721 : }
3722 0 : switch (uni.kind()) {
3723 0 : case XTypes::TK_BOOLEAN: {
3724 0 : return (strm << ACE_OutputCDR::from_boolean(uni.boolean_value()));
3725 : }
3726 0 : case XTypes::TK_BYTE: {
3727 0 : return (strm << ACE_OutputCDR::from_octet(uni.byte_value()));
3728 : }
3729 0 : case XTypes::TK_INT16: {
3730 0 : return (strm << uni.int16_value());
3731 : }
3732 0 : case XTypes::TK_UINT16: {
3733 0 : return (strm << uni.uint16_value());
3734 : }
3735 0 : case XTypes::TK_INT32: {
3736 0 : return (strm << uni.int32_value());
3737 : }
3738 0 : case XTypes::TK_UINT32: {
3739 0 : return (strm << uni.uint32_value());
3740 : }
3741 0 : case XTypes::TK_INT64: {
3742 0 : return (strm << uni.int64_value());
3743 : }
3744 0 : case XTypes::TK_UINT64: {
3745 0 : return (strm << uni.uint64_value());
3746 : }
3747 0 : case XTypes::TK_FLOAT32: {
3748 0 : return (strm << uni.float32_value());
3749 : }
3750 0 : case XTypes::TK_FLOAT64: {
3751 0 : return (strm << uni.float64_value());
3752 : }
3753 0 : case XTypes::TK_FLOAT128: {
3754 0 : return (strm << uni.float128_value());
3755 : }
3756 0 : case XTypes::TK_CHAR8: {
3757 0 : return (strm << ACE_OutputCDR::from_char(uni.char_value()));
3758 : }
3759 0 : case XTypes::TK_CHAR16: {
3760 0 : return (strm << ACE_OutputCDR::from_wchar(uni.wchar_value()));
3761 : }
3762 0 : case XTypes::TK_ENUM: {
3763 0 : return (strm << uni.enumerated_value());
3764 : }
3765 0 : case XTypes::TK_STRING8: {
3766 0 : return (strm << Serializer::FromBoundedString<char>(uni.string8_value(), 128));
3767 : }
3768 0 : case XTypes::TK_STRING16: {
3769 : #ifdef DDS_HAS_WCHAR
3770 0 : return (strm << Serializer::FromBoundedString<wchar_t>(uni.string16_value(), 128));
3771 : #else
3772 : return false;
3773 : #endif
3774 : }
3775 0 : default: {
3776 0 : return (strm << uni.extended_value());
3777 : }
3778 : }
3779 : }
3780 :
3781 0 : bool operator>>(Serializer& strm, XTypes::AnnotationParameterValue& uni)
3782 : {
3783 : ACE_CDR::Octet kind;
3784 0 : if (!(strm >> ACE_InputCDR::to_octet(kind))) {
3785 0 : return false;
3786 : }
3787 0 : uni = XTypes::AnnotationParameterValue(kind);
3788 :
3789 0 : switch (kind) {
3790 0 : case XTypes::TK_BOOLEAN:
3791 0 : return (strm >> ACE_InputCDR::to_boolean(uni.boolean_value()));
3792 0 : case XTypes::TK_BYTE:
3793 0 : return (strm >> ACE_InputCDR::to_octet(uni.byte_value()));
3794 0 : case XTypes::TK_INT16:
3795 0 : return (strm >> uni.int16_value());
3796 0 : case XTypes::TK_UINT16:
3797 0 : return (strm >> uni.uint16_value());
3798 0 : case XTypes::TK_INT32:
3799 0 : return (strm >> uni.int32_value());
3800 0 : case XTypes::TK_UINT32:
3801 0 : return (strm >> uni.uint32_value());
3802 0 : case XTypes::TK_INT64:
3803 0 : return (strm >> uni.int64_value());
3804 0 : case XTypes::TK_UINT64:
3805 0 : return (strm >> uni.uint64_value());
3806 0 : case XTypes::TK_FLOAT32:
3807 0 : return (strm >> uni.float32_value());
3808 0 : case XTypes::TK_FLOAT64:
3809 0 : return (strm >> uni.float64_value());
3810 0 : case XTypes::TK_FLOAT128:
3811 0 : return (strm >> uni.float128_value());
3812 0 : case XTypes::TK_CHAR8:
3813 0 : return (strm >> ACE_InputCDR::to_char(uni.char_value()));
3814 0 : case XTypes::TK_CHAR16:
3815 0 : return (strm >> ACE_InputCDR::to_wchar(uni.wchar_value()));
3816 0 : case XTypes::TK_ENUM:
3817 0 : return (strm >> uni.enumerated_value());
3818 0 : case XTypes::TK_STRING8:
3819 0 : return (strm >> Serializer::ToBoundedString<char>(uni.string8_value(), 128));
3820 0 : case XTypes::TK_STRING16:
3821 : #ifdef DDS_HAS_WCHAR
3822 0 : return (strm >> Serializer::ToBoundedString<wchar_t>(uni.string16_value(), 128));
3823 : #endif
3824 : return false;
3825 0 : default:
3826 0 : return (strm >> uni.extended_value());
3827 : }
3828 : }
3829 :
3830 :
3831 0 : void serialized_size(const Encoding& encoding, size_t& size,
3832 : const XTypes::AppliedAnnotationParameter& stru)
3833 : {
3834 0 : serialized_size_delimiter(encoding, size);
3835 0 : XTypes::NameHash_forany stru_paramname_hash(const_cast<XTypes::NameHash_slice*>(stru.paramname_hash));
3836 0 : serialized_size(encoding, size, stru_paramname_hash);
3837 0 : serialized_size(encoding, size, stru.value);
3838 0 : }
3839 :
3840 0 : bool operator<<(Serializer& strm, const XTypes::AppliedAnnotationParameter& stru)
3841 : {
3842 0 : size_t total_size = 0;
3843 0 : serialized_size(strm.encoding(), total_size, stru);
3844 0 : if (!strm.write_delimiter(total_size)) {
3845 0 : return false;
3846 : }
3847 :
3848 0 : XTypes::NameHash_forany stru_paramname_hash(const_cast<XTypes::NameHash_slice*>(stru.paramname_hash));
3849 0 : return (strm << stru_paramname_hash)
3850 0 : && (strm << stru.value);
3851 : }
3852 :
3853 0 : bool operator>>(Serializer& strm, XTypes::AppliedAnnotationParameter& stru)
3854 : {
3855 0 : size_t total_size = 0;
3856 0 : if (!strm.read_delimiter(total_size)) {
3857 0 : return false;
3858 : }
3859 :
3860 0 : const size_t start_pos = strm.rpos();
3861 :
3862 0 : XTypes::NameHash_forany stru_paramname_hash(const_cast<XTypes::NameHash_slice*>(stru.paramname_hash));
3863 0 : const bool ret = (strm >> stru_paramname_hash)
3864 0 : && (strm >> stru.value);
3865 :
3866 0 : if (ret && strm.rpos() - start_pos < total_size) {
3867 0 : strm.skip(total_size - strm.rpos() + start_pos);
3868 : }
3869 0 : return ret;
3870 : }
3871 :
3872 :
3873 0 : void serialized_size(const Encoding& encoding, size_t& size,
3874 : const XTypes::AppliedBuiltinMemberAnnotations& stru)
3875 : {
3876 0 : serialized_size_delimiter(encoding, size);
3877 :
3878 0 : size += DCPS::boolean_cdr_size;
3879 0 : if (stru.unit) {
3880 0 : DCPS::primitive_serialized_size_ulong(encoding, size);
3881 0 : size += ACE_OS::strlen(stru.unit.value().c_str()) + 1;
3882 : }
3883 :
3884 0 : serialized_size(encoding, size, stru.min);
3885 0 : serialized_size(encoding, size, stru.max);
3886 :
3887 0 : size += DCPS::boolean_cdr_size;
3888 0 : if (stru.hash_id) {
3889 0 : DCPS::primitive_serialized_size_ulong(encoding, size);
3890 0 : size += ACE_OS::strlen(stru.hash_id.value().c_str()) + 1;
3891 : }
3892 0 : }
3893 :
3894 0 : bool operator<<(Serializer& strm, const XTypes::AppliedBuiltinMemberAnnotations& stru)
3895 : {
3896 0 : size_t total_size = 0;
3897 0 : serialized_size(strm.encoding(), total_size, stru);
3898 0 : if (!strm.write_delimiter(total_size)) {
3899 0 : return false;
3900 : }
3901 :
3902 0 : return (strm << stru.unit)
3903 0 : && (strm << stru.min)
3904 0 : && (strm << stru.max)
3905 0 : && (strm << stru.hash_id);
3906 : }
3907 :
3908 0 : bool operator>>(Serializer& strm, XTypes::AppliedBuiltinMemberAnnotations& stru)
3909 : {
3910 0 : size_t total_size = 0;
3911 0 : if (!strm.read_delimiter(total_size)) {
3912 0 : return false;
3913 : }
3914 :
3915 0 : const size_t start_pos = strm.rpos();
3916 :
3917 0 : const bool ret = (strm >> stru.unit)
3918 0 : && (strm >> stru.min)
3919 0 : && (strm >> stru.max)
3920 0 : && (strm >> stru.hash_id);
3921 :
3922 0 : if (ret && strm.rpos() - start_pos < total_size) {
3923 0 : strm.skip(total_size - strm.rpos() + start_pos);
3924 : }
3925 0 : return ret;
3926 : }
3927 :
3928 :
3929 0 : void serialized_size(const Encoding& encoding, size_t& size,
3930 : const XTypes::AppliedVerbatimAnnotation& stru)
3931 : {
3932 0 : DCPS::primitive_serialized_size_ulong(encoding, size);
3933 0 : size += ACE_OS::strlen(stru.placement.c_str()) + 1;
3934 0 : DCPS::primitive_serialized_size_ulong(encoding, size);
3935 0 : size += ACE_OS::strlen(stru.language.c_str()) + 1;
3936 0 : DCPS::primitive_serialized_size_ulong(encoding, size);
3937 0 : size += ACE_OS::strlen(stru.text.c_str()) + 1;
3938 0 : }
3939 :
3940 0 : bool operator<<(Serializer& strm, const XTypes::AppliedVerbatimAnnotation& stru)
3941 : {
3942 0 : return (strm << Serializer::FromBoundedString<char>(stru.placement, 32))
3943 0 : && (strm << Serializer::FromBoundedString<char>(stru.language, 32))
3944 0 : && (strm << stru.text);
3945 : }
3946 :
3947 0 : bool operator>>(Serializer& strm, XTypes::AppliedVerbatimAnnotation& stru)
3948 : {
3949 0 : return (strm >> Serializer::ToBoundedString<char>(stru.placement, 32))
3950 0 : && (strm >> Serializer::ToBoundedString<char>(stru.language, 32))
3951 0 : && (strm >> stru.text);
3952 : }
3953 :
3954 :
3955 98 : void serialized_size(const Encoding& encoding, size_t& size,
3956 : const XTypes::CommonAliasBody& stru)
3957 : {
3958 98 : primitive_serialized_size(encoding, size, stru.related_flags);
3959 98 : serialized_size(encoding, size, stru.related_type);
3960 98 : }
3961 :
3962 0 : bool operator<<(Serializer& strm, const XTypes::CommonAliasBody& stru)
3963 : {
3964 0 : return (strm << stru.related_flags)
3965 0 : && (strm << stru.related_type);
3966 : }
3967 :
3968 148 : bool operator>>(Serializer& strm, XTypes::CommonAliasBody& stru)
3969 : {
3970 148 : return (strm >> stru.related_flags)
3971 148 : && (strm >> stru.related_type);
3972 : }
3973 :
3974 :
3975 0 : void serialized_size(const Encoding& encoding, size_t& size,
3976 : const XTypes::CommonAnnotationParameter& stru)
3977 : {
3978 0 : primitive_serialized_size(encoding, size, stru.member_flags);
3979 0 : serialized_size(encoding, size, stru.member_type_id);
3980 0 : }
3981 :
3982 0 : bool operator<<(Serializer& strm, const XTypes::CommonAnnotationParameter& stru)
3983 : {
3984 0 : return (strm << stru.member_flags)
3985 0 : && (strm << stru.member_type_id);
3986 : }
3987 :
3988 0 : bool operator>>(Serializer& strm, XTypes::CommonAnnotationParameter& stru)
3989 : {
3990 0 : return (strm >> stru.member_flags)
3991 0 : && (strm >> stru.member_type_id);
3992 : }
3993 :
3994 :
3995 0 : void serialized_size(const Encoding& encoding, size_t& size,
3996 : const XTypes::CommonArrayHeader& stru)
3997 : {
3998 0 : serialized_size(encoding, size, stru.bound_seq);
3999 0 : }
4000 :
4001 0 : bool operator<<(Serializer& strm, const XTypes::CommonArrayHeader& stru)
4002 : {
4003 0 : return (strm << stru.bound_seq);
4004 : }
4005 :
4006 2 : bool operator>>(Serializer& strm, XTypes::CommonArrayHeader& stru)
4007 : {
4008 2 : return (strm >> stru.bound_seq);
4009 : }
4010 :
4011 :
4012 0 : void serialized_size(const Encoding& encoding, size_t& size,
4013 : const XTypes::CommonBitfield& stru)
4014 : {
4015 0 : primitive_serialized_size(encoding, size, stru.position);
4016 0 : primitive_serialized_size(encoding, size, stru.flags);
4017 0 : primitive_serialized_size(encoding, size, ACE_OutputCDR::from_octet(stru.bitcount));
4018 0 : primitive_serialized_size(encoding, size, ACE_OutputCDR::from_octet(stru.holder_type));
4019 0 : }
4020 :
4021 0 : bool operator<<(Serializer& strm, const XTypes::CommonBitfield& stru)
4022 : {
4023 0 : return (strm << stru.position)
4024 0 : && (strm << stru.flags)
4025 0 : && (strm << ACE_OutputCDR::from_octet(stru.bitcount))
4026 0 : && (strm << ACE_OutputCDR::from_octet(stru.holder_type));
4027 : }
4028 :
4029 0 : bool operator>>(Serializer& strm, XTypes::CommonBitfield& stru)
4030 : {
4031 0 : return (strm >> stru.position)
4032 0 : && (strm >> stru.flags)
4033 0 : && (strm >> ACE_InputCDR::to_octet(stru.bitcount))
4034 0 : && (strm >> ACE_InputCDR::to_octet(stru.holder_type));
4035 : }
4036 :
4037 :
4038 0 : void serialized_size(const Encoding& encoding, size_t& size,
4039 : const XTypes::CommonBitflag& stru)
4040 : {
4041 0 : primitive_serialized_size(encoding, size, stru.position);
4042 0 : primitive_serialized_size(encoding, size, stru.flags);
4043 0 : }
4044 :
4045 0 : bool operator<<(Serializer& strm, const XTypes::CommonBitflag& stru)
4046 : {
4047 0 : return (strm << stru.position)
4048 0 : && (strm << stru.flags);
4049 : }
4050 :
4051 0 : bool operator>>(Serializer& strm, XTypes::CommonBitflag& stru)
4052 : {
4053 0 : return (strm >> stru.position)
4054 0 : && (strm >> stru.flags);
4055 : }
4056 :
4057 :
4058 0 : void serialized_size(const Encoding& encoding, size_t& size,
4059 : const XTypes::CommonCollectionElement& stru)
4060 : {
4061 0 : primitive_serialized_size(encoding, size, stru.element_flags);
4062 0 : serialized_size(encoding, size, stru.type);
4063 0 : }
4064 :
4065 0 : bool operator<<(Serializer& strm, const XTypes::CommonCollectionElement& stru)
4066 : {
4067 0 : return (strm << stru.element_flags)
4068 0 : && (strm << stru.type);
4069 : }
4070 :
4071 12 : bool operator>>(Serializer& strm, XTypes::CommonCollectionElement& stru)
4072 : {
4073 12 : return (strm >> stru.element_flags)
4074 12 : && (strm >> stru.type);
4075 : }
4076 :
4077 :
4078 0 : void serialized_size(const Encoding& encoding, size_t& size,
4079 : const XTypes::CommonCollectionHeader& stru)
4080 : {
4081 0 : primitive_serialized_size(encoding, size, stru.bound);
4082 0 : }
4083 :
4084 0 : bool operator<<(Serializer& strm, const XTypes::CommonCollectionHeader& stru)
4085 : {
4086 0 : return (strm << stru.bound);
4087 : }
4088 :
4089 10 : bool operator>>(Serializer& strm, XTypes::CommonCollectionHeader& stru)
4090 : {
4091 10 : return (strm >> stru.bound);
4092 : }
4093 :
4094 :
4095 68 : void serialized_size(const Encoding& encoding, size_t& size,
4096 : const XTypes::CommonDiscriminatorMember& stru)
4097 : {
4098 68 : primitive_serialized_size(encoding, size, stru.member_flags);
4099 68 : serialized_size(encoding, size, stru.type_id);
4100 68 : }
4101 :
4102 0 : bool operator<<(Serializer& strm, const XTypes::CommonDiscriminatorMember& stru)
4103 : {
4104 0 : return (strm << stru.member_flags)
4105 0 : && (strm << stru.type_id);
4106 : }
4107 :
4108 39 : bool operator>>(Serializer& strm, XTypes::CommonDiscriminatorMember& stru)
4109 : {
4110 39 : return (strm >> stru.member_flags)
4111 39 : && (strm >> stru.type_id);
4112 : }
4113 :
4114 :
4115 28 : void serialized_size(const Encoding& encoding, size_t& size,
4116 : const XTypes::CommonEnumeratedHeader& stru)
4117 : {
4118 28 : primitive_serialized_size(encoding, size, stru.bit_bound);
4119 28 : }
4120 :
4121 0 : bool operator<<(Serializer& strm, const XTypes::CommonEnumeratedHeader& stru)
4122 : {
4123 0 : return (strm << stru.bit_bound);
4124 : }
4125 :
4126 10 : bool operator>>(Serializer& strm, XTypes::CommonEnumeratedHeader& stru)
4127 : {
4128 10 : return (strm >> stru.bit_bound);
4129 : }
4130 :
4131 :
4132 130 : void serialized_size(const Encoding& encoding, size_t& size,
4133 : const XTypes::CommonEnumeratedLiteral& stru)
4134 : {
4135 130 : serialized_size_delimiter(encoding, size);
4136 130 : primitive_serialized_size(encoding, size, stru.value);
4137 130 : primitive_serialized_size(encoding, size, stru.flags);
4138 130 : }
4139 :
4140 0 : bool operator<<(Serializer& strm, const XTypes::CommonEnumeratedLiteral& stru)
4141 : {
4142 0 : size_t total_size = 0;
4143 0 : serialized_size(strm.encoding(), total_size, stru);
4144 0 : if (!strm.write_delimiter(total_size)) {
4145 0 : return false;
4146 : }
4147 :
4148 0 : return (strm << stru.value)
4149 0 : && (strm << stru.flags);
4150 : }
4151 :
4152 88 : bool operator>>(Serializer& strm, XTypes::CommonEnumeratedLiteral& stru)
4153 : {
4154 88 : size_t total_size = 0;
4155 88 : if (!strm.read_delimiter(total_size)) {
4156 0 : return false;
4157 : }
4158 :
4159 88 : const size_t start_pos = strm.rpos();
4160 :
4161 88 : const bool ret = (strm >> stru.value)
4162 88 : && (strm >> stru.flags);
4163 :
4164 88 : if (ret && strm.rpos() - start_pos < total_size) {
4165 0 : strm.skip(total_size - strm.rpos() + start_pos);
4166 : }
4167 88 : return ret;
4168 : }
4169 :
4170 :
4171 573 : void serialized_size(const Encoding& encoding, size_t& size,
4172 : const XTypes::CommonStructMember& stru)
4173 : {
4174 573 : primitive_serialized_size(encoding, size, stru.member_id);
4175 573 : primitive_serialized_size(encoding, size, stru.member_flags);
4176 573 : serialized_size(encoding, size, stru.member_type_id);
4177 573 : }
4178 :
4179 2 : bool operator<<(Serializer& strm, const XTypes::CommonStructMember& stru)
4180 : {
4181 2 : return (strm << stru.member_id)
4182 2 : && (strm << stru.member_flags)
4183 4 : && (strm << stru.member_type_id);
4184 : }
4185 :
4186 678 : bool operator>>(Serializer& strm, XTypes::CommonStructMember& stru)
4187 : {
4188 678 : return (strm >> stru.member_id)
4189 678 : && (strm >> stru.member_flags)
4190 1356 : && (strm >> stru.member_type_id);
4191 : }
4192 :
4193 :
4194 198 : void serialized_size(const Encoding& encoding, size_t& size,
4195 : const XTypes::CommonUnionMember& stru)
4196 : {
4197 198 : primitive_serialized_size(encoding, size, stru.member_id);
4198 198 : primitive_serialized_size(encoding, size, stru.member_flags);
4199 198 : serialized_size(encoding, size, stru.type_id);
4200 198 : serialized_size(encoding, size, stru.label_seq);
4201 198 : }
4202 :
4203 0 : bool operator<<(Serializer& strm, const XTypes::CommonUnionMember& stru)
4204 : {
4205 0 : return (strm << stru.member_id)
4206 0 : && (strm << stru.member_flags)
4207 0 : && (strm << stru.type_id)
4208 0 : && (strm << stru.label_seq);
4209 : }
4210 :
4211 303 : bool operator>>(Serializer& strm, XTypes::CommonUnionMember& stru)
4212 : {
4213 303 : return (strm >> stru.member_id)
4214 303 : && (strm >> stru.member_flags)
4215 303 : && (strm >> stru.type_id)
4216 606 : && (strm >> stru.label_seq);
4217 : }
4218 :
4219 :
4220 0 : void serialized_size(const Encoding& encoding, size_t& size,
4221 : const XTypes::CompleteElementDetail& stru)
4222 : {
4223 0 : serialized_size(encoding, size, stru.ann_builtin);
4224 0 : serialized_size(encoding, size, stru.ann_custom);
4225 0 : }
4226 :
4227 0 : bool operator<<(Serializer& strm, const XTypes::CompleteElementDetail& stru)
4228 : {
4229 0 : return (strm << stru.ann_builtin)
4230 0 : && (strm << stru.ann_custom);
4231 : }
4232 :
4233 7 : bool operator>>(Serializer& strm, XTypes::CompleteElementDetail& stru)
4234 : {
4235 7 : return (strm >> stru.ann_builtin)
4236 7 : && (strm >> stru.ann_custom);
4237 : }
4238 :
4239 :
4240 447 : void serialized_size(const Encoding& encoding, size_t& size,
4241 : const XTypes::CompleteMemberDetail& stru)
4242 : {
4243 447 : DCPS::primitive_serialized_size_ulong(encoding, size);
4244 447 : size += ACE_OS::strlen(stru.name.c_str()) + 1;
4245 447 : serialized_size(encoding, size, stru.ann_builtin);
4246 447 : serialized_size(encoding, size, stru.ann_custom);
4247 447 : }
4248 :
4249 0 : bool operator<<(Serializer& strm, const XTypes::CompleteMemberDetail& stru)
4250 : {
4251 0 : return (strm << Serializer::FromBoundedString<char>(stru.name, MEMBER_NAME_MAX_LENGTH))
4252 0 : && (strm << stru.ann_builtin)
4253 0 : && (strm << stru.ann_custom);
4254 : }
4255 :
4256 814 : bool operator>>(Serializer& strm, XTypes::CompleteMemberDetail& stru)
4257 : {
4258 814 : return (strm >> Serializer::ToBoundedString<char>(stru.name, MEMBER_NAME_MAX_LENGTH))
4259 814 : && (strm >> stru.ann_builtin)
4260 1628 : && (strm >> stru.ann_custom);
4261 : }
4262 :
4263 :
4264 454 : void serialized_size(const Encoding& encoding, size_t& size,
4265 : const XTypes::MinimalMemberDetail& stru)
4266 : {
4267 454 : XTypes::NameHash_forany stru_name_hash(const_cast<XTypes::NameHash_slice*>(stru.name_hash));
4268 454 : serialized_size(encoding, size, stru_name_hash);
4269 454 : }
4270 :
4271 2 : bool operator<<(Serializer& strm, const XTypes::MinimalMemberDetail& stru)
4272 : {
4273 2 : XTypes::NameHash_forany stru_name_hash(const_cast<XTypes::NameHash_slice*>(stru.name_hash));
4274 4 : return (strm << stru_name_hash);
4275 : }
4276 :
4277 255 : bool operator>>(Serializer& strm, XTypes::MinimalMemberDetail& stru)
4278 : {
4279 255 : XTypes::NameHash_forany stru_name_hash(const_cast<XTypes::NameHash_slice*>(stru.name_hash));
4280 510 : return (strm >> stru_name_hash);
4281 : }
4282 :
4283 :
4284 0 : void serialized_size(const Encoding& encoding, size_t& size,
4285 : const XTypes::ExtendedTypeDefn&)
4286 : {
4287 0 : serialized_size_delimiter(encoding, size);
4288 0 : }
4289 :
4290 0 : bool operator<<(Serializer& strm, const XTypes::ExtendedTypeDefn&)
4291 : {
4292 0 : return XTypes::write_empty_xcdr2_nonfinal(strm);
4293 : }
4294 :
4295 0 : bool operator>>(Serializer& strm, XTypes::ExtendedTypeDefn&)
4296 : {
4297 0 : return XTypes::read_empty_xcdr2_nonfinal(strm);
4298 : }
4299 :
4300 :
4301 0 : void serialized_size(const Encoding& encoding, size_t& size,
4302 : const XTypes::PlainArrayLElemDefn& stru)
4303 : {
4304 0 : serialized_size(encoding, size, stru.header);
4305 0 : serialized_size(encoding, size, stru.array_bound_seq);
4306 0 : serialized_size(encoding, size, *stru.element_identifier);
4307 0 : }
4308 :
4309 0 : bool operator<<(Serializer& strm, const XTypes::PlainArrayLElemDefn& stru)
4310 : {
4311 0 : return (strm << stru.header)
4312 0 : && (strm << stru.array_bound_seq)
4313 0 : && (strm << *stru.element_identifier);
4314 : }
4315 :
4316 0 : bool operator>>(Serializer& strm, XTypes::PlainArrayLElemDefn& stru)
4317 : {
4318 0 : return (strm >> stru.header)
4319 0 : && (strm >> stru.array_bound_seq)
4320 0 : && (strm >> *stru.element_identifier);
4321 : }
4322 :
4323 :
4324 112 : void serialized_size(const Encoding& encoding, size_t& size,
4325 : const XTypes::PlainArraySElemDefn& stru)
4326 : {
4327 112 : serialized_size(encoding, size, stru.header);
4328 112 : serialized_size(encoding, size, stru.array_bound_seq);
4329 112 : serialized_size(encoding, size, *stru.element_identifier);
4330 112 : }
4331 :
4332 0 : bool operator<<(Serializer& strm, const XTypes::PlainArraySElemDefn& stru)
4333 : {
4334 0 : return (strm << stru.header)
4335 0 : && (strm << stru.array_bound_seq)
4336 0 : && (strm << *stru.element_identifier);
4337 : }
4338 :
4339 113 : bool operator>>(Serializer& strm, XTypes::PlainArraySElemDefn& stru)
4340 : {
4341 113 : return (strm >> stru.header)
4342 113 : && (strm >> stru.array_bound_seq)
4343 226 : && (strm >> *stru.element_identifier);
4344 : }
4345 :
4346 :
4347 0 : void serialized_size(const Encoding& encoding, size_t& size,
4348 : const XTypes::PlainMapLTypeDefn& stru)
4349 : {
4350 0 : serialized_size(encoding, size, stru.header);
4351 0 : primitive_serialized_size(encoding, size, stru.bound);
4352 0 : serialized_size(encoding, size, *stru.element_identifier);
4353 0 : primitive_serialized_size(encoding, size, stru.key_flags);
4354 0 : serialized_size(encoding, size, *stru.key_identifier);
4355 0 : }
4356 :
4357 0 : bool operator<<(Serializer& strm, const XTypes::PlainMapLTypeDefn& stru)
4358 : {
4359 0 : return (strm << stru.header)
4360 0 : && (strm << stru.bound)
4361 0 : && (strm << *stru.element_identifier)
4362 0 : && (strm << stru.key_flags)
4363 0 : && (strm << *stru.key_identifier);
4364 : }
4365 :
4366 0 : bool operator>>(Serializer& strm, XTypes::PlainMapLTypeDefn& stru)
4367 : {
4368 0 : return (strm >> stru.header)
4369 0 : && (strm >> stru.bound)
4370 0 : && (strm >> *stru.element_identifier)
4371 0 : && (strm >> stru.key_flags)
4372 0 : && (strm >> *stru.key_identifier);
4373 : }
4374 :
4375 :
4376 0 : void serialized_size(const Encoding& encoding, size_t& size,
4377 : const XTypes::PlainMapSTypeDefn& stru)
4378 : {
4379 0 : serialized_size(encoding, size, stru.header);
4380 0 : primitive_serialized_size(encoding, size, ACE_OutputCDR::from_octet(stru.bound));
4381 0 : serialized_size(encoding, size, *stru.element_identifier);
4382 0 : primitive_serialized_size(encoding, size, stru.key_flags);
4383 0 : serialized_size(encoding, size, *stru.key_identifier);
4384 0 : }
4385 :
4386 0 : bool operator<<(Serializer& strm, const XTypes::PlainMapSTypeDefn& stru)
4387 : {
4388 0 : return (strm << stru.header)
4389 0 : && (strm << ACE_OutputCDR::from_octet(stru.bound))
4390 0 : && (strm << *stru.element_identifier)
4391 0 : && (strm << stru.key_flags)
4392 0 : && (strm << *stru.key_identifier);
4393 : }
4394 :
4395 0 : bool operator>>(Serializer& strm, XTypes::PlainMapSTypeDefn& stru)
4396 : {
4397 0 : return (strm >> stru.header)
4398 0 : && (strm >> ACE_InputCDR::to_octet(stru.bound))
4399 0 : && (strm >> *stru.element_identifier)
4400 0 : && (strm >> stru.key_flags)
4401 0 : && (strm >> *stru.key_identifier);
4402 : }
4403 :
4404 :
4405 0 : void serialized_size(const Encoding& encoding, size_t& size,
4406 : const XTypes::PlainSequenceLElemDefn& stru)
4407 : {
4408 0 : serialized_size(encoding, size, stru.header);
4409 0 : primitive_serialized_size(encoding, size, stru.bound);
4410 0 : serialized_size(encoding, size, *stru.element_identifier);
4411 0 : }
4412 :
4413 0 : bool operator<<(Serializer& strm, const XTypes::PlainSequenceLElemDefn& stru)
4414 : {
4415 0 : return (strm << stru.header)
4416 0 : && (strm << stru.bound)
4417 0 : && (strm << *stru.element_identifier);
4418 : }
4419 :
4420 0 : bool operator>>(Serializer& strm, XTypes::PlainSequenceLElemDefn& stru)
4421 : {
4422 0 : return (strm >> stru.header)
4423 0 : && (strm >> stru.bound)
4424 0 : && (strm >> *stru.element_identifier);
4425 : }
4426 :
4427 :
4428 104 : void serialized_size(const Encoding& encoding, size_t& size,
4429 : const XTypes::PlainSequenceSElemDefn& stru)
4430 : {
4431 104 : serialized_size(encoding, size, stru.header);
4432 104 : primitive_serialized_size(encoding, size, ACE_OutputCDR::from_octet(stru.bound));
4433 104 : serialized_size(encoding, size, *stru.element_identifier);
4434 104 : }
4435 :
4436 0 : bool operator<<(Serializer& strm, const XTypes::PlainSequenceSElemDefn& stru)
4437 : {
4438 0 : return (strm << stru.header)
4439 0 : && (strm << ACE_OutputCDR::from_octet(stru.bound))
4440 0 : && (strm << *stru.element_identifier);
4441 : }
4442 :
4443 127 : bool operator>>(Serializer& strm, XTypes::PlainSequenceSElemDefn& stru)
4444 : {
4445 127 : return (strm >> stru.header)
4446 127 : && (strm >> ACE_InputCDR::to_octet(stru.bound))
4447 254 : && (strm >> *stru.element_identifier);
4448 : }
4449 :
4450 :
4451 0 : void serialized_size(const Encoding& encoding, size_t& size,
4452 : const XTypes::StringLTypeDefn& stru)
4453 : {
4454 0 : primitive_serialized_size(encoding, size, stru.bound);
4455 0 : }
4456 :
4457 0 : bool operator<<(Serializer& strm, const XTypes::StringLTypeDefn& stru)
4458 : {
4459 0 : return (strm << stru.bound);
4460 : }
4461 :
4462 0 : bool operator>>(Serializer& strm, XTypes::StringLTypeDefn& stru)
4463 : {
4464 0 : return (strm >> stru.bound);
4465 : }
4466 :
4467 :
4468 28 : void serialized_size(const Encoding& encoding, size_t& size,
4469 : const XTypes::StringSTypeDefn& stru)
4470 : {
4471 28 : primitive_serialized_size(encoding, size, ACE_OutputCDR::from_octet(stru.bound));
4472 28 : }
4473 :
4474 0 : bool operator<<(Serializer& strm, const XTypes::StringSTypeDefn& stru)
4475 : {
4476 0 : return (strm << ACE_OutputCDR::from_octet(stru.bound));
4477 : }
4478 :
4479 56 : bool operator>>(Serializer& strm, XTypes::StringSTypeDefn& stru)
4480 : {
4481 56 : return (strm >> ACE_InputCDR::to_octet(stru.bound));
4482 : }
4483 :
4484 :
4485 0 : void serialized_size(const Encoding& encoding, size_t& size,
4486 : const XTypes::StronglyConnectedComponentId& stru)
4487 : {
4488 0 : serialized_size_delimiter(encoding, size);
4489 0 : serialized_size(encoding, size, stru.sc_component_id);
4490 0 : primitive_serialized_size(encoding, size, stru.scc_length);
4491 0 : primitive_serialized_size(encoding, size, stru.scc_index);
4492 0 : }
4493 :
4494 0 : bool operator<<(Serializer& strm, const XTypes::StronglyConnectedComponentId& stru)
4495 : {
4496 0 : size_t total_size = 0;
4497 0 : serialized_size(XTypes::get_typeobject_encoding(), total_size, stru);
4498 0 : if (!strm.write_delimiter(total_size)) {
4499 0 : return false;
4500 : }
4501 :
4502 0 : return (strm << stru.sc_component_id)
4503 0 : && (strm << stru.scc_length)
4504 0 : && (strm << stru.scc_index);
4505 : }
4506 :
4507 26 : bool operator>>(Serializer& strm, XTypes::StronglyConnectedComponentId& stru)
4508 : {
4509 26 : size_t total_size = 0;
4510 26 : if (!strm.read_delimiter(total_size)) {
4511 0 : return false;
4512 : }
4513 :
4514 26 : const size_t start_pos = strm.rpos();
4515 :
4516 : // appendable, but no need to handle truncated streams since
4517 : // this struct is defined in the spec with the following members:
4518 26 : const bool ret = (strm >> stru.sc_component_id)
4519 26 : && (strm >> stru.scc_length)
4520 52 : && (strm >> stru.scc_index);
4521 :
4522 26 : if (ret && strm.rpos() - start_pos < total_size) {
4523 0 : strm.skip(total_size - strm.rpos() + start_pos);
4524 : }
4525 :
4526 26 : return ret;
4527 : }
4528 :
4529 :
4530 216 : void serialized_size(const Encoding& encoding, size_t& size,
4531 : const XTypes::PlainCollectionHeader& stru)
4532 : {
4533 216 : primitive_serialized_size(encoding, size, ACE_OutputCDR::from_octet(stru.equiv_kind));
4534 216 : primitive_serialized_size(encoding, size, stru.element_flags);
4535 216 : }
4536 :
4537 0 : bool operator<<(Serializer& strm, const XTypes::PlainCollectionHeader& stru)
4538 : {
4539 0 : return (strm << ACE_OutputCDR::from_octet(stru.equiv_kind))
4540 0 : && (strm << stru.element_flags);
4541 : }
4542 :
4543 240 : bool operator>>(Serializer& strm, XTypes::PlainCollectionHeader& stru)
4544 : {
4545 240 : return (strm >> ACE_InputCDR::to_octet(stru.equiv_kind))
4546 240 : && (strm >> stru.element_flags);
4547 : }
4548 :
4549 :
4550 0 : void serialized_size(const Encoding& encoding, size_t& size,
4551 : const XTypes::TypeObjectHashId& uni)
4552 : {
4553 0 : primitive_serialized_size(encoding, size, ACE_OutputCDR::from_octet(uni.kind));
4554 0 : switch (uni.kind) {
4555 0 : case XTypes::EK_MINIMAL:
4556 : case XTypes::EK_COMPLETE: {
4557 0 : XTypes::EquivalenceHash_forany uni_hash(const_cast<XTypes::EquivalenceHash_slice*>(uni.hash));
4558 0 : serialized_size(encoding, size, uni_hash);
4559 0 : break;
4560 : }
4561 0 : default:
4562 0 : break;
4563 : }
4564 0 : }
4565 :
4566 0 : bool operator<<(Serializer& strm, const XTypes::TypeObjectHashId& uni)
4567 : {
4568 0 : if (!(strm << ACE_OutputCDR::from_octet(uni.kind))) {
4569 0 : return false;
4570 : }
4571 0 : switch (uni.kind) {
4572 0 : case XTypes::EK_MINIMAL:
4573 : case XTypes::EK_COMPLETE: {
4574 0 : XTypes::EquivalenceHash_forany uni_hash(const_cast<XTypes::EquivalenceHash_slice*>(uni.hash));
4575 0 : return strm << uni_hash;
4576 : }
4577 0 : default:
4578 0 : return true;
4579 : }
4580 : }
4581 :
4582 26 : bool operator>>(Serializer& strm, XTypes::TypeObjectHashId& uni)
4583 : {
4584 26 : if (!(strm >> ACE_InputCDR::to_octet(uni.kind))) {
4585 0 : return false;
4586 : }
4587 26 : switch (uni.kind) {
4588 26 : case XTypes::EK_MINIMAL:
4589 : case XTypes::EK_COMPLETE: {
4590 26 : XTypes::EquivalenceHash_forany uni_hash(uni.hash);
4591 26 : return strm >> uni_hash;
4592 : }
4593 0 : default:
4594 0 : return true;
4595 : }
4596 : }
4597 :
4598 :
4599 207 : void serialized_size(const Encoding& encoding, size_t& size,
4600 : const XTypes::CompleteTypeObject& type_object)
4601 : {
4602 : using namespace XTypes;
4603 207 : primitive_serialized_size_octet(encoding, size); // discriminator
4604 :
4605 207 : switch (type_object.kind) {
4606 49 : case TK_ALIAS:
4607 49 : serialized_size(encoding, size, type_object.alias_type);
4608 49 : return;
4609 0 : case TK_ANNOTATION:
4610 0 : serialized_size(encoding, size, type_object.annotation_type);
4611 0 : return;
4612 110 : case TK_STRUCTURE:
4613 110 : serialized_size(encoding, size, type_object.struct_type);
4614 110 : return;
4615 34 : case TK_UNION:
4616 34 : serialized_size(encoding, size, type_object.union_type);
4617 34 : return;
4618 0 : case TK_BITSET:
4619 0 : serialized_size(encoding, size, type_object.bitset_type);
4620 0 : return;
4621 0 : case TK_SEQUENCE:
4622 0 : serialized_size(encoding, size, type_object.sequence_type);
4623 0 : return;
4624 0 : case TK_ARRAY:
4625 0 : serialized_size(encoding, size, type_object.array_type);
4626 0 : return;
4627 0 : case TK_MAP:
4628 0 : serialized_size(encoding, size, type_object.map_type);
4629 0 : return;
4630 14 : case TK_ENUM:
4631 14 : serialized_size(encoding, size, type_object.enumerated_type);
4632 14 : return;
4633 0 : case TK_BITMASK:
4634 0 : serialized_size(encoding, size, type_object.bitmask_type);
4635 0 : return;
4636 0 : default:
4637 0 : serialized_size(encoding, size, type_object.extended_type);
4638 : }
4639 : }
4640 :
4641 0 : bool operator<<(Serializer& ser, const XTypes::CompleteTypeObject& type_object)
4642 : {
4643 : using namespace XTypes;
4644 0 : if (!(ser << ACE_OutputCDR::from_octet(type_object.kind))) {
4645 0 : return false;
4646 : }
4647 :
4648 0 : switch (type_object.kind) {
4649 0 : case TK_ALIAS:
4650 0 : return ser << type_object.alias_type;
4651 0 : case TK_ANNOTATION:
4652 0 : return ser << type_object.annotation_type;
4653 0 : case TK_STRUCTURE:
4654 0 : return ser << type_object.struct_type;
4655 0 : case TK_UNION:
4656 0 : return ser << type_object.union_type;
4657 0 : case TK_BITSET:
4658 0 : return ser << type_object.bitset_type;
4659 0 : case TK_SEQUENCE:
4660 0 : return ser << type_object.sequence_type;
4661 0 : case TK_ARRAY:
4662 0 : return ser << type_object.array_type;
4663 0 : case TK_MAP:
4664 0 : return ser << type_object.map_type;
4665 0 : case TK_ENUM:
4666 0 : return ser << type_object.enumerated_type;
4667 0 : case TK_BITMASK:
4668 0 : return ser << type_object.bitmask_type;
4669 0 : default:
4670 0 : return ser << type_object.extended_type;
4671 : }
4672 : }
4673 :
4674 215 : bool operator>>(Serializer& ser, XTypes::CompleteTypeObject& type_object)
4675 : {
4676 : using namespace XTypes;
4677 215 : if (!(ser >> ACE_InputCDR::to_octet(type_object.kind))) {
4678 0 : return false;
4679 : }
4680 :
4681 215 : switch (type_object.kind) {
4682 94 : case TK_ALIAS:
4683 94 : return ser >> type_object.alias_type;
4684 0 : case TK_ANNOTATION:
4685 0 : return ser >> type_object.annotation_type;
4686 79 : case TK_STRUCTURE:
4687 79 : return ser >> type_object.struct_type;
4688 29 : case TK_UNION:
4689 29 : return ser >> type_object.union_type;
4690 0 : case TK_BITSET:
4691 0 : return ser >> type_object.bitset_type;
4692 6 : case TK_SEQUENCE:
4693 6 : return ser >> type_object.sequence_type;
4694 1 : case TK_ARRAY:
4695 1 : return ser >> type_object.array_type;
4696 0 : case TK_MAP:
4697 0 : return ser >> type_object.map_type;
4698 6 : case TK_ENUM:
4699 6 : return ser >> type_object.enumerated_type;
4700 0 : case TK_BITMASK:
4701 0 : return ser >> type_object.bitmask_type;
4702 0 : default:
4703 0 : return ser >> type_object.extended_type;
4704 : }
4705 : }
4706 :
4707 :
4708 211 : void serialized_size(const Encoding& encoding, size_t& size,
4709 : const XTypes::MinimalTypeObject& type_object)
4710 : {
4711 : using namespace XTypes;
4712 211 : primitive_serialized_size_octet(encoding, size); // discriminator
4713 :
4714 211 : switch (type_object.kind) {
4715 49 : case TK_ALIAS:
4716 49 : return serialized_size(encoding, size, type_object.alias_type);
4717 0 : case TK_ANNOTATION:
4718 0 : return serialized_size(encoding, size, type_object.annotation_type);
4719 114 : case TK_STRUCTURE:
4720 114 : return serialized_size(encoding, size, type_object.struct_type);
4721 34 : case TK_UNION:
4722 34 : return serialized_size(encoding, size, type_object.union_type);
4723 0 : case TK_BITSET:
4724 0 : return serialized_size(encoding, size, type_object.bitset_type);
4725 0 : case TK_SEQUENCE:
4726 0 : return serialized_size(encoding, size, type_object.sequence_type);
4727 0 : case TK_ARRAY:
4728 0 : return serialized_size(encoding, size, type_object.array_type);
4729 0 : case TK_MAP:
4730 0 : return serialized_size(encoding, size, type_object.map_type);
4731 14 : case TK_ENUM:
4732 14 : return serialized_size(encoding, size, type_object.enumerated_type);
4733 0 : case TK_BITMASK:
4734 0 : return serialized_size(encoding, size, type_object.bitmask_type);
4735 0 : default:
4736 0 : return serialized_size(encoding, size, type_object.extended_type);
4737 : }
4738 : }
4739 :
4740 2 : bool operator<<(Serializer& ser, const XTypes::MinimalTypeObject& type_object)
4741 : {
4742 : using namespace XTypes;
4743 2 : if (!(ser << ACE_OutputCDR::from_octet(type_object.kind))) {
4744 0 : return false;
4745 : }
4746 :
4747 2 : switch (type_object.kind) {
4748 0 : case TK_ALIAS:
4749 0 : return ser << type_object.alias_type;
4750 0 : case TK_ANNOTATION:
4751 0 : return ser << type_object.annotation_type;
4752 2 : case TK_STRUCTURE:
4753 2 : return ser << type_object.struct_type;
4754 0 : case TK_UNION:
4755 0 : return ser << type_object.union_type;
4756 0 : case TK_BITSET:
4757 0 : return ser << type_object.bitset_type;
4758 0 : case TK_SEQUENCE:
4759 0 : return ser << type_object.sequence_type;
4760 0 : case TK_ARRAY:
4761 0 : return ser << type_object.array_type;
4762 0 : case TK_MAP:
4763 0 : return ser << type_object.map_type;
4764 0 : case TK_ENUM:
4765 0 : return ser << type_object.enumerated_type;
4766 0 : case TK_BITMASK:
4767 0 : return ser << type_object.bitmask_type;
4768 0 : default:
4769 0 : return ser << type_object.extended_type;
4770 : }
4771 : }
4772 :
4773 112 : bool operator>>(Serializer& ser, XTypes::MinimalTypeObject& type_object)
4774 : {
4775 : using namespace XTypes;
4776 112 : if (!(ser >> ACE_InputCDR::to_octet(type_object.kind))) {
4777 0 : return false;
4778 : }
4779 :
4780 112 : switch (type_object.kind) {
4781 54 : case TK_ALIAS:
4782 54 : return ser >> type_object.alias_type;
4783 0 : case TK_ANNOTATION:
4784 0 : return ser >> type_object.annotation_type;
4785 39 : case TK_STRUCTURE:
4786 39 : return ser >> type_object.struct_type;
4787 10 : case TK_UNION:
4788 10 : return ser >> type_object.union_type;
4789 0 : case TK_BITSET:
4790 0 : return ser >> type_object.bitset_type;
4791 4 : case TK_SEQUENCE:
4792 4 : return ser >> type_object.sequence_type;
4793 1 : case TK_ARRAY:
4794 1 : return ser >> type_object.array_type;
4795 0 : case TK_MAP:
4796 0 : return ser >> type_object.map_type;
4797 4 : case TK_ENUM:
4798 4 : return ser >> type_object.enumerated_type;
4799 0 : case TK_BITMASK:
4800 0 : return ser >> type_object.bitmask_type;
4801 0 : default:
4802 0 : return ser >> type_object.extended_type;
4803 : }
4804 : }
4805 :
4806 :
4807 418 : void serialized_size(const Encoding& encoding, size_t& size,
4808 : const XTypes::TypeObject& type_object)
4809 : {
4810 : using namespace XTypes;
4811 418 : primitive_serialized_size_ulong(encoding, size); // DHEADER
4812 418 : primitive_serialized_size_octet(encoding, size); // discriminator
4813 :
4814 418 : switch (type_object.kind) {
4815 207 : case EK_COMPLETE:
4816 207 : return serialized_size(encoding, size, type_object.complete);
4817 211 : case EK_MINIMAL:
4818 211 : return serialized_size(encoding, size, type_object.minimal);
4819 : }
4820 : }
4821 :
4822 2 : bool operator<<(Serializer& ser, const XTypes::TypeObject& type_object)
4823 : {
4824 2 : size_t total_size = 0;
4825 2 : serialized_size(ser.encoding(), total_size, type_object);
4826 2 : if (!ser.write_delimiter(total_size)) {
4827 0 : return false;
4828 : }
4829 :
4830 2 : if (!(ser << ACE_OutputCDR::from_octet(type_object.kind))) {
4831 0 : return false;
4832 : }
4833 :
4834 2 : switch (type_object.kind) {
4835 0 : case XTypes::EK_COMPLETE:
4836 0 : return ser << type_object.complete;
4837 2 : case XTypes::EK_MINIMAL:
4838 2 : return ser << type_object.minimal;
4839 : }
4840 :
4841 0 : return true;
4842 : }
4843 :
4844 327 : bool operator>>(Serializer& ser, XTypes::TypeObject& type_object)
4845 : {
4846 327 : size_t total_size = 0;
4847 327 : if (!ser.read_delimiter(total_size)) {
4848 0 : return false;
4849 : }
4850 :
4851 327 : if (!(ser >> ACE_InputCDR::to_octet(type_object.kind))) {
4852 0 : return false;
4853 : }
4854 :
4855 327 : bool ret = true;
4856 327 : switch (type_object.kind) {
4857 215 : case XTypes::EK_COMPLETE:
4858 215 : ret = ser >> type_object.complete;
4859 215 : break;
4860 112 : case XTypes::EK_MINIMAL:
4861 112 : ret = ser >> type_object.minimal;
4862 112 : break;
4863 : }
4864 :
4865 327 : return ret;
4866 : }
4867 :
4868 :
4869 0 : void serialized_size(const Encoding& encoding, size_t& size,
4870 : const XTypes::MinimalExtendedType&)
4871 : {
4872 0 : serialized_size_delimiter(encoding, size);
4873 0 : }
4874 :
4875 0 : bool operator<<(Serializer& strm, const XTypes::MinimalExtendedType&)
4876 : {
4877 0 : return XTypes::write_empty_xcdr2_nonfinal(strm);
4878 : }
4879 :
4880 0 : bool operator>>(Serializer& strm, XTypes::MinimalExtendedType&)
4881 : {
4882 0 : return XTypes::read_empty_xcdr2_nonfinal(strm);
4883 : }
4884 :
4885 :
4886 162 : void serialized_size(const Encoding& encoding, size_t& size,
4887 : const XTypes::TypeInformation& stru)
4888 : {
4889 162 : size_t mutable_running_total = 0;
4890 162 : serialized_size_delimiter(encoding, size);
4891 :
4892 162 : serialized_size_parameter_id(encoding, size, mutable_running_total);
4893 162 : serialized_size(encoding, size, stru.minimal);
4894 :
4895 162 : serialized_size_parameter_id(encoding, size, mutable_running_total);
4896 162 : serialized_size(encoding, size, stru.complete);
4897 :
4898 162 : serialized_size_list_end_parameter_id(encoding, size, mutable_running_total);
4899 162 : }
4900 :
4901 81 : bool operator<<(Serializer& strm, const XTypes::TypeInformation& stru)
4902 : {
4903 81 : const Encoding& encoding = strm.encoding();
4904 81 : size_t total_size = 0;
4905 81 : serialized_size(encoding, total_size, stru);
4906 81 : if (!strm.write_delimiter(total_size)) {
4907 0 : return false;
4908 : }
4909 :
4910 81 : size_t size = 0;
4911 :
4912 81 : serialized_size(encoding, size, stru.minimal);
4913 81 : if (!strm.write_parameter_id(4097, size)) {
4914 0 : return false;
4915 : }
4916 81 : size = 0;
4917 81 : if (!(strm << stru.minimal)) {
4918 0 : return false;
4919 : }
4920 :
4921 81 : serialized_size(encoding, size, stru.complete);
4922 81 : if (!strm.write_parameter_id(4098, size)) {
4923 0 : return false;
4924 : }
4925 81 : size = 0;
4926 81 : if (!(strm << stru.complete)) {
4927 0 : return false;
4928 : }
4929 :
4930 81 : return true;
4931 : }
4932 :
4933 39 : bool operator>>(Serializer& strm, XTypes::TypeInformation& stru)
4934 : {
4935 39 : size_t total_size = 0;
4936 39 : if (!strm.read_delimiter(total_size)) {
4937 0 : return false;
4938 : }
4939 :
4940 39 : const size_t start_pos = strm.rpos();
4941 :
4942 : unsigned member_id;
4943 : size_t field_size;
4944 : while (true) {
4945 :
4946 117 : if (strm.rpos() - start_pos >= total_size) {
4947 39 : return true;
4948 : }
4949 :
4950 78 : bool must_understand = false;
4951 78 : if (!strm.read_parameter_id(member_id, field_size, must_understand)) {
4952 0 : return false;
4953 : }
4954 :
4955 78 : switch (member_id) {
4956 39 : case 4097: {
4957 39 : if (!(strm >> stru.minimal)) {
4958 0 : return false;
4959 : }
4960 39 : break;
4961 : }
4962 39 : case 4098: {
4963 39 : if (!(strm >> stru.complete)) {
4964 0 : return false;
4965 : }
4966 39 : break;
4967 : }
4968 0 : default:
4969 0 : if (must_understand) {
4970 0 : if (DCPS_debug_level >= 8) {
4971 0 : ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) unknown must_understand field(%u) in OpenDDS::XTypes::TypeInformation\n"), member_id));
4972 : }
4973 0 : return false;
4974 : }
4975 0 : strm.skip(field_size);
4976 0 : break;
4977 : }
4978 78 : }
4979 : return false;
4980 : }
4981 :
4982 :
4983 0 : void serialized_size(const Encoding& encoding, size_t& size,
4984 : const XTypes::TypeIdentifierTypeObjectPair& stru)
4985 : {
4986 0 : serialized_size(encoding, size, stru.type_identifier);
4987 0 : serialized_size(encoding, size, stru.type_object);
4988 0 : }
4989 :
4990 0 : void serialized_size(const Encoding& encoding, size_t& size,
4991 : const NestedKeyOnly<const XTypes::TypeIdentifierTypeObjectPair>& stru)
4992 : {
4993 0 : serialized_size(encoding, size, stru.value);
4994 0 : }
4995 :
4996 0 : bool operator<<(Serializer& strm, const XTypes::TypeIdentifierTypeObjectPair& stru)
4997 : {
4998 0 : return (strm << stru.type_identifier)
4999 0 : && (strm << stru.type_object);
5000 : }
5001 :
5002 0 : bool operator<<(Serializer& strm, const NestedKeyOnly<const XTypes::TypeIdentifierTypeObjectPair>& stru)
5003 : {
5004 0 : return (strm << stru.value);
5005 : }
5006 :
5007 0 : bool operator>>(Serializer& strm, XTypes::TypeIdentifierTypeObjectPair& stru)
5008 : {
5009 0 : return (strm >> stru.type_identifier)
5010 0 : && (strm >> stru.type_object);
5011 : }
5012 :
5013 0 : bool operator>>(Serializer& strm, NestedKeyOnly<XTypes::TypeIdentifierTypeObjectPair>& stru)
5014 : {
5015 0 : return (strm >> stru.value);
5016 : }
5017 :
5018 0 : void serialized_size(const Encoding& encoding, size_t& size,
5019 : const XTypes::TypeIdentifierPair& stru)
5020 : {
5021 0 : serialized_size(encoding, size, stru.type_identifier1);
5022 0 : serialized_size(encoding, size, stru.type_identifier2);
5023 0 : }
5024 :
5025 0 : void serialized_size(const Encoding& encoding, size_t& size,
5026 : const NestedKeyOnly<const XTypes::TypeIdentifierPair>& stru)
5027 : {
5028 0 : serialized_size(encoding, size, stru.value);
5029 0 : }
5030 :
5031 0 : bool operator<<(Serializer& strm, const XTypes::TypeIdentifierPair& stru)
5032 : {
5033 0 : return (strm << stru.type_identifier1)
5034 0 : && (strm << stru.type_identifier2);
5035 : }
5036 :
5037 0 : bool operator<<(Serializer& strm, const NestedKeyOnly<const XTypes::TypeIdentifierPair>& stru)
5038 : {
5039 0 : return (strm << stru.value);
5040 : }
5041 :
5042 0 : bool operator>>(Serializer& strm, XTypes::TypeIdentifierPair& stru)
5043 : {
5044 0 : return (strm >> stru.type_identifier1)
5045 0 : && (strm >> stru.type_identifier2);
5046 : }
5047 :
5048 0 : bool operator>>(Serializer& strm, NestedKeyOnly<XTypes::TypeIdentifierPair>& stru)
5049 : {
5050 0 : return (strm >> stru.value);
5051 : }
5052 :
5053 327 : bool to_type_object(const unsigned char* buffer, size_t size, XTypes::TypeObject& to)
5054 : {
5055 327 : ACE_Message_Block message_block(reinterpret_cast<const char*>(buffer), size);
5056 327 : message_block.length(size);
5057 327 : DCPS::Serializer ser(&message_block, XTypes::get_typeobject_encoding());
5058 654 : return ser >> to;
5059 327 : }
5060 :
5061 : } // namespace DCPS
5062 : } // namespace OpenDDS
5063 :
5064 : OPENDDS_END_VERSIONED_NAMESPACE_DECL
|
