void
PortableServer_POAManager_activate (PortableServer_POAManager manager,
CORBA_Environment *ev)
{
GSList *l;
if (!manager) {
CORBA_exception_set_system (ev, ex_CORBA_BAD_PARAM,
CORBA_COMPLETED_NO);
return;
}
POA_MGR_LOCK (poa_mgr);
if (manager->state == PortableServer_POAManager_INACTIVE)
CORBA_exception_set
(ev, CORBA_USER_EXCEPTION,
ex_PortableServer_POAManager_AdapterInactive,
NULL);
else {
manager->state = PortableServer_POAManager_ACTIVE;
for (l = manager->poa_collection; l; l = l->next) {
PortableServer_POA poa = (PortableServer_POA)l->data;
/* FIXME: need better locking here */
ORBit_POA_handle_held_requests (poa);
}
}
POA_MGR_UNLOCK (poa_mgr);
}
/** The InvalidName exception is raised at @ev when
* ORB.resolve_initial_references is passed an @identifier for which
* there is no initial reference.
*/
CORBA_Object
CORBA_ORB_resolve_initial_references (CORBA_ORB orb,
const CORBA_char *identifier,
CORBA_Environment *ev)
{
CORBA_Object objref;
/* FIXME, verify identifier and raise exception for invalid
* service names, valid names might be: NameService, RootPOA,
* SecurityCurrent, PolicyCurrent, etc. */
if (!orb->initial_refs ||
!(objref = g_hash_table_lookup (orb->initial_refs, identifier)))
return CORBA_OBJECT_NIL;
return MateCORBA_RootObject_duplicate (objref);
#if 0
raise_invalid_name:
CORBA_exception_set (ev,
CORBA_USER_EXCEPTION,
ex_CORBA_ORB_InvalidName,
NULL);
return CORBA_OBJECT_NIL;
#endif
}
static void
mem_truncate (PortableServer_Servant servant,
const CORBA_long new_size,
CORBA_Environment *ev)
{
BonoboStreamMem *smem = BONOBO_STREAM_MEM (
bonobo_object (servant));
void *newp;
if (smem->read_only)
return;
newp = g_realloc (smem->buffer, new_size);
if (!newp) {
CORBA_exception_set (ev, CORBA_USER_EXCEPTION,
ex_Bonobo_Stream_NoPermission, NULL);
return;
}
smem->buffer = newp;
smem->size = new_size;
if (smem->pos > new_size)
smem->pos = new_size;
}
void
PortableServer_POAManager_hold_requests (PortableServer_POAManager manager,
const CORBA_boolean wait_for_completion,
CORBA_Environment *ev)
{
if (!manager) {
CORBA_exception_set_system (ev, ex_CORBA_BAD_PARAM,
CORBA_COMPLETED_NO);
return;
}
POA_MGR_LOCK (poa_mgr);
if (manager->state == PortableServer_POAManager_INACTIVE)
CORBA_exception_set
(ev, CORBA_USER_EXCEPTION,
ex_PortableServer_POAManager_AdapterInactive,
NULL);
else {
manager->state = PortableServer_POAManager_HOLDING;
if (!wait_for_completion)
g_warning ("hold_requests not finished - don't "
"know how to kill outstanding request fulfillments");
}
POA_MGR_UNLOCK (poa_mgr);
}
static void
mem_revert (PortableServer_Servant servant,
CORBA_Environment *ev)
{
CORBA_exception_set (ev, CORBA_USER_EXCEPTION,
ex_Bonobo_Stream_NotSupported, NULL);
}
static GNOME_C_Camera
impl_connect (PortableServer_Servant servant, const CORBA_char *manufacturer,
const CORBA_char *model, const CORBA_char *port,
CORBA_Environment *ev)
{
KncCMngr *m = KNC_C_MNGR (bonobo_object (servant));
KncCCamera *c;
GPPort *p = NULL;
GPPortInfo info;
unsigned int i;
gp_port_new (&p);
for (i = 0; i < MAX (gp_port_info_list_count (m->priv->il), 0); i++) {
gp_port_info_list_get_info (m->priv->il, i, &info);
if (!strcmp (info.name, port)) {
gp_port_set_info (p, info);
c = knc_c_camera_new (manufacturer, model, p, ev);
if (BONOBO_EX (ev)) return CORBA_OBJECT_NIL;
return CORBA_Object_duplicate (BONOBO_OBJREF (c), ev);
}
}
gp_port_free (p);
CORBA_exception_set (ev, CORBA_USER_EXCEPTION, ex_GNOME_C_Error, NULL);
return CORBA_OBJECT_NIL;
}
static void
impl_MateComponent_EventSource_removeListener (PortableServer_Servant servant,
const MateComponent_Listener listener,
CORBA_Environment *ev)
{
GSList *l, *next;
MateComponentEventSourcePrivate *priv;
priv = matecomponent_event_source_from_servant (servant)->priv;
for (l = priv->listeners; l; l = next) {
ListenerDesc *desc = l->data;
next = l->next;
if (CORBA_Object_is_equivalent (listener, desc->listener, ev)) {
priv->listeners = g_slist_remove_link (
priv->listeners, l);
g_slist_free_1 (l);
desc_free (desc, ev);
return;
}
}
CORBA_exception_set (ev, CORBA_USER_EXCEPTION,
ex_MateComponent_EventSource_UnknownListener,
NULL);
}
static MateComponent_Control
impl_MateComponent_PropertyControl_getControl (PortableServer_Servant servant,
CORBA_long pagenumber,
CORBA_Environment *ev)
{
MateComponentObject *matecomponent_object;
MateComponentPropertyControl *property_control;
MateComponentPropertyControlPrivate *priv;
MateComponentControl *control;
matecomponent_object = matecomponent_object_from_servant (servant);
property_control = MATECOMPONENT_PROPERTY_CONTROL (matecomponent_object);
priv = property_control->priv;
if (pagenumber < 0 || pagenumber >= priv->page_count) {
CORBA_exception_set (ev, CORBA_USER_EXCEPTION,
ex_MateComponent_PropertyControl_NoPage, NULL);
return CORBA_OBJECT_NIL;
}
control = priv->get_fn (property_control,
pagenumber,
priv->closure);
if (control == NULL)
return CORBA_OBJECT_NIL;
return (MateComponent_Control) CORBA_Object_duplicate
(MATECOMPONENT_OBJREF (control), ev);
}
/*
* This function implements the Bonobo::PersistStream:load method.
*/
static void
pstream_load (BonoboPersistStream *ps, const Bonobo_Stream stream,
Bonobo_Persist_ContentType type, void *data,
CORBA_Environment *ev)
{
GList *list;
char *vcard;
EABVCardControl *vcard_control = data;
if (type && g_ascii_strcasecmp (type, "text/vCard") != 0 &&
g_ascii_strcasecmp (type, "text/x-vCard") != 0) {
CORBA_exception_set (ev, CORBA_USER_EXCEPTION,
ex_Bonobo_Persist_WrongDataType, NULL);
return;
}
if ((vcard = stream_read (stream)) == NULL) {
CORBA_exception_set (ev, CORBA_USER_EXCEPTION,
ex_Bonobo_Persist_FileNotFound, NULL);
return;
}
g_list_foreach (
vcard_control->card_list,
(GFunc) g_object_unref, NULL);
g_list_free (vcard_control->card_list);
list = eab_contact_list_from_string (vcard);
g_free(vcard);
vcard_control->card_list = list;
if (list) {
eab_contact_display_render (vcard_control->display, E_CONTACT (list->data),
vcard_control->render_mode);
}
if (list && list->next) {
char *message;
int length = g_list_length (list) - 1;
message = g_strdup_printf (ngettext("There is one other contact.",
"There are %d other contacts.", length),
length);
gtk_label_set_text (GTK_LABEL (vcard_control->label), message);
g_free (message);
gtk_widget_show (vcard_control->label);
} else {
gtk_widget_hide (vcard_control->label);
}
} /* pstream_load */
void CORBA_exception_set_system(
CORBA_Environment *ev,
CORBA_unsigned_long minor,
CORBA_completion_status completed
)
{
const char * const exception_table[] = {
NULL,
"IDL:CORBA/UNKNOWN:1.0", /* 1 */
"IDL:CORBA/BAD_PARAM:1.0", /* 2 */
"IDL:CORBA/NO_MEMORY:1.0", /* 3 */
"IDL:CORBA/IMP_LIMIT:1.0", /* 4 */
"IDL:CORBA/COMM_FAILURE:1.0", /* 5 */
"IDL:CORBA/INV_OBJREF:1.0", /* 6 */
"IDL:CORBA/NO_PERMISSION:1.0", /* 7 */
"IDL:CORBA/INTERNAL:1.0", /* 8 */
"IDL:CORBA/MARSHAL:1.0", /* 9 */
"IDL:CORBA/INITIALIZE:1.0", /* 10 */
"IDL:CORBA/NO_IMPLEMENT:1.0", /* 11 */
"IDL:CORBA/BAD_TYPECODE:1.0", /* 12 */
"IDL:CORBA/BAD_OPERATION:1.0", /* 13 */
"IDL:CORBA/NO_RESOURCES:1.0", /* 14 */
"IDL:CORBA/NO_RESPONSE:1.0", /* 15 */
"IDL:CORBA/PERSIST_STORE:1.0", /* 16 */
"IDL:CORBA/BAD_INV_ORDER:1.0", /* 17 */
"IDL:CORBA/TRANSIENT:1.0", /* 18 */
"IDL:CORBA/FREE_MEM:1.0", /* 19 */
"IDL:CORBA/INV_IDENT:1.0", /* 20 */
"IDL:CORBA/INV_FLAG:1.0", /* 21 */
"IDL:CORBA/INTF_REPOS:1.0", /* 22 */
"IDL:CORBA/BAD_CONTEXT:1.0", /* 23 */
"IDL:CORBA/OBJ_ADAPTER:1.0", /* 24 */
"IDL:CORBA/DATA_CONVERSION:1.0", /* 25 */
"IDL:CORBA/OBJECT_NOT_EXIST:1.0", /* 26 */
"IDL:CORBA/TRANSACTION_REQUIRED:1.0", /* 27 */
"IDL:CORBA/TRANSACTION_ROLLEDBACK:1.0", /* 28 */
"IDL:CORBA/INVALID_TRANSACTION:1.0", /* 29 */
"IDL:CORBA/INV_POLICY:1.0", /* 30 */
"IDL:CORBA/CODESET_INCOMPATIBLE:1.0", /* 31 */
"IDL:CORBA/REBIND:1.0", /* 32 */
"IDL:CORBA/TIMEOUT:1.0", /* 33 */
"IDL:CORBA/TRANSACTION_UNAVAILABLE:1.0", /* 34 */
"IDL:CORBA/TRANSACTION_MODE:1.0", /* 35 */
"IDL:CORBA/BAD_QOS:1.0", /* 36 */
};
static CORBA_SystemException _CORBA_SystemException;
char * repo_id = NULL;
if (minor > 0 && minor <= 36) {
repo_id = (char *)exception_table[minor];
}
_CORBA_SystemException.minor = minor;
_CORBA_SystemException.completed = completed;
CORBA_exception_set(ev, CORBA_SYSTEM_EXCEPTION, repo_id,
&_CORBA_SystemException);
}
Bonobo_Unknown
bonobo_moniker_ior_resolve (BonoboMoniker *moniker,
const Bonobo_ResolveOptions *options,
const CORBA_char *requested_interface,
CORBA_Environment *ev)
{
const char *ior;
CORBA_Object object;
Bonobo_Unknown retval;
gboolean is_unknown, is_correct;
ior = bonobo_moniker_get_name (moniker);
object = CORBA_ORB_string_to_object (bonobo_orb (), ior, ev);
BONOBO_RET_VAL_EX (ev, CORBA_OBJECT_NIL);
is_unknown = CORBA_Object_is_a (object, "IDL:Bonobo/Unknown:1.0", ev);
BONOBO_RET_VAL_EX (ev, CORBA_OBJECT_NIL);
if (!is_unknown) {
is_correct = CORBA_Object_is_a (object, requested_interface, ev);
BONOBO_RET_VAL_EX (ev, CORBA_OBJECT_NIL);
if (is_correct)
return object;
else {
CORBA_exception_set (
ev, CORBA_USER_EXCEPTION,
ex_Bonobo_Moniker_InterfaceNotFound, NULL);
return CORBA_OBJECT_NIL;
}
}
retval = Bonobo_Unknown_queryInterface (
object, requested_interface, ev);
BONOBO_RET_VAL_EX (ev, CORBA_OBJECT_NIL);
if (retval == CORBA_OBJECT_NIL)
CORBA_exception_set (
ev, CORBA_USER_EXCEPTION,
ex_Bonobo_Moniker_InterfaceNotFound, NULL);
return retval;
}
static void
mem_set_info (PortableServer_Servant servant,
const Bonobo_StorageInfo *info,
const Bonobo_StorageInfoFields mask,
CORBA_Environment *ev)
{
BonoboStreamMem *smem = BONOBO_STREAM_MEM (
bonobo_object (servant));
if (smem->read_only) {
CORBA_exception_set (
ev, CORBA_USER_EXCEPTION,
ex_Bonobo_Stream_NoPermission, NULL);
return;
}
if (mask & Bonobo_FIELD_SIZE) {
CORBA_exception_set (
ev, CORBA_USER_EXCEPTION,
ex_Bonobo_Stream_NotSupported, NULL);
return;
}
if ((mask & Bonobo_FIELD_TYPE) &&
(info->type != Bonobo_STORAGE_TYPE_REGULAR)) {
CORBA_exception_set (
ev, CORBA_USER_EXCEPTION,
ex_Bonobo_Stream_NotSupported, NULL);
return;
}
if (mask & Bonobo_FIELD_CONTENT_TYPE) {
bonobo_return_if_fail (info->content_type != NULL, ev);
g_free (smem->content_type);
smem->content_type = g_strdup (info->content_type);
}
if (strcmp (info->name, smem->name)) {
bonobo_return_if_fail (info->name != NULL, ev);
g_free (smem->name);
smem->name = g_strdup (info->name);
}
}
static void
impl_requestCreateItem (PortableServer_Servant servant,
const CORBA_char *item_type_name,
CORBA_Environment *ev)
{
MailComponent *mc = MAIL_COMPONENT(bonobo_object_from_servant(servant));
if (create_item(item_type_name, mc->priv->model, NULL, NULL) == -1) {
CORBA_exception_set (ev, CORBA_USER_EXCEPTION,
ex_GNOME_Evolution_Component_UnknownType, NULL);
}
}
MateComponent_Unknown
matecomponent_moniker_oaf_resolve (MateComponentMoniker *moniker,
const MateComponent_ResolveOptions *options,
const CORBA_char *requested_interface,
CORBA_Environment *ev)
{
MateComponent_Moniker parent;
MateComponent_Unknown object;
parent = matecomponent_moniker_get_parent (moniker, ev);
if (ev->_major != CORBA_NO_EXCEPTION)
return CORBA_OBJECT_NIL;
if (parent != CORBA_OBJECT_NIL) {
matecomponent_object_release_unref (parent, ev);
#ifdef G_ENABLE_DEBUG
g_warning ("wierd; oafid moniker with a parent; strange");
#endif
CORBA_exception_set (ev, CORBA_USER_EXCEPTION,
ex_MateComponent_Moniker_InterfaceNotFound, NULL);
return CORBA_OBJECT_NIL;
}
object = matecomponent_activation_activate_from_id (
(char *) matecomponent_moniker_get_name_full (moniker), 0, NULL, ev);
if (MATECOMPONENT_EX (ev)) {
if (ev->_major == CORBA_USER_EXCEPTION) {
if (strcmp (ev->_id, ex_MateComponent_GeneralError)) {
CORBA_exception_free (ev);
matecomponent_exception_general_error_set (
ev, NULL, _("Exception activating '%s'"),
matecomponent_moniker_get_name_full (moniker));
}
}
return CORBA_OBJECT_NIL;
} else if (object == CORBA_OBJECT_NIL) {
matecomponent_exception_general_error_set (
ev, NULL, _("Failed to activate '%s'"),
matecomponent_moniker_get_name_full (moniker));
return CORBA_OBJECT_NIL;
}
return matecomponent_moniker_util_qi_return (object, requested_interface, ev);
}
void
CORBA_exception_set_system (CORBA_Environment *ev,
const CORBA_char *except_repos_id,
CORBA_completion_status completed)
{
CORBA_SystemException *se;
g_return_if_fail (ev != NULL);
se = CORBA_SystemException__alloc ();
/* I have never seen a case where 'minor' is actually necessary */
se->minor = 0 /* minor */;
se->completed = completed;
CORBA_exception_set (
ev, CORBA_SYSTEM_EXCEPTION, except_repos_id, se);
}
CORBA_Object
impl_GNOME_FileManagerFactory_create_object(impl_POA_GNOME_FileManagerFactory * servant,
CORBA_char * goad_id,
GNOME_stringlist * params,
CORBA_Environment * ev)
{
if(!strcmp(goad_id, "gmc_filemanager_window"))
return impl_GNOME_FileManagerFactory_create_window(
servant,
params->_length ? params->_buffer [0] : home_dir, ev);
CORBA_exception_set (ev, CORBA_USER_EXCEPTION,
ex_GNOME_GenericFactory_CannotActivate,
NULL);
return CORBA_OBJECT_NIL;
}
Bonobo_Unknown
bonobo_moniker_new_resolve (BonoboMoniker *moniker,
const Bonobo_ResolveOptions *options,
const CORBA_char *requested_interface,
CORBA_Environment *ev)
{
Bonobo_Moniker parent;
Bonobo_GenericFactory factory;
Bonobo_Unknown containee;
Bonobo_Unknown retval = CORBA_OBJECT_NIL;
parent = bonobo_moniker_get_parent (moniker, ev);
if (ev->_major != CORBA_NO_EXCEPTION)
return CORBA_OBJECT_NIL;
g_assert (parent != CORBA_OBJECT_NIL);
factory = Bonobo_Moniker_resolve (parent, options,
"IDL:Bonobo/GenericFactory:1.0", ev);
if (ev->_major != CORBA_NO_EXCEPTION)
goto return_unref_parent;
if (factory == CORBA_OBJECT_NIL) {
#ifdef G_ENABLE_DEBUG
g_warning ("Failed to extract a factory from our parent");
#endif
CORBA_exception_set (ev, CORBA_USER_EXCEPTION,
ex_Bonobo_Moniker_InterfaceNotFound, NULL);
goto return_unref_parent;
}
containee = Bonobo_GenericFactory_createObject (
factory, requested_interface, ev);
bonobo_object_release_unref (factory, ev);
return bonobo_moniker_util_qi_return (containee, requested_interface, ev);
return_unref_parent:
bonobo_object_release_unref (parent, ev);
return retval;
}
static void
BasicServer_opException (PortableServer_Servant servant,
CORBA_Environment *ev)
{
test_TestException *ex = test_TestException__alloc ();
ex->reason = CORBA_string_dup (constants_STRING_IN);
ex->number = constants_LONG_IN;
ex->aseq._buffer = CORBA_sequence_CORBA_long_allocbuf (1);
ex->aseq._length = 1;
ex->aseq._buffer [0] = constants_LONG_IN;
ex->factory = getFactoryInstance(ev);
CORBA_sequence_set_release (&ex->aseq, CORBA_TRUE);
CORBA_exception_set (
ev, CORBA_USER_EXCEPTION, ex_test_TestException,ex);
}
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);
}
/*
* This function implements the Bonobo::PersistStream:save method.
*/
static void
pstream_save (BonoboPersistStream *ps, const Bonobo_Stream stream,
Bonobo_Persist_ContentType type, void *data,
CORBA_Environment *ev)
{
EABVCardControl *vcard_control = data;
char *vcard;
int length;
if (type && g_ascii_strcasecmp (type, "text/vCard") != 0 &&
g_ascii_strcasecmp (type, "text/x-vCard") != 0) {
CORBA_exception_set (ev, CORBA_USER_EXCEPTION,
ex_Bonobo_Persist_WrongDataType, NULL);
return;
}
vcard = eab_contact_list_to_string (vcard_control->card_list);
length = strlen (vcard);
bonobo_stream_client_write (stream, vcard, length, ev);
g_free (vcard);
} /* pstream_save */
/* ARGSUSED */
CORBA_long
Calc_Div(
Calc _o,
CORBA_long val1, // in (fixed length)
CORBA_long val2, // in (fixed length)
CORBA_Environment * _ev
)
{
/* START_EDIT (Calc_Div) */
static Calc_DivisionByZero _Calc_DivisionByZero;
if (0 == val2)
{
CORBA_exception_set(_ev, CORBA_USER_EXCEPTION, ex_Calc_DivisionByZero, &_Calc_DivisionByZero);
return 0;
}
else
{
return val1 / val2;
}
/* STOP_EDIT (Calc_Div) */
}
static void
impl_MateComponent_PropertyControl_notifyAction (PortableServer_Servant servant,
CORBA_long pagenumber,
MateComponent_PropertyControl_Action action,
CORBA_Environment *ev)
{
MateComponentObject *matecomponent_object;
MateComponentPropertyControl *property_control;
MateComponentPropertyControlPrivate *priv;
matecomponent_object = matecomponent_object_from_servant (servant);
property_control = MATECOMPONENT_PROPERTY_CONTROL (matecomponent_object);
priv = property_control->priv;
if (pagenumber < 0 || pagenumber >= priv->page_count) {
CORBA_exception_set (ev, CORBA_USER_EXCEPTION,
ex_MateComponent_PropertyControl_NoPage, NULL);
return;
}
g_signal_emit (matecomponent_object, signals [ACTION], 0, pagenumber, action);
}
void
PortableServer_POAManager_deactivate (PortableServer_POAManager manager,
const CORBA_boolean etherealize_objects,
const CORBA_boolean wait_for_completion,
CORBA_Environment *ev)
{
GSList *l;
if (!manager) {
CORBA_exception_set_system (ev, ex_CORBA_BAD_PARAM,
CORBA_COMPLETED_NO);
return;
}
POA_MGR_LOCK (poa_mgr);
if (manager->state == PortableServer_POAManager_INACTIVE)
CORBA_exception_set
(ev, CORBA_USER_EXCEPTION,
ex_PortableServer_POAManager_AdapterInactive,
NULL);
else {
if (wait_for_completion)
for (l = manager->poa_collection; l; l = l->next)
if (!ORBit_POA_is_inuse (l->data, FALSE, ev)) {
CORBA_exception_set_system
(ev, ex_CORBA_BAD_INV_ORDER,
CORBA_COMPLETED_NO);
POA_MGR_UNLOCK (poa_mgr);
return;
}
manager->state = PortableServer_POAManager_INACTIVE;
for (l = manager->poa_collection; l; l = l->next)
ORBit_POA_deactivate (l->data, etherealize_objects, ev);
}
POA_MGR_UNLOCK (poa_mgr);
}
IDL4_INLINE void ILanAddress_generate_lan_address_implementation(
CORBA_Object _caller,
lanaddress_t *lanaddress,
idl4_server_environment *_env)
{
if( !lanaddress_valid )
{
CORBA_exception_set( _env, ex_ILanAddress_insufficient_resources, NULL);
return;
}
// Create a new address, combined from the base, and the handle.
lanaddress_set_handle( &lanaddress_base, lanaddress_handle );
lanaddress->align4.lsb = lanaddress_base.align4.lsb;
lanaddress->align4.msb = lanaddress_base.align4.msb;
// Move to the next handle.
lanaddress_handle++;
if( lanaddress_handle == 0 )
{
// wrap around
lanaddress_valid = 0;
}
}
static Examples_BadCall_Foo
impl_Examples_BadCall_trigger(impl_POA_Examples_BadCall * servant,
const CORBA_long val,
Examples_BadCall_Foo * bar,
CORBA_Environment * ev)
{
Examples_BadCall_Foo ret_val = {0.0};
/* ------ insert method code here ------ */
switch ((servant->counter++) % 2)
{
case 0:
{
/* this piece of code demonstrates how to raise exception
* without any further parameter */
Examples_BadCall_Foo dummy_foo = {0.0};
/* after user has assinged exception attributes, user may
* not touch the data anymore, ownership is handed over to
* CORBA environment */
CORBA_exception_set (ev,
CORBA_USER_EXCEPTION,
ex_Examples_BadCall_NoParam,
NULL); /* exception has no members */
/* on exception you need not to care about out-argument
* @bar, but due to programming language C it is necessary
* to return valid value */
return dummy_foo;
break;
}
case 1:
{
/* this piece of code demonstrates how to raise exception
* that has a string as parameter */
Examples_BadCall_Foo dummy_foo = {0.0};
Examples_BadCall_SingleParam* ex_parameters
= Examples_BadCall_SingleParam__alloc();
ex_parameters->mesg
= CORBA_string_dup ("raised in \"" __FILE__ "\"");
/* after user has assinged exception attributes, user may
* not touch the data anymore, ownership is handed over to
* CORBA environment */
CORBA_exception_set (ev,
CORBA_USER_EXCEPTION,
ex_Examples_BadCall_SingleParam,
ex_parameters); /* exception has members */
/* on exception you need not to care about out-argument
* @bar, but due to programming language C it is necessary
* to return valid value */
return dummy_foo;
break;
}
/* this code will never raise exception DoubleParam */
default:
g_assert_not_reached ();
}
/* ------ ---------- end ------------ ------ */
return ret_val;
}
/**
* matecomponent_activation_activate_shlib_server:
* @sh:
* @ev:
*
* Private function.
*
* Return value:
*/
CORBA_Object
matecomponent_activation_activate_shlib_server (MateComponent_ActivationResult *sh,
CORBA_Environment *ev)
{
CORBA_Object retval;
const MateComponentActivationPlugin *plugin;
ActivePluginInfo *local_plugin_info = NULL;
const MateComponentActivationPluginObject *pobj;
int i;
PortableServer_POA poa;
CORBA_ORB orb;
char *filename;
const char *iid;
g_return_val_if_fail (sh->res._d == MateComponent_ACTIVATION_RESULT_SHLIB,
CORBA_OBJECT_NIL);
g_return_val_if_fail (sh->res._u.res_shlib._length > 0,
CORBA_OBJECT_NIL);
MATECOMPONENT_ACTIVATION_LOCK ();
/* The location info is at the end to of the string list */
filename = sh->res._u.res_shlib._buffer[sh->res._u.res_shlib._length - 1];
if (living_by_filename)
local_plugin_info =
g_hash_table_lookup (living_by_filename, filename);
if (!local_plugin_info) {
/* We have to load the thing from scratch */
GModule *gmod;
gboolean success;
gmod = g_module_open (filename, G_MODULE_BIND_LAZY);
if (!gmod) {
char *error_string;
MateComponent_GeneralError *error = MateComponent_GeneralError__alloc ();
error_string = g_strdup_printf (
_("g_module_open of `%s' failed with `%s'"),
filename, g_module_error ());
error->description = CORBA_string_dup (error_string);
CORBA_exception_set (ev, CORBA_USER_EXCEPTION,
ex_MateComponent_GeneralError, error);
g_free (error_string);
MATECOMPONENT_ACTIVATION_UNLOCK ();
return CORBA_OBJECT_NIL; /* Couldn't load it */
}
success = g_module_symbol (gmod, "MateComponent_Plugin_info",
(gpointer *) &plugin);
if (!success) {
char *error_string;
MateComponent_GeneralError *error = MateComponent_GeneralError__alloc ();
g_module_close (gmod);
error_string = g_strdup_printf (
_("Can't find symbol MateComponent_Plugin_info in `%s'"),
filename);
error->description = CORBA_string_dup (error_string);
CORBA_exception_set (ev, CORBA_USER_EXCEPTION,
ex_MateComponent_GeneralError, error);
g_free (error_string);
MATECOMPONENT_ACTIVATION_UNLOCK ();
return CORBA_OBJECT_NIL;
}
local_plugin_info =
g_malloc (sizeof (ActivePluginInfo) +
strlen (filename) + 1);
local_plugin_info->refcount = 0;
local_plugin_info->loaded = gmod;
strcpy (local_plugin_info->filename, filename);
if (!living_by_filename)
living_by_filename =
g_hash_table_new (g_str_hash, g_str_equal);
g_hash_table_insert (living_by_filename,
local_plugin_info->filename,
local_plugin_info);
} else {
int success;
success =
g_module_symbol (local_plugin_info->loaded,
"MateComponent_Plugin_info",
(gpointer *) & plugin);
if (!success) {
char *error_string;
MateComponent_GeneralError *error = MateComponent_GeneralError__alloc ();
error_string = g_strdup_printf (
_("Can't find symbol MateComponent_Plugin_info in `%s'"),
filename);
error->description = CORBA_string_dup (error_string);
CORBA_exception_set (ev, CORBA_USER_EXCEPTION,
ex_MateComponent_GeneralError, error);
g_free (error_string);
MATECOMPONENT_ACTIVATION_UNLOCK ();
return CORBA_OBJECT_NIL;
}
}
retval = CORBA_OBJECT_NIL;
orb = matecomponent_activation_orb_get ();
poa = (PortableServer_POA)
CORBA_ORB_resolve_initial_references (orb, "RootPOA", ev);
/* Index into the string list one element from the end to get the iid of the shlib */
iid = sh->res._u.res_shlib._buffer[sh->res._u.res_shlib._length - 2];
for (pobj = plugin->plugin_object_list; pobj->iid; pobj++) {
if (strcmp (iid, pobj->iid) == 0) {
/* Found a match */
break;
}
}
if (pobj->iid) {
/* Activate the shlib */
retval = pobj->activate (poa, pobj->iid, local_plugin_info, ev);
if (ev->_major != CORBA_NO_EXCEPTION)
retval = CORBA_OBJECT_NIL;
/* Activate the factiories contained in the shlib */
i = sh->res._u.res_shlib._length - 2;
for (i--; i >= 0 && !CORBA_Object_is_nil (retval, ev); i--) {
CORBA_Object new_retval;
iid = sh->res._u.res_shlib._buffer[i];
new_retval =
MateComponent_GenericFactory_createObject (
retval, (char *) iid, ev);
if (ev->_major != CORBA_NO_EXCEPTION
|| CORBA_Object_is_nil (new_retval, ev)) {
if (ev->_major == CORBA_NO_EXCEPTION) {
MateComponent_GeneralError *error = MateComponent_GeneralError__alloc ();
char *error_string = g_strdup_printf (
_("Factory `%s' returned NIL for `%s'"),
pobj->iid, iid);
error->description = CORBA_string_dup (error_string);
CORBA_exception_set (ev, CORBA_USER_EXCEPTION,
ex_MateComponent_GeneralError, error);
g_free (error_string);
}
new_retval = CORBA_OBJECT_NIL;
}
CORBA_Object_release (retval, ev);
retval = new_retval;
}
} else {
MateComponent_GeneralError *error = MateComponent_GeneralError__alloc ();
char *error_string = g_strdup_printf (
_("Shlib `%s' didn't contain `%s'"),
filename, iid);
error->description = CORBA_string_dup (error_string);
CORBA_exception_set (ev, CORBA_USER_EXCEPTION,
ex_MateComponent_GeneralError, error);
g_free (error_string);
}
CORBA_Object_release ((CORBA_Object) poa, ev);
MATECOMPONENT_ACTIVATION_UNLOCK ();
return retval;
}
static GNOME_Evolution_Addressbook_Book
impl_GNOME_Evolution_Addressbook_BookFactory_getBook (PortableServer_Servant servant,
const CORBA_char *source_xml,
const GNOME_Evolution_Addressbook_BookListener listener,
CORBA_Environment *ev)
{
EDataBookFactory *factory = E_DATA_BOOK_FACTORY (bonobo_object (servant));
GNOME_Evolution_Addressbook_Book corba_book;
EBookBackend *backend;
EDataBook *book = NULL;
ESource *source;
gchar *uri;
printf ("impl_GNOME_Evolution_Addressbook_BookFactory_getBook\n");
source = e_source_new_from_standalone_xml (source_xml);
if (!source) {
CORBA_exception_set (ev, CORBA_USER_EXCEPTION,
ex_GNOME_Evolution_Addressbook_BookFactory_ProtocolNotSupported,
NULL);
return CORBA_OBJECT_NIL;
}
uri = e_source_get_uri (source);
if (!uri) {
g_object_unref (source);
CORBA_exception_set (ev, CORBA_USER_EXCEPTION,
ex_GNOME_Evolution_Addressbook_BookFactory_ProtocolNotSupported,
NULL);
return CORBA_OBJECT_NIL;
}
printf (" + %s\n", uri);
/* Look up the backend and create one if needed */
g_mutex_lock (factory->priv->map_mutex);
backend = g_hash_table_lookup (factory->priv->active_server_map, uri);
if (!backend) {
EBookBackendFactory* backend_factory;
backend_factory = e_data_book_factory_lookup_backend_factory (factory, uri);
if (backend_factory == NULL) {
CORBA_exception_set (ev, CORBA_USER_EXCEPTION,
ex_GNOME_Evolution_Addressbook_BookFactory_ProtocolNotSupported,
NULL);
g_mutex_unlock (factory->priv->map_mutex);
g_free (uri);
return CORBA_OBJECT_NIL;
}
backend = e_data_book_factory_launch_backend (factory, backend_factory, listener, uri);
}
g_free (uri);
if (backend) {
g_mutex_unlock (factory->priv->map_mutex);
book = e_data_book_new (backend, source, listener);
e_book_backend_add_client (backend, book);
e_book_backend_set_mode (backend, factory->priv->mode);
corba_book = bonobo_object_corba_objref (BONOBO_OBJECT (book));
}
else {
/* probably need a more descriptive exception here */
CORBA_exception_set (ev, CORBA_USER_EXCEPTION,
ex_GNOME_Evolution_Addressbook_BookFactory_ProtocolNotSupported,
NULL);
g_mutex_unlock (factory->priv->map_mutex);
corba_book = CORBA_OBJECT_NIL;
}
g_object_unref (source);
if (book)
printf (" => %p\n", book);
return corba_book;
}
Bonobo_Unknown
bonobo_stream_extender_resolve (BonoboMonikerExtender *extender,
const Bonobo_Moniker m,
const Bonobo_ResolveOptions *options,
const CORBA_char *display_name,
const CORBA_char *requested_interface,
CORBA_Environment *ev)
{
char *mime_type;
char *requirements;
Bonobo_Unknown object;
Bonobo_Unknown stream;
Bonobo_Persist persist;
#ifdef G_ENABLE_DEBUG
g_message ("Stream extender: '%s'", display_name);
#endif
if (!m)
return CORBA_OBJECT_NIL;
stream = Bonobo_Moniker_resolve (m, options, "IDL:Bonobo/Stream:1.0", ev);
if (!stream)
return CORBA_OBJECT_NIL;
mime_type = get_stream_type (stream, ev);
if (!mime_type)
goto unref_stream_exception;
requirements = g_strdup_printf (
"bonobo:supported_mime_types.has ('%s') AND repo_ids.has ('%s') AND "
"repo_ids.has ('IDL:Bonobo/PersistStream:1.0')",
mime_type, requested_interface);
object = bonobo_activation_activate (requirements, NULL, 0, NULL, ev);
#ifdef G_ENABLE_DEBUG
g_message ("Attempt activate object satisfying '%s': %p",
requirements, object);
#endif
g_free (requirements);
if (ev->_major != CORBA_NO_EXCEPTION)
goto unref_stream_exception;
if (object == CORBA_OBJECT_NIL) {
#ifdef G_ENABLE_DEBUG
g_warning ("Can't find object satisfying requirements");
#endif
CORBA_exception_set (ev, CORBA_USER_EXCEPTION,
ex_Bonobo_Moniker_InterfaceNotFound, NULL);
goto unref_stream_exception;
}
persist = Bonobo_Unknown_queryInterface (
object, "IDL:Bonobo/PersistStream:1.0", ev);
if (ev->_major != CORBA_NO_EXCEPTION)
goto unref_object_exception;
if (persist != CORBA_OBJECT_NIL) {
Bonobo_PersistStream_load (
persist, stream, (const Bonobo_Persist_ContentType) mime_type, ev);
bonobo_object_release_unref (persist, ev);
bonobo_object_release_unref (stream, ev);
return bonobo_moniker_util_qi_return (
object, requested_interface, ev);
}
g_free (mime_type);
unref_object_exception:
bonobo_object_release_unref (object, ev);
unref_stream_exception:
bonobo_object_release_unref (stream, ev);
return CORBA_OBJECT_NIL;
}
int
main (int argc, char *argv [])
{
BonoboObject *object;
Bonobo_Unknown ref;
CORBA_Environment *ev, real_ev;
g_thread_init (NULL);
free (malloc (8));
if (bonobo_init (&argc, argv) == FALSE)
g_error ("Can not bonobo_init");
bonobo_activate ();
ev = &real_ev;
CORBA_exception_init (ev);
fprintf (stderr, "Local lifecycle\n");
{
object = BONOBO_OBJECT (g_object_new (
bonobo_moniker_get_type (), NULL));
g_assert (bonobo_object_ref (object) == object);
g_assert (bonobo_object_unref (BONOBO_OBJECT (object)) == NULL);
bonobo_object_unref (BONOBO_OBJECT (object));
}
fprintf (stderr, "In-proc lifecycle\n");
{
object = BONOBO_OBJECT (g_object_new (
bonobo_moniker_get_type (), NULL));
ref = CORBA_Object_duplicate (BONOBO_OBJREF (object), NULL);
bonobo_object_release_unref (ref, NULL);
}
fprintf (stderr, "Query interface\n");
{
BonoboObject *a, *b;
a = BONOBO_OBJECT (g_object_new (
bonobo_moniker_get_type (), NULL));
b = BONOBO_OBJECT (g_object_new (
bonobo_stream_mem_get_type (), NULL));
bonobo_object_add_interface (a, b);
fprintf (stderr, " invalid interface\n");
object = bonobo_object_query_local_interface (
a, "IDL:This/Is/Not/There:1.0");
g_assert (object == CORBA_OBJECT_NIL);
fprintf (stderr, " symmetry\n");
object = bonobo_object_query_local_interface (
a, "IDL:Bonobo/Stream:1.0");
g_assert (object == b);
bonobo_object_unref (object);
object = bonobo_object_query_local_interface (
b, "IDL:Bonobo/Stream:1.0");
g_assert (object == b);
bonobo_object_unref (object);
object = bonobo_object_query_local_interface (
a, "IDL:Bonobo/Moniker:1.0");
g_assert (object == a);
bonobo_object_unref (object);
object = bonobo_object_query_local_interface (
b, "IDL:Bonobo/Moniker:1.0");
g_assert (object == a);
bonobo_object_unref (object);
fprintf (stderr, " remote\n");
ref = Bonobo_Unknown_queryInterface (
BONOBO_OBJREF (a), "IDL:Broken/1.0", ev);
g_assert (!BONOBO_EX (ev));
g_assert (ref == CORBA_OBJECT_NIL);
ref = Bonobo_Unknown_queryInterface (
BONOBO_OBJREF (a), "IDL:Bonobo/Stream:1.0", ev);
g_assert (!BONOBO_EX (ev));
g_assert (ref == BONOBO_OBJREF (b));
bonobo_object_release_unref (ref, ev);
g_assert (!BONOBO_EX (ev));
bonobo_object_unref (a);
}
fprintf (stderr, "Environment exception checks\n");
{
object = BONOBO_OBJECT (g_object_new (
bonobo_moniker_get_type (), NULL));
g_signal_connect (G_OBJECT (object),
"system_exception",
G_CALLBACK (system_exception_cb),
object);
CORBA_exception_set_system (
ev, ex_CORBA_COMM_FAILURE,
CORBA_COMPLETED_MAYBE);
g_assert (BONOBO_EX (ev));
signal_emitted = 0;
BONOBO_OBJECT_CHECK (
object, BONOBO_OBJREF (object), ev);
g_assert (signal_emitted);
CORBA_exception_free (ev);
bonobo_object_unref (object);
}
fprintf (stderr, "Servant mapping...\n");
{
PortableServer_Servant servant;
object = BONOBO_OBJECT (g_object_new (
bonobo_moniker_get_type (), NULL));
servant = (PortableServer_Servant) &object->servant;
g_assert (bonobo_object (object) == object);
g_assert (bonobo_object (&object->servant) == object);
g_assert (bonobo_object_get_servant (object) == servant);
g_assert (bonobo_object_from_servant (servant) == object);
g_assert (bonobo_object_fast (object) == object);
g_assert (bonobo_object_fast (servant) == object);
bonobo_object_unref (object);
}
fprintf (stderr, "Ret-ex tests...\n");
{
g_assert (!ret_ex_test (ev));
ex_test (ev);
CORBA_exception_set (ev, CORBA_USER_EXCEPTION,
ex_Bonobo_PropertyBag_NotFound, NULL);
g_assert (ret_ex_test (ev));
CORBA_exception_free (ev);
}
fprintf (stderr, "General error tests...\n");
{
bonobo_exception_general_error_set (
ev, NULL, "a%s exception occurred", "n exceptional");
g_assert (BONOBO_EX (ev));
g_assert (!strcmp (BONOBO_EX_REPOID (ev), ex_Bonobo_GeneralError));
g_assert (!strcmp (bonobo_exception_get_text (ev),
"an exceptional exception occurred"));
}
fprintf (stderr, "All tests passed\n");
return bonobo_debug_shutdown ();
}
