dict_entry_internal.c

Go to the documentation of this file.

/*
 EasyDbus: DBUS Binding library. 
 Copyright (C) 2007  Daniele Rondina aka ge@@ru, geaaru@gmail.com 

 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 as published by the Free Software Foundation; either version 2
 of the License, or (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

 Filename:  dict_entry_internal.c
 
 Description: Contains functions used on easydbus library but not
  visible from user of easydbus library.
 
 Version:  1.0
 Created:  09/06/07 22:03:50 CEST
 Revision: 
        0 - created (Ge@@ru)
 
 Author:   Daniele Rondina aka Ge@@ru (geaaru@gmail.com) 
 License:  GPL 2.0
*/

#include <stdlib.h>
#include <string.h>
// easydbus includes
#include "easydbus-core.h"
#include "debug.h"
#include "dict_entry_internal.h"
#include "variant_internal.h"
#include "elem_internal.h"
#include "utils.h"

struct EasyDbus_container *
easydbus_dict_entry_build_container (enum event_type type,
                                     void *container,
                                     DBusMessageIter * iter)
{
   struct EasyDbus_container *dict_entry = NULL;
   struct EasyDbus_container *variant = NULL;
   DBusMessageIter subiter;
   int i32 = 0, i = 0;
   unsigned int ui32 = 0;
   short i16 = 0;
   char byte = 0;
   char *string = NULL;
   unsigned short ui16 = 0;
   long long i64 = 0;
   double d = 0;
   unsigned long long ui64 = 0;

#ifdef EASYDBUS_DEBUG
   char *signature = NULL;
#endif

   if (container == NULL || iter == NULL)
      return NULL;

   dict_entry =
      easydbus_container_create_skeleton (EASYDBUS_ELTYPE_DICT_ENTRY);

   if (dict_entry == NULL)
      return NULL;


   // see if there a dedicated function to inizialize 
   // this variable.
   memset (&subiter, 0, sizeof (DBusMessageIter));

   dbus_message_iter_recurse (iter, &subiter);

#ifdef EASYDBUS_DEBUG
   signature = dbus_message_iter_get_signature (&subiter);
   EasyDbusDebug ("Current Signature = %s", signature);
   dbus_free (signature);
#endif

   for (i = 0; i < 2; i++) {
      switch (dbus_message_iter_get_arg_type (&subiter)) {
         case DBUS_TYPE_STRING:
            dbus_message_iter_get_basic (&subiter, &string);
            EasyDbusDebug ("founded string = %s\n", string);
            easydbus_dict_entry_add_string (dict_entry, string);
            break;
         case DBUS_TYPE_INT32:
            dbus_message_iter_get_basic (&subiter, &i32);
            EasyDbusDebug ("founded int32 = %d", i32);
            easydbus_dict_entry_add_i32 (dict_entry, i32);
            break;
         case DBUS_TYPE_UINT32:
            dbus_message_iter_get_basic (&subiter, &ui32);
            EasyDbusDebug ("founded uint32 = %d", ui32);
            easydbus_dict_entry_add_ui32 (dict_entry, ui32);
            break;
         case DBUS_TYPE_INT16:
            dbus_message_iter_get_basic (&subiter, &i16);
            EasyDbusDebug ("founded int16 = %d", i16);
            easydbus_dict_entry_add_i16 (dict_entry, i16);
            break;
         case DBUS_TYPE_UINT16:
            dbus_message_iter_get_basic (&subiter, &ui16);
            EasyDbusDebug ("founded uint16 = %d", ui16);
            easydbus_dict_entry_add_ui16 (dict_entry, ui16);
            break;
         case DBUS_TYPE_INT64:
            dbus_message_iter_get_basic (&subiter, &i64);
            EasyDbusDebug ("founded int64 = %lld", i64);
            easydbus_dict_entry_add_i64 (dict_entry, i64);
            break;
         case DBUS_TYPE_UINT64:
            dbus_message_iter_get_basic (&subiter, &ui64);
            EasyDbusDebug ("founded uint64 = %lld", ui64);
            easydbus_dict_entry_add_ui64 (dict_entry, ui64);
            break;
         case DBUS_TYPE_BYTE:
            dbus_message_iter_get_basic (&subiter, &byte);
            EasyDbusDebug ("founded byte = %d", byte);
            easydbus_dict_entry_add_byte (dict_entry, byte);
            break;
         case DBUS_TYPE_BOOLEAN:
            dbus_message_iter_get_basic (&subiter, &byte);
            EasyDbusDebug ("founded boolean = %d", byte);
            easydbus_dict_entry_add_boolean (dict_entry, byte);
            break;
         case DBUS_TYPE_DOUBLE:
            dbus_message_iter_get_basic (&subiter, &d);
            EasyDbusDebug ("founded double = %f", d);
            easydbus_dict_entry_add_double (dict_entry, d);
            break;
         case DBUS_TYPE_OBJECT_PATH:
            dbus_message_iter_get_basic (&subiter, &string);
            EasyDbusDebug ("founded obj_path = %s\n", string);
            easydbus_dict_entry_add_obj_path (dict_entry, string);
            break;
         case DBUS_TYPE_SIGNATURE:
            dbus_message_iter_get_basic (&subiter, &string);
            EasyDbusDebug ("founded signature = %s\n", string);
            easydbus_dict_entry_add_signature (dict_entry, string);
            break;
         case DBUS_TYPE_VARIANT:
            variant = easydbus_variant_build_elem
               (type, (void *) container, &subiter);
            if (variant != NULL) {
               easydbus_dict_entry_add_variant (dict_entry, variant);
               EasyDbusDebug ("Added variant to container");
            }
            else
               EasyDbusDebug ("Error on add variant to container");
            break;
         default:
            goto error;
            break;
      }
      dbus_message_iter_next (&subiter);
   }

   return dict_entry;

 error:
   if (dict_entry != NULL)
      easydbus_container_free (dict_entry);
   return NULL;
}

