static test_StrArray_slice *
ArrayServer_opStrArray(PortableServer_Servant _servant,
const test_StrArray inArg,
test_StrArray inoutArg,
test_StrArray_slice ** outArg,
CORBA_Environment * ev)
{
int i;
test_StrArray_slice *retn;
for(i=0;i<test_SequenceLen;i++)
g_assert(strcmp(inArg[i],constants_SEQ_STRING_IN[i])==0);
for(i=0;i<test_SequenceLen;i++)
g_assert(strcmp(inoutArg[i],constants_SEQ_STRING_INOUT_IN[i])==0);
for(i=0;i<test_SequenceLen;i++){
CORBA_free(inoutArg[i]);
inoutArg[i] = CORBA_string_dup(constants_SEQ_STRING_INOUT_OUT[i]);
}
*outArg = test_StrArray__alloc();
for(i=0;i<test_SequenceLen;i++)
(*outArg)[i] = CORBA_string_dup(constants_SEQ_STRING_OUT[i]);
retn = test_StrArray__alloc();
for(i=0;i<test_SequenceLen;i++)
retn[i] = CORBA_string_dup(constants_SEQ_STRING_RETN[i]);
return retn;
}
static void remap_hsp(gpointer key,gpointer data,gpointer user_data)
{
HSPset * set = (HSPset*)data;
Wise2HSP_HSPmanager* manager = (Wise2HSP_HSPmanager*) user_data;
int pos;
int i;
pos = manager->target._length++;
/* first off, allocate and store this target */
manager->target._buffer[pos].target.name = CORBA_string_dup(set->hsp[0]->target->name);
manager->target._buffer[pos].target.seq = CORBA_string_dup(set->hsp[0]->target->seq);
manager->target._buffer[pos].hsp._buffer = CORBA_sequence_Wise2HSP_HSPinfo_allocbuf(set->len);
manager->target._buffer[pos].hsp._maximum =set->len;
manager->target._buffer[pos].hsp._length =set->len;
for(i=0;i<set->len;i++) {
manager->target._buffer[pos].hsp._buffer[i].query_start = set->hsp[i]->query_start;
manager->target._buffer[pos].hsp._buffer[i].target_start = set->hsp[i]->target_start;
manager->target._buffer[pos].hsp._buffer[i].length = set->hsp[i]->length;
manager->target._buffer[pos].hsp._buffer[i].score = set->hsp[i]->score;
}
return;
}
static Wise2HSP_HSPtargetset *
impl_Wise2HSP_HSP_ts_iterator_next(impl_POA_Wise2HSP_HSP_ts_iterator * servant,
CORBA_Environment * ev)
{
Wise2HSP_HSPtargetset *retval;
HSPset * s;
int i;
s = servant->lm->set[servant->current_pos];
/* fprintf(stderr,"Going to pass to client %d block %s\n",servant->current_pos,s->hsp[0]->target->name);*/
retval = Wise2HSP_HSPtargetset__alloc();
/* do we need to worry about string dup's ... probably!*/
retval->target.name = CORBA_string_dup(s->hsp[0]->target->name);
retval->target.seq = CORBA_string_dup(s->hsp[0]->target->seq);
retval->hsp._buffer = CORBA_sequence_Wise2HSP_HSPinfo_allocbuf(s->len);
retval->hsp._maximum = retval->hsp._length = s->len;
for(i=0;i<s->len;i++) {
retval->hsp._buffer[i].query_start = s->hsp[i]->query_start;
retval->hsp._buffer[i].target_start = s->hsp[i]->target_start;
retval->hsp._buffer[i].length = s->hsp[i]->length;
retval->hsp._buffer[i].score = s->hsp[i]->score;
}
servant->current_pos++;
/* fprintf(stderr,"Going to return with score %d length %d\n",s->score,s->len); */
return retval;
}
static GNOME_C_Mngr_ManufacturerList *
impl_get_devices (PortableServer_Servant servant, CORBA_Environment *ev)
{
KncCMngr *m = KNC_C_MNGR (bonobo_object (servant));
GNOME_C_Mngr_ManufacturerList *l;
unsigned int i, j, k, n, o;
GPPortInfo info;
int c;
l = GNOME_C_Mngr_ManufacturerList__alloc ();
/* List all manufacturers */
l->_buffer = GNOME_C_Mngr_ManufacturerList_allocbuf (
knc_count_devices ());
l->_length = 0;
for (i = 0; i < knc_count_devices (); i++) {
for (j = 0; j < l->_length; j++)
if (!strcmp (l->_buffer[j].manufacturer,
knc_get_device_manufacturer (i))) break;
if (j == l->_length) {
l->_length++;
l->_buffer[j].manufacturer = CORBA_string_dup (
knc_get_device_manufacturer (i));
l->_buffer[j].models._length = 0;
l->_buffer[j].models._buffer =
GNOME_C_Mngr_ModelList_allocbuf (knc_count_devices ());
/* List all models */
for (k = 0; k < knc_count_devices (); k++) {
if (strcmp (l->_buffer[j].manufacturer,
knc_get_device_manufacturer (k))) continue;
n = l->_buffer[j].models._length;
l->_buffer[j].models._length++;
l->_buffer[j].models._buffer[n].model =
CORBA_string_dup (knc_get_device_model (k));
/* List all serial ports */
c = gp_port_info_list_count (m->priv->il);
l->_buffer[j].models._buffer[n].ports._length = 0;
l->_buffer[j].models._buffer[n].ports._buffer =
CORBA_sequence_CORBA_string_allocbuf (MAX (c, 0));
for (o = 0; o < MAX (c, 0); o++) {
gp_port_info_list_get_info (m->priv->il, o, &info);
if (info.type == GP_PORT_SERIAL) {
l->_buffer[j].models._buffer[n].ports._buffer[
l->_buffer[j].models._buffer[n].ports._length] =
CORBA_string_dup (info.name);
l->_buffer[j].models._buffer[n].ports._length++;
}
}
}
}
}
CORBA_sequence_set_release (l, CORBA_TRUE);
return l;
}
static CORBA_char *
BasicServer_opString (PortableServer_Servant servant,
const CORBA_char *inArg,
CORBA_char **inoutArg,
CORBA_char **outArg,
CORBA_Environment *ev)
{
g_assert (!strcmp (inArg, constants_STRING_IN));
g_assert (!strcmp (*inoutArg, constants_STRING_INOUT_IN));
CORBA_free (*inoutArg);
*inoutArg = CORBA_string_dup (constants_STRING_INOUT_OUT);
*outArg = CORBA_string_dup (constants_STRING_OUT);
return CORBA_string_dup (constants_STRING_RETN);
}
void
MateComponent_ActivationProperty_copy (MateComponent_ActivationProperty *copy,
const MateComponent_ActivationProperty *original)
{
copy->name = CORBA_string_dup (original->name);
MateComponent_ActivationPropertyValue_copy (©->v, &original->v);
}
static CORBA_string
impl_accessibility_application_get_locale (PortableServer_Servant servant,
Accessibility_LOCALE_TYPE lctype,
CORBA_Environment *ev)
{
int category;
switch (lctype)
{
case Accessibility_LOCALE_TYPE_COLLATE:
category = LC_COLLATE;
break;
case Accessibility_LOCALE_TYPE_CTYPE:
category = LC_CTYPE;
break;
case Accessibility_LOCALE_TYPE_MONETARY:
category = LC_MONETARY;
break;
case Accessibility_LOCALE_TYPE_NUMERIC:
category = LC_NUMERIC;
break;
case Accessibility_LOCALE_TYPE_MESSAGES:
default:
category = LC_MESSAGES;
break;
}
return CORBA_string_dup (setlocale (category, NULL));
}
static void
MateCORBA_service_list_add_id (CORBA_string key,
gpointer value,
struct MateCORBA_service_list_info *info)
{
info->list->_buffer [info->index++] = CORBA_string_dup (key);
}
/**
* AccessibleStreamableContent_open:
* @obj: a pointer to the #AccessibleStreamableContent implementor on which to operate.
* @content_type: a string specifying the content type to retrieve (should match one
* of the return strings from #AccessibleStreamableContent_getContentTypes ()).
*
* Open a streaming connection to an AccessibleStreamableContent implementor,
* of a particular content type. Note that a client may only have one
* open stream per streamable interface instance in the current
* implementation.
*
* @Since: AT-SPI 1.4
*
* Returns: #TRUE if successful, #FALSE if unsuccessful.
*
**/
SPIBoolean
AccessibleStreamableContent_open (AccessibleStreamableContent *obj,
const char *content_type)
{
Accessibility_ContentStream stream;
struct StreamCacheItem *cache;
stream = Accessibility_StreamableContent_getStream (CSPI_OBJREF (obj),
content_type,
cspi_ev ());
cspi_return_val_if_ev ("getContent", FALSE);
if (stream != CORBA_OBJECT_NIL) {
cache = g_new0 (struct StreamCacheItem, 1);
cache->stream = stream;
cache->mimetype = CORBA_string_dup (content_type);
g_hash_table_replace (get_streams (), CSPI_OBJREF (obj), cache);
/* FIXME
* This limits us to one concurrent stream per streamable interface
* for a given client.
* It might be reasonable for a client to open more than one stream
* to content, in different mime-types, at the same time.
*/
return TRUE;
}
static CORBA_string
impl_getLocale (PortableServer_Servant servant,
CORBA_Environment *ev)
{
const gchar *lc;
AtkDocument *document = get_document_from_servant (servant);
g_return_val_if_fail (document != NULL, "");
lc = atk_document_get_locale (document);
if (lc)
return CORBA_string_dup (lc);
else
return CORBA_string_dup (""); /* Should we return 'C' by default? */
}
static CORBA_EnumMemberSeq *
MateCORBA_imodule_get_enum_members (IDL_tree tree,
CORBA_Environment *ev)
{
CORBA_EnumMemberSeq *members;
IDL_tree l;
int num_members = 0;
int i;
g_return_val_if_fail (IDL_NODE_TYPE (tree) == IDLN_TYPE_ENUM, NULL);
num_members = IDL_list_length (IDL_TYPE_ENUM (tree).enumerator_list);
members = CORBA_EnumMemberSeq__alloc ();
members->_length = members->_maximum = num_members;
members->_buffer = CORBA_EnumMemberSeq_allocbuf (members->_length);
members->_release = CORBA_TRUE;
for (i = 0, l = IDL_TYPE_ENUM (tree).enumerator_list; l; i++, l = IDL_LIST (l).next)
members->_buffer [i] = CORBA_string_dup (IDL_IDENT (IDL_LIST (l).data).str);
g_assert (i == num_members);
return members;
}
void
spi_init_any_rect (CORBA_any *any_details,
Accessibility_Application app,
Accessibility_Role role,
CORBA_string name,
AtkRectangle *rect)
{
Accessibility_EventDetails *details = Accessibility_EventDetails__alloc();
Accessibility_BoundingBox *box = Accessibility_BoundingBox__alloc ();
any_details->_type = TC_Accessibility_EventDetails;
any_details->_value = details;
any_details->_release = TRUE;
details->host_application = app;
details->source_role = role;
details->source_name = CORBA_string_dup (name);
box->x = rect->x;
box->y = rect->y;
box->width = rect->width;
box->height = rect->height;
details->any_data._type = TC_Accessibility_BoundingBox;
details->any_data._value = box;
details->any_data._release = TRUE;
}
static GNOME_GnoCam_PortList *
impl_GNOME_GnoCam_getPortList (PortableServer_Servant servant,
CORBA_Environment *ev)
{
GnoCamMain *gm;
GNOME_GnoCam_PortList *list;
GPPortInfoList *il = NULL;
GPPortInfo info;
int n, i;
gm = GNOCAM_MAIN (bonobo_object_from_servant (servant));
gp_port_info_list_new (&il);
gp_port_info_list_load (il);
n = MAX (0, gp_port_info_list_count (il));
list = GNOME_GnoCam_PortList__alloc ();
list->_buffer = CORBA_sequence_CORBA_string_allocbuf (n);
for (i = 0; i < n; i++) {
if (gp_port_info_list_get_info (il, i, &info) >= 0) {
list->_buffer[list->_length] =
CORBA_string_dup (info.name);
list->_length++;
}
}
CORBA_sequence_set_release (list, TRUE);
gp_port_info_list_free (il);
return (list);
}
static void
get_object_names (gpointer key, gpointer value, gpointer user_data)
{
GSList **l = user_data;
*l = g_slist_prepend (*l, CORBA_string_dup (key));
}
static CORBA_char *
impl_Bonobo_UIComponent_describeVerbs (PortableServer_Servant servant,
CORBA_Environment *ev)
{
g_warning ("FIXME: Describe verbs unimplemented");
return CORBA_string_dup ("<NoUIVerbDescriptionCodeYet/>");
}
void
CORBA_NVList_add_item (CORBA_NVList list,
const CORBA_char *item_name,
const CORBA_TypeCode item_type,
const CORBA_OpaqueValue value,
const CORBA_long value_len,
const CORBA_Flags item_flags,
CORBA_Environment *ev)
{
CORBA_NamedValue newval;
g_assert (list != NULL);
newval.name = CORBA_string_dup (item_name);
newval.argument._type = MateCORBA_RootObject_duplicate (
item_type);
if (item_flags & CORBA_IN_COPY_VALUE) {
newval.argument._value = MateCORBA_copy_value (
value, item_type);
newval.argument._release = CORBA_TRUE;
} else {
newval.argument._value = value;
newval.argument._release = CORBA_FALSE;
}
newval.len = value_len; /* Is this even useful? *sigh* */
newval.arg_modes = item_flags;
g_array_append_val (list->list, newval);
}
static void
test_ORBit_alloc (void)
{
gpointer p;
int i;
p = ORBit_alloc_string (100);
g_assert ((gulong)p & 0x1);
for (i = 0; i < 100; i++)
((guchar *)p) [i] = i;
CORBA_free (p);
p = CORBA_string_dup ("Foo");
g_assert (((gulong)p & 0x1));
CORBA_free (p);
p = ORBit_alloc_simple (100);
g_assert (!((gulong)p & 0x1));
for (i = 0; i < 100; i++)
((guchar *)p) [i] = i;
CORBA_free (p);
p = ORBit_alloc_tcval (TC_CORBA_sequence_CORBA_octet, 1);
g_assert (!((gulong)p & 0x1));
CORBA_free (p);
p = ORBit_alloc_tcval (TC_ORBit_IInterface, 8);
g_assert (!((gulong)p & 0x1));
CORBA_free (p);
}
Wise2Corba_Singleton * get_Wise2Corba_Singleton(int * argc,char ** argv,char * init_string)
{
if( static_init_string != NULL ) {
if( strcmp(static_init_string,init_string) == 0 ) {
return &singleton;
} else {
fprintf(stderr,"Trouble! Asked for orbs of different types %s and %s",init_string,static_init_string);
return NULL;
}
}
/* else, initiate orb */
singleton.ev = g_new0(CORBA_Environment,1);
CORBA_exception_init(singleton.ev);
singleton.orb = CORBA_ORB_init(argc,argv,init_string,singleton.ev);
/* FIXME: Exception check! */
singleton.poa = (PortableServer_POA)CORBA_ORB_resolve_initial_references(singleton.orb,
"RootPOA",singleton.ev);
static_init_string = CORBA_string_dup(init_string);
return &singleton;
}
static GNOME_GnoCam_ModelList *
impl_GNOME_GnoCam_getModelList (PortableServer_Servant servant,
CORBA_Environment *ev)
{
GnoCamMain *gm;
GNOME_GnoCam_ModelList *list;
CameraAbilitiesList *al = NULL;
int n, i;
CameraAbilities a;
gm = GNOCAM_MAIN (bonobo_object_from_servant (servant));
gp_abilities_list_new (&al);
gp_abilities_list_load (al, NULL);
n = MAX (0, gp_abilities_list_count (al));
list = GNOME_GnoCam_ModelList__alloc ();
list->_buffer = CORBA_sequence_CORBA_string_allocbuf (n);
for (i = 0; i < n; i++) {
if (gp_abilities_list_get_abilities (al, i, &a) >= 0) {
list->_buffer[list->_length] =
CORBA_string_dup (a.model);
list->_length++;
}
}
CORBA_sequence_set_release (list, TRUE);
gp_abilities_list_free (al);
return (list);
}
static CORBA_char*
impl_MateComponent_Persist_getIId (PortableServer_Servant servant,
CORBA_Environment *ev)
{
MateComponentPersist *persist = matecomponent_persist_from_servant (servant);
return CORBA_string_dup (persist->priv->iid);
}
static CORBA_char*
impl_Bonobo_Persist_getIId (PortableServer_Servant servant,
CORBA_Environment *ev)
{
BonoboPersist *persist = bonobo_persist_from_servant (servant);
return CORBA_string_dup (persist->priv->iid);
}
static CORBA_string
impl_getAttributeValue (PortableServer_Servant servant,
const CORBA_char *attributename,
CORBA_Environment *ev){
const gchar *atr;
AtkDocument *document = get_document_from_servant (servant);
g_return_val_if_fail (document != NULL, "");
atr = atk_document_get_attribute_value (document, attributename);
if (atr)
return CORBA_string_dup (atr);
else
return CORBA_string_dup ("");
}
/*
* CORBA Accessibility::Accessible::getLocalizedRole method implementation
*/
static CORBA_char *
impl_accessibility_accessible_get_local_role_name (PortableServer_Servant servant,
CORBA_Environment *ev)
{
const gchar *role_name;
AtkRole role;
AtkObject *object = get_atkobject_from_servant (servant);
g_return_val_if_fail (object != NULL, NULL);
role = atk_object_get_role (object);
role_name = atk_role_get_localized_name (role);
if (role_name)
return CORBA_string_dup (role_name);
else
return CORBA_string_dup ("");
}
CORBA_Object
etk_name_service_resolve (CosNaming_NamingContext name_service,
gchar *id_vec[],
CORBA_Environment *ev)
{
CORBA_Object retval = CORBA_OBJECT_NIL;
gint i = 0;
gint len = id_vec_len (id_vec);
/* Allocate a CosNaming::Name (sequence of CosNaming::NameComponent) */
CosNaming_Name *name = CosNaming_Name__alloc();
g_assert (id_vec_len (id_vec) > 0);
name->_buffer = CORBA_sequence_CosNaming_NameComponent_allocbuf(len);
name->_maximum = len;
name->_length = 0;
/* Relinquish ownership of the NameComponent to the
* sequence. When CORBA_free is called on it later, the
* NameComponent will be freed */
CORBA_sequence_set_release (name, TRUE);
/* iterate components of name and create sub-context
* (directory) if needed */
for (i = 0; i < len; ++i) {
name->_length = i+1;
name->_buffer[i].id = CORBA_string_dup(id_vec[i]);
name->_buffer[i].kind = CORBA_string_dup("");
/* don't know what 'kind' shall be good for */
}
retval = CosNaming_NamingContext_resolve (name_service,
name,
ev);
if (etk_raised_exception (ev)) {
CORBA_free (name);
return CORBA_OBJECT_NIL;
}
return retval;
}
static void
impl_GNOME_GnoCam_getCameraByModelAndPort (
PortableServer_Servant servant,
Bonobo_Listener listener,
const CORBA_char *model, const CORBA_char *port,
CORBA_Environment *ev)
{
IdleData *d;
d = g_new0 (IdleData, 1);
d->model = CORBA_string_dup (model);
d->port = CORBA_string_dup (port);
d->gm = GNOCAM_MAIN (bonobo_object_from_servant (servant));
bonobo_object_ref (d->gm);
d->listener = bonobo_object_dup_ref (listener, NULL);
g_message ("Adding idle function...");
g_idle_add (get_camera_idle, d);
}
/**
* SPI_dupString:
* @s: a UTF-8 string to be duplicated
*
* @Since: AT-SPI 1.4
*
* Returns: a duplicate of the string passed as a parameter, which should
* be freed via SPI_freeString after use.
**/
char *
SPI_dupString (char *s)
{
if (s)
{
return CORBA_string_dup (s);
}
else
return NULL;
}
static CORBA_UnionMemberSeq *
MateCORBA_imodule_get_union_members (GHashTable *typecodes,
IDL_tree tree,
CORBA_TypeCode switchtc,
CORBA_Environment *ev)
{
CORBA_UnionMemberSeq *members;
IDL_tree l;
int num_members = 0;
int i;
g_return_val_if_fail (IDL_NODE_TYPE (tree) == IDLN_TYPE_UNION, NULL);
for (l = IDL_TYPE_UNION (tree).switch_body; l; l = IDL_LIST (l).next)
num_members += IDL_list_length (IDL_CASE_STMT (IDL_LIST (l).data).labels);
members = CORBA_UnionMemberSeq__alloc ();
members->_length = members->_maximum = num_members;
members->_buffer = CORBA_UnionMemberSeq_allocbuf (members->_length);
members->_release = CORBA_TRUE;
for (i = 0, l = IDL_TYPE_UNION (tree).switch_body; l; l = IDL_LIST (l).next) {
CORBA_TypeCode subtc;
IDL_tree member, label, dcl;
member = IDL_CASE_STMT (IDL_LIST (l).data).element_spec;
g_assert (IDL_NODE_TYPE (member) == IDLN_MEMBER);
subtc = MateCORBA_imodule_get_typecode (
typecodes, IDL_MEMBER (member).type_spec);
dcl = IDL_LIST (IDL_MEMBER (member).dcls).data;
for (label = IDL_CASE_STMT (IDL_LIST (l).data).labels; label;
label = IDL_LIST (label).next, i++) {
CORBA_UnionMember *umember = &members->_buffer [i];
MateCORBA_imodule_setup_label_any (
switchtc, IDL_LIST (label).data, &umember->label);
umember->label._release = CORBA_TRUE;
umember->name = CORBA_string_dup (IDL_IDENT (dcl).str);
umember->type = (CORBA_TypeCode)
CORBA_Object_duplicate ((CORBA_Object) subtc, ev);
umember->type_def = CORBA_OBJECT_NIL; /* Not used? */
}
CORBA_Object_release ((CORBA_Object) subtc, ev);
}
g_assert (i == num_members);
return members;
}
static Wise2HSP_HSPmanager * corba_manager_from_wise_manager(LinearHSPmanager * lm)
{
Wise2HSP_HSPmanager* retval;
int size;
int i;
int pos;
size = lm->len;
/* ok, we need to build the return structure now */
retval = Wise2HSP_HSPmanager__alloc();
retval->target._buffer = CORBA_sequence_Wise2HSP_HSPtargetset_allocbuf(size);
retval->target._length = 0;
retval->target._maximum = size;
for(pos=0;pos<lm->len;pos++) {
auto HSPset * set = lm->set[pos];
retval->target._length++;
/* first off, allocate and store this target */
retval->target._buffer[pos].target.name = CORBA_string_dup(set->hsp[0]->target->name);
retval->target._buffer[pos].target.seq = CORBA_string_dup(set->hsp[0]->target->seq);
retval->target._buffer[pos].hsp._buffer = CORBA_sequence_Wise2HSP_HSPinfo_allocbuf(set->len);
retval->target._buffer[pos].hsp._maximum =set->len;
retval->target._buffer[pos].hsp._length =set->len;
for(i=0;i<set->len;i++) {
retval->target._buffer[pos].hsp._buffer[i].query_start = set->hsp[i]->query_start;
retval->target._buffer[pos].hsp._buffer[i].target_start = set->hsp[i]->target_start;
retval->target._buffer[pos].hsp._buffer[i].length = set->hsp[i]->length;
retval->target._buffer[pos].hsp._buffer[i].score = set->hsp[i]->score;
}
}
return retval;
}
static void
impl_upgradeFromVersion (PortableServer_Servant servant, const short major, const short minor, const short revision, CORBA_Environment *ev)
{
MailComponent *component;
CamelException ex;
component = mail_component_peek ();
camel_exception_init (&ex);
if (em_migrate (e_get_user_data_dir (), major, minor, revision, &ex) == -1) {
GNOME_Evolution_Component_UpgradeFailed *failedex;
failedex = GNOME_Evolution_Component_UpgradeFailed__alloc();
failedex->what = CORBA_string_dup(_("Failed upgrading Mail settings or folders."));
failedex->why = CORBA_string_dup(ex.desc);
CORBA_exception_set(ev, CORBA_USER_EXCEPTION, ex_GNOME_Evolution_Component_UpgradeFailed, failedex);
}
camel_exception_clear (&ex);
}
static void
test_copy (void)
{
int i, j;
#define ELEMS (sizeof (tc) / sizeof (tc[0]))
CORBA_TypeCode tc[] = {
TC_CORBA_octet,
TC_CORBA_sequence_CORBA_octet,
TC_CORBA_double,
TC_CORBA_string,
TC_CORBA_sequence_CORBA_string,
TC_GIOP_TargetAddress
};
gpointer data [ELEMS];
const char *test_string = "This is a sample string, for dupping";
fprintf (stderr, "Testing copy...\n");
for (i = 0; i < ELEMS; i++) {
data [i] = ORBit_dynany_new_default (tc [i]);
g_timer_reset (timer);
for (j = 0; j < 1000; j++) {
gpointer foo = ORBit_copy_value (data [i], tc [i]);
CORBA_free (foo);
}
elapsed_time = g_timer_elapsed (timer, NULL);
bogomark += elapsed_time;
fprintf (stderr, " copy %20s : %g(ms)\n",
tc[i]->repo_id == NULL ? "(null)" : tc[i]->repo_id,
elapsed_time);
}
fprintf (stderr, "Testing strdup ...\n");
g_timer_reset (timer);
for (i = 0; i < 10000; i++) {
char *str = g_strdup (test_string);
g_free (str);
}
elapsed_time = g_timer_elapsed (timer, NULL) / 10.0;
bogomark += elapsed_time;
fprintf (stderr, " g_strdup : %g(ns)\n", elapsed_time * 1000.0);
g_timer_reset (timer);
for (i = 0; i < 10000; i++) {
char *str = CORBA_string_dup (test_string);
CORBA_free (str);
}
elapsed_time = g_timer_elapsed (timer, NULL) / 10.0;
bogomark += elapsed_time;
fprintf (stderr, " CORBA_strdup : %g(ns)\n", elapsed_time * 1000.0);
}
