bonobo-arg

Name

bonobo-arg -- simplified CORBA_Any wrappers

Synopsis



typedef     BonoboArg;
typedef     BonoboArgType;
#define     BONOBO_ARG_NULL
#define     BONOBO_ARG_BOOLEAN
#define     BONOBO_ARG_SHORT
#define     BONOBO_ARG_INT
#define     BONOBO_ARG_LONG
#define     BONOBO_ARG_LONGLONG
#define     BONOBO_ARG_FLOAT
#define     BONOBO_ARG_DOUBLE
#define     BONOBO_ARG_CHAR
#define     BONOBO_ARG_STRING
#define     BONOBO_ARG_GET_GENERAL          (a,c,t,e)
#define     BONOBO_ARG_SET_GENERAL          (a,v,c,t,e)
#define     BONOBO_ARG_GET_BOOLEAN          (a)
#define     BONOBO_ARG_SET_BOOLEAN          (a,v)
#define     BONOBO_ARG_GET_SHORT            (a)
#define     BONOBO_ARG_SET_SHORT            (a,v)
#define     BONOBO_ARG_GET_INT              (a)
#define     BONOBO_ARG_SET_INT              (a,v)
#define     BONOBO_ARG_GET_LONG             (a)
#define     BONOBO_ARG_SET_LONG             (a,v)
#define     BONOBO_ARG_GET_LONGLONG         (a)
#define     BONOBO_ARG_SET_LONGLONG         (a,v)
#define     BONOBO_ARG_GET_FLOAT            (a)
#define     BONOBO_ARG_SET_FLOAT            (a,v)
#define     BONOBO_ARG_GET_DOUBLE           (a)
#define     BONOBO_ARG_SET_DOUBLE           (a,v)
#define     BONOBO_ARG_GET_CHAR             (a)
#define     BONOBO_ARG_SET_CHAR             (a,v)
#define     BONOBO_ARG_GET_STRING           (a)
#define     BONOBO_ARG_SET_STRING           (a,v)
BonoboArg*  bonobo_arg_new                  (BonoboArgType t);
BonoboArg*  bonobo_arg_new_from             (BonoboArgType t,
                                             gconstpointer data);
void        bonobo_arg_release              (BonoboArg *arg);
BonoboArg*  bonobo_arg_copy                 (const BonoboArg *arg);
void        bonobo_arg_from_gvalue          (BonoboArg *a,
                                             const GValue *value);
BonoboArgType bonobo_arg_type_from_gtype    (GType t);
void        bonobo_arg_to_gvalue            (GValue *value,
                                             const BonoboArg *arg);
GType       bonobo_arg_type_to_gtype        (BonoboArgType id);
gboolean    bonobo_arg_is_equal             (const BonoboArg *a,
                                             const BonoboArg *b,
                                             CORBA_Environment *opt_ev);
gboolean    bonobo_arg_type_is_equal        (BonoboArgType a,
                                             BonoboArgType b,
                                             CORBA_Environment *opt_ev);

Description

The BonoboArg code, and macros are designed to make the use of CORBA_Any's slightly simpler by providing a glib like binding for them. The bonobo-arg code also provides mappings between Gtk Args and CORBA_anys.

A typical use of the BonoboArg macros would be in

Example 1. Property bag implementation

static void
get_prop (BonoboPropertyBag *bag,
	  BonoboArg         *arg,
	  guint              arg_id,
	  CORBA_Environment *ev,
	  gpointer           user_data)
{
	GtkObject *clock = user_data;

	switch (arg_id) {

	case PROP_RUNNING: {
		BONOBO_ARG_SET_BOOLEAN (arg, is_it_running);
		break;
	}

	default:
		bonobo_exception_set (ev, ex_Bonobo_PropertyBag_NotFound);
		break;
	}
}
     

Details

BonoboArg

typedef CORBA_any      BonoboArg;

A glib style looking type alias for a CORBA_any


BonoboArgType

typedef CORBA_TypeCode BonoboArgType;

A glib style looking typedef for a CORBA type description.


BONOBO_ARG_NULL

#define BONOBO_ARG_NULL     TC_null

the null type


BONOBO_ARG_BOOLEAN

#define BONOBO_ARG_BOOLEAN  TC_CORBA_boolean