int
easydbus_add_dict_entry_tomsg (DBusMessage * msg,
                               DBusMessageIter * iter,
                               struct EasyDbus_elem *el)
{
   int i;
   DBusMessageIter iter2;
   struct EasyDbus_elem *dict_entry = NULL;
   //char *signature = NULL;
   int ret_val = 0;

   dbus_message_iter_open_container (iter,
                                     DBUS_TYPE_DICT_ENTRY, NULL,
                                     //DBUS_TYPE_DICT_ENTRY, signature,
                                     &iter2);
   dict_entry = (struct EasyDbus_elem *)
      el->payload.p_container->p_data;

   for (i = 0; i < 2; i++) {
      switch (dict_entry->type) {
         case EASYDBUS_ELTYPE_STRING:
            dbus_message_iter_append_basic (&iter2,
                                            DBUS_TYPE_STRING,
                                            &dict_entry->payload.
                                            string);
            break;
         case EASYDBUS_ELTYPE_BYTE:
            dbus_message_iter_append_basic (&iter2,
                                            DBUS_TYPE_BYTE,
                                            &dict_entry->payload.
                                            byte);
            break;
         case EASYDBUS_ELTYPE_BOOLEAN:
            dbus_message_iter_append_basic (&iter2,
                                            DBUS_TYPE_BOOLEAN,
                                            &dict_entry->payload.
                                            boolean);
            break;
         case EASYDBUS_ELTYPE_DOUBLE:
            dbus_message_iter_append_basic (&iter2,
                                            DBUS_TYPE_DOUBLE,
                                            &dict_entry->payload.
                                            Double);
            break;
         case EASYDBUS_ELTYPE_INT16:
            dbus_message_iter_append_basic (&iter2,
                                            DBUS_TYPE_INT16,
                                            &dict_entry->payload.i16);
            break;
         case EASYDBUS_ELTYPE_UINT16:
            dbus_message_iter_append_basic (&iter2,
                                            DBUS_TYPE_UINT16,
                                            &dict_entry->payload.
                                            ui16);
            break;
         case EASYDBUS_ELTYPE_INT32:
            dbus_message_iter_append_basic (&iter2,
                                            DBUS_TYPE_INT32,
                                            &dict_entry->payload.i32);
            break;
         case EASYDBUS_ELTYPE_UINT32:
            dbus_message_iter_append_basic (&iter2,
                                            DBUS_TYPE_UINT32,
                                            &dict_entry->payload.
                                            ui32);
            break;
         case EASYDBUS_ELTYPE_INT64:
            dbus_message_iter_append_basic (&iter2,
                                            DBUS_TYPE_INT64,
                                            &dict_entry->payload.i64);
            break;
         case EASYDBUS_ELTYPE_UINT64:
            dbus_message_iter_append_basic (&iter2,
                                            DBUS_TYPE_UINT64,
                                            &dict_entry->payload.
                                            ui64);
            break;
         case EASYDBUS_ELTYPE_OBJECT_PATH:
            dbus_message_iter_append_basic (&iter2,
                                            DBUS_TYPE_OBJECT_PATH,
                                            &dict_entry->payload.
                                            string);
            break;
         case EASYDBUS_ELTYPE_SIGNATURE:
            dbus_message_iter_append_basic (&iter2,
                                            DBUS_TYPE_SIGNATURE,
                                            &dict_entry->payload.
                                            string);
            break;
         case EASYDBUS_ELTYPE_VARIANT:
            if (add_variant_to_container_on_msg
                (msg, dict_entry, &iter2)) {
               ret_val = -1;
               goto end;
            }
            break;
         default:
            EasyDbusDebug ("Element not managed!");
            ret_val = -1;
            goto end;
            break;
      }
      dict_entry = dict_entry->next;
   }                            // end of for with i
 end:
   dbus_message_iter_close_container (iter, &iter2);
//   free (signature);
   return ret_val;
}
// vim: ts=3 shiftwidth=3 expandtab

---