void
UnionIntSwitchPath::extract_from_dynany(const DynamicAny::DynAny_ptr& from,
DynamicAny::DynAny_ptr& value) const
throw (BadTypeException)
{
CORBA::TCKind tk;
DynamicAny::DynUnion_var any_union;
DynamicAny::DynAny_var discriminator;
tk = from->type()->kind();
if (tk != CORBA::tk_union)
throw BadTypeException();
any_union = DynamicAny::DynUnion::_narrow(from);
if (any_union == DynamicAny::DynUnion::_nil())
throw BadTypeException();
discriminator->insert_short(switch_value);
try{
any_union->set_discriminator(discriminator);
}
catch (CORBA::Exception& e)
{
throw BadTypeException();
}
value = any_union->member();
}
void
Any_Handler::extract_into_any (const Any& desc,
CORBA::Any& toconfig)
{
DANCE_TRACE("Any_Handler::extract_into_any");
try
{
DynamicAny::DynAny_var dyn = DYNANY_HANDLER->extract_into_dynany (desc.type (),
desc.value ());
CORBA::Any_var any_safe (dyn->to_any ());
toconfig = *any_safe;
dyn->destroy ();
}
catch (CORBA::Exception &ex)
{
DANCE_ERROR (DANCE_LOG_TERMINAL_ERROR, (LM_ERROR, DLINFO
ACE_TEXT ("Any_Handler::extract_into_any -")
ACE_TEXT (" Caught CORBA Exception while extracting into")
ACE_TEXT (" dynany: %C\n"),
ex._info ().c_str ()));
throw Config_Error (ACE_TEXT (""),
ACE_TEXT ("CORBA Exception while extracting into dynany\n"));
}
catch (Config_Error &ex)
{
throw ex;
}
catch (...)
{
throw Config_Error (ACE_TEXT (""), ACE_TEXT ("Caught error whilst parsing XML into Any\n"));
}
}
//----------------------------------------------------------------------
std::string
AnyAide::enumToString(const CORBA::Any& value)
{
CORBA::ORB_ptr orb_p = ORBHelper::getORB();
//get the dynamic any factory
CORBA::Object_var factory_obj = orb_p->resolve_initial_references ("DynAnyFactory");
//narrow it
DynamicAny::DynAnyFactory_var dynany_factory = DynamicAny::DynAnyFactory::_narrow(factory_obj.in());
//sanity check
ACE_ASSERT(!CORBA::is_nil(dynany_factory.in()));
//get the dynamic any
DynamicAny::DynAny_var dynValue = dynany_factory->create_dyn_any(value);
//sanity check
ACE_ASSERT(!CORBA::is_nil(dynValue.in()));
//narrow it to an enum
DynamicAny::DynEnum_var dynEnum = DynamicAny::DynEnum::_narrow(dynValue.in());
//another sanity check
ACE_ASSERT(!CORBA::is_nil(dynEnum.in()));
char* tString = dynEnum->get_as_string();
std::string retVal(tString);
//destroy the dynamic any
dynEnum->destroy();
//free up some dynamic memory
CORBA::string_free(tString);
return retVal;
}
// Creates DynUnion using typecodes generated through IDL compiler.
int runStatic(CORBA::ORB_ptr orb)
{
try
{
CORBA::Object_var obj =
orb->resolve_initial_references("DynAnyFactory");
DynamicAny::DynAnyFactory_var dfact =
DynamicAny::DynAnyFactory::_narrow(obj.in ());
if (CORBA::is_nil (dfact.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"Nil dynamic any factory after narrow\n"),
-1);
}
DynamicAny::DynAny_var dany =
dfact->create_dyn_any_from_type_code(DynAnyTest::_tc_EventData);
DynamicAny::DynUnion_var dunion =
DynamicAny::DynUnion::_narrow(dany.in ());
DynamicAny::DynAny_var disc = dunion->get_discriminator();
DynamicAny::DynEnum_var denum =
DynamicAny::DynEnum::_narrow(disc.in ());
if (CORBA::is_nil (denum.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"Nil dynamic enum after narrow\n"),
-1);
}
ACE_DEBUG ((LM_DEBUG, "Static Test Passed\n"));
}
catch (const CORBA::Exception & ex)
{
ex._tao_print_exception ("runStatic");
return -1;
}
return 0;
}
virtual void push_structured_event(CosNotification::StructuredEvent const& event)
throw(CosEventComm::Disconnected)
{
cout << "domain_name: " << event.header.fixed_header.event_type.domain_name
<< " type_name: " << event.header.fixed_header.event_type.type_name << " " << flush;
if (false) {
Miro::Client client;
DynamicAny::DynAnyFactory_var daf =
client.resolveInit<DynamicAny::DynAnyFactory>("DynAnyFactory");
DynamicAny::DynAny_var da = daf->create_dyn_any(event.remainder_of_body);
CORBA::TypeCode_var tc = da->type();
if (tc->kind() == CORBA::tk_struct) {
CORBA::String_var name = tc->name();
CORBA::String_var id = tc->id();
DynamicAny::DynStruct_var ds =
DynamicAny::DynStruct::_narrow(da);
for (CORBA::ULong i = 0; i < ds->component_count(); ++i) {
DynamicAny::DynAny_var member = ds->current_component();
CORBA::String_var name = ds->current_member_name();
if (std::string("timestamp") == name.in()) {
long long int i = member->get_ulonglong();
ACE_Time_Value t;
ORBSVCS_Time::Absolute_TimeT_to_Time_Value(t, i);
cout << "latency: " << ACE_OS::gettimeofday() - t << endl;
break;
}
ds->next();
}
}
else {
cerr << "unknown event layout" << endl;
}
}
ACE_Time_Value t;
t.set(time_out);
ACE_OS::sleep(t);
cout << "waking up after sleep" << endl;
}
CORBA::Boolean
TAO_DynSequence_i::equal (DynamicAny::DynAny_ptr rhs)
{
if (this->destroyed_)
{
throw ::CORBA::OBJECT_NOT_EXIST ();
}
CORBA::TypeCode_var tc = rhs->type ();
CORBA::Boolean equivalent = tc->equivalent (this->type_.in ());
if (!equivalent)
{
return false;
}
if (rhs->component_count () != this->component_count_)
{
return false;
}
DynamicAny::DynAny_var tmp;
CORBA::Boolean member_equal;
for (CORBA::ULong i = 0; i < this->component_count_; ++i)
{
rhs->seek (static_cast<CORBA::Long> (i));
tmp = rhs->current_component ();
// Recursive step.
member_equal = tmp->equal (this->da_members_[i].in ());
if (!member_equal)
{
return false;
}
}
return true;
}
CORBA::Boolean
TAO_Log_Constraint_Visitor::union_does_contain (
const CORBA::Any *any,
TAO_ETCL_Literal_Constraint &item
)
{
try
{
TAO_DynUnion_i dyn_union;
dyn_union.init (*any);
DynamicAny::DynAny_var cc =
dyn_union.current_component ();
CORBA::Any_var member = cc->to_any ();
CORBA::TypeCode_var tc = member->type ();
CORBA::TCKind kind = TAO_DynAnyFactory::unalias (tc.in ());
// The literal and the union member must be
// of the same simple type.
CORBA::Boolean match = this->simple_type_match (item.expr_type (),
kind);
if (!match)
{
return false;
}
TAO_ETCL_Literal_Constraint element (&member.inout ());
return (item == element);
}
catch (const CORBA::Exception&)
{
return false;
}
}
int
TAO_Log_Constraint_Visitor::visit_special (ETCL_Special *special)
{
try
{
CORBA::TypeCode_var tc = this->current_member_->type ();
switch (special->type ())
{
case ETCL_LENGTH:
{
// If the TCKind is not a sequence or an array, the
// call to length() will raise an exception, and the
// catch block will return -1;
CORBA::ULong length = tc->length ();
TAO_ETCL_Literal_Constraint lit (length);
this->queue_.enqueue_head (lit);
return 0;
}
case ETCL_DISCRIMINANT:
{
// If the TCKind is not a union, the
// call to init() will raise an exception, and the
// catch block will return -1;
TAO_DynUnion_i dyn_union;
dyn_union.init (this->current_member_.in ());
DynamicAny::DynAny_var disc =
dyn_union.get_discriminator ();
CORBA::Any_var disc_any = disc->to_any ();
TAO_ETCL_Literal_Constraint lit (disc_any.ptr ());
this->queue_.enqueue_head (lit);
return 0;
}
case ETCL_TYPE_ID:
{
const char *name = tc->name ();
TAO_ETCL_Literal_Constraint lit (name);
this->queue_.enqueue_head (lit);
return 0;
}
case ETCL_REPOS_ID:
{
const char *id = tc->id ();
TAO_ETCL_Literal_Constraint lit (id);
this->queue_.enqueue_head (lit);
return 0;
}
default:
return -1;
}
}
catch (const CORBA::Exception&)
{
return -1;
}
}
int
TAO_Log_Constraint_Visitor::visit_component_array (
ETCL_Component_Array *array)
{
try
{
// If we are here (from visit_component) the Any containing the
// component as found in property_lookup_ will be in current_member_.
CORBA::TypeCode_var tc = this->current_member_->type ();
CORBA::TCKind kind = TAO_DynAnyFactory::unalias (tc.in ());
DynamicAny::DynAny_var member;
CORBA::Boolean success = 0;
CORBA::ULong slot = (CORBA::ULong) *array->integer ();
switch (kind)
{
case CORBA::tk_array:
{
TAO_DynEnum_i dyn_array;
dyn_array.init (this->current_member_.in ());
success = dyn_array.seek (slot);
if (success == 0)
{
return -1;
}
member = dyn_array.current_component ();
break;
}
case CORBA::tk_sequence:
{
TAO_DynStruct_i dyn_sequence;
dyn_sequence.init (this->current_member_.in ());
success = dyn_sequence.seek (slot);
if (success == 0)
{
return -1;
}
member =
dyn_sequence.current_component ();
break;
}
// Enums and sequences are the only two cases handled
// by Component_Array.
default:
return -1;
}
CORBA::Any_var value = member->to_any ();
ETCL_Constraint *comp = array->component ();
if (comp == 0)
{
TAO_ETCL_Literal_Constraint result (value.ptr ());
this->queue_.enqueue_head (result);
return 0;
}
else
{
this->current_member_ = value._retn ();
return comp->accept (this);
}
}
catch (const CORBA::Exception&)
{
return -1;
}
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
int result= 0;
ACE_DEBUG (( LM_DEBUG, "Start\n" ));
try
{
// init orb
CORBA::ORB_var the_orb =
CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) == -1)
return -1;
ACE_DEBUG (( LM_DEBUG, "Get IFR\n" ));
CORBA::Object_var objref =
the_orb->string_to_object (ifr_ior_file);
if (objref.in () == 0)
{
ACE_ERROR_RETURN ((LM_ERROR,
"The received objref is nil\n"),
-1);
}
ACE_DEBUG (( LM_DEBUG, "Narrow IFR\n" ));
CORBA::ComponentIR::Repository_var the_repo_ref;
the_repo_ref = CORBA::ComponentIR::Repository::_narrow (objref.in ());
ACE_DEBUG (( LM_DEBUG, "Obtaining DynamicAny\n" ));
CORBA::Object_var factory_obj =
the_orb->resolve_initial_references ("DynAnyFactory");
DynamicAny::DynAnyFactory_var dynanyfactory =
DynamicAny::DynAnyFactory::_narrow (factory_obj.in ());
ACE_DEBUG (( LM_DEBUG, "\nLook up c2\n" ));
CORBA::Contained_var c2 =
the_repo_ref->lookup_id ("IDL:m1/c2:1.0");
if (CORBA::is_nil (c2.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"Can't look up the const m1/c2\n"),
-1);
}
CORBA::ConstantDef_var c2_def = CORBA::ConstantDef::_narrow (c2.in ());
CORBA::String_var c2_name= c2_def->absolute_name ();
CORBA::TypeCode_var c2_tc = c2_def->type ();
CORBA::String_var c2_id = c2_tc->id ();
ACE_DEBUG (( LM_DEBUG, "constant \"%C\" is type \"%C\"", c2_name.in (), c2_id.in () ));
CORBA::TCKind c2_tckind = c2_tc->kind ();
ACE_DEBUG (( LM_DEBUG, ", tkkind %d", c2_tckind ));
if (CORBA::tk_enum == c2_tckind)
{
ACE_DEBUG (( LM_DEBUG, " (CORBA::tk_enum)\n" ));
CORBA::Any_var the_value = c2_def->value ();
DynamicAny::DynAny_var dany =
dynanyfactory->create_dyn_any (the_value.in ());
DynamicAny::DynEnum_var denum =
DynamicAny::DynEnum::_narrow (dany.in ());
CORBA::String_var the_strValue = denum->get_as_string ();
CORBA::ULong the_intValue = denum->get_as_ulong ();
ACE_DEBUG ((LM_DEBUG, "Whose value is \"%C\" which has an integer value of %d\n",
the_strValue.in (), the_intValue ));
if (0 == ACE_OS::strcmp( "e1_2", the_strValue.in () ))
{
ACE_DEBUG ((LM_DEBUG, "The string value is correct\n" ));
}
else
{
ACE_DEBUG ((LM_DEBUG, "ERROR: The string value should be \"e1_2\"\n" ));
result = -1;
}
if (1 == the_intValue )
{
ACE_DEBUG ((LM_DEBUG, "The corresponding integer value is correct\n" ));
}
else
{
ACE_DEBUG ((LM_DEBUG, "ERROR: The corresponding integer value should be 1\n" ));
result = -1;
}
}
else
{
ACE_DEBUG ((LM_DEBUG, "\nERROR: Wrong tkkind for m1::c2, should be %d\n", CORBA::tk_enum));
result= -1;
}
}
catch (CORBA::Exception &ex)
{
ex._tao_print_exception ("ERROR: CORBA Exception");
result= -1;
}
catch (...)
{
ACE_DEBUG ((LM_DEBUG, "ERROR: UNKNOWN Excetion\n"));
result= -1;
}
ACE_DEBUG (( LM_DEBUG, "\nDone\n" ));
return result;
}
DynamicAny::DynAny_ptr
DynAny_Handler::extract_into_dynany (const DataType &type,
const DataValue &value,
CORBA::TypeCode_ptr req_tc)
{
DANCE_TRACE("DynAny_Handler::extract_into_dynany");
DynamicAny::DynAny_var retval;
if (req_tc)
retval = this->daf_->create_dyn_any_from_type_code (req_tc);
TCKind::Value tkind = type.kind ().integral ();
if ((value.count_short () && tkind != TCKind::tk_short_l) ||
(value.count_long () && tkind != TCKind::tk_long_l) ||
(value.count_ushort () && tkind != TCKind::tk_ushort_l ) ||
(value.count_ulong () && tkind != TCKind::tk_ulong_l) ||
(value.count_float () && tkind != TCKind::tk_float_l) ||
(value.count_double () && tkind != TCKind::tk_double_l) ||
(value.count_boolean () && tkind != TCKind::tk_boolean_l) ||
(value.count_octet () && tkind != TCKind::tk_octet_l) ||
(value.count_longlong () && tkind != TCKind::tk_longlong_l) ||
(value.count_ulonglong () && tkind != TCKind::tk_ulonglong_l) ||
(value.count_string () && !(tkind == TCKind::tk_string_l ||
tkind == TCKind::tk_char_l ||
tkind == TCKind::tk_wchar_l)))
{
throw Config_Error (ACE_TEXT (""), ACE_TEXT ("Wrong value type for data type"));
}
switch (tkind)
{
// ========== BASIC TYPES
case TCKind::tk_null_l:
case TCKind::tk_void_l:
DANCE_ERROR (DANCE_LOG_TERMINAL_ERROR,
(LM_ERROR,
ACE_TEXT ("DynAny_Handler::extract_into_dynany - Don't know how to handle null or void types\n")));
throw Config_Error (ACE_TEXT (""),
ACE_TEXT ("Null or void types not supported"));
break;
case TCKind::tk_short_l:
{
if (!req_tc)
{
retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_short);
}
CORBA::Short s = 0;
if (value.count_short ())
{
s = *(*value.begin_short ());
}
retval->insert_short (s);
}
break;
case TCKind::tk_long_l:
{
if (!req_tc)
{
retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_long);
}
CORBA::Long l = 0;
if (value.count_long ())
{
l = *(*value.begin_long ());
}
retval->insert_long (l);
}
break;
case TCKind::tk_ushort_l:
{
if (!req_tc)
{
retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_ushort);
}
CORBA::UShort us = 0;
if (value.count_ushort ())
{
us = *(*value.begin_ushort ());
}
retval->insert_ushort (us);
}
break;
case TCKind::tk_ulong_l:
{
if (!req_tc)
{
retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_ulong);
}
CORBA::ULong ul = 0;
if (value.count_ulong ())
{
ul = *(*value.begin_ulong ());
}
retval->insert_ulong (ul);
}
break;
case TCKind::tk_float_l:
{
if (!req_tc)
{
retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_float);
}
CORBA::Float f = 0.0f;
if (value.count_float ())
{
f = *(*value.begin_float ());
}
retval->insert_float (f);
}
break;
case TCKind::tk_double_l:
{
if (!req_tc)
{
retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_double);
}
CORBA::Double d = 0.0;
if (value.count_double ())
{
d = *(*value.begin_double ());
}
retval->insert_double (d);
}
break;
case TCKind::tk_boolean_l:
{
if (!req_tc)
{
retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_boolean);
}
CORBA::Boolean b = false;
if (value.count_boolean ())
{
b = *(*value.begin_boolean ());
}
retval->insert_boolean (b);
}
break;
case TCKind::tk_octet_l:
{
if (!req_tc)
{
retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_octet);
}
CORBA::Octet o = 0;
if (value.count_octet ())
{
o = *(*(value.begin_octet ()));
}
retval->insert_octet (o);
}
break;
case TCKind::tk_longlong_l:
{
if (!req_tc)
{
retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_longlong);
}
CORBA::LongLong ll = 0;
if (value.count_longlong ())
{
ll = *(*value.begin_longlong ());
}
retval->insert_longlong (ll);
}
break;
case TCKind::tk_ulonglong_l:
{
if (!req_tc)
{
retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_ulonglong);
}
CORBA::ULongLong ull = 0;
if (value.count_ulonglong ())
{
ull = *(*value.begin_ulonglong ());
}
retval->insert_ulonglong (ull);
}
break;
case TCKind::tk_string_l:
return DynString_Handler::extract_into_dynany (type, value, req_tc);
case TCKind::tk_char_l:
{
if (!req_tc)
{
retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_char);
}
CORBA::Char c = 0;
if (value.count_string ())
{
c = *(*value.begin_string ())->c_str ();
}
retval->insert_char (c);
}
break;
case TCKind::tk_wchar_l:
{
if (!req_tc)
{
retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_wchar);
}
CORBA::WChar wc = 0;
if (value.count_string ())
{
wc = *(*value.begin_string ())->c_str ();
}
retval->insert_wchar (wc);
}
break;
case TCKind::tk_enum_l:
return DynEnum_Handler::extract_into_dynany (type, value, req_tc);
case TCKind::tk_sequence_l:
return DynSequence_Handler::extract_into_dynany (type, value, req_tc);
case TCKind::tk_struct_l:
return DynStruct_Handler::extract_into_dynany (type, value, req_tc);
case TCKind::tk_alias_l:
return DynAlias_Handler::extract_into_dynany (type, value, req_tc);
case TCKind::tk_array_l:
return DynArray_Handler::extract_into_dynany (type, value, req_tc);
case TCKind::tk_longdouble_l:
// Not supported since a longdouble is defined in the xsd as double.
// We are then creating a long double initialized with a regular
// double. This is a very tricky conversion and doesn't work in
// combination with certain (versions of) compilers.
case TCKind::tk_wstring_l:
case TCKind::tk_fixed_l:
case TCKind::tk_any_l:
case TCKind::tk_TypeCode_l:
case TCKind::tk_Principal_l:
case TCKind::tk_objref_l:
case TCKind::tk_union_l:
case TCKind::tk_except_l:
case TCKind::tk_value_l:
case TCKind::tk_value_box_l:
case TCKind::tk_native_l:
case TCKind::tk_abstract_interface_l:
case TCKind::tk_local_interface_l:
case TCKind::tk_component_l:
case TCKind::tk_home_l:
case TCKind::tk_event_l:
DANCE_ERROR (DANCE_LOG_TERMINAL_ERROR, (LM_ERROR,
DLINFO ACE_TEXT ("DynAny_Handler::extract_into_dynany - Type not supported\n")));
throw Config_Error (ACE_TEXT (""), ACE_TEXT ("Type not supported"));
}
return retval._retn ();
}
int runDynamic(CORBA::ORB_ptr orb)
{
try
{
// Create typecode for EventKind.
CORBA::EnumMemberSeq eseq;
eseq.length(2);
eseq[0] = CORBA::string_dup("ALARM_EVENT");
eseq[1] = CORBA::string_dup("LOG_EVENT");
CORBA::TypeCode_var eventKindTc;
eventKindTc = orb->create_enum_tc("IDL:DynAnyTest/EventKind:1.0",
"EventKind",
eseq);
// Create typecode for EventData. EventKind tc is used.
CORBA::Any label;
CORBA::UnionMemberSeq useq;
useq.length(2);
label <<= DynAnyTest::ALARM_EVENT;
useq[0].name = CORBA::string_dup("ev_data");
useq[0].label = label;
useq[0].type = CORBA::TypeCode::_duplicate(CORBA::_tc_any);
useq[0].type_def = CORBA::IDLType::_nil ();
label <<= DynAnyTest::LOG_EVENT;
useq[1].name = CORBA::string_dup("ev_desc");
useq[1].label = label;
useq[1].type = CORBA::TypeCode::_duplicate(CORBA::_tc_string);
useq[1].type_def = CORBA::IDLType::_nil ();
CORBA::TypeCode_var eventDataTc;
eventDataTc = orb->create_union_tc("IDL:DynAnyTest/EventData:1.0",
"EventData",
eventKindTc.in (),
useq);
// Now create DynUnion
CORBA::Object_var obj = orb->resolve_initial_references("DynAnyFactory");
DynamicAny::DynAnyFactory_var dfact =
DynamicAny::DynAnyFactory::_narrow(obj.in ());
if (CORBA::is_nil (dfact.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"Nil dynamic any factory after narrow\n"),
-1);
}
DynamicAny::DynAny_var dany =
dfact->create_dyn_any_from_type_code(eventDataTc.in ());
DynamicAny::DynUnion_var dunion =
DynamicAny::DynUnion::_narrow(dany.in ());
DynamicAny::DynAny_var disc = dunion->get_discriminator();
DynamicAny::DynEnum_var denum =
DynamicAny::DynEnum::_narrow(disc.in ());
// This fails. The type of discriminator is ulong
if (CORBA::is_nil (denum.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"Nil dynamic enum after narrow\n"),
-1);
}
ACE_DEBUG ((LM_DEBUG, "Dynamic Test Passed\n"));
denum->destroy();
dunion->destroy();
}
catch (const CORBA::Exception & ex)
{
ex._tao_print_exception ("Dynamic Test Failed with exception");
}
return 0;
}
DynamicAny::DynAny_ptr
DynAlias_Handler::extract_into_dynany (const DataType &type,
const DataValue &value,
CORBA::TypeCode_ptr req_tc)
{
DANCE_TRACE("DynAlias_Handler::extract_into_dynany");
try
{
CORBA::TypeCode_var tc;
if (req_tc)
tc = req_tc;
else
tc = DynAlias_Handler::create_typecode (type);
// Make the actual DynAlias
// DynamicAny::DynAny_var retval =
//DYNANY_HANDLER->daf ()->create_dyn_any_from_type_code (tc);
// DynamicAny::DynAlias_var retval =
// DynamicAny::DynAlias::_narrow (temp.in ());
DynamicAny::DynAny_var alias = DYNANY_HANDLER->extract_into_dynany (
type.alias ().elementType (), value, tc);
return alias._retn ();
/*
switch (type.kind ().integral ())
{
// ========== BASIC TYPES
case TCKind::tk_null_l:
case TCKind::tk_void_l:
DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
(LM_WARNING, "I don't know how to handle null or
void types\n"));
case TCKind::tk_short_l:
retval->insert_short (CORBA::Short (static_cast <
::XMLSchema::short_ const & > (*value.begin_short ())));
break;
case TCKind::tk_long_l:
retval->insert_long (CORBA::Long (static_cast <
::XMLSchema::int_ const& > (*value.begin_long ())));
break;
case TCKind::tk_ushort_l:
retval->insert_ushort (CORBA::UShort (static_cast<
::XMLSchema::unsignedShort const & > (*value.begin_ushort ())));
break;
case TCKind::tk_ulong_l:
retval->insert_ulong (CORBA::ULong (static_cast <
::XMLSchema::unsignedInt const& > (*value.begin_ulong ())));
break;
case TCKind::tk_float_l:
retval->insert_float (CORBA::Float (*value.begin_float ()));
break;
case TCKind::tk_double_l:
retval->insert_double (CORBA::Double (*value.begin_double ()));
break;
case TCKind::tk_boolean_l:
retval->insert_boolean (static_cast <
::XMLSchema::boolean const& > (*value.begin_boolean ()));
break;
case TCKind::tk_char_l:
retval->insert_char (CORBA::Char (
*value.begin_string ()->c_str ()));
break;
case TCKind::tk_octet_l:
retval->insert_octet (static_cast <
const unsigned char &> (*value.begin_octet ()));
break;
case TCKind::tk_string_l:
retval->insert_string (value.begin_string ()->c_str ());
break;
case TCKind::tk_longlong_l:
retval->insert_longlong (CORBA::LongLong (static_cast <
::XMLSchema::long_ const& > (*value.begin_longlong ())));
break;
case TCKind::tk_ulonglong_l:
retval->insert_ulonglong (CORBA::ULongLong (static_cast <
::XMLSchema::unsignedLong const& > (
*value.begin_ulonglong ())));
break;
case TCKind::tk_wchar_l:
retval->insert_wchar (CORBA::WChar (
*value.begin_string ()->c_str ()));
break;
case TCKind::tk_enum_l:
return DynEnum_Handler::extract_into_dynany (type, value);
case TCKind::tk_sequence_l:
return DynSequence_Handler::extract_into_dynany (type, value);
case TCKind::tk_struct_l:
return DynStruct_Handler::extract_into_dynany (type, value);
case TCKind::tk_alias_l:
return DynAlias_Handler::extract_into_dynany (type, value);
case TCKind::tk_longdouble_l:
case TCKind::tk_wstring_l:
case TCKind::tk_wfixed_l:
case TCKind::tk_any_l:
case TCKind::tk_TypeCode_l:
case TCKind::tk_Principal_l:
case TCKind::tk_objref_l:
case TCKind::tk_union_l:
case TCKind::tk_array_l:
case TCKind::tk_except_l:
case TCKind::tk_value_l:
case TCKind::tk_value_box_l:
case TCKind::tk_native_l:
case TCKind::tk_abstract_interface_l:
case TCKind::tk_local_interface_l:
case TCKind::tk_component_l:
case TCKind::tk_home_l:
case TCKind::tk_event_l:
DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
(LM_ERROR, "Type not supported\n"));
throw Config_Error ("", "Type not supported");
}
*/
// retval->assign (alias);
// return retval._retn ();
}
catch (const DynamicAny::DynAny::InvalidValue&)
{
DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
(LM_ERROR,
ACE_TEXT ("Invalid value provided in XML when trying to ")
ACE_TEXT ("initialize an instance of enumerated type %s\n"),
type.alias ().typeId ().c_str ()));
throw Config_Error (type.alias ().typeId (),
ACE_TEXT ("Invalid value provided in XML"));
}
catch (Config_Error &ex)
{
DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
(LM_ERROR, ACE_TEXT ("DynAlias_Handler caught Config_Error\n")));
if (type.alias_p ())
ex.add_name (type.alias ().typeId ());
throw ex;
}
catch (...)
{
DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_ERROR,
ACE_TEXT ("DynAlias_Handler caught unknown exception\n")));
throw Config_Error (type.alias ().typeId (),
ACE_TEXT ("Unknown exception"));
}
}
void DynAnyAnalyzer::analyze (DynamicAny::DynAny_ptr da)
{
CORBA::TypeCode_var tc = da->type ();
CORBA::TCKind kind = tc->kind ();
CORBA::TypeCode_var dup = CORBA::TypeCode::_duplicate (tc.in ());
// strip aliases
while (kind == CORBA::tk_alias)
{
dup = dup->content_type ();
kind = dup->kind ();
}
switch (kind)
{
case CORBA::tk_struct:
{
DynamicAny::DynStruct_var ds
= DynamicAny::DynStruct::_narrow (da);
tab (level_);
if (debug_)
{
ACE_DEBUG ((LM_DEBUG,
"STRUCT\n"));
}
if (da->seek (0) )
{
level_++;
do
{
DynamicAny::DynAny_var cc =
ds->current_component ();
DynamicAny::FieldName_var fn =
ds->current_member_name ();
tab(level_);
if (debug_)
{
ACE_DEBUG ((LM_DEBUG,
"Member = %C\n", fn.in ()));
}
if (!CORBA::is_nil (cc.in ()))
{
this->analyze (cc.in ());
}
} while (da->next ());
level_--;
}
}
break; // end tk_struct
case CORBA::tk_sequence:
{
if (TAO_DynCommon::is_basic_type_seq (tc.in ()))
{
this->analyze_basic_seq (dup.in (), da);
}
else
{
DynamicAny::DynSequence_var ds =
DynamicAny::DynSequence::_narrow (da);
int i = 0;
tab(level_);
if (debug_)
{
ACE_DEBUG ((LM_DEBUG,
"SEQUENCE\n"));
}
if (ds->seek (0UL))
{
level_++;
do
{
tab(level_);
if (debug_)
ACE_DEBUG ((LM_DEBUG,
"[%d]\n", i));
DynamicAny::DynAny_var cc (ds->current_component ());
if (!CORBA::is_nil (cc.in ()))
{
analyze (cc.in ());
}
i++;
} while (da->next ());
level_--;
}
}
}
break; // end tk_sequence
case CORBA::tk_array:
{
tab (level_);
if (debug_)
{
ACE_DEBUG ((LM_DEBUG,
"ARRAY\n"));
}
level_++;
CORBA::ULong const len =
dup->length ();
for (CORBA::ULong i = 0 ; i < len; ++i)
{
tab (level_);
if (debug_)
{
ACE_DEBUG ((LM_DEBUG, "[%d]\n", i));
}
DynamicAny::DynAny_var cc = da->current_component();
if (!CORBA::is_nil (cc.in ()))
{
analyze (cc.in ());
}
da->next ();
}
level_--;
}
break;
case CORBA::tk_union:
{
DynamicAny::DynUnion_var value =
DynamicAny::DynUnion::_narrow (da);
if (!value->has_no_active_member ())
{
DynamicAny::DynAny_var disc = value->member ();
if (!CORBA::is_nil (disc.in ()))
{
this->analyze (disc.in ());
}
}
}
break;
case CORBA::tk_any:
{
DynamicAny::DynAny_var dynany;
CORBA::Any_var any = da->get_any ();
dynany =
dynany_factory_->create_dyn_any (any.in ());
if (!CORBA::is_nil (dynany.in ()))
{
this->analyze (dynany.in ());
}
dynany->destroy ();
}
break;
case CORBA::tk_enum:
{
DynamicAny::DynEnum_var value =
DynamicAny::DynEnum::_narrow (da);
CORBA::String_var s = value->get_as_string ();
tab (level_);
if (debug_)
{
ACE_DEBUG ((LM_DEBUG, " Value (enum) = %C\n", s.in()));
}
}
break;
CASEE (boolean, Boolean, " Value (bool) = %d\n");
CASEE (short, Short, " Value (short) = %d\n");
CASEE (ushort, UShort, " Value (ushort) = %u\n");
CASEE (long, Long, " Value (long) = %d\n");
CASEE (ulong, ULong, " Value (ulong) = %u\n");
CASEE (longlong, LongLong, " Value (longlong) %Ld\n");
CASEE (ulonglong, ULongLong, " Value (ulonglong) %Lu\n");
CASEE (char, Char, " Value (char) = %c\n");
CASEE (float, Float, " Value (float) = %f\n");
CASEE (double, Double, " Value (double) = %f\n");
CASEE (octet, Octet, " Value (octet) = %c\n");
case CORBA::tk_string:
{
CORBA::String_var b (da->get_string ());
tab (level_);
if (debug_)
{
ACE_DEBUG ((LM_DEBUG, " Value (string) = %C\n", b.in ()));
}
}
break;
case CORBA::tk_TypeCode:
{
tab (level_);
if (debug_)
{
CORBA::TCKind const kind =
da->get_typecode ()->kind ();
ACE_DEBUG ((LM_DEBUG,
" Value (TypeCode) = %d\n",
static_cast<int> (kind)));
}
}
break;
default:
{
tab (level_);
if (debug_)
{
CORBA::TCKind const kind =
tc->kind ();
ACE_DEBUG ((LM_DEBUG,
" unhandled typecode = %d\n",
static_cast<int> (kind)));
}
}
break;
}
if (debug_)
{
ACE_DEBUG ((LM_DEBUG, "\n"));
}
}