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 ();
}
}
}
}
CORBA::TypeCode_ptr
TAO_AliasDef_i::type_i (void)
{
ACE_TString id;
this->repo_->config ()->get_string_value (this->section_key_,
ACE_TEXT("id"),
id);
ACE_TString name;
this->repo_->config ()->get_string_value (this->section_key_,
ACE_TEXT("name"),
name);
ACE_TString original_type;
this->repo_->config ()->get_string_value (this->section_key_,
ACE_TEXT("original_type"),
original_type);
TAO_IDLType_i *impl =
TAO_IFR_Service_Utils::path_to_idltype (original_type,
this->repo_);
if (0 == impl)
{
throw CORBA::OBJECT_NOT_EXIST();
}
CORBA::TypeCode_var tc = impl->type_i ();
return this->repo_->tc_factory ()->create_alias_tc (id.c_str (),
name.c_str (),
tc.in ());
}
CORBA::TypeCode_ptr
TAO_ValueBoxDef_i::type_i (void)
{
ACE_TString id;
this->repo_->config ()->get_string_value (this->section_key_,
"id",
id);
ACE_TString name;
this->repo_->config ()->get_string_value (this->section_key_,
"name",
name);
ACE_TString boxed_type_path;
this->repo_->config ()->get_string_value (this->section_key_,
"boxed_type",
boxed_type_path);
TAO_IDLType_i *impl =
TAO_IFR_Service_Utils::path_to_idltype (boxed_type_path,
this->repo_);
CORBA::TypeCode_var tc = impl->type_i ();
return this->repo_->tc_factory ()->create_value_box_tc (id.c_str (),
name.c_str (),
tc.in ());
}
CORBA::TypeCode_ptr
TAO_ConstantDef_i::type_i (void)
{
ACE_TString type_path;
this->repo_->config ()->get_string_value (this->section_key_,
"type_path",
type_path);
TAO_IDLType_i *impl = TAO_IFR_Service_Utils::path_to_idltype (type_path,
this->repo_);
return impl->type_i ();
}
CORBA::TypeCode_ptr
TAO_ArrayDef_i::element_type_i (void)
{
ACE_TString element_path;
this->repo_->config ()->get_string_value (this->section_key_,
"element_path",
element_path);
TAO_IDLType_i *impl =
TAO_IFR_Service_Utils::path_to_idltype (element_path,
this->repo_);
return impl->type_i ();
}
CORBA::TypeCode_ptr
TAO_OperationDef_i::result_i (void)
{
ACE_TString result_path;
this->repo_->config ()->get_string_value (this->section_key_,
"result",
result_path);
TAO_IDLType_i *impl =
TAO_IFR_Service_Utils::path_to_idltype (result_path,
this->repo_);
return impl->type_i ();
}
void
TAO_ArrayDef_i::destroy_element_type (
)
{
ACE_TString element_path;
this->repo_->config ()->get_string_value (this->section_key_,
"element_path",
element_path);
ACE_Configuration_Section_Key element_key;
this->repo_->config ()->expand_path (this->repo_->root_key (),
element_path,
element_key,
0);
u_int kind = 0;
this->repo_->config ()->get_integer_value (element_key,
ACE_TEXT("def_kind"),
kind);
CORBA::DefinitionKind def_kind =
TAO_IFR_Service_Utils::path_to_def_kind (element_path,
this->repo_);
switch (def_kind)
{
// These exist only as our elements, so the type should
// be destroyed when we are destroyed, or when our element type
// is mutated.
case CORBA::dk_String:
case CORBA::dk_Wstring:
case CORBA::dk_Fixed:
case CORBA::dk_Array:
case CORBA::dk_Sequence:
{
TAO_IDLType_i *impl = this->repo_->select_idltype (def_kind);
impl->section_key (element_key);
impl->destroy_i ();
break;
}
default:
break;
}
}
CORBA::TypeCode_ptr
TAO_UnionDef_i::discriminator_type_i (void)
{
ACE_TString disc_path;
this->repo_->config ()->get_string_value (this->section_key_,
"disc_path",
disc_path);
TAO_IDLType_i *impl =
TAO_IFR_Service_Utils::path_to_idltype (disc_path,
this->repo_);
if (0 == impl)
{
throw CORBA::OBJECT_NOT_EXIST();
}
return impl->type_i ();
}
TAO_IDLType_i *
TAO_IFR_Service_Utils::path_to_idltype (ACE_TString &path,
TAO_Repository_i *repo)
{
CORBA::DefinitionKind def_kind =
TAO_IFR_Service_Utils::path_to_def_kind (path, repo);
TAO_IDLType_i *retval = repo->select_idltype (def_kind);
if (retval == 0)
{
ORBSVCS_DEBUG ((LM_DEBUG,
"path_to_idltype - not an IDLType: '%s'\n",
path.c_str ()));
return 0;
}
retval->section_key (TAO_IFR_Service_Utils::tmp_key_);
return retval;
}
CORBA::UnionMemberSeq *
TAO_UnionDef_i::members_i (void)
{
ACE_Unbounded_Queue<ACE_Configuration_Section_Key> key_queue;
ACE_Configuration_Section_Key refs_key;
this->repo_->config ()->open_section (this->section_key_,
"refs",
0,
refs_key);
u_int count;
this->repo_->config ()->get_integer_value (refs_key,
"count",
count);
for (u_int i = 0; i < count; ++i)
{
ACE_Configuration_Section_Key member_key;
char *stringified = TAO_IFR_Service_Utils::int_to_string (i);
if (this->repo_->config ()->open_section (refs_key,
stringified,
0,
member_key)
== 0)
{
ACE_TString path;
this->repo_->config ()->get_string_value (member_key,
"path",
path);
ACE_Configuration_Section_Key entry_key;
// This entry may have been removed.
if (this->repo_->config ()->expand_path (this->repo_->root_key (),
path,
entry_key,
0)
== 0)
{
key_queue.enqueue_tail (member_key);
}
}
}
CORBA::ULong size = static_cast<CORBA::ULong> (key_queue.size ());
CORBA::UnionMemberSeq *members = 0;
ACE_NEW_THROW_EX (members,
CORBA::UnionMemberSeq (size),
CORBA::NO_MEMORY ());
members->length (size);
CORBA::UnionMemberSeq_var retval = members;
ACE_TString name, path;
ACE_Configuration_Section_Key next_key, entry_key;
CORBA::Object_var obj;
TAO_IDLType_i *impl = 0;
// Store to replace below.
ACE_Configuration_Section_Key key_holder = this->section_key_;
for (CORBA::ULong k = 0; k < size; ++k)
{
key_queue.dequeue_head (next_key);
this->repo_->config ()->get_string_value (next_key,
"name",
name);
retval[k].name = name.c_str ();
this->fetch_label (next_key,
retval[k]);
this->repo_->config ()->get_string_value (next_key,
"path",
path);
obj = TAO_IFR_Service_Utils::path_to_ir_object (path,
this->repo_);
retval[k].type_def = CORBA::IDLType::_narrow (obj.in ());
impl = TAO_IFR_Service_Utils::path_to_idltype (path,
this->repo_);
if (0 == impl)
{
throw CORBA::OBJECT_NOT_EXIST();
}
retval[k].type = impl->type_i ();
// If this union contains a nested union (of another type) at
// some level, the above code will have changed the section key
// so we have to replace it with the value we stored above.
this->section_key (key_holder);
}
return retval._retn ();
}
CORBA::ParDescriptionSeq *
TAO_OperationDef_i::params_i (void)
{
CORBA::ULong i = 0;
ACE_Configuration_Section_Key params_key;
int status =
this->repo_->config ()->open_section (this->section_key_,
"params",
0,
params_key);
ACE_Unbounded_Queue<ACE_Configuration_Section_Key> key_queue;
// This section may not have been created.
if (status == 0)
{
u_int count = 0;
this->repo_->config ()->get_integer_value (params_key,
"count",
count);
for (i = 0; i < count; ++i)
{
ACE_Configuration_Section_Key param_key;
char *stringified = TAO_IFR_Service_Utils::int_to_string (i);
status =
this->repo_->config ()->open_section (params_key,
stringified,
0,
param_key);
if (status == 0)
{
key_queue.enqueue_tail (param_key);
}
}
}
CORBA::ULong size = static_cast<CORBA::ULong> (key_queue.size ());
CORBA::ParDescriptionSeq *pd_seq = 0;
ACE_NEW_THROW_EX (pd_seq,
CORBA::ParDescriptionSeq (size),
CORBA::NO_MEMORY ());
pd_seq->length (size);
if (size == 0)
{
return pd_seq;
}
CORBA::ParDescriptionSeq_var retval = pd_seq;
for (i = 0; i < size; ++i)
{
ACE_Configuration_Section_Key key;
key_queue.dequeue_head (key);
ACE_TString name;
this->repo_->config ()->get_string_value (key,
"name",
name);
retval[i].name = name.c_str ();
u_int mode = 0;
this->repo_->config ()->get_integer_value (key,
"mode",
mode);
retval[i].mode = static_cast<CORBA::ParameterMode> (mode);
ACE_TString type_path;
this->repo_->config ()->get_string_value (key,
"type_path",
type_path);
TAO_IDLType_i *impl =
TAO_IFR_Service_Utils::path_to_idltype (type_path,
this->repo_);
// We have an undefined interface
if (impl == 0)
{
ORBSVCS_DEBUG ((LM_DEBUG,
ACE_TEXT ("Encountered undefined parameter type "
"for variable: %s\n"),
name.c_str ()));
throw CORBA::INTF_REPOS ();
}
retval[i].type = impl->type_i ();
CORBA::Object_var obj =
TAO_IFR_Service_Utils::path_to_ir_object (type_path,
this->repo_);
retval[i].type_def = CORBA::IDLType::_narrow (obj.in ());
}
return retval._retn ();
}
void
TAO_IFR_Service_Utils::fill_valuemember_seq (
CORBA::ValueMemberSeq &vm_seq,
ACE_Configuration_Section_Key &key,
TAO_Repository_i *repo
)
{
ACE_Configuration_Section_Key members_key;
int status =
repo->config ()->open_section (key,
"members",
0,
members_key);
if (status != 0)
{
vm_seq.length (0);
return;
}
CORBA::ULong count = 0;
repo->config ()->get_integer_value (members_key,
"count",
count);
vm_seq.length (count);
char *stringified = 0;
ACE_Configuration_Section_Key member_key, type_key;
ACE_TString holder;
CORBA::ULong access = 0;
for (CORBA::ULong i = 0; i < count; ++i)
{
stringified = TAO_IFR_Service_Utils::int_to_string (i);
repo->config ()->open_section (members_key,
stringified,
0,
member_key);
repo->config ()->get_string_value (member_key,
"name",
holder);
vm_seq[i].name = holder.fast_rep ();
repo->config ()->get_string_value (member_key,
"id",
holder);
vm_seq[i].id = holder.fast_rep ();
repo->config ()->get_string_value (key,
"id",
holder);
vm_seq[i].defined_in = holder.fast_rep ();
repo->config ()->get_string_value (member_key,
"version",
holder);
vm_seq[i].version = holder.fast_rep ();
repo->config ()->get_string_value (member_key,
"type_path",
holder);
TAO_IDLType_i *impl =
TAO_IFR_Service_Utils::path_to_idltype (holder,
repo);
vm_seq[i].type = impl->type_i ();
repo->config ()->get_integer_value (member_key,
"access",
access);
vm_seq[i].access = static_cast<CORBA::Visibility> (access);
}
}
CORBA::ExtInitializerSeq *
TAO_ExtValueDef_i::ext_initializers_i (
)
{
CORBA::ExtInitializerSeq *iseq = 0;
ACE_NEW_RETURN (iseq,
CORBA::ExtInitializerSeq,
0);
CORBA::ExtInitializerSeq_var retval = iseq;
ACE_Configuration_Section_Key initializers_key;
int status =
this->repo_->config ()->open_section (this->section_key_,
"initializers",
0,
initializers_key);
if (status != 0)
{
iseq->length (0);
return retval._retn ();
}
CORBA::ULong count = 0;
this->repo_->config ()->get_integer_value (initializers_key,
"count",
count);
iseq->length (count);
char *stringified = 0;
ACE_Configuration_Section_Key initializer_key, params_key, arg_key;
ACE_TString holder;
CORBA::ULong arg_count = 0;
for (CORBA::ULong i = 0; i < count; ++i)
{
stringified = TAO_IFR_Service_Utils::int_to_string (i);
this->repo_->config ()->open_section (initializers_key,
stringified,
0,
initializer_key);
this->repo_->config ()->get_string_value (initializer_key,
"name",
holder);
retval[i].name = holder.fast_rep ();
status =
this->repo_->config ()->open_section (initializer_key,
"params",
0,
params_key);
if (status != 0)
{
retval[i].members.length (0);
continue;
}
this->repo_->config ()->get_integer_value (params_key,
"count",
arg_count);
retval[i].members.length (arg_count);
CORBA::Object_var obj;
for (CORBA::ULong j = 0; j < arg_count; ++j)
{
stringified = TAO_IFR_Service_Utils::int_to_string (j);
this->repo_->config ()->open_section (params_key,
stringified,
0,
arg_key);
this->repo_->config ()->get_string_value (arg_key,
"arg_name",
holder);
retval[i].members[j].name = holder.fast_rep ();
this->repo_->config ()->get_string_value (arg_key,
"arg_path",
holder);
TAO_IDLType_i *impl =
TAO_IFR_Service_Utils::path_to_idltype (holder,
this->repo_);
retval[i].members[j].type =
impl->type_i ();
obj =
TAO_IFR_Service_Utils::path_to_ir_object (holder,
this->repo_);
retval[i].members[j].type_def =
CORBA::IDLType::_narrow (obj.in ());
}
this->fill_exceptions (retval[i].exceptions,
initializer_key,
"excepts");
}
return retval._retn ();
}
CORBA::ExtValueDef::ExtFullValueDescription *
TAO_ExtValueDef_i::describe_ext_value_i (
)
{
CORBA::ExtValueDef::ExtFullValueDescription *fv_desc = 0;
ACE_NEW_RETURN (fv_desc,
CORBA::ExtValueDef::ExtFullValueDescription,
0);
CORBA::ExtValueDef::ExtFullValueDescription_var retval = fv_desc;
ACE_TString holder;
this->repo_->config ()->get_string_value (this->section_key_,
"name",
holder);
fv_desc->name = holder.fast_rep ();
this->repo_->config ()->get_string_value (this->section_key_,
"id",
holder);
fv_desc->id = holder.fast_rep ();
CORBA::ULong val = 0;
this->repo_->config ()->get_integer_value (this->section_key_,
"is_abstract",
val);
fv_desc->is_abstract = static_cast<CORBA::Boolean> (val);
this->repo_->config ()->get_integer_value (this->section_key_,
"is_custom",
val);
fv_desc->is_custom = static_cast<CORBA::Boolean> (val);
this->repo_->config ()->get_string_value (this->section_key_,
"container_id",
holder);
fv_desc->defined_in = holder.fast_rep ();
this->repo_->config ()->get_string_value (this->section_key_,
"version",
holder);
fv_desc->version = holder.fast_rep ();
// Operations.
fv_desc->operations.length (0);
ACE_Configuration_Section_Key ops_key;
int status =
this->repo_->config ()->open_section (this->section_key_,
"ops",
0,
ops_key);
CORBA::ULong count = 0;
CORBA::ULong param_count = 0;
char *stringified = 0;
CORBA::ULong i = 0;
CORBA::ULong j = 0;
TAO_IDLType_i *idl_type = 0;
CORBA::Object_var obj;
ACE_Configuration_Section_Key params_key, excepts_key, except_def_key;
if (status == 0)
{
this->repo_->config ()->get_integer_value (ops_key,
"count",
count);
fv_desc->operations.length (count);
ACE_Configuration_Section_Key op_key, result_key, contexts_key;
for (i = 0; i < count; ++i)
{
stringified = TAO_IFR_Service_Utils::int_to_string (i);
this->repo_->config ()->open_section (ops_key,
stringified,
0,
op_key);
this->repo_->config ()->get_string_value (op_key,
"name",
holder);
fv_desc->operations[i].name = holder.fast_rep ();
this->repo_->config ()->get_string_value (op_key,
"id",
holder);
fv_desc->operations[i].id = holder.fast_rep ();
this->repo_->config ()->get_string_value (this->section_key_,
"id",
holder);
fv_desc->operations[i].defined_in = holder.fast_rep ();
this->repo_->config ()->get_string_value (op_key,
"result",
holder);
idl_type =
TAO_IFR_Service_Utils::path_to_idltype (holder,
this->repo_);
fv_desc->operations[i].result =
idl_type->type_i ();
this->repo_->config ()->get_integer_value (op_key,
"mode",
val);
fv_desc->operations[i].mode = static_cast<CORBA::OperationMode> (val);
CORBA::TCKind kind =
fv_desc->operations[i].result->kind ();
if (fv_desc->operations[i].mode == CORBA::OP_ONEWAY
&& kind != CORBA::tk_void)
{
throw CORBA::BAD_PARAM (
CORBA::OMGVMCID | 31,
CORBA::COMPLETED_NO);
}
// Operation contexts.
TAO_IFR_Strseq_Utils<CORBA::ContextIdSeq>::fill_string_seq (
"contexts",
this->repo_->config (),
op_key,
fv_desc->operations[i].contexts
);
// Operation parameters.
fv_desc->operations[i].parameters.length (0);
status =
this->repo_->config ()->open_section (op_key,
"params",
0,
params_key);
if (status == 0)
{
ACE_Configuration_Section_Key param_key;
this->repo_->config ()->get_integer_value (params_key,
"count",
param_count);
fv_desc->operations[i].parameters.length (param_count);
for (j = 0; j < param_count; ++j)
{
stringified = TAO_IFR_Service_Utils::int_to_string (j);
this->repo_->config ()->open_section (params_key,
stringified,
0,
param_key);
this->repo_->config ()->get_string_value (param_key,
"name",
holder);
fv_desc->operations[i].parameters[j].name =
holder.fast_rep ();
this->repo_->config ()->get_string_value (param_key,
"type_path",
holder);
idl_type =
TAO_IFR_Service_Utils::path_to_idltype (holder,
this->repo_);
fv_desc->operations[i].parameters[j].type =
idl_type->type_i ();
obj =
TAO_IFR_Service_Utils::path_to_ir_object (
holder,
this->repo_
);
fv_desc->operations[i].parameters[j].type_def =
CORBA::IDLType::_narrow (obj.in ());
this->repo_->config ()->get_integer_value (param_key,
"mode",
val);
fv_desc->operations[i].parameters[j].mode =
static_cast<CORBA::ParameterMode> (val);
}
}
// Operation exceptions.
status =
this->repo_->config ()->open_section (op_key,
"excepts",
0,
excepts_key);
fv_desc->operations[i].exceptions.length (0);
if (status == 0)
{
CORBA::ULong excep_count = 0;
this->repo_->config ()->get_integer_value (excepts_key,
"count",
excep_count);
fv_desc->operations[i].exceptions.length (excep_count);
ACE_Configuration_Section_Key except_def_key;
for (j = 0; j < excep_count; ++j)
{
stringified = TAO_IFR_Service_Utils::int_to_string (j);
this->repo_->config ()->get_string_value (excepts_key,
stringified,
holder);
this->repo_->config ()->expand_path (
this->repo_->root_key (),
holder,
except_def_key,
0
);
this->repo_->config ()->get_string_value (except_def_key,
"name",
holder);
fv_desc->operations[i].exceptions[j].name =
holder.fast_rep ();
this->repo_->config ()->get_string_value (except_def_key,
"id",
holder);
fv_desc->operations[i].exceptions[j].id =
holder.fast_rep ();
this->repo_->config ()->get_string_value (except_def_key,
"container_id",
holder);
fv_desc->operations[i].exceptions[j].defined_in =
holder.fast_rep ();
this->repo_->config ()->get_string_value (except_def_key,
"version",
holder);
fv_desc->operations[i].exceptions[j].version =
holder.fast_rep ();
TAO_ExceptionDef_i impl (this->repo_);
impl.section_key (except_def_key);
fv_desc->operations[i].exceptions[j].type =
impl.type_i ();
}
}
}
}
// Attributes..
fv_desc->attributes.length (0);
ACE_Configuration_Section_Key attrs_key;
status =
this->repo_->config ()->open_section (this->section_key_,
"attrs",
0,
attrs_key);
if (status == 0)
{
this->repo_->config ()->get_integer_value (attrs_key,
"count",
count);
fv_desc->attributes.length (count);
ACE_Configuration_Section_Key attr_key, attr_def_key;
for (i = 0; i < count; ++i)
{
stringified = TAO_IFR_Service_Utils::int_to_string (i);
this->repo_->config ()->open_section (attrs_key,
stringified,
0,
attr_key);
this->repo_->config ()->get_string_value (attr_key,
"name",
holder);
fv_desc->attributes[i].name = holder.fast_rep ();
this->repo_->config ()->get_string_value (attr_key,
"id",
holder);
fv_desc->attributes[i].id = holder.fast_rep ();
this->repo_->config ()->get_string_value (attr_key,
"version",
holder);
fv_desc->attributes[i].version = holder.fast_rep ();
this->repo_->config ()->get_integer_value (attr_key,
"mode",
val);
fv_desc->attributes[i].mode =
static_cast<CORBA::AttributeMode> (val);
this->repo_->config ()->get_string_value (attr_key,
"type_path",
holder);
// Use the type path for 'defined_in' and 'type'.
idl_type =
TAO_IFR_Service_Utils::path_to_idltype (holder,
this->repo_);
fv_desc->attributes[i].type =
idl_type->type_i ();
this->repo_->config ()->expand_path (this->repo_->root_key (),
holder,
attr_def_key,
0);
this->repo_->config ()->get_string_value (attr_def_key,
"container_id",
holder);
fv_desc->attributes[i].defined_in = holder.fast_rep ();
this->fill_exceptions (fv_desc->attributes[i].get_exceptions,
attr_key,
"get_excepts");
this->fill_exceptions (fv_desc->attributes[i].put_exceptions,
attr_key,
"put_excepts");
}
}
// Members..
fv_desc->members.length (0);
ACE_Configuration_Section_Key members_key;
status =
this->repo_->config ()->open_section (this->section_key_,
"members",
0,
members_key);
if (status == 0)
{
this->repo_->config ()->get_integer_value (members_key,
"count",
count);
fv_desc->members.length (count);
ACE_Configuration_Section_Key member_key, member_def_key;
for (i = 0; i < count; ++i)
{
stringified = TAO_IFR_Service_Utils::int_to_string (i);
this->repo_->config ()->open_section (members_key,
stringified,
0,
member_key);
this->repo_->config ()->get_string_value (member_key,
"name",
holder);
fv_desc->members[i].name = holder.fast_rep ();
this->repo_->config ()->get_string_value (member_key,
"id",
holder);
fv_desc->members[i].id = holder.fast_rep ();
this->repo_->config ()->get_string_value (member_key,
"container_id",
holder);
fv_desc->members[i].defined_in = holder.fast_rep ();
this->repo_->config ()->get_string_value (member_key,
"version",
holder);
fv_desc->members[i].version = holder.fast_rep ();
this->repo_->config ()->get_integer_value (member_key,
"access",
val);
fv_desc->members[i].access =
static_cast<CORBA::Visibility> (val);
// Use type path for 'type' and 'type_def',
this->repo_->config ()->get_string_value (member_key,
"type_path",
holder);
idl_type =
TAO_IFR_Service_Utils::path_to_idltype (holder,
this->repo_);
fv_desc->members[i].type =
idl_type->type_i ();
obj =
TAO_IFR_Service_Utils::path_to_ir_object (holder,
this->repo_);
fv_desc->members[i].type_def =
CORBA::IDLType::_narrow (obj.in ());
}
}
// Initializers
fv_desc->initializers.length (0);
ACE_Configuration_Section_Key initializers_key;
status =
this->repo_->config ()->open_section (this->section_key_,
"initializers",
0,
initializers_key);
if (status == 0)
{
this->repo_->config ()->get_integer_value (initializers_key,
"count",
count);
fv_desc->initializers.length (count);
ACE_Configuration_Section_Key initializer_key,
params_key,
arg_key,
excepts_key;
for (i = 0; i < count; ++i)
{
stringified = TAO_IFR_Service_Utils::int_to_string (i);
this->repo_->config ()->open_section (initializers_key,
stringified,
0,
initializer_key);
this->repo_->config ()->get_string_value (initializer_key,
"name",
holder);
fv_desc->initializers[i].name = holder.fast_rep ();
fv_desc->initializers[i].members.length (0);
status =
this->repo_->config ()->open_section (initializer_key,
"params",
0,
params_key);
if (status == 0)
{
this->repo_->config ()->get_integer_value (params_key,
"count",
param_count);
fv_desc->initializers[i].members.length (param_count);
for (j = 0; j < param_count; ++j)
{
stringified = TAO_IFR_Service_Utils::int_to_string (j);
this->repo_->config ()->open_section (params_key,
stringified,
0,
arg_key);
this->repo_->config ()->get_string_value (arg_key,
"arg_name",
holder);
fv_desc->initializers[i].members[j].name =
holder.fast_rep ();
this->repo_->config ()->get_string_value (arg_key,
"arg_path",
holder);
TAO_IDLType_i *impl =
TAO_IFR_Service_Utils::path_to_idltype (holder,
this->repo_);
fv_desc->initializers[i].members[j].type =
impl->type_i ();
obj =
TAO_IFR_Service_Utils::path_to_ir_object (
holder,
this->repo_
);
fv_desc->initializers[i].members[j].type_def =
CORBA::IDLType::_narrow (obj.in ());
}
}
this->fill_exceptions (fv_desc->initializers[i].exceptions,
initializer_key,
"excepts");
}
}
TAO_IFR_Strseq_Utils<CORBA::RepositoryIdSeq>::fill_string_seq (
"supported",
this->repo_->config (),
this->section_key_,
fv_desc->supported_interfaces
);
TAO_IFR_Strseq_Utils<CORBA::RepositoryIdSeq>::fill_string_seq (
"abstract_bases",
this->repo_->config (),
this->section_key_,
fv_desc->abstract_base_values
);
this->repo_->config ()->get_integer_value (this->section_key_,
"is_truncatable",
val);
fv_desc->is_truncatable = static_cast<CORBA::Boolean> (val);
status =
this->repo_->config ()->get_string_value (this->section_key_,
"base_value",
holder);
if (status == 0)
{
ACE_Configuration_Section_Key base_key;
this->repo_->config ()->expand_path (this->repo_->root_key (),
holder,
base_key,
0);
this->repo_->config ()->get_string_value (base_key,
"id",
holder);
}
// If status isn't 0, then holder will be empty anyway.
fv_desc->base_value = holder.fast_rep ();
fv_desc->type = this->type_i ();
return retval._retn ();
}
