elem.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:  elem.c
 
  Version:  0.1
  Created:  08/09/07 19:09:05 CEST
  Revision:  none
 
  Author:   Daniele Rondina aka Ge@@ru (geaaru@gmail.com) 
  License:  GPL 2.0
*/

/* easydbus includes */
#include "easydbus-core.h"
#include "utils.h"
#include "debug.h"
#include "variant_internal.h"
#include "struct_internal.h"
#include "array_internal.h"
#include "elem_internal.h"

#include <string.h>
#include <stdlib.h>
#include <stdio.h>

const char *
easydbus_elem_get_string (const EasyDbus_elem * elem)
{
   if (elem == NULL || (elem->type != EASYDBUS_ELTYPE_STRING))
      return NULL;
   return (const char *) elem->payload.string;
}

const char *
easydbus_elem_get_obj_path (const EasyDbus_elem * elem)
{
   if (elem == NULL || (elem->type != EASYDBUS_ELTYPE_OBJECT_PATH))
      return NULL;
   return (const char *) elem->payload.string;
}

const char *
easydbus_elem_get_signature (const EasyDbus_elem * elem)
{
   if (elem == NULL || (elem->type != EASYDBUS_ELTYPE_SIGNATURE))
      return NULL;
   return (const char *) elem->payload.string;
}

int
easydbus_elem_get_byte (const EasyDbus_elem * elem, char *byte)
{
   if (elem == NULL || byte == NULL ||
       (elem->type != EASYDBUS_ELTYPE_BYTE))
      return -1;
   *byte = elem->payload.byte;
   return 0;
}

char
easydbus_elem_get_boolean (const EasyDbus_elem * elem)
{
   if (elem == NULL || (elem->type != EASYDBUS_ELTYPE_BOOLEAN))
      return -1;
   return elem->payload.boolean;
}

int
easydbus_elem_get_double (const EasyDbus_elem * elem, double *d)
{
   if (elem == NULL || d == NULL ||
       (elem->type != EASYDBUS_ELTYPE_DOUBLE))
      return -1;
   *d = elem->payload.Double;
   return 0;
}


int
easydbus_elem_get_i16 (const EasyDbus_elem * elem, short *i16)
{
   if (elem == NULL || i16 == NULL ||
       (elem->type != EASYDBUS_ELTYPE_INT16))
      return -1;
   *i16 = elem->payload.i16;
   return 0;
}

int
easydbus_elem_get_ui16 (const EasyDbus_elem * elem,
                        unsigned short *ui16)
{
   if (elem == NULL || ui16 == NULL ||
       (elem->type != EASYDBUS_ELTYPE_UINT16))
      return -1;
   *ui16 = elem->payload.ui16;
   return 0;
}

int
easydbus_elem_get_ui32 (const EasyDbus_elem * elem,
                        unsigned int *ui32)
{
   if (elem == NULL || ui32 == NULL ||
       (elem->type != EASYDBUS_ELTYPE_UINT32))
      return -1;
   *ui32 = elem->payload.ui32;
   return 0;
}

int
easydbus_elem_get_i32 (const EasyDbus_elem * elem, int *i32)
{
   if (elem == NULL || i32 == NULL ||
       (elem->type != EASYDBUS_ELTYPE_INT32))
      return -1;
   *i32 = elem->payload.i32;
   return 0;
}

int
easydbus_elem_get_ui64 (const EasyDbus_elem * elem,
                        unsigned long long *ui64)
{
   if (elem == NULL || ui64 == NULL ||
       (elem->type != EASYDBUS_ELTYPE_UINT64))
      return -1;
   *ui64 = elem->payload.ui64;
   return 0;
}

const EasyDbus_container *
easydbus_elem_get_container (const EasyDbus_elem * elem)
{
   if (elem == NULL ||
       (elem->type != EASYDBUS_ELTYPE_ARRAY &&
        elem->type != EASYDBUS_ELTYPE_DICT_ENTRY &&
        elem->type != EASYDBUS_ELTYPE_VARIANT &&
        elem->type != EASYDBUS_ELTYPE_STRUCT))
      return NULL;
   return (const EasyDbus_container *) elem->payload.p_container;
}

