EasyDbus-0.2: variant_internal.c Source File

00001 /*
00002  EasyDbus: DBUS Binding library. 
00003  Copyright (C) 2007  Daniele Rondina aka ge@@ru, geaaru@gmail.com 
00004 
00005  This program is free software; you can redistribute it and/or
00006  modify it under the terms of the GNU General Public License
00007  as published by the Free Software Foundation; either version 2
00008  of the License, or (at your option) any later version.
00009 
00010  This program is distributed in the hope that it will be useful,
00011  but WITHOUT ANY WARRANTY; without even the implied warranty of
00012  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00013  GNU General Public License for more details.
00014 
00015  You should have received a copy of the GNU General Public License
00016  along with this program; if not, write to the Free Software
00017  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
00018 
00019  Filename:  variant_internal.c
00020  
00021  Description: Function connect to variant element but not used
00022               from user of the Easydbus library.
00023  
00024  Version:  1.0
00025  Created:  09/06/07 12:45:31 CEST
00026  Revision:  
00027    0 - created (Ge@@ru)
00028  
00029  Author:   Daniele Rondina aka ge@@ru (geaaru@gmail.com) 
00030  License:  GPL 2.0
00031 */
00032 
00038 #include <stdlib.h>
00039 #include <string.h>
00040 #include <stdio.h>
00041 // easydbus includes 
00042 #include "utils.h"
00043 #include "debug.h"
00044 #include "easydbus-core.h"
00045 #include "variant_internal.h"
00046 
00057 struct EasyDbus_container *
00058 easydbus_variant_build_elem (enum event_type type,
00059                              void *container, 
00060                              DBusMessageIter * iter)
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 }
00171 
00182 int
00183 add_variant_to_msg (DBusMessage * msg, struct EasyDbus_elem *el)
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 }
00262 
00263 
00275 int
00276 add_variant_to_container_on_msg (DBusMessage * msg,
00277                                  struct EasyDbus_elem *el,
00278                                  DBusMessageIter * iter)
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 }
00356 // vim: ts=3 shiftwidth=3 expandtab