Line data Source code
1 : /*
2 : * Distributed under the OpenDDS License.
3 : * See: http://www.opendds.org/license.html
4 : */
5 : #include <DCPS/DdsDcps_pch.h>
6 :
7 : #include "TypeLookupService.h"
8 :
9 : #include "../debug.h"
10 :
11 : #include <sstream>
12 :
13 : OPENDDS_BEGIN_VERSIONED_NAMESPACE_DECL
14 :
15 : #ifndef OPENDDS_SAFETY_PROFILE
16 : namespace {
17 :
18 : using namespace OpenDDS::XTypes;
19 1254 : void handle_tryconstruct_flags(DDS::MemberDescriptor* md, MemberFlag mf)
20 : {
21 1254 : if (mf & TRY_CONSTRUCT1) {
22 1254 : md->try_construct_kind((mf & TRY_CONSTRUCT2) ? DDS::TRIM : DDS::DISCARD);
23 0 : } else if (mf & TRY_CONSTRUCT2) {
24 0 : md->try_construct_kind(DDS::USE_DEFAULT);
25 : } else {
26 0 : ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) handle_tryconstruct_flags -")
27 : ACE_TEXT(" Invalid TryConstruct Kind\n")));
28 : }
29 1254 : }
30 :
31 : }
32 : #endif
33 :
34 : namespace OpenDDS {
35 : namespace XTypes {
36 :
37 136 : TypeLookupService::TypeLookupService()
38 : {
39 136 : to_empty_.minimal.kind = TK_NONE;
40 136 : to_empty_.complete.kind = TK_NONE;
41 :
42 136 : type_info_empty_.minimal.typeid_with_size.type_id = TypeIdentifier(TK_NONE);
43 136 : type_info_empty_.complete.typeid_with_size.type_id = TypeIdentifier(TK_NONE);
44 136 : }
45 :
46 202 : TypeLookupService::~TypeLookupService()
47 : {
48 : #ifndef OPENDDS_SAFETY_PROFILE
49 225 : for (GuidTypeMap::const_iterator pos = gt_map_.begin(), limit = gt_map_.end(); pos != limit; ++pos) {
50 1866 : for (DynamicTypeMap::const_iterator pos2 = pos->second.begin(), limit2 = pos->second.end(); pos2 != limit2; ++pos2) {
51 1777 : pos2->second->clear();
52 : }
53 : }
54 : #endif
55 202 : }
56 :
57 0 : void TypeLookupService::get_type_objects(const TypeIdentifierSeq& type_ids,
58 : TypeIdentifierTypeObjectPairSeq& types) const
59 : {
60 0 : ACE_GUARD(ACE_Thread_Mutex, g, mutex_);
61 0 : for (unsigned i = 0; i < type_ids.length(); ++i) {
62 0 : TypeMap::const_iterator pos = type_map_.find(type_ids[i]);
63 0 : if (pos != type_map_.end()) {
64 0 : types.append(TypeIdentifierTypeObjectPair(pos->first, pos->second));
65 : }
66 : }
67 0 : }
68 :
69 620 : const TypeObject& TypeLookupService::get_type_object(const TypeIdentifier& type_id) const
70 : {
71 620 : ACE_GUARD_RETURN(ACE_Thread_Mutex, g, mutex_, to_empty_);
72 620 : return get_type_object_i(type_id);
73 620 : }
74 :
75 1124 : const TypeObject& TypeLookupService::get_type_object_i(const TypeIdentifier& type_id) const
76 : {
77 1124 : const TypeMap::const_iterator pos = type_map_.find(type_id);
78 1124 : if (pos != type_map_.end()) {
79 1120 : return pos->second;
80 : }
81 4 : return to_empty_;
82 : }
83 :
84 0 : bool TypeLookupService::get_type_dependencies(const TypeIdentifier& type_id,
85 : TypeIdentifierWithSizeSeq& dependencies) const
86 : {
87 0 : ACE_GUARD_RETURN(ACE_Thread_Mutex, g, mutex_, false);
88 0 : const TypeIdentifierWithSizeSeqMap::const_iterator it = type_dependencies_map_.find(type_id);
89 0 : if (it != type_dependencies_map_.end()) {
90 0 : dependencies = it->second;
91 0 : return true;
92 : }
93 0 : return false;
94 0 : }
95 :
96 0 : void TypeLookupService::get_type_dependencies(const TypeIdentifierSeq& type_ids,
97 : TypeIdentifierWithSizeSeq& dependencies) const
98 : {
99 0 : ACE_GUARD(ACE_Thread_Mutex, g, mutex_);
100 0 : get_type_dependencies_i(type_ids, dependencies);
101 0 : }
102 :
103 0 : void TypeLookupService::get_type_dependencies_i(const TypeIdentifierSeq& type_ids,
104 : TypeIdentifierWithSizeSeq& dependencies) const
105 : {
106 0 : OPENDDS_SET(TypeIdentifier) tmp;
107 0 : for (unsigned i = 0; i < type_ids.length(); ++i) {
108 0 : const TypeIdentifierWithSizeSeqMap::const_iterator it = type_dependencies_map_.find(type_ids[i]);
109 0 : if (it != type_dependencies_map_.end()) {
110 0 : for (unsigned j = 0; j < it->second.length(); ++j) {
111 0 : tmp.insert(it->second[j].type_id);
112 : }
113 : }
114 : }
115 :
116 : // All dependent TypeIdentifiers are expected to have an entry in the TypeObject cache.
117 0 : dependencies.length(static_cast<unsigned>(tmp.size()));
118 0 : OPENDDS_SET(TypeIdentifier)::const_iterator iter = tmp.begin();
119 0 : for (unsigned i = 0; iter != tmp.end(); ++i, ++iter) {
120 0 : const TypeMap::const_iterator tobj_it = type_map_.find(*iter);
121 0 : if (tobj_it != type_map_.end()) {
122 0 : dependencies[i].type_id = *iter;
123 0 : const size_t sz = DCPS::serialized_size(get_typeobject_encoding(), tobj_it->second);
124 0 : dependencies[i].typeobject_serialized_size = static_cast<unsigned>(sz);
125 : }
126 : }
127 0 : }
128 :
129 0 : void TypeLookupService::add_type_objects_to_cache(const TypeIdentifierTypeObjectPairSeq& types)
130 : {
131 0 : ACE_GUARD(ACE_Thread_Mutex, g, mutex_);
132 0 : for (unsigned i = 0; i < types.length(); ++i) {
133 0 : const TypeMap::iterator pos = type_map_.find(types[i].type_identifier);
134 0 : if (pos == type_map_.end()) {
135 0 : TypeObject to = types[i].type_object;
136 0 : if (set_type_object_defaults(to)) {
137 0 : type_map_.insert(std::make_pair(types[i].type_identifier, to));
138 : }
139 0 : }
140 : }
141 0 : }
142 :
143 230 : void TypeLookupService::add(TypeMap::const_iterator begin, TypeMap::const_iterator end)
144 : {
145 230 : ACE_GUARD(ACE_Thread_Mutex, g, mutex_);
146 230 : type_map_.insert(begin, end);
147 230 : }
148 :
149 104 : void TypeLookupService::add(const TypeIdentifier& ti, const TypeObject& tobj)
150 : {
151 104 : ACE_GUARD(ACE_Thread_Mutex, g, mutex_);
152 104 : TypeMap::const_iterator pos = type_map_.find(ti);
153 104 : if (pos == type_map_.end()) {
154 104 : type_map_.insert(std::make_pair(ti, tobj));
155 : }
156 104 : }
157 :
158 53 : void TypeLookupService::update_type_identifier_map(const TypeIdentifierPairSeq& tid_pairs)
159 : {
160 230 : for (ACE_CDR::ULong i = 0; i < tid_pairs.length(); ++i) {
161 177 : const TypeIdentifierPair& pair = tid_pairs[i];
162 177 : complete_to_minimal_ti_map_.insert(std::make_pair(pair.type_identifier1, pair.type_identifier2));
163 : }
164 53 : }
165 :
166 0 : void TypeLookupService::cache_type_info(const DDS::BuiltinTopicKey_t& key,
167 : const TypeInformation& type_info)
168 : {
169 0 : ACE_GUARD(ACE_Thread_Mutex, g, mutex_);
170 0 : if (type_info_map_.find(key) == type_info_map_.end()) {
171 0 : type_info_map_.insert(std::make_pair(key, type_info));
172 : }
173 0 : }
174 :
175 0 : const TypeInformation& TypeLookupService::get_type_info(const DDS::BuiltinTopicKey_t& key) const
176 : {
177 0 : ACE_GUARD_RETURN(ACE_Thread_Mutex, g, mutex_, type_info_empty_);
178 0 : const TypeInformationMap::const_iterator it = type_info_map_.find(key);
179 0 : if (it != type_info_map_.end()) {
180 0 : return it->second;
181 : }
182 0 : return type_info_empty_;
183 0 : }
184 :
185 7 : bool TypeLookupService::get_minimal_type_identifier(const TypeIdentifier& ct, TypeIdentifier& mt) const
186 : {
187 7 : if (ct.kind() == TK_NONE || is_fully_descriptive(ct)) {
188 6 : mt = ct;
189 6 : return true;
190 : }
191 :
192 : // Non-fully descriptive plain collection is a special case where we have to
193 : // get the minimal TypeIdentifier of the element type to create the TypeIdentifier
194 : // of the minimal collection type.
195 1 : if (is_plain_collection(ct)) {
196 0 : mt = ct;
197 0 : TypeIdentifier complete_elem_ti, minimal_elem_ti;
198 0 : switch (mt.kind()) {
199 0 : case TI_PLAIN_SEQUENCE_SMALL:
200 0 : mt.seq_sdefn().header.equiv_kind = EK_MINIMAL;
201 0 : complete_elem_ti = *ct.seq_sdefn().element_identifier;
202 0 : break;
203 0 : case TI_PLAIN_SEQUENCE_LARGE:
204 0 : mt.seq_ldefn().header.equiv_kind = EK_MINIMAL;
205 0 : complete_elem_ti = *ct.seq_ldefn().element_identifier;
206 0 : break;
207 0 : case TI_PLAIN_ARRAY_SMALL:
208 0 : mt.array_sdefn().header.equiv_kind = EK_MINIMAL;
209 0 : complete_elem_ti = *ct.array_sdefn().element_identifier;
210 0 : break;
211 0 : case TI_PLAIN_ARRAY_LARGE:
212 0 : mt.array_ldefn().header.equiv_kind = EK_MINIMAL;
213 0 : complete_elem_ti = *ct.array_ldefn().element_identifier;
214 0 : break;
215 0 : case TI_PLAIN_MAP_SMALL:
216 0 : mt.map_sdefn().header.equiv_kind = EK_MINIMAL;
217 0 : complete_elem_ti = *ct.map_sdefn().element_identifier;
218 0 : break;
219 0 : case TI_PLAIN_MAP_LARGE:
220 0 : mt.map_ldefn().header.equiv_kind = EK_MINIMAL;
221 0 : complete_elem_ti = *ct.map_ldefn().element_identifier;
222 0 : break;
223 : }
224 0 : get_minimal_type_identifier(complete_elem_ti, minimal_elem_ti);
225 :
226 0 : switch (mt.kind()) {
227 0 : case TI_PLAIN_SEQUENCE_SMALL:
228 0 : mt.seq_sdefn().element_identifier = minimal_elem_ti;
229 0 : break;
230 0 : case TI_PLAIN_SEQUENCE_LARGE:
231 0 : mt.seq_ldefn().element_identifier = minimal_elem_ti;
232 0 : break;
233 0 : case TI_PLAIN_ARRAY_SMALL:
234 0 : mt.array_sdefn().element_identifier = minimal_elem_ti;
235 0 : break;
236 0 : case TI_PLAIN_ARRAY_LARGE:
237 0 : mt.array_ldefn().element_identifier = minimal_elem_ti;
238 0 : break;
239 0 : case TI_PLAIN_MAP_SMALL:
240 : {
241 0 : mt.map_sdefn().element_identifier = minimal_elem_ti;
242 0 : TypeIdentifier minimal_key_ti;
243 0 : get_minimal_type_identifier(*ct.map_sdefn().key_identifier, minimal_key_ti);
244 0 : mt.map_sdefn().key_identifier = minimal_key_ti;
245 0 : break;
246 0 : }
247 0 : case TI_PLAIN_MAP_LARGE:
248 : {
249 0 : mt.map_ldefn().element_identifier = minimal_elem_ti;
250 0 : TypeIdentifier minimal_key_ti;
251 0 : get_minimal_type_identifier(*ct.map_ldefn().key_identifier, minimal_key_ti);
252 0 : mt.map_ldefn().key_identifier = minimal_key_ti;
253 0 : break;
254 0 : }
255 : }
256 :
257 0 : return true;
258 0 : }
259 :
260 : // Mapping for the remaining type kinds should be provided by the remote endpoint.
261 1 : const TypeIdentifierMap::const_iterator pos = complete_to_minimal_ti_map_.find(ct);
262 1 : if (pos == complete_to_minimal_ti_map_.end()) {
263 0 : ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) TypeLookupService::get_minimal_type_identifier: ")
264 : ACE_TEXT("complete TypeIdentifier not found.\n")));
265 0 : if (ct.kind() == EK_COMPLETE) {
266 0 : ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) TypeLookupService::get_minimal_type_identifier: ")
267 : ACE_TEXT(" Kind: EK_COMPLETE. Hash: (%C)\n"),
268 : equivalence_hash_to_string(ct.equivalence_hash()).c_str()));
269 0 : } else if (ct.kind() == TI_STRONGLY_CONNECTED_COMPONENT) {
270 0 : const EquivalenceKind ek = ct.sc_component_id().sc_component_id.kind;
271 0 : if (ek == EK_MINIMAL) {
272 0 : ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) TypeLookupService::get_minimal_type_identifier: ")
273 : ACE_TEXT("Expect EK_COMPLETE but received EK_MINIMAL.\n")));
274 : }
275 0 : const DCPS::String ek_str = ek == EK_COMPLETE ? "EK_COMPLETE" : "EK_MINIMAL";
276 0 : ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) TypeLookupService::get_minimal_type_identifier: ")
277 : ACE_TEXT("Kind: TI_STRONGLY_CONNECTED_COMPONENT. ")
278 : ACE_TEXT("Equivalence kind: %C. Hash: (%C). Scc length: %d. Scc index: %d\n"),
279 : ek_str.c_str(),
280 : equivalence_hash_to_string(ct.sc_component_id().sc_component_id.hash).c_str(),
281 : ct.sc_component_id().scc_length,
282 : ct.sc_component_id().scc_index));
283 0 : }
284 :
285 0 : mt = TypeIdentifier(TK_NONE);
286 0 : return false;
287 : }
288 1 : mt = pos->second;
289 1 : return true;
290 : }
291 :
292 0 : bool TypeLookupService::set_type_object_defaults(TypeObject& to)
293 : {
294 0 : switch (to.minimal.kind) {
295 0 : case TK_STRUCTURE:
296 : {
297 0 : const TypeFlag flags = to.minimal.struct_type.struct_flags & TypeFlagMinimalMask;
298 0 : if (!(flags == IS_FINAL || flags == IS_APPENDABLE || flags == IS_MUTABLE)) {
299 0 : if (DCPS::log_level >= DCPS::LogLevel::Error) {
300 0 : ACE_ERROR((LM_ERROR,
301 : "(%P|%t) ERROR: TypeLookupService::set_type_object_defaults: "
302 : "Invalid extensibility kind in TK_STRUCTURE\n"));
303 : }
304 0 : return false;
305 : }
306 : }
307 0 : break;
308 0 : case TK_UNION:
309 : {
310 0 : const TypeFlag flags = to.minimal.union_type.union_flags & TypeFlagMinimalMask;
311 0 : if (!(flags == IS_FINAL || flags == IS_APPENDABLE || flags == IS_MUTABLE)) {
312 0 : if (DCPS::log_level >= DCPS::LogLevel::Error) {
313 0 : ACE_ERROR((LM_ERROR,
314 : "(%P|%t) ERROR: TypeLookupService::set_type_object_defaults: "
315 : "Invalid extensibility kind in TK_UNION\n"));
316 : }
317 0 : return false;
318 : }
319 : }
320 0 : break;
321 0 : case TK_ENUM:
322 : {
323 0 : const TypeFlag flags = to.minimal.enumerated_type.enum_flags & TypeFlagMinimalMask;
324 : // flags == 0 is for backwards compatibility.
325 0 : if (!(flags == 0 || flags == IS_FINAL || flags == IS_APPENDABLE)) {
326 0 : if (DCPS::log_level >= DCPS::LogLevel::Error) {
327 0 : ACE_ERROR((LM_ERROR,
328 : "(%P|%t) ERROR: TypeLookupService::set_type_object_defaults: "
329 : "Invalid extensibility kind in TK_ENUM\n"));
330 : }
331 0 : return false;
332 : }
333 0 : if (flags == 0 && DCPS::log_level >= DCPS::LogLevel::Warning) {
334 0 : ACE_ERROR((LM_WARNING,
335 : "(%P|%t) WARNING: TypeLookupService::set_type_object_defaults: "
336 : "Zero extensibility flags in TK_ENUM\n"));
337 : }
338 : }
339 0 : break;
340 0 : case TK_BITMASK:
341 : {
342 0 : const TypeFlag flags = to.minimal.bitmask_type.bitmask_flags & TypeFlagMinimalMask;
343 0 : if (!(flags == IS_FINAL || flags == IS_APPENDABLE)) {
344 0 : if (DCPS::log_level >= DCPS::LogLevel::Error) {
345 0 : ACE_ERROR((LM_ERROR,
346 : "(%P|%t) ERROR: TypeLookupService::set_type_object_defaults: "
347 : "Invalid extensibility kind in TK_BITMASK\n"));
348 : }
349 0 : return false;
350 : }
351 : }
352 0 : break;
353 0 : default:
354 0 : break;
355 : }
356 :
357 0 : switch (to.complete.kind) {
358 0 : case TK_STRUCTURE:
359 : {
360 0 : const TypeFlag flags = to.complete.struct_type.struct_flags & TypeFlagMinimalMask;
361 0 : if (!(flags == IS_FINAL || flags == IS_APPENDABLE || flags == IS_MUTABLE)) {
362 0 : if (DCPS::log_level >= DCPS::LogLevel::Error) {
363 0 : ACE_ERROR((LM_ERROR,
364 : "(%P|%t) ERROR: TypeLookupService::set_type_object_defaults: "
365 : "Invalid extensibility kind in TK_STRUCTURE\n"));
366 : }
367 0 : return false;
368 : }
369 : }
370 0 : break;
371 0 : case TK_UNION:
372 : {
373 0 : const TypeFlag flags = to.complete.union_type.union_flags & TypeFlagMinimalMask;
374 0 : if (!(flags == IS_FINAL || flags == IS_APPENDABLE || flags == IS_MUTABLE)) {
375 0 : if (DCPS::log_level >= DCPS::LogLevel::Error) {
376 0 : ACE_ERROR((LM_ERROR,
377 : "(%P|%t) ERROR: TypeLookupService::set_type_object_defaults: "
378 : "Invalid extensibility kind in TK_UNION\n"));
379 : }
380 0 : return false;
381 : }
382 : }
383 0 : break;
384 0 : case TK_ENUM:
385 : {
386 0 : const TypeFlag flags = to.complete.enumerated_type.enum_flags & TypeFlagMinimalMask;
387 : // flags == 0 is for backwards compatibility.
388 0 : if (!(flags == 0 || flags == IS_FINAL || flags == IS_APPENDABLE)) {
389 0 : if (DCPS::log_level >= DCPS::LogLevel::Error) {
390 0 : ACE_ERROR((LM_ERROR,
391 : "(%P|%t) ERROR: TypeLookupService::set_type_object_defaults: "
392 : "Invalid extensibility kind in TK_ENUM\n"));
393 : }
394 0 : return false;
395 : }
396 0 : if (flags == 0 && DCPS::log_level >= DCPS::LogLevel::Warning) {
397 0 : ACE_ERROR((LM_WARNING,
398 : "(%P|%t) WARNING: TypeLookupService::set_type_object_defaults: "
399 : "Zero extensibility flags in TK_ENUM\n"));
400 : }
401 : }
402 0 : break;
403 0 : case TK_BITMASK:
404 : {
405 0 : const TypeFlag flags = to.complete.bitmask_type.bitmask_flags & TypeFlagMinimalMask;
406 0 : if (!(flags == IS_FINAL || flags == IS_APPENDABLE)) {
407 0 : if (DCPS::log_level >= DCPS::LogLevel::Error) {
408 0 : ACE_ERROR((LM_ERROR,
409 : "(%P|%t) ERROR: TypeLookupService::set_type_object_defaults: "
410 : "Invalid extensibility kind in TK_BITMASK\n"));
411 : }
412 0 : return false;
413 : }
414 : }
415 0 : break;
416 0 : default:
417 0 : break;
418 : }
419 :
420 0 : return true;
421 : }
422 :
423 1 : bool TypeLookupService::complete_to_minimal_struct(const CompleteStructType& ct,
424 : MinimalStructType& mt) const
425 : {
426 1 : mt.struct_flags = ct.struct_flags;
427 1 : if (!get_minimal_type_identifier(ct.header.base_type, mt.header.base_type)) {
428 0 : return false;
429 : }
430 1 : mt.member_seq.length(ct.member_seq.length());
431 :
432 2 : for (ACE_CDR::ULong i = 0; i < ct.member_seq.length(); ++i) {
433 1 : mt.member_seq[i].common.member_id = ct.member_seq[i].common.member_id;
434 1 : mt.member_seq[i].common.member_flags = ct.member_seq[i].common.member_flags;
435 1 : if (!get_minimal_type_identifier(ct.member_seq[i].common.member_type_id,
436 1 : mt.member_seq[i].common.member_type_id)) {
437 0 : return false;
438 : }
439 1 : hash_member_name(mt.member_seq[i].detail.name_hash, ct.member_seq[i].detail.name);
440 : }
441 1 : return true;
442 : }
443 :
444 1 : bool TypeLookupService::complete_to_minimal_union(const CompleteUnionType& ct,
445 : MinimalUnionType& mt) const
446 : {
447 1 : mt.union_flags = ct.union_flags;
448 1 : mt.discriminator.common.member_flags = ct.discriminator.common.member_flags;
449 1 : if (!get_minimal_type_identifier(ct.discriminator.common.type_id,
450 1 : mt.discriminator.common.type_id)) {
451 0 : return false;
452 : }
453 1 : mt.member_seq.length(ct.member_seq.length());
454 :
455 3 : for (ACE_CDR::ULong i = 0; i < ct.member_seq.length(); ++i) {
456 2 : mt.member_seq[i].common.member_id = ct.member_seq[i].common.member_id;
457 2 : mt.member_seq[i].common.member_flags = ct.member_seq[i].common.member_flags;
458 2 : if (!get_minimal_type_identifier(ct.member_seq[i].common.type_id,
459 2 : mt.member_seq[i].common.type_id)) {
460 0 : return false;
461 : }
462 2 : mt.member_seq[i].common.label_seq = ct.member_seq[i].common.label_seq;
463 2 : hash_member_name(mt.member_seq[i].detail.name_hash, ct.member_seq[i].detail.name);
464 : }
465 1 : return true;
466 : }
467 :
468 0 : bool TypeLookupService::complete_to_minimal_annotation(const CompleteAnnotationType& ct,
469 : MinimalAnnotationType& mt) const
470 : {
471 0 : mt.annotation_flag = ct.annotation_flag;
472 0 : mt.member_seq.length(ct.member_seq.length());
473 :
474 0 : for (ACE_CDR::ULong i = 0; i < ct.member_seq.length(); ++i) {
475 0 : mt.member_seq[i].common.member_flags = ct.member_seq[i].common.member_flags;
476 0 : if (!get_minimal_type_identifier(ct.member_seq[i].common.member_type_id,
477 0 : mt.member_seq[i].common.member_type_id)) {
478 0 : return false;
479 : }
480 0 : hash_member_name(mt.member_seq[i].name_hash, ct.member_seq[i].name);
481 0 : mt.member_seq[i].default_value = ct.member_seq[i].default_value;
482 : }
483 0 : return true;
484 : }
485 :
486 2 : bool TypeLookupService::complete_to_minimal_alias(const CompleteAliasType& ct,
487 : MinimalAliasType& mt) const
488 : {
489 2 : mt.alias_flags = ct.alias_flags;
490 2 : mt.body.common.related_flags = ct.body.common.related_flags;
491 2 : if (!get_minimal_type_identifier(ct.body.common.related_type,
492 2 : mt.body.common.related_type)) {
493 0 : return false;
494 : }
495 2 : return true;
496 : }
497 :
498 0 : bool TypeLookupService::complete_to_minimal_sequence(const CompleteSequenceType& ct,
499 : MinimalSequenceType& mt) const
500 : {
501 0 : mt.collection_flag = ct.collection_flag;
502 0 : mt.header.common = ct.header.common;
503 0 : mt.element.common.element_flags = ct.element.common.element_flags;
504 0 : if (!get_minimal_type_identifier(ct.element.common.type, mt.element.common.type)) {
505 0 : return false;
506 : }
507 0 : return true;
508 : }
509 :
510 0 : bool TypeLookupService::complete_to_minimal_array(const CompleteArrayType& ct,
511 : MinimalArrayType& mt) const
512 : {
513 0 : mt.collection_flag = ct.collection_flag;
514 0 : mt.header.common = ct.header.common;
515 0 : mt.element.common.element_flags = ct.element.common.element_flags;
516 0 : if (!get_minimal_type_identifier(ct.element.common.type, mt.element.common.type)) {
517 0 : return false;
518 : }
519 0 : return true;
520 : }
521 :
522 0 : bool TypeLookupService::complete_to_minimal_map(const CompleteMapType& ct,
523 : MinimalMapType& mt) const
524 : {
525 0 : mt.collection_flag = ct.collection_flag;
526 0 : mt.header.common = ct.header.common;
527 0 : mt.key.common.element_flags = ct.key.common.element_flags;
528 0 : if (!get_minimal_type_identifier(ct.key.common.type, mt.key.common.type)) {
529 0 : return false;
530 : }
531 0 : mt.element.common.element_flags = ct.element.common.element_flags;
532 0 : if (!get_minimal_type_identifier(ct.element.common.type, mt.element.common.type)) {
533 0 : return false;
534 : }
535 0 : return true;
536 : }
537 :
538 1 : bool TypeLookupService::complete_to_minimal_enumerated(const CompleteEnumeratedType& ct,
539 : MinimalEnumeratedType& mt) const
540 : {
541 1 : mt.enum_flags = ct.enum_flags;
542 1 : mt.header.common = ct.header.common;
543 1 : mt.literal_seq.length(ct.literal_seq.length());
544 3 : for (ACE_CDR::ULong i = 0; i < ct.literal_seq.length(); ++i) {
545 2 : mt.literal_seq[i].common = ct.literal_seq[i].common;
546 2 : hash_member_name(mt.literal_seq[i].detail.name_hash, ct.literal_seq[i].detail.name);
547 : }
548 1 : return true;
549 : }
550 :
551 0 : bool TypeLookupService::complete_to_minimal_bitmask(const CompleteBitmaskType& ct,
552 : MinimalBitmaskType& mt) const
553 : {
554 0 : mt.bitmask_flags = ct.bitmask_flags;
555 0 : mt.header.common = ct.header.common;
556 0 : mt.flag_seq.length(ct.flag_seq.length());
557 0 : for (ACE_CDR::ULong i = 0; i < ct.flag_seq.length(); ++i) {
558 0 : mt.flag_seq[i].common = ct.flag_seq[i].common;
559 0 : hash_member_name(mt.flag_seq[i].detail.name_hash, ct.flag_seq[i].detail.name);
560 : }
561 0 : return true;
562 : }
563 :
564 0 : bool TypeLookupService::complete_to_minimal_bitset(const CompleteBitsetType& ct,
565 : MinimalBitsetType& mt) const
566 : {
567 0 : mt.bitset_flags = ct.bitset_flags;
568 0 : mt.field_seq.length(ct.field_seq.length());
569 0 : for (ACE_CDR::ULong i = 0; i < ct.field_seq.length(); ++i) {
570 0 : mt.field_seq[i].common = ct.field_seq[i].common;
571 0 : hash_member_name(mt.field_seq[i].name_hash, ct.field_seq[i].detail.name);
572 : }
573 0 : return true;
574 : }
575 :
576 5 : bool TypeLookupService::complete_to_minimal_type_object(const TypeObject& cto, TypeObject& mto) const
577 : {
578 5 : mto.kind = EK_MINIMAL;
579 5 : mto.minimal.kind = cto.complete.kind;
580 :
581 5 : switch (cto.complete.kind) {
582 2 : case TK_ALIAS:
583 2 : return complete_to_minimal_alias(cto.complete.alias_type, mto.minimal.alias_type);
584 0 : case TK_ANNOTATION:
585 0 : return complete_to_minimal_annotation(cto.complete.annotation_type, mto.minimal.annotation_type);
586 1 : case TK_STRUCTURE:
587 1 : return complete_to_minimal_struct(cto.complete.struct_type, mto.minimal.struct_type);
588 1 : case TK_UNION:
589 1 : return complete_to_minimal_union(cto.complete.union_type, mto.minimal.union_type);
590 0 : case TK_BITSET:
591 0 : return complete_to_minimal_bitset(cto.complete.bitset_type, mto.minimal.bitset_type);
592 0 : case TK_SEQUENCE:
593 0 : return complete_to_minimal_sequence(cto.complete.sequence_type, mto.minimal.sequence_type);
594 0 : case TK_ARRAY:
595 0 : return complete_to_minimal_array(cto.complete.array_type, mto.minimal.array_type);
596 0 : case TK_MAP:
597 0 : return complete_to_minimal_map(cto.complete.map_type, mto.minimal.map_type);
598 1 : case TK_ENUM:
599 1 : return complete_to_minimal_enumerated(cto.complete.enumerated_type, mto.minimal.enumerated_type);
600 0 : case TK_BITMASK:
601 0 : return complete_to_minimal_bitmask(cto.complete.bitmask_type, mto.minimal.bitmask_type);
602 0 : default:
603 0 : return false;
604 : }
605 : }
606 :
607 : #ifndef OPENDDS_SAFETY_PROFILE
608 834 : DDS::MemberDescriptor* TypeLookupService::complete_struct_member_to_member_descriptor(
609 : const CompleteStructMember& cm, const DCPS::GUID_t& guid)
610 : {
611 834 : DDS::MemberDescriptor_var md = new MemberDescriptorImpl();
612 834 : md->name(cm.detail.name.c_str());
613 834 : md->id(cm.common.member_id);
614 834 : DDS::DynamicType_var dt = type_identifier_to_dynamic(cm.common.member_type_id, guid);
615 834 : md->type(dt);
616 834 : handle_tryconstruct_flags(md, cm.common.member_flags);
617 834 : md->is_key(cm.common.member_flags & IS_KEY);
618 834 : md->is_optional(cm.common.member_flags & IS_OPTIONAL);
619 834 : md->is_must_understand(cm.common.member_flags & IS_MUST_UNDERSTAND);
620 834 : md->is_shared(cm.common.member_flags & IS_EXTERNAL);
621 834 : md->is_default_label(false);
622 1668 : return md._retn();
623 834 : }
624 :
625 420 : DDS::MemberDescriptor* TypeLookupService::complete_union_member_to_member_descriptor(
626 : const CompleteUnionMember& cm, const DCPS::GUID_t& guid)
627 : {
628 420 : DDS::MemberDescriptor_var md = new MemberDescriptorImpl();
629 420 : md->name(cm.detail.name.c_str());
630 420 : md->id(cm.common.member_id);
631 420 : DDS::DynamicType_var dt = type_identifier_to_dynamic(cm.common.type_id, guid);
632 420 : md->type(dt);
633 : // Make a copy.
634 : // FUTURE: Have the TypeObject code use DDS::UnionCaseLabelSeq
635 420 : DDS::UnionCaseLabelSeq labels;
636 420 : labels.length(cm.common.label_seq.length());
637 822 : for (unsigned int idx = 0; idx != labels.length(); ++idx) {
638 402 : labels[idx] = cm.common.label_seq[idx];
639 : }
640 420 : md->label(labels);
641 420 : handle_tryconstruct_flags(md, cm.common.member_flags);
642 420 : md->is_key(false);
643 420 : md->is_optional(false);
644 420 : md->is_must_understand(false);
645 420 : md->is_shared(cm.common.member_flags & IS_EXTERNAL);
646 420 : md->is_default_label(cm.common.member_flags & IS_DEFAULT);
647 840 : return md._retn();
648 420 : }
649 :
650 0 : DDS::MemberDescriptor* TypeLookupService::complete_annotation_member_to_member_descriptor(
651 : const CompleteAnnotationParameter& cm, const DCPS::GUID_t& guid)
652 : {
653 0 : DDS::MemberDescriptor_var md = new MemberDescriptorImpl();
654 0 : md->name(cm.name.c_str());
655 0 : DDS::DynamicType_var dt = type_identifier_to_dynamic(cm.common.member_type_id, guid);
656 0 : md->type(dt);
657 0 : md->try_construct_kind(DDS::DISCARD);
658 0 : md->is_key(false);
659 0 : md->is_optional(false);
660 0 : md->is_must_understand(false);
661 0 : md->is_shared(false);
662 0 : md->is_default_label(false);
663 0 : return md._retn();
664 0 : }
665 :
666 117 : DDS::DynamicType_ptr TypeLookupService::complete_to_dynamic(const CompleteTypeObject& cto, const DCPS::GUID_t& guid)
667 : {
668 117 : DynamicTypeImpl* dt = new DynamicTypeImpl();
669 117 : DDS::DynamicType_var dt_var = dt;
670 117 : complete_to_dynamic_i(dt, cto, guid);
671 234 : return dt_var._retn();
672 117 : }
673 :
674 : namespace {
675 :
676 269 : DDS::ExtensibilityKind type_flags_to_extensibility(TypeFlag flags)
677 : {
678 269 : if (flags & IS_MUTABLE) {
679 50 : return DDS::MUTABLE;
680 : }
681 219 : if (flags & IS_APPENDABLE) {
682 147 : return DDS::APPENDABLE;
683 : }
684 72 : return DDS::FINAL;
685 : }
686 :
687 : }
688 :
689 621 : void TypeLookupService::complete_to_dynamic_i(DynamicTypeImpl* dt,
690 : const CompleteTypeObject& cto,
691 : const DCPS::GUID_t& guid)
692 : {
693 621 : DDS::TypeDescriptor_var td = new TypeDescriptorImpl();
694 621 : switch (cto.kind) {
695 348 : case TK_ALIAS: {
696 348 : td->kind(TK_ALIAS);
697 348 : td->name(cto.alias_type.header.detail.type_name.c_str());
698 348 : const DDS::DynamicType_var temp = type_identifier_to_dynamic(cto.alias_type.body.common.related_type, guid);
699 348 : td->base_type(temp);
700 : // The spec says that Alias DynamicTypes should have DynamicTypeMembers, but that leads to redundancy
701 348 : }
702 348 : break;
703 62 : case TK_ENUM:
704 62 : td->kind(TK_ENUM);
705 62 : td->name(cto.enumerated_type.header.detail.type_name.c_str());
706 62 : if ((cto.enumerated_type.enum_flags & TypeFlagMinimalMask) == 0) {
707 0 : td->extensibility_kind(DDS::APPENDABLE);
708 : } else {
709 62 : td->extensibility_kind(type_flags_to_extensibility(cto.enumerated_type.enum_flags));
710 : }
711 62 : td->bound().length(1);
712 62 : td->bound()[0] = cto.enumerated_type.header.common.bit_bound;
713 1078 : for (ACE_CDR::ULong i = 0; i < cto.enumerated_type.literal_seq.length(); ++i) {
714 1016 : DynamicTypeMemberImpl* dtm = new DynamicTypeMemberImpl();
715 1016 : DDS::DynamicTypeMember_var dtm_var = dtm;
716 1016 : MemberDescriptorImpl* md = new MemberDescriptorImpl();
717 1016 : DDS::MemberDescriptor_var md_var = md;
718 1016 : md->name(cto.enumerated_type.literal_seq[i].detail.name.c_str());
719 : // Use Id to convey the value of the enumerator.
720 1016 : md->id(cto.enumerated_type.literal_seq[i].common.value);
721 1016 : md->type(dt);
722 1016 : md->is_default_label(cto.enumerated_type.literal_seq[i].common.flags & IS_DEFAULT);
723 1016 : md->index(i);
724 1016 : dtm->set_descriptor(md);
725 1016 : dt->insert_dynamic_member(dtm);
726 1016 : }
727 62 : break;
728 0 : case TK_BITMASK: {
729 0 : td->kind(TK_BITMASK);
730 0 : td->name(cto.bitmask_type.header.detail.type_name.c_str());
731 0 : td->extensibility_kind(type_flags_to_extensibility(cto.bitmask_type.bitmask_flags));
732 0 : td->bound().length(1);
733 0 : td->bound()[0] = cto.bitmask_type.header.common.bit_bound;
734 0 : const DDS::DynamicType_var temp = type_identifier_to_dynamic(TypeIdentifier(TK_BOOLEAN), guid);
735 0 : td->element_type(temp);
736 0 : for (ACE_CDR::ULong i = 0; i < cto.bitmask_type.flag_seq.length(); ++i) {
737 0 : DynamicTypeMemberImpl* dtm = new DynamicTypeMemberImpl();
738 0 : DDS::DynamicTypeMember_var dtm_var = dtm;
739 0 : MemberDescriptorImpl* md = new MemberDescriptorImpl();
740 0 : DDS::MemberDescriptor_var md_var = md;
741 0 : md->name(cto.bitmask_type.flag_seq[i].detail.name.c_str());
742 0 : const DDS::DynamicType_var temp = type_identifier_to_dynamic(TypeIdentifier(TK_BOOLEAN), guid);
743 0 : md->type(temp);
744 0 : md->index(i);
745 0 : dtm->set_descriptor(md);
746 0 : dt->insert_dynamic_member(dtm);
747 0 : }
748 0 : }
749 0 : break;
750 0 : case TK_ANNOTATION:
751 0 : td->kind(TK_ANNOTATION);
752 0 : td->name(cto.annotation_type.header.annotation_name.c_str());
753 0 : for (ACE_CDR::ULong i = 0; i < cto.annotation_type.member_seq.length(); ++i) {
754 0 : DDS::MemberDescriptor_var md = complete_annotation_member_to_member_descriptor(cto.annotation_type.member_seq[i], guid);
755 0 : md->index(i);
756 0 : md->id(i);
757 0 : DynamicTypeMemberImpl* dtm = new DynamicTypeMemberImpl();
758 0 : DDS::DynamicTypeMember_var dtm_var = dtm;
759 0 : dtm->set_descriptor(md);
760 0 : dt->insert_dynamic_member(dtm);
761 0 : }
762 0 : break;
763 158 : case TK_STRUCTURE: {
764 158 : td->kind(TK_STRUCTURE);
765 158 : td->name(cto.struct_type.header.detail.type_name.c_str());
766 158 : if (cto.struct_type.header.base_type.kind() != TK_NONE) {
767 0 : const DDS::DynamicType_var base = type_identifier_to_dynamic(cto.struct_type.header.base_type, guid);
768 0 : td->base_type(base);
769 0 : }
770 158 : td->extensibility_kind(type_flags_to_extensibility(cto.struct_type.struct_flags));
771 158 : td->is_nested(cto.struct_type.struct_flags & IS_NESTED);
772 992 : for (ACE_CDR::ULong i = 0; i < cto.struct_type.member_seq.length(); ++i) {
773 834 : DynamicTypeMemberImpl* dtm = new DynamicTypeMemberImpl();
774 834 : DDS::DynamicTypeMember_var dtm_var = dtm;
775 834 : DDS::MemberDescriptor_var md = complete_struct_member_to_member_descriptor(cto.struct_type.member_seq[i], guid);
776 834 : md->index(i);
777 834 : dtm->set_descriptor(md);
778 834 : dt->insert_dynamic_member(dtm);
779 834 : }
780 : }
781 158 : break;
782 49 : case TK_UNION: {
783 49 : td->kind(TK_UNION);
784 49 : td->name(cto.union_type.header.detail.type_name.c_str());
785 49 : td->extensibility_kind(type_flags_to_extensibility(cto.union_type.union_flags));
786 49 : td->is_nested(cto.union_type.union_flags & IS_NESTED);
787 :
788 : const DDS::DynamicType_var disc_type =
789 49 : type_identifier_to_dynamic(cto.union_type.discriminator.common.type_id, guid);
790 49 : td->discriminator_type(disc_type);
791 49 : DDS::MemberDescriptor_var disc_md = new MemberDescriptorImpl();
792 49 : disc_md->name("discriminator");
793 49 : disc_md->is_key(cto.union_type.discriminator.common.member_flags & IS_KEY);
794 49 : disc_md->type(disc_type);
795 49 : disc_md->id(DISCRIMINATOR_ID);
796 49 : disc_md->index(DISCRIMINATOR_ID);
797 49 : DynamicTypeMemberImpl* disc_dtm = new DynamicTypeMemberImpl();
798 49 : DDS::DynamicTypeMember_var disc_dtm_var = disc_dtm;
799 49 : disc_dtm->set_descriptor(disc_md);
800 49 : dt->insert_dynamic_member(disc_dtm);
801 :
802 469 : for (ACE_CDR::ULong i = 0; i < cto.union_type.member_seq.length(); ++i) {
803 420 : DDS::MemberDescriptor_var md = complete_union_member_to_member_descriptor(cto.union_type.member_seq[i], guid);
804 420 : md->index(i);
805 420 : DynamicTypeMemberImpl* dtm = new DynamicTypeMemberImpl();
806 420 : DDS::DynamicTypeMember_var dtm_var = dtm;
807 420 : dtm->set_descriptor(md);
808 420 : dt->insert_dynamic_member(dtm);
809 420 : }
810 49 : }
811 49 : break;
812 0 : case TK_BITSET:
813 0 : td->kind(TK_BITSET);
814 0 : td->name(cto.bitset_type.header.detail.type_name.c_str());
815 0 : break;
816 4 : case TK_SEQUENCE: {
817 4 : td->kind(TK_SEQUENCE);
818 4 : if (cto.sequence_type.header.detail) {
819 0 : td->name(cto.sequence_type.header.detail.value().type_name.c_str());
820 : }
821 4 : td->bound().length(1);
822 4 : td->bound()[0] = cto.sequence_type.header.common.bound;
823 4 : const DDS::DynamicType_var temp = type_identifier_to_dynamic(cto.sequence_type.element.common.type, guid);
824 4 : td->element_type(temp);
825 4 : }
826 4 : break;
827 0 : case TK_ARRAY: {
828 0 : td->kind(TK_ARRAY);
829 0 : td->name(cto.array_type.header.detail.type_name.c_str());
830 : // FUTURE: Have the TypeObject code use DDS::BoundSeq
831 0 : DDS::BoundSeq bounds;
832 0 : bounds.length(cto.array_type.header.common.bound_seq.length());
833 0 : for (unsigned int idx = 0; idx != bounds.length(); ++idx) {
834 0 : bounds[idx] = cto.array_type.header.common.bound_seq[idx];
835 : }
836 0 : td->bound(bounds);
837 0 : const DDS::DynamicType_var temp = type_identifier_to_dynamic(cto.array_type.element.common.type, guid);
838 0 : td->element_type(temp);
839 0 : }
840 0 : break;
841 0 : case TK_MAP: {
842 0 : td->kind(TK_MAP);
843 0 : if (cto.map_type.header.detail) {
844 0 : td->name(cto.map_type.header.detail.value().type_name.c_str());
845 : }
846 0 : td->bound().length(1);
847 0 : td->bound()[0] = cto.map_type.header.common.bound;
848 0 : const DDS::DynamicType_var el_temp = type_identifier_to_dynamic(cto.map_type.element.common.type, guid);
849 0 : td->element_type(el_temp);
850 0 : const DDS::DynamicType_var key_temp = type_identifier_to_dynamic(cto.map_type.key.common.type, guid);
851 0 : td->key_element_type(key_temp);
852 0 : }
853 0 : break;
854 : }
855 621 : dt->set_descriptor(td);
856 621 : }
857 :
858 2117 : DDS::DynamicType_ptr TypeLookupService::type_identifier_to_dynamic(const TypeIdentifier& ti, const DCPS::GUID_t& guid)
859 : {
860 2117 : if (ti.kind() == TK_NONE) {
861 0 : if (DCPS::DCPS_debug_level >= 1) {
862 0 : ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) TypeLookupService::type_identifier_to_dynamic -")
863 : ACE_TEXT(" Encountered TK_NONE: returning nil Dynamic Type\n")));
864 : }
865 0 : return 0;
866 : }
867 2117 : DynamicTypeImpl* dt = new DynamicTypeImpl();
868 2117 : DDS::DynamicType_var dt_var = dt;
869 2117 : DDS::TypeDescriptor_var td = new TypeDescriptorImpl();
870 : {
871 2117 : ACE_Guard<ACE_Thread_Mutex> guard(mutex_);
872 2117 : const GuidTypeMap::iterator guid_found = gt_map_.find(guid);
873 2117 : if (guid_found != gt_map_.end()) {
874 2028 : const DynamicTypeMap::const_iterator ti_found = guid_found->second.find(ti);
875 2028 : if (ti_found != guid_found->second.end()) {
876 340 : return DDS::DynamicType::_duplicate(ti_found->second);
877 : } else {
878 1688 : guid_found->second.insert(std::make_pair(ti, dt_var));
879 : }
880 : } else {
881 89 : DynamicTypeMap dt_map;
882 89 : dt_map.insert(std::make_pair(ti, dt_var));
883 89 : gt_map_.insert(std::make_pair(guid, dt_map));
884 89 : }
885 2117 : }
886 :
887 1777 : switch (ti.kind()) {
888 50 : case TK_BOOLEAN:
889 50 : td->kind(TK_BOOLEAN);
890 50 : td->name("Boolean");
891 50 : dt->set_descriptor(td);
892 50 : break;
893 50 : case TK_BYTE:
894 50 : td->kind(TK_BYTE);
895 50 : td->name("Byte");
896 50 : dt->set_descriptor(td);
897 50 : break;
898 64 : case TK_INT16:
899 64 : td->kind(TK_INT16);
900 64 : td->name("Int16");
901 64 : dt->set_descriptor(td);
902 64 : break;
903 87 : case TK_INT32:
904 87 : td->kind(TK_INT32);
905 87 : td->name("Int32");
906 87 : dt->set_descriptor(td);
907 87 : break;
908 46 : case TK_INT64:
909 46 : td->kind(TK_INT64);
910 46 : td->name("Int64");
911 46 : dt->set_descriptor(td);
912 46 : break;
913 52 : case TK_UINT16:
914 52 : td->kind(TK_UINT16);
915 52 : td->name("UInt16");
916 52 : dt->set_descriptor(td);
917 52 : break;
918 70 : case TK_UINT32:
919 70 : td->kind(TK_UINT32);
920 70 : td->name("UInt32");
921 70 : dt->set_descriptor(td);
922 70 : break;
923 46 : case TK_UINT64:
924 46 : td->kind(TK_UINT64);
925 46 : td->name("UInt64");
926 46 : dt->set_descriptor(td);
927 46 : break;
928 48 : case TK_FLOAT32:
929 48 : td->kind(TK_FLOAT32);
930 48 : td->name("Float32");
931 48 : dt->set_descriptor(td);
932 48 : break;
933 46 : case TK_FLOAT64:
934 46 : td->kind(TK_FLOAT64);
935 46 : td->name("Float64");
936 46 : dt->set_descriptor(td);
937 46 : break;
938 26 : case TK_FLOAT128:
939 26 : td->kind(TK_FLOAT128);
940 26 : td->name("Float128");
941 26 : dt->set_descriptor(td);
942 26 : break;
943 69 : case TK_INT8:
944 69 : td->kind(TK_INT8);
945 69 : td->name("Int8");
946 69 : dt->set_descriptor(td);
947 69 : break;
948 46 : case TK_UINT8:
949 46 : td->kind(TK_UINT8);
950 46 : td->name("UInt8");
951 46 : dt->set_descriptor(td);
952 46 : break;
953 65 : case TK_CHAR8:
954 65 : td->kind(TK_CHAR8);
955 65 : td->name("Char8");
956 65 : dt->set_descriptor(td);
957 65 : break;
958 46 : case TK_CHAR16:
959 46 : td->kind(TK_CHAR16);
960 46 : td->name("Char16");
961 46 : dt->set_descriptor(td);
962 46 : break;
963 46 : case TI_STRING8_SMALL: {
964 46 : td->kind(TK_STRING8);
965 46 : td->name("String8");
966 46 : td->bound().length(1);
967 46 : td->bound()[0] = ti.string_sdefn().bound;
968 46 : const DDS::DynamicType_var temp = type_identifier_to_dynamic(TypeIdentifier(TK_CHAR8), guid);
969 46 : td->element_type(temp);
970 46 : dt->set_descriptor(td);
971 46 : }
972 46 : break;
973 0 : case TI_STRING8_LARGE: {
974 0 : td->kind(TK_STRING8);
975 0 : td->name("String8");
976 0 : td->bound().length(1);
977 0 : td->bound()[0] = ti.string_ldefn().bound;
978 0 : const DDS::DynamicType_var temp = type_identifier_to_dynamic(TypeIdentifier(TK_CHAR8), guid);
979 0 : td->element_type(temp);
980 0 : dt->set_descriptor(td);
981 0 : }
982 0 : break;
983 46 : case TI_STRING16_SMALL: {
984 46 : td->kind(TK_STRING16);
985 46 : td->name("WString16");
986 46 : td->bound().length(1);
987 46 : td->bound()[0] = ti.string_sdefn().bound;
988 46 : const DDS::DynamicType_var temp = type_identifier_to_dynamic(TypeIdentifier(TK_CHAR16), guid);
989 46 : td->element_type(temp);
990 46 : dt->set_descriptor(td);
991 46 : }
992 46 : break;
993 0 : case TI_STRING16_LARGE: {
994 0 : td->kind(TK_STRING16);
995 0 : td->name("WString16");
996 0 : td->bound().length(1);
997 0 : td->bound()[0] = ti.string_ldefn().bound;
998 0 : const DDS::DynamicType_var temp = type_identifier_to_dynamic(TypeIdentifier(TK_CHAR16), guid);
999 0 : td->element_type(temp);
1000 0 : dt->set_descriptor(td);
1001 0 : }
1002 0 : break;
1003 314 : case TI_PLAIN_SEQUENCE_SMALL: {
1004 314 : td->kind(TK_SEQUENCE);
1005 314 : td->name("Sequence");
1006 314 : td->bound().length(1);
1007 314 : td->bound()[0] = ti.seq_sdefn().bound;
1008 314 : const DDS::DynamicType_var temp = type_identifier_to_dynamic(*ti.seq_sdefn().element_identifier, guid);
1009 314 : td->element_type(temp);
1010 314 : dt->set_descriptor(td);
1011 314 : }
1012 314 : break;
1013 0 : case TI_PLAIN_SEQUENCE_LARGE: {
1014 0 : td->kind(TK_SEQUENCE);
1015 0 : td->name("Sequence");
1016 0 : td->bound().length(1);
1017 0 : td->bound()[0] = ti.seq_ldefn().bound;
1018 0 : const DDS::DynamicType_var temp = type_identifier_to_dynamic(*ti.seq_ldefn().element_identifier, guid);
1019 0 : td->element_type(temp);
1020 0 : dt->set_descriptor(td);
1021 0 : }
1022 0 : break;
1023 56 : case TI_PLAIN_ARRAY_SMALL: {
1024 56 : td->kind(TK_ARRAY);
1025 56 : td->name("Array");
1026 56 : td->bound().length(ti.array_sdefn().array_bound_seq.length());
1027 116 : for (ACE_CDR::ULong i = 0; i< td->bound().length(); ++i) {
1028 60 : td->bound()[i] = ti.array_sdefn().array_bound_seq[i];
1029 : }
1030 56 : const DDS::DynamicType_var temp = type_identifier_to_dynamic(*ti.array_sdefn().element_identifier, guid);
1031 56 : td->element_type(temp);
1032 56 : dt->set_descriptor(td);
1033 56 : }
1034 56 : break;
1035 0 : case TI_PLAIN_ARRAY_LARGE: {
1036 0 : td->kind(TK_ARRAY);
1037 0 : td->name("Array");
1038 0 : DDS::BoundSeq bounds;
1039 0 : bounds.length(ti.array_ldefn().array_bound_seq.length());
1040 0 : for (unsigned int idx = 0; idx != bounds.length(); ++idx) {
1041 0 : bounds[idx] = ti.array_ldefn().array_bound_seq[idx];
1042 : }
1043 0 : td->bound(bounds);
1044 0 : const DDS::DynamicType_var temp = type_identifier_to_dynamic(*ti.array_ldefn().element_identifier, guid);
1045 0 : td->element_type(temp);
1046 0 : dt->set_descriptor(td);
1047 0 : }
1048 0 : break;
1049 0 : case TI_PLAIN_MAP_SMALL: {
1050 0 : td->kind(TK_MAP);
1051 0 : td->name("Map");
1052 0 : td->bound().length(1);
1053 0 : td->bound()[0] = ti.map_sdefn().bound;
1054 0 : const DDS::DynamicType_var el_temp = type_identifier_to_dynamic(*ti.map_sdefn().element_identifier, guid);
1055 0 : td->element_type(el_temp);
1056 0 : const DDS::DynamicType_var key_temp = type_identifier_to_dynamic(*ti.map_sdefn().key_identifier, guid);
1057 0 : td->key_element_type(key_temp);
1058 0 : dt->set_descriptor(td);
1059 0 : }
1060 0 : break;
1061 0 : case TI_PLAIN_MAP_LARGE: {
1062 0 : td->kind(TK_MAP);
1063 0 : td->name("Map");
1064 0 : td->bound().length(1);
1065 0 : td->bound()[0] = ti.map_ldefn().bound;
1066 0 : const DDS::DynamicType_var el_temp = type_identifier_to_dynamic(*ti.map_ldefn().element_identifier, guid);
1067 0 : td->element_type(el_temp);
1068 0 : const DDS::DynamicType_var key_temp = type_identifier_to_dynamic(*ti.map_ldefn().key_identifier, guid);
1069 0 : td->key_element_type(key_temp);
1070 0 : dt->set_descriptor(td);
1071 0 : }
1072 0 : break;
1073 504 : case TI_STRONGLY_CONNECTED_COMPONENT:
1074 : case EK_COMPLETE:
1075 : {
1076 504 : const TypeObject& to = get_type_object_i(ti);
1077 504 : if (to.kind == TK_NONE) {
1078 0 : ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) TypeLookupService::type_identifier_to_dynamic -")
1079 : ACE_TEXT(" get_type_object_i returned TK_NONE\n")));
1080 : } else {
1081 504 : complete_to_dynamic_i(dt, to.complete, guid);
1082 : }
1083 : }
1084 504 : break;
1085 0 : case EK_MINIMAL:
1086 0 : if (DCPS::DCPS_debug_level >= 1) {
1087 0 : ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) TypeLookupService::type_identifier_to_dynamic -")
1088 : ACE_TEXT(" Encountered EK_MINIMAL: returning nil Dynamic Type\n")));
1089 : }
1090 0 : break;
1091 0 : case TK_ANNOTATION:
1092 0 : td->kind(TK_ANNOTATION);
1093 0 : td->name("Annotation");
1094 0 : dt->set_descriptor(td);
1095 0 : break;
1096 : }
1097 :
1098 1777 : return dt_var._retn();
1099 2117 : }
1100 : #endif // OPENDDS_SAFETY_PROFILE
1101 :
1102 160 : void TypeLookupService::add_type_dependencies(const TypeIdentifier& type_id,
1103 : const TypeIdentifierWithSizeSeq& dependencies)
1104 : {
1105 160 : ACE_GUARD(ACE_Thread_Mutex, g, mutex_);
1106 160 : if (type_dependencies_map_.find(type_id) == type_dependencies_map_.end()) {
1107 160 : type_dependencies_map_.insert(std::make_pair(type_id, dependencies));
1108 : }
1109 160 : }
1110 :
1111 0 : bool TypeLookupService::type_object_in_cache(const TypeIdentifier& ti) const
1112 : {
1113 0 : ACE_GUARD_RETURN(ACE_Thread_Mutex, g, mutex_, false);
1114 0 : return type_map_.find(ti) != type_map_.end();
1115 0 : }
1116 :
1117 0 : bool TypeLookupService::extensibility(TypeFlag extensibility_mask, const TypeIdentifier& type_id) const
1118 : {
1119 0 : ACE_GUARD_RETURN(ACE_Thread_Mutex, g, mutex_, false);
1120 0 : bool result = false;
1121 0 : const TypeObject& to = get_type_object_i(type_id);
1122 0 : TypeKind tk = to.kind == EK_MINIMAL ? to.minimal.kind : to.complete.kind;
1123 :
1124 0 : if (TK_UNION == tk) {
1125 0 : result = to.kind == EK_MINIMAL ?
1126 0 : (to.minimal.union_type.union_flags & extensibility_mask) :
1127 0 : (to.complete.union_type.union_flags & extensibility_mask);
1128 0 : } else if (TK_STRUCTURE == tk) {
1129 0 : result = to.kind == EK_MINIMAL ?
1130 0 : (to.minimal.struct_type.struct_flags & extensibility_mask) :
1131 0 : (to.complete.struct_type.struct_flags & extensibility_mask);
1132 : }
1133 :
1134 0 : if (result) {
1135 0 : return true;
1136 : }
1137 :
1138 0 : TypeIdentifierWithSizeSeq dependencies;
1139 0 : TypeIdentifierSeq type_ids;
1140 0 : type_ids.append(type_id);
1141 0 : get_type_dependencies_i(type_ids, dependencies);
1142 :
1143 0 : for (unsigned i = 0; i < dependencies.length(); ++i) {
1144 0 : const TypeObject& dep_to = get_type_object_i(dependencies[i].type_id);
1145 0 : tk = dep_to.kind == EK_MINIMAL ? dep_to.minimal.kind : dep_to.complete.kind;
1146 :
1147 0 : if (TK_UNION == tk) {
1148 0 : result = dep_to.kind == EK_MINIMAL ?
1149 0 : (dep_to.minimal.union_type.union_flags & extensibility_mask) :
1150 0 : (dep_to.complete.union_type.union_flags & extensibility_mask);
1151 0 : } else if (TK_STRUCTURE == tk) {
1152 0 : result = dep_to.kind == EK_MINIMAL ?
1153 0 : (dep_to.minimal.struct_type.struct_flags & extensibility_mask) :
1154 0 : (dep_to.complete.struct_type.struct_flags & extensibility_mask);
1155 : }
1156 0 : if (result) {
1157 0 : return true;
1158 : }
1159 : }
1160 0 : return false;
1161 0 : }
1162 :
1163 : #ifndef OPENDDS_SAFETY_PROFILE
1164 0 : void TypeLookupService::remove_guid_from_dynamic_map(const DCPS::GUID_t& guid)
1165 : {
1166 0 : ACE_Guard<ACE_Thread_Mutex> guard(mutex_);
1167 0 : const GuidTypeMap::iterator g_found = gt_map_.find(guid);
1168 0 : if (g_found != gt_map_.end()) {
1169 0 : for (DynamicTypeMap::const_iterator pos2 = g_found->second.begin(), limit2 = g_found->second.end(); pos2 != limit2; ++pos2) {
1170 0 : pos2->second->clear();
1171 : }
1172 0 : gt_map_.erase(g_found);
1173 0 : if (DCPS::DCPS_debug_level >= 4) {
1174 0 : ACE_DEBUG((LM_DEBUG, "(%P|%t) TypeLookupService::remove_guid_from_dynamic_map: ",
1175 : "Alerted to removal of %C, removing GUID from GuidTypeMap.\n", DCPS::to_string(guid).c_str()));
1176 : }
1177 : }
1178 0 : }
1179 :
1180 0 : bool TypeLookupService::has_complete(const TypeIdentifier& ti) const
1181 : {
1182 0 : ACE_GUARD_RETURN(ACE_Thread_Mutex, g, mutex_, false);
1183 0 : return ti.kind() == EK_COMPLETE && type_map_.count(ti);
1184 0 : }
1185 : #endif
1186 :
1187 : } // namespace XTypes
1188 : } // namespace OpenDDS
1189 :
1190 : OPENDDS_END_VERSIONED_NAMESPACE_DECL
|