int
easydbus_elem_get_i64 (const EasyDbus_elem * elem, long long *i64)
{
   if (elem == NULL || i64 == NULL ||
       (elem->type != EASYDBUS_ELTYPE_INT64))
      return -1;
   *i64 = elem->payload.i64;
   return 0;
}

inline enum el_type 
easydbus_elem_get_type (const EasyDbus_elem * elem) 
{
   if (elem == NULL)
      return EASYDBUS_ELTYPE_INVALID;
   return elem->type;
}

const EasyDbus_elem *
easydbus_elem_get_element (const EasyDbus_elem * elem, 
                           unsigned int n)
{
   unsigned int i;
   EasyDbus_elem *el = (EasyDbus_elem *) elem;

   if (elem == NULL || n == 0)
      return NULL;

   for (i = 1; i < n; i++) {
      el = el->next;
      if (el == NULL && i < n)
         break;
   }
   return (const EasyDbus_elem *) el;
}

inline const EasyDbus_elem *
easydbus_elem_get_next (const EasyDbus_elem * el) 
{
  return (el ? (const EasyDbus_elem *) el->next : NULL);
}

void
easydbus_elem_free (EasyDbus_elem * el)
{
   if (el == NULL)
      return;
   switch (el->type) {
      case EASYDBUS_ELTYPE_STRING:
      case EASYDBUS_ELTYPE_OBJECT_PATH:
      case EASYDBUS_ELTYPE_SIGNATURE:
         if (el->payload.string != NULL)
            free (el->payload.string);
         break;
      case EASYDBUS_ELTYPE_STRUCT:
      case EASYDBUS_ELTYPE_ARRAY:
      case EASYDBUS_ELTYPE_DICT_ENTRY:
      case EASYDBUS_ELTYPE_VARIANT:
         if (el->payload.p_container != NULL) {
            easydbus_container_free (el->payload.p_container);
         }
         break;
      default:
         break;
   }
   free (el);
}

inline EasyDbus_elem * 
easydbus_elem_create (enum el_type type)
{
   struct EasyDbus_elem *el = NULL;

   if (type == EASYDBUS_ELTYPE_INVALID)
      return NULL;

   el =
      (struct EasyDbus_elem *) malloc (sizeof (struct EasyDbus_elem));

   if (!el)
      return NULL;

   memset (el, 0, sizeof (struct EasyDbus_elem));

   el->type = type;
   switch (type) {
      case EASYDBUS_ELTYPE_STRING:
      case EASYDBUS_ELTYPE_OBJECT_PATH:
      case EASYDBUS_ELTYPE_SIGNATURE:
         el->payload.string = NULL;
         break;
      case EASYDBUS_ELTYPE_ARRAY:
      case EASYDBUS_ELTYPE_VARIANT:
      case EASYDBUS_ELTYPE_DICT_ENTRY:
      case EASYDBUS_ELTYPE_STRUCT:
         el->payload.p_container = NULL;
         break;
      default: /* do nothing because its are already initialize */
         //case EASYDBUS_ELTYPE_BYTE:
         //case EASYDBUS_ELTYPE_BOOLEAN:
         //case EASYDBUS_ELTYPE_INT16:
         //case EASYDBUS_ELTYPE_UINT16:
         //case EASYDBUS_ELTYPE_INT32,
         //case EASYDBUS_ELTYPE_UINT32,
         //case EASYDBUS_ELTYPE_INT64,
         //case EASYDBUS_ELTYPE_UINT64,
         //case EASYDBUS_ELTYPE_DOUBLE,
         break;
   }
   el->next = NULL;
   return el;
}

