int
ifr_adding_visitor_structure::visit_enum (AST_Enum *node)
{
try
{
// Is this enum already in the respository?
CORBA::Contained_var prev_def =
be_global->repository ()->lookup_id (node->repoID ());
// If not, create a new entry.
if (CORBA::is_nil (prev_def.in ()))
{
CORBA::ULong member_count =
static_cast<CORBA::ULong> (node->member_count ());
CORBA::EnumMemberSeq members (member_count);
members.length (member_count);
UTL_ScopedName *member_name = 0;
// Get a list of the member names.
for (CORBA::ULong i = 0; i < member_count; ++i)
{
member_name = node->value_to_name (i);
members[i] =
CORBA::string_dup (
member_name->last_component ()->get_string ()
);
}
this->ir_current_ =
be_global->repository ()->create_enum (
node->repoID (),
node->local_name ()->get_string (),
node->version (),
members
);
node->ifr_added (true);
}
else
{
// If the line below is true, we are clobbering a previous
// entry (from another IDL file) of another type. In that
// case we do what other ORB vendors do, and destroy the
// original entry, create the new one, and let the user beware.
if (!node->ifr_added ())
{
prev_def->destroy ();
// This call will take the other branch.
return this->visit_enum (node);
}
this->ir_current_ =
CORBA::IDLType::_narrow (prev_def.in ());
}
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception (
ACE_TEXT (
"ifr_adding_visitor_structure::visit_enum"));
return -1;
}
return 0;
}
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;
}