the boolean type


BONOBO_ARG_SHORT

#define BONOBO_ARG_SHORT    TC_CORBA_short


BONOBO_ARG_INT

#define BONOBO_ARG_INT      TC_CORBA_long

the integer type [ in fact a long ]


BONOBO_ARG_LONG

#define BONOBO_ARG_LONG     TC_CORBA_long

the long type


BONOBO_ARG_LONGLONG

#define BONOBO_ARG_LONGLONG TC_CORBA_long_long


BONOBO_ARG_FLOAT

#define BONOBO_ARG_FLOAT    TC_CORBA_float

the float type


BONOBO_ARG_DOUBLE

#define BONOBO_ARG_DOUBLE   TC_CORBA_double

the double type


BONOBO_ARG_CHAR

#define BONOBO_ARG_CHAR     TC_CORBA_char


BONOBO_ARG_STRING

#define BONOBO_ARG_STRING   TC_CORBA_string

the string type


BONOBO_ARG_GET_GENERAL()

#define     BONOBO_ARG_GET_GENERAL(a,c,t,e)

A macro to extract a value from a BonoboArg with the given CORBA type t.


BONOBO_ARG_SET_GENERAL()

#define     BONOBO_ARG_SET_GENERAL(a,v,c,t,e)

A macro to insert a value into an empty BonoboArg with the given CORBA type t.


BONOBO_ARG_GET_BOOLEAN()

#define BONOBO_ARG_GET_BOOLEAN(a)   (BONOBO_ARG_GET_GENERAL (a, TC_CORBA_boolean, CORBA_boolean, NULL))

this macro returns a CORBA_boolean from inside a BonoboArg, if the BonoboArg's type does not match, the behavior is undefined, and may cause faults.


BONOBO_ARG_SET_BOOLEAN()

#define BONOBO_ARG_SET_BOOLEAN(a,v) (BONOBO_ARG_SET_GENERAL (a, v, TC_CORBA_boolean, CORBA_boolean, NULL))

This macro sets the value of a to contain v


BONOBO_ARG_GET_SHORT()

#define BONOBO_ARG_GET_SHORT(a)     (BONOBO_ARG_GET_GENERAL (a, TC_CORBA_short, CORBA_short, NULL))


BONOBO_ARG_SET_SHORT()

#define BONOBO_ARG_SET_SHORT(a,v)   (BONOBO_ARG_SET_GENERAL (a, v, TC_CORBA_short, CORBA_short, NULL))


BONOBO_ARG_GET_INT()

#define BONOBO_ARG_GET_INT(a)       (BONOBO_ARG_GET_GENERAL (a, TC_CORBA_long, CORBA_long, NULL))

this macro returns a CORBA_long from inside a BonoboArg, if the BonoboArg's type does not match, the behavior is undefined, and may cause faults.


BONOBO_ARG_SET_INT()

#define BONOBO_ARG_SET_INT(a,v)     (BONOBO_ARG_SET_GENERAL (a, v, TC_CORBA_long, CORBA_long, NULL))

This macro sets the value of a to contain v


BONOBO_ARG_GET_LONG()

#define BONOBO_ARG_GET_LONG(a)      (BONOBO_ARG_GET_GENERAL (a, TC_CORBA_long, CORBA_long, NULL))

this macro returns a CORBA_long from from inside a BonoboArg, if the BonoboArg's type does not match, the behavior is undefined, and may cause faults.


BONOBO_ARG_SET_LONG()

#define BONOBO_ARG_SET_LONG(a,v)    (BONOBO_ARG_SET_GENERAL (a, v, TC_CORBA_long, CORBA_long, NULL))

This macro sets the value of a to contain v


BONOBO_ARG_GET_LONGLONG()

#define BONOBO_ARG_GET_LONGLONG(a)  (BONOBO_ARG_GET_GENERAL (a, TC_CORBA_long_long, CORBA_long_long, NULL))


BONOBO_ARG_SET_LONGLONG()

#define BONOBO_ARG_SET_LONGLONG(a,v) (BONOBO_ARG_SET_GENERAL (a, v, TC_CORBA_long_long, CORBA_long_long, NULL))


BONOBO_ARG_GET_FLOAT()