int
add_elems_to_msg (DBusMessage * msg, struct EasyDbus_elem *first)
{
   struct EasyDbus_elem *el = NULL;

   /* see if use directly first on insert steps */
   el = first;
   int ret_val = 1;

   if (msg == NULL || first == NULL)
      return -1;

   while (el != NULL) {
      switch (el->type) {
         case EASYDBUS_ELTYPE_STRING:
            if (!dbus_message_append_args (msg, DBUS_TYPE_STRING,
                                           &el->payload.string,
                                           DBUS_TYPE_INVALID))
               ret_val = 0;
            break;
         case EASYDBUS_ELTYPE_BYTE:
            if (!dbus_message_append_args (msg, DBUS_TYPE_BYTE,
                                           &el->payload.byte,
                                           DBUS_TYPE_INVALID))
               ret_val = 0;
            break;
         case EASYDBUS_ELTYPE_BOOLEAN:
            if (!dbus_message_append_args (msg, DBUS_TYPE_BOOLEAN,
                                           &el->payload.boolean,
                                           DBUS_TYPE_INVALID))
               ret_val = 0;
            break;
         case EASYDBUS_ELTYPE_DOUBLE:
            if (!dbus_message_append_args (msg, DBUS_TYPE_DOUBLE,
                                           &el->payload.Double,
                                           DBUS_TYPE_INVALID))
               ret_val = 0;
            break;
         case EASYDBUS_ELTYPE_INT16:
            if (!dbus_message_append_args (msg, DBUS_TYPE_INT16,
                                           &el->payload.i16,
                                           DBUS_TYPE_INVALID))
               ret_val = 0;
            break;
         case EASYDBUS_ELTYPE_UINT16:
            if (!dbus_message_append_args (msg, DBUS_TYPE_UINT16,
                                           &el->payload.ui16,
                                           DBUS_TYPE_INVALID))
               ret_val = 0;
            break;
         case EASYDBUS_ELTYPE_INT32:
            if (!dbus_message_append_args (msg, DBUS_TYPE_INT32,
                                           &el->payload.i32,
                                           DBUS_TYPE_INVALID))
               ret_val = 0;
            break;
         case EASYDBUS_ELTYPE_UINT32:
            if (!dbus_message_append_args (msg, DBUS_TYPE_UINT32,
                                           &el->payload.ui32,
                                           DBUS_TYPE_INVALID))
               ret_val = 0;
            break;
         case EASYDBUS_ELTYPE_INT64:
            if (!dbus_message_append_args (msg, DBUS_TYPE_INT64,
                                           &el->payload.i64,
                                           DBUS_TYPE_INVALID))
               ret_val = 0;
            break;
         case EASYDBUS_ELTYPE_UINT64:
            if (!dbus_message_append_args (msg, DBUS_TYPE_UINT64,
                                           &el->payload.ui64,
                                           DBUS_TYPE_INVALID))
               ret_val = 0;
            break;
         case EASYDBUS_ELTYPE_OBJECT_PATH:
            if (!dbus_message_append_args (msg, DBUS_TYPE_OBJECT_PATH,
                                           &el->payload.string,
                                           DBUS_TYPE_INVALID))
               ret_val = 0;
            break;
         case EASYDBUS_ELTYPE_SIGNATURE:
            if (!dbus_message_append_args (msg, DBUS_TYPE_SIGNATURE,
                                           &el->payload.string,
                                           DBUS_TYPE_INVALID))
               ret_val = 0;
            break;
         case EASYDBUS_ELTYPE_ARRAY:
            /* todo */
            if (!add_array_to_msg (msg, el))
               ret_val = 0;
            break;
         case EASYDBUS_ELTYPE_VARIANT:
            if (!add_variant_to_msg (msg, el))
               ret_val = 0;
            break;
         case EASYDBUS_ELTYPE_STRUCT:
            if (!easydbus_add_struct_to_msg (msg, el))
               ret_val = 0;
            break;
         case EASYDBUS_ELTYPE_DICT_ENTRY:
         case EASYDBUS_ELTYPE_INVALID:
            return -1;
            break;
      }
      el = el->next;
   }
   return ret_val;
}
// vim: ts=3 shiftwidth=3 expandtab

---