CORBA::TypeCode_ptr TAO_Repository_i::get_canonical_typecode_i (CORBA::TypeCode_ptr tc) { CORBA::TCKind kind = tc->kind (); switch (kind) { // For all the TCKinds not covered below, no change is needed. default: return CORBA::TypeCode::_duplicate (tc); case CORBA::tk_fixed: throw CORBA::NO_IMPLEMENT (); case CORBA::tk_array: { CORBA::ULong length = tc->length (); CORBA::TypeCode_var ctype = tc->content_type (); CORBA::TypeCode_var canon_ctype = this->get_canonical_typecode_i (ctype.in ()); return this->tc_factory ()->create_array_tc (length, canon_ctype.in ()); } case CORBA::tk_sequence: { CORBA::ULong length = tc->length (); CORBA::TypeCode_var ctype = tc->content_type (); CORBA::TypeCode_var canon_ctype = this->get_canonical_typecode_i (ctype.in ()); return this->tc_factory ()->create_sequence_tc (length, canon_ctype.in ()); } case CORBA::tk_alias: case CORBA::tk_objref: case CORBA::tk_struct: case CORBA::tk_union: case CORBA::tk_enum: case CORBA::tk_except: case CORBA::tk_value: case CORBA::tk_value_box: case CORBA::tk_native: case CORBA::tk_abstract_interface: case CORBA::tk_component: case CORBA::tk_home: { CORBA::String_var id = tc->id (); ACE_TString path; int status = this->config ()->get_string_value (this->repo_ids_key (), id.in (), path); // TODO - something in case the repo id is an empty string, // or if it is not found in this repository if (status != 0) { return CORBA::TypeCode::_nil (); } ACE_Configuration_Section_Key key; this->config ()->expand_path (this->root_key (), path, key, 0); // An ExceptionDef is not an IDLType. if (kind == CORBA::tk_except) { TAO_ExceptionDef_i impl (this->repo_); impl.section_key (key); return impl.type_i (); } else { TAO_IDLType_i *impl = TAO_IFR_Service_Utils::path_to_idltype (path, this); impl->section_key (key); return impl->type_i (); } } } }
void TAO::TypeCode::Indirected_Type::set_recursive_tc (CORBA::TypeCode_ptr tc) { // link only once (should never happen that this is called twice but test anyway) if (this->recursive_tc_ == 0) { ACE_GUARD (TAO_SYNCH_MUTEX, ace_mon, this->mutex_); if (tc == 0) // should never happen return; // make sure we are the right kind CORBA::TCKind & mutable_kind = const_cast<CORBA::TCKind &> (this->kind_); mutable_kind = tc->kind (); // for every reference beside the master reference (1) // increase the master tc's reference count to keep it // safe while we're referenced outside the master's context for (unsigned long cnt = this->refcount_; cnt > 1 ;--cnt) { tc->tao_duplicate (); } this->recursive_tc_ = tc; } }
CORBA::TypeCode_ptr TAO::unaliased_typecode (CORBA::TypeCode_ptr tc) { if (CORBA::is_nil (tc)) { throw ::CORBA::BAD_PARAM (CORBA::OMGVMCID | 13, CORBA::COMPLETED_NO); } CORBA::TCKind tc_kind = tc->kind (); if (tc_kind == CORBA::tk_alias) { CORBA::TypeCode_var tc_content = CORBA::TypeCode::_duplicate (tc); // Iterate until we get to the actual unaliased type. do { tc_content = tc_content->content_type (); tc_kind = tc_content->kind (); } while (tc_kind == CORBA::tk_alias); return tc_content._retn (); } return CORBA::TypeCode::_duplicate (tc); }
DataType DataType_Handler::data_type ( const CORBA::TypeCode_ptr& src) { DANCE_TRACE("DataType_Handler::data_type"); DataType type; switch (src->kind ()) { case ::CORBA::tk_null: type.kind (TCKind::tk_null); break; case CORBA::tk_short: type.kind (TCKind::tk_short); break; case CORBA::tk_long: type.kind (TCKind::tk_long); break; case CORBA::tk_ushort: type.kind (TCKind::tk_ushort); break; case CORBA::tk_ulong: type.kind (TCKind::tk_ulong); break; case CORBA::tk_float: type.kind (TCKind::tk_float); break; case CORBA::tk_double: type.kind (TCKind::tk_double); break; case CORBA::tk_boolean: type.kind (TCKind::tk_boolean); break; case CORBA::tk_char: type.kind (TCKind::tk_char); break; case CORBA::tk_octet: type.kind (TCKind::tk_octet); break; case CORBA::tk_string: type.kind (TCKind::tk_string); break; case CORBA::tk_longlong: type.kind (TCKind::tk_longlong); break; case CORBA::tk_ulonglong: type.kind (TCKind::tk_ulonglong); break; case CORBA::tk_longdouble: type.kind (TCKind::tk_longdouble); break; case CORBA::tk_wchar: type.kind (TCKind::tk_wchar); break; case CORBA::tk_wstring: type.kind (TCKind::tk_wstring); break; case CORBA::tk_any: type.kind (TCKind::tk_any); break; case CORBA::tk_TypeCode: type.kind (TCKind::tk_TypeCode); default: DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_ERROR, "DataType_Handler::data_type - Invalid typecode\n")); throw Config_Error ("", "Invalid typecode"); } return type; }
// In this version of TAO typecodes are based on CDR, we have to // verify that CDR offers the services needed for Typecode... int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { try { CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); static const CORBA::TypeCode_ptr tcs[]= { CORBA::_tc_null, CORBA::_tc_void, CORBA::_tc_short, CORBA::_tc_long, CORBA::_tc_ushort, CORBA::_tc_ulong, CORBA::_tc_float, CORBA::_tc_double, CORBA::_tc_boolean, CORBA::_tc_char, CORBA::_tc_octet, CORBA::_tc_any, CORBA::_tc_TypeCode, CORBA::_tc_Principal, CORBA::_tc_Object, // CORBA::_tc_struct, // CORBA::_tc_union, // CORBA::_tc_enum, CORBA::_tc_string, // CORBA::_tc_sequence, // CORBA::_tc_array, // CORBA::_tc_alias, // CORBA::_tc_except, CORBA::_tc_longlong, CORBA::_tc_ulonglong, CORBA::_tc_longdouble, CORBA::_tc_wchar, CORBA::_tc_wstring, CORBA::_tc_UNKNOWN, CORBA::_tc_BAD_PARAM, CORBA::_tc_NO_MEMORY, CORBA::_tc_IMP_LIMIT, CORBA::_tc_COMM_FAILURE, CORBA::_tc_INV_OBJREF, CORBA::_tc_OBJECT_NOT_EXIST, CORBA::_tc_NO_PERMISSION, CORBA::_tc_INTERNAL, CORBA::_tc_MARSHAL, CORBA::_tc_INITIALIZE, CORBA::_tc_NO_IMPLEMENT, CORBA::_tc_BAD_TYPECODE, CORBA::_tc_BAD_OPERATION, CORBA::_tc_NO_RESOURCES, CORBA::_tc_NO_RESPONSE, CORBA::_tc_PERSIST_STORE, CORBA::_tc_BAD_INV_ORDER, CORBA::_tc_TRANSIENT, CORBA::_tc_FREE_MEM, CORBA::_tc_INV_IDENT, CORBA::_tc_INV_FLAG, CORBA::_tc_INTF_REPOS, CORBA::_tc_BAD_CONTEXT, CORBA::_tc_OBJ_ADAPTER, CORBA::_tc_DATA_CONVERSION, CORBA::TypeCode::_tc_Bounds, CORBA::TypeCode::_tc_BadKind }; static int n = sizeof (tcs) / sizeof (tcs[0]); for (const CORBA::TypeCode_ptr *i = tcs; i != tcs + n; ++i) { CORBA::TypeCode_ptr tc = *i; CORBA::TCKind k = tc->kind (); switch (k) { case CORBA::tk_objref: case CORBA::tk_struct: case CORBA::tk_union: case CORBA::tk_enum: case CORBA::tk_alias: case CORBA::tk_except: { const char *id = tc->id (); const char *name = tc->name (); CORBA::ULong length = 0; // tc->length (TAO_TRY_ENV); if (TAO_debug_level > 0) { ACE_DEBUG ((LM_DEBUG, "ID = '%C'\n" "%{%{ NAME = %C%$" " KIND = %d%$" " LENGTH = %d" "%}%}\n", (id?id:"empty ID"), (name?name:"empty name"), k, length)); } break; } default: if (TAO_debug_level > 0) { ACE_DEBUG ((LM_DEBUG, "basic type: %d\n", k)); } break; } } } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("TC"); return 1; } return 0; }
string IDLBase::tcToName(CORBA::TypeCode_ptr type) { switch(type->kind()) { case CORBA::tk_null: return ""; break; case CORBA::tk_void: return "void"; break; case CORBA::tk_short: return "short"; break; case CORBA::tk_long: return "long"; break; case CORBA::tk_longlong: return "long long"; break; case CORBA::tk_ushort: return "unsigned short"; break; case CORBA::tk_ulong: return "unsigned long"; break; case CORBA::tk_ulonglong: return "unsigned long long"; break; case CORBA::tk_float: return "float"; break; case CORBA::tk_double: return "double"; break; case CORBA::tk_longdouble: return "long double"; break; case CORBA::tk_boolean: return "boolean"; break; case CORBA::tk_char: return "char"; break; case CORBA::tk_wchar: return "wchar"; break; case CORBA::tk_octet: return "octet"; break; case CORBA::tk_any: return "any"; break; case CORBA::tk_TypeCode: return "CORBA::TypeCode"; break; case CORBA::tk_Principal: return "CORBA::Principal"; break; case CORBA::tk_fixed: break; case CORBA::tk_objref: try { return map_absolute_name(repository_->lookup_id(type->id())); } catch (...) { // CORBA::Object is not in the repository // but it can be used as parameter return "Object"; } break; case CORBA::tk_abstract_interface: case CORBA::tk_local_interface: case CORBA::tk_native: case CORBA::tk_struct: case CORBA::tk_except: case CORBA::tk_union: case CORBA::tk_enum: case CORBA::tk_sequence: case CORBA::tk_array: case CORBA::tk_alias: case CORBA::tk_value_box: case CORBA::tk_value: return map_absolute_name(repository_->lookup_id(type->id())); break; case CORBA::tk_string: return "string"; break; case CORBA::tk_wstring: return "wstring"; break; default: std::cerr << "Unknown type code (" << (int)type->kind() << ")" << std::endl; assert(false); } return ""; }
CORBA::Boolean Any_Basic_Impl::extract (const CORBA::Any &any, CORBA::TypeCode_ptr tc, void *_tao_elem) { try { CORBA::TypeCode_ptr any_tc = any._tao_get_typecode (); CORBA::Boolean const _tao_equiv = any_tc->equivalent (tc); if (!_tao_equiv) { return false; } TAO::Any_Impl * const impl = any.impl (); if (impl && !impl->encoded ()) { TAO::Any_Basic_Impl * const narrow_impl = dynamic_cast<TAO::Any_Basic_Impl *> (impl); if (narrow_impl == 0) { return false; } Any_Basic_Impl::assign_value (_tao_elem, narrow_impl); return true; } TAO::Any_Basic_Impl *replacement = TAO::Any_Basic_Impl::create_empty (any_tc); auto_ptr<TAO::Any_Basic_Impl> replacement_safety (replacement); // We know this will work since the unencoded case is covered above. TAO::Unknown_IDL_Type * const unk = dynamic_cast<TAO::Unknown_IDL_Type *> (impl); if (!unk) return false; // Get the kind of the type where we are extracting in ie. the // aliased type if there are any. Passing the aliased kind // will not help. CORBA::TCKind const tck = tc->kind (); // We don't want the rd_ptr of unk to move, in case it is // shared by another Any. This copies the state, not the buffer. TAO_InputCDR for_reading (unk->_tao_get_cdr ()); CORBA::Boolean const good_decode = replacement->demarshal_value (for_reading, static_cast<CORBA::Long> (tck)); if (good_decode) { Any_Basic_Impl::assign_value (_tao_elem, replacement, tck); const_cast<CORBA::Any &> (any).replace (replacement); replacement_safety.release (); return true; } // Duplicated by Any_Impl base class constructor. ::CORBA::release (any_tc); } catch (const ::CORBA::Exception&) { } return false; }