#define BONOBO_ARG_GET_FLOAT(a)     (BONOBO_ARG_GET_GENERAL (a, TC_CORBA_float, CORBA_float, NULL))

this macro returns a CORBA_float from inside a BonoboArg, if the BonoboArg's type does not match, the behavior is undefined, and may cause faults.


BONOBO_ARG_SET_FLOAT()

#define BONOBO_ARG_SET_FLOAT(a,v)   (BONOBO_ARG_SET_GENERAL (a, v, TC_CORBA_float, CORBA_float, NULL))

This macro sets the value of a to contain v


BONOBO_ARG_GET_DOUBLE()

#define BONOBO_ARG_GET_DOUBLE(a)    (BONOBO_ARG_GET_GENERAL (a, TC_CORBA_double, CORBA_double, NULL))

this macro returns a CORBA_double from inside a BonoboArg, if the BonoboArg's type does not match, the behavior is undefined, and may cause faults.


BONOBO_ARG_SET_DOUBLE()

#define BONOBO_ARG_SET_DOUBLE(a,v)  (BONOBO_ARG_SET_GENERAL (a, v, TC_CORBA_double, CORBA_double, NULL))

This macro sets the value of a to contain v


BONOBO_ARG_GET_CHAR()

#define BONOBO_ARG_GET_CHAR(a)      (BONOBO_ARG_GET_GENERAL (a, TC_CORBA_char, CORBA_char, NULL))


BONOBO_ARG_SET_CHAR()

#define BONOBO_ARG_SET_CHAR(a,v)    (BONOBO_ARG_SET_GENERAL (a, v, TC_CORBA_char, CORBA_char, NULL))


BONOBO_ARG_GET_STRING()

#define     BONOBO_ARG_GET_STRING(a)

this macro returns a const CORBA_char * from from inside a BonoboArg, if the BonoboArg's type does not match, the behavior is undefined, and may cause faults. The pointer to the string is only valid for the scope of the lifetime of a.


BONOBO_ARG_SET_STRING()

#define     BONOBO_ARG_SET_STRING(a,v)

This macro sets the value of a to contain a duplicated copy of v


bonobo_arg_new ()

BonoboArg*  bonobo_arg_new                  (BonoboArgType t);

Create a new BonoboArg with the specified type the value of the BonoboArg is initially empty.


bonobo_arg_new_from ()

BonoboArg*  bonobo_arg_new_from             (BonoboArgType t,
                                             gconstpointer data);

Create a new BonoboArg with the specified type and data


bonobo_arg_release ()

void        bonobo_arg_release              (BonoboArg *arg);

This frees the memory associated with arg


bonobo_arg_copy ()

BonoboArg*  bonobo_arg_copy                 (const BonoboArg *arg);

This function duplicates a by a deep copy


bonobo_arg_from_gvalue ()

void        bonobo_arg_from_gvalue          (BonoboArg *a,
                                             const GValue *value);

This maps a GValue value to a BonoboArg a; a must point to a freshly allocated BonoboArg eg. such as returned by bonobo_arg_new


bonobo_arg_type_from_gtype ()

BonoboArgType bonobo_arg_type_from_gtype    (GType t);


bonobo_arg_to_gvalue ()

void        bonobo_arg_to_gvalue            (GValue *value,
                                             const BonoboArg *arg);

Maps a BonoboArg to a GtkArg; a must point to a blank GtkArg.


bonobo_arg_type_to_gtype ()

GType       bonobo_arg_type_to_gtype        (BonoboArgType id);

This maps a BonoboArgType to a GType


bonobo_arg_is_equal ()

gboolean    bonobo_arg_is_equal             (const BonoboArg *a,
                                             const BonoboArg *b,
                                             CORBA_Environment *opt_ev);

Compares two BonoboArgs for equivalence; will return TRUE if equivalent for all simple cases. For Object references CORBA sometimes denies 2 object references are equivalent even if they are [ this is a feature_not_bug ].

This function is commutative.


bonobo_arg_type_is_equal ()

gboolean    bonobo_arg_type_is_equal        (BonoboArgType a,
                                             BonoboArgType b,
                                             CORBA_Environment *opt_ev);

This compares two BonoboArgType's in a and b. The opt_ev is an optional CORBA_Environment for exceptions, or NULL. This function is commutative.