variant_internal
[container_internal]

Collaboration diagram for variant_internal:

Detailed Description

Module for manage EasyDbus Variant Internal.

Functions for manage easydbus variant containers

For easydbus developers:
Todo:

Variant Meta Information

Contact:
Daniele Rondina aka Ge@@ru <geaaru@gmail.com>
Status:
EasyDbus Core Library
License:
GPL
Contributor(s):


Functions

int add_variant_to_container_on_msg (DBusMessage *msg, struct EasyDbus_elem *el, DBusMessageIter *iter)
 Add variant element on marshalled data to DBusMessage message.
int add_variant_to_msg (DBusMessage *msg, struct EasyDbus_elem *el)
 Add variant element to DBusMessage message.
struct EasyDbus_container * easydbus_variant_build_elem (enum event_type type, void *container, DBusMessageIter *iter)
 Create a variant container from iter passed in input.

Function Documentation

int add_variant_to_container_on_msg ( DBusMessage *  msg,
struct EasyDbus_elem *  el,
DBusMessageIter *  iter 
)

Add variant element on marshalled data to DBusMessage message.

For internal use only.

Parameters:
msg dbus message where variant must be insert (this field can be removed, it isn't used).
el element that containts variant container.
iter pointer to dbus iterator connect to a container (a dict entry or an array).
Returns:
-1 error

0 ok

Definition at line 276 of file variant_internal.c.

References EASYDBUS_ELTYPE_BOOLEAN, EASYDBUS_ELTYPE_BYTE, EASYDBUS_ELTYPE_DOUBLE, EASYDBUS_ELTYPE_INT16, EASYDBUS_ELTYPE_INT32, EASYDBUS_ELTYPE_INT64, EASYDBUS_ELTYPE_OBJECT_PATH, EASYDBUS_ELTYPE_SIGNATURE, EASYDBUS_ELTYPE_STRING, EASYDBUS_ELTYPE_UINT16, EASYDBUS_ELTYPE_UINT32, EASYDBUS_ELTYPE_UINT64, EASYDBUS_SIGNATURE_VARIANT, EasyDbusDebug, EasyDbus_container::elem_type, EasyDbus_elem::p_container, EasyDbus_container::p_data, EasyDbus_elem::payload, prepare_signature(), and EasyDbus_container::signature.

Referenced by add_array_to_msg(), easydbus_add_array_on_container_tomsg(), easydbus_add_dict_entry_tomsg(), easydbus_add_struct_on_container_msg(), and easydbus_add_struct_to_msg().

00279 {
00280    DBusMessageIter iter2;
00281    int ret_val = 0;
00282    struct EasyDbus_container *container = el->payload.p_container;
00283 
00284    char *signature = prepare_signature (el,
00285                                         EASYDBUS_SIGNATURE_VARIANT);
00286 
00287    EasyDbusDebug ("Signature of variant on a container = %s",
00288                   signature);
00289    signature++;
00290 
00291    dbus_message_iter_open_container (iter,
00292                                      DBUS_TYPE_VARIANT, signature,
00293                                      &iter2);
00294 
00295    switch (container->elem_type) {
00296       case EASYDBUS_ELTYPE_INT16:
00297          dbus_message_iter_append_basic
00298             (&iter2, DBUS_TYPE_INT16, container->p_data);
00299          break;
00300       case EASYDBUS_ELTYPE_UINT16:
00301          dbus_message_iter_append_basic
00302             (&iter2, DBUS_TYPE_UINT16, container->p_data);
00303          break;
00304       case EASYDBUS_ELTYPE_INT32:
00305          dbus_message_iter_append_basic
00306             (&iter2, DBUS_TYPE_INT32, container->p_data);
00307          break;
00308       case EASYDBUS_ELTYPE_UINT32:
00309          dbus_message_iter_append_basic
00310             (&iter2, DBUS_TYPE_UINT32, container->p_data);
00311          break;
00312       case EASYDBUS_ELTYPE_INT64:
00313          dbus_message_iter_append_basic
00314             (&iter2, DBUS_TYPE_INT64, container->p_data);
00315          break;
00316       case EASYDBUS_ELTYPE_UINT64:
00317          dbus_message_iter_append_basic
00318             (&iter2, DBUS_TYPE_UINT64, container->p_data);
00319          break;
00320       case EASYDBUS_ELTYPE_BYTE:
00321          dbus_message_iter_append_basic
00322             (&iter2, DBUS_TYPE_BYTE, container->p_data);
00323          break;
00324       case EASYDBUS_ELTYPE_DOUBLE:
00325          dbus_message_iter_append_basic
00326             (&iter2, DBUS_TYPE_DOUBLE, (double *) container->p_data);
00327          break;
00328       case EASYDBUS_ELTYPE_BOOLEAN:
00329          dbus_message_iter_append_basic
00330             (&iter2, DBUS_TYPE_BOOLEAN, container->p_data);
00331          break;
00332       case EASYDBUS_ELTYPE_STRING:
00333          dbus_message_iter_append_basic
00334             (&iter2, DBUS_TYPE_STRING, &container->p_data);
00335          break;
00336       case EASYDBUS_ELTYPE_OBJECT_PATH:
00337          dbus_message_iter_append_basic
00338             (&iter2, DBUS_TYPE_OBJECT_PATH, &container->p_data);
00339          break;
00340       case EASYDBUS_ELTYPE_SIGNATURE:
00341          dbus_message_iter_append_basic
00342             (&iter2, DBUS_TYPE_SIGNATURE, &container->p_data);
00343          break;
00344       default:
00345          ret_val = -1;
00346          break;
00347    }
00348 
00349    --signature;
00350    free (signature);
00351 
00352    dbus_message_iter_close_container (iter, &iter2);
00353 
00354    return ret_val;
00355 }

Here is the call graph for this function:

int add_variant_to_msg ( DBusMessage *  msg,
struct EasyDbus_elem *  el 
)

Add variant element to DBusMessage message.

For internal use only.

Parameters:
msg DBusMessage where it is inserted variant element.
el element object that contains variant container.
Returns:
-1 error

0 ok

Definition at line 183 of file variant_internal.c.

References EASYDBUS_ELTYPE_ARRAY, EASYDBUS_ELTYPE_BOOLEAN, EASYDBUS_ELTYPE_BYTE, EASYDBUS_ELTYPE_DICT_ENTRY, EASYDBUS_ELTYPE_DOUBLE, EASYDBUS_ELTYPE_INT16, EASYDBUS_ELTYPE_INT32, EASYDBUS_ELTYPE_INT64, EASYDBUS_ELTYPE_INVALID, EASYDBUS_ELTYPE_OBJECT_PATH, EASYDBUS_ELTYPE_SIGNATURE, EASYDBUS_ELTYPE_STRING, EASYDBUS_ELTYPE_STRUCT, EASYDBUS_ELTYPE_UINT16, EASYDBUS_ELTYPE_UINT32, EASYDBUS_ELTYPE_UINT64, EASYDBUS_ELTYPE_VARIANT, EASYDBUS_SIGNATURE_VARIANT, EasyDbusDebug, EasyDbus_container::elem_type, EasyDbus_elem::p_container, EasyDbus_container::p_data, EasyDbus_elem::payload, prepare_signature(), and EasyDbus_container::signature.

Referenced by add_elems_to_msg().

00184 {
00185    DBusMessageIter iter;
00186    DBusMessageIter iter2;
00187    int ret_val = -1;
00188    struct EasyDbus_container *container = el->payload.p_container;
00189 
00190    dbus_message_iter_init_append (msg, &iter);
00191 
00192    char *signature =
00193       prepare_signature (el, EASYDBUS_SIGNATURE_VARIANT);
00194    EasyDbusDebug ("Signature of Variant = %s", signature);
00195    signature++;
00196 
00197    dbus_message_iter_open_container (&iter,
00198                                      DBUS_TYPE_VARIANT, signature,
00199                                      &iter2);
00200 
00201    switch (container->elem_type) {
00202       case EASYDBUS_ELTYPE_INT16:
00203          dbus_message_iter_append_basic
00204             (&iter2, DBUS_TYPE_INT16, container->p_data);
00205          break;
00206       case EASYDBUS_ELTYPE_UINT16:
00207          dbus_message_iter_append_basic
00208             (&iter2, DBUS_TYPE_UINT16, container->p_data);
00209          break;
00210       case EASYDBUS_ELTYPE_INT32:
00211          dbus_message_iter_append_basic
00212             (&iter2, DBUS_TYPE_INT32, container->p_data);
00213          break;
00214       case EASYDBUS_ELTYPE_UINT32:
00215          dbus_message_iter_append_basic
00216             (&iter2, DBUS_TYPE_UINT32, container->p_data);
00217          break;
00218       case EASYDBUS_ELTYPE_INT64:
00219          dbus_message_iter_append_basic
00220             (&iter2, DBUS_TYPE_INT64, container->p_data);
00221          break;
00222       case EASYDBUS_ELTYPE_UINT64:
00223          dbus_message_iter_append_basic
00224             (&iter2, DBUS_TYPE_UINT64, container->p_data);
00225          break;
00226       case EASYDBUS_ELTYPE_BYTE:
00227          dbus_message_iter_append_basic
00228             (&iter2, DBUS_TYPE_BYTE, container->p_data);
00229          break;
00230       case EASYDBUS_ELTYPE_DOUBLE:
00231          dbus_message_iter_append_basic
00232             (&iter2, DBUS_TYPE_DOUBLE, (double *) container->p_data);
00233          break;
00234       case EASYDBUS_ELTYPE_BOOLEAN:
00235          dbus_message_iter_append_basic
00236             (&iter2, DBUS_TYPE_BOOLEAN, container->p_data);
00237          break;
00238       case EASYDBUS_ELTYPE_STRING:
00239          dbus_message_iter_append_basic
00240             (&iter2, DBUS_TYPE_STRING, &container->p_data);
00241          break;
00242       case EASYDBUS_ELTYPE_OBJECT_PATH:
00243          dbus_message_iter_append_basic
00244             (&iter2, DBUS_TYPE_OBJECT_PATH, &container->p_data);
00245          break;
00246       case EASYDBUS_ELTYPE_ARRAY:
00247       case EASYDBUS_ELTYPE_SIGNATURE:
00248       case EASYDBUS_ELTYPE_STRUCT:
00249       case EASYDBUS_ELTYPE_VARIANT:
00250       case EASYDBUS_ELTYPE_DICT_ENTRY:
00251       case EASYDBUS_ELTYPE_INVALID:
00252          break;
00253    }
00254 
00255    --signature;
00256    free (signature);
00257 
00258    dbus_message_iter_close_container (&iter, &iter2);
00259 
00260    return ret_val;
00261 }

Here is the call graph for this function:

struct EasyDbus_container* easydbus_variant_build_elem ( enum event_type  type,
void *  container,
DBusMessageIter *  iter 
) [read]

Create a variant container from iter passed in input.

For internal use only.

Parameters:
type type of message (skeleton) object
container skeleton object.
iter DBusMessageIter iterator pointer for recover variant data
Returns:
NULL on error

pointer to new variant container

Definition at line 58 of file variant_internal.c.

References easydbus_container_create_skeleton(), easydbus_container_free(), EASYDBUS_ELTYPE_VARIANT, easydbus_variant_add_boolean(), easydbus_variant_add_byte(), easydbus_variant_add_double(), easydbus_variant_add_i16(), easydbus_variant_add_i32(), easydbus_variant_add_i64(), easydbus_variant_add_obj_path(), easydbus_variant_add_signature(), easydbus_variant_add_string(), easydbus_variant_add_ui16(), easydbus_variant_add_ui32(), easydbus_variant_add_ui64(), EasyDbusDebug, and EasyDbus_container::signature.

Referenced by easydbus_build_skeleton_data(), easydbus_dict_entry_build_container(), easydbus_get_marshal_data_from_array(), and easydbus_struct_build_elem().

00061 {
00062    struct EasyDbus_container *variant = NULL;
00063    DBusMessageIter subiter;
00064    int i32 = 0;
00065    unsigned int ui32 = 0;
00066    short i16 = 0;
00067    char byte = 0;
00068    char *string = NULL;
00069    unsigned short ui16 = 0;
00070    long long i64 = 0;
00071    double d = 0;
00072    unsigned long long ui64 = 0;
00073 
00074 #ifdef EASYDBUS_DEBUG
00075    char *signature = NULL;
00076 #endif
00077 
00078    if (container == NULL || iter == NULL)
00079       return NULL;
00080 
00081    variant =
00082       easydbus_container_create_skeleton (EASYDBUS_ELTYPE_VARIANT);
00083 
00084    if (variant == NULL)
00085       return NULL;
00086 
00087    // see if there a dedicated function to inizialize 
00088    // this variable.
00089    memset (&subiter, 0, sizeof (DBusMessageIter));
00090 
00091    dbus_message_iter_recurse (iter, &subiter);
00092 
00093 #ifdef EASYDBUS_DEBUG
00094    signature = dbus_message_iter_get_signature (&subiter);
00095    EasyDbusDebug ("Current Signature = %s", signature);
00096    dbus_free (signature);
00097 #endif
00098    switch (dbus_message_iter_get_arg_type (&subiter)) {
00099       case DBUS_TYPE_STRING:
00100          dbus_message_iter_get_basic (&subiter, &string);
00101          EasyDbusDebug ("founded string = %s\n", string);
00102          easydbus_variant_add_string (variant, string);
00103          break;
00104       case DBUS_TYPE_INT32:
00105          dbus_message_iter_get_basic (&subiter, &i32);
00106          EasyDbusDebug ("founded int32 = %d", i32);
00107          easydbus_variant_add_i32 (variant, i32);
00108          break;
00109       case DBUS_TYPE_UINT32:
00110          dbus_message_iter_get_basic (&subiter, &ui32);
00111          EasyDbusDebug ("founded uint32 = %d", ui32);
00112          easydbus_variant_add_ui32 (variant, ui32);
00113          break;
00114       case DBUS_TYPE_INT16:
00115          dbus_message_iter_get_basic (&subiter, &i16);
00116          EasyDbusDebug ("founded int16 = %d", i16);
00117          easydbus_variant_add_i16 (variant, i16);
00118          break;
00119       case DBUS_TYPE_UINT16:
00120          dbus_message_iter_get_basic (&subiter, &ui16);
00121          EasyDbusDebug ("founded uint16 = %d", ui16);
00122          easydbus_variant_add_ui16 (variant, ui16);
00123          break;
00124       case DBUS_TYPE_INT64:
00125          dbus_message_iter_get_basic (&subiter, &i64);
00126          EasyDbusDebug ("founded int64 = %lld", i64);
00127          easydbus_variant_add_i64 (variant, i64);
00128          break;
00129       case DBUS_TYPE_UINT64:
00130          dbus_message_iter_get_basic (&subiter, &ui64);
00131          EasyDbusDebug ("founded uint64 = %lld", ui64);
00132          easydbus_variant_add_ui64 (variant, ui64);
00133          break;
00134       case DBUS_TYPE_BYTE:
00135          dbus_message_iter_get_basic (&subiter, &byte);
00136          EasyDbusDebug ("founded byte = %d", byte);
00137          easydbus_variant_add_byte (variant, byte);
00138          break;
00139       case DBUS_TYPE_BOOLEAN:
00140          dbus_message_iter_get_basic (&subiter, &byte);
00141          EasyDbusDebug ("founded boolean = %d", byte);
00142          easydbus_variant_add_boolean (variant, byte);
00143          break;
00144       case DBUS_TYPE_DOUBLE:
00145          dbus_message_iter_get_basic (&subiter, &d);
00146          EasyDbusDebug ("founded double = %f", d);
00147          easydbus_variant_add_double (variant, d);
00148          break;
00149       case DBUS_TYPE_OBJECT_PATH:
00150          dbus_message_iter_get_basic (&subiter, &string);
00151          EasyDbusDebug ("founded obj_path = %s\n", string);
00152          easydbus_variant_add_obj_path (variant, string);
00153          break;
00154       case DBUS_TYPE_SIGNATURE:
00155          dbus_message_iter_get_basic (&subiter, &string);
00156          EasyDbusDebug ("founded signature = %s\n", string);
00157          easydbus_variant_add_signature (variant, string);
00158          break;
00159       default:
00160          goto error;
00161          break;
00162    }
00163 
00164    return variant;
00165 
00166  error:
00167    if (variant != NULL)
00168       easydbus_container_free (variant);
00169    return NULL;
00170 }

Here is the call graph for this function:

Generated on Thu Apr 10 10:01:36 2008 for EasyDbus-0.2 by  doxygen 1.5.4