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;
}
