array.c

Go to the documentation of this file.

/*
 EasyDbus Library: 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:  array.c
 
  Description:  
 
  Version:  0.1
  Created:  06/09/07 11:15:51 CEST
  Revision:  
     0 - created
 
  Author:   Daniele Rondina aka ge@@ru (geaaru@gmail.com) 
  License:  GPL 2.0
*/

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

int
easydbus_array_add_array (EasyDbus_container * array_src,
                          EasyDbus_container * array_dst)
{

   struct EasyDbus_elem *el = NULL;
   struct EasyDbus_elem *elms = NULL;

   if (!array_src || !array_dst ||
       array_src->container_type != EASYDBUS_ELTYPE_ARRAY ||
       array_dst->container_type != EASYDBUS_ELTYPE_ARRAY)
      return -1;

   /* create dict_entry element */
   el = easydbus_elem_create (EASYDBUS_ELTYPE_ARRAY);
   if (!el)
      return -1;

   el->payload.p_container = array_src;

   if (array_dst->nel) {
      /* array already contains dict_entry */
      elms = (struct EasyDbus_elem *) array_dst->p_data;
      while (elms->next)
         elms = elms->next;
      elms->next = el;
   }
   else {
      /* array is empty */
      array_dst->elem_type = EASYDBUS_ELTYPE_ARRAY;
      array_dst->p_data = el;
   }

   array_dst->nel++;
   return 0;
}

int
easydbus_array_add_dict_entry (EasyDbus_container * dict_entry,
                               EasyDbus_container * array)
{

   struct EasyDbus_elem *el = NULL;
   struct EasyDbus_elem *elms = NULL;

   if (!array || !dict_entry ||
       dict_entry->container_type != EASYDBUS_ELTYPE_DICT_ENTRY ||
       array->container_type != EASYDBUS_ELTYPE_ARRAY)
      return -1;

   /* create dict_entry element */
   el = easydbus_elem_create (EASYDBUS_ELTYPE_DICT_ENTRY);
   if (!el)
      return -1;

   el->payload.p_container = dict_entry;

   if (array->nel) {
      /* array already contains dict_entry */
      elms = (struct EasyDbus_elem *) array->p_data;
      while (elms->next)
         elms = elms->next;
      elms->next = el;
   }
   else {
      /* array is empty */
      array->elem_type = EASYDBUS_ELTYPE_DICT_ENTRY;
      array->p_data = el;
   }

   array->nel++;
   return 0;
}

int
easydbus_array_add_variant (EasyDbus_container * variant,
                            EasyDbus_container * array)
{

   struct EasyDbus_elem *el = NULL;
   struct EasyDbus_elem *elms = NULL;

   if (!array || !variant ||
       variant->container_type != EASYDBUS_ELTYPE_VARIANT ||
       array->container_type != EASYDBUS_ELTYPE_ARRAY)
      return -1;

   /* create dict_entry element */
   el = easydbus_elem_create (EASYDBUS_ELTYPE_VARIANT);
   if (!el)
      return -1;

   el->payload.p_container = variant;

   if (array->nel) {
      /* array already contains dict_entry */
      elms = (struct EasyDbus_elem *) array->p_data;
      while (elms->next)
         elms = elms->next;
      elms->next = el;
   }
   else {
      /* array is empty */
      array->elem_type = EASYDBUS_ELTYPE_VARIANT;
      array->p_data = el;
   }

   array->nel++;
   return 0;
}

int
easydbus_array_add_struct (EasyDbus_container * struct_internal,
                           EasyDbus_container * array)
{

   struct EasyDbus_elem *el = NULL;
   struct EasyDbus_elem *elms = NULL;

   if (!array || !struct_internal ||
       struct_internal->container_type != EASYDBUS_ELTYPE_STRUCT ||
       array->container_type != EASYDBUS_ELTYPE_ARRAY)
      return -1;

   /* create dict_entry element */
   el = easydbus_elem_create (EASYDBUS_ELTYPE_STRUCT);
   if (!el)
      return -1;

   el->payload.p_container = struct_internal;

   if (array->nel) {
      /* array already contains dict_entry */
      elms = (struct EasyDbus_elem *) array->p_data;
      while (elms->next)
         elms = elms->next;
      elms->next = el;
   }
   else {
      /* array is empty */
      array->elem_type = EASYDBUS_ELTYPE_STRUCT;
      array->p_data = el;
   }

   array->nel++;
   return 0;
}

int
easydbus_array_add_byte_array (EasyDbus_container * container,
                               unsigned int nel, char *bytes)
{
   if (nel == 0 || !bytes || !container)
      return -1;

   if (container->container_type != EASYDBUS_ELTYPE_ARRAY)
      return -1;

   if (container->nel)
      return -1;


   container->p_data = malloc (nel);
   if (!container->p_data)
      return -1;

   EASYDBUS_MEMCOPY (container->p_data, bytes, nel);

   container->nel = nel;
   container->elem_type = EASYDBUS_ELTYPE_BYTE;
   return 0;
}

int
easydbus_array_add_boolean_array (EasyDbus_container * container,
                                  unsigned int nel,
                                  char *boolean_array)
{
   if (nel == 0 || !boolean_array || !container ||
       container->container_type != EASYDBUS_ELTYPE_ARRAY)
      return -1;

   if (container->nel)
      return -1;

   container->p_data = malloc (nel);
   if (!container->p_data)
      return -1;

   EASYDBUS_MEMCOPY (container->p_data, boolean_array, nel);

   container->nel = nel;
   container->elem_type = EASYDBUS_ELTYPE_BOOLEAN;

   return 0;
}

int
easydbus_array_add_i16_array (EasyDbus_container * container,
                              unsigned int nel, short *i16_array)
{
   size_t size_array = 0;

   if (nel == 0 || !i16_array || !container ||
       container->container_type != EASYDBUS_ELTYPE_ARRAY)
      return -1;

   if (container->nel)
      return -1;

   size_array = sizeof (short[nel]);

   container->p_data = malloc (size_array);
   if (!container->p_data)
      return -1;

   EASYDBUS_MEMCOPY (container->p_data, i16_array, size_array);

   container->nel = nel;
   container->elem_type = EASYDBUS_ELTYPE_INT16;

   return 0;
}

int
easydbus_array_add_ui16_array (EasyDbus_container * container,
                               unsigned int nel,
                               unsigned short *ui16_array)
{
   size_t size_array = 0;

   if (nel == 0 || !ui16_array || !container ||
       container->container_type != EASYDBUS_ELTYPE_ARRAY)
      return -1;

   if (container->nel)
      return -1;

   size_array = sizeof (short[nel]);

   container->p_data = malloc (size_array);
   if (!container->p_data)
      return -1;

   EASYDBUS_MEMCOPY (container->p_data, ui16_array, size_array);

   container->nel = nel;
   container->elem_type = EASYDBUS_ELTYPE_UINT16;

   return 0;
}

int
easydbus_array_add_i32_array (EasyDbus_container * container,
                              unsigned int nel, int *i32_array)
{
   size_t size_array = 0;

   if (nel == 0 || !i32_array || !container ||
       container->container_type != EASYDBUS_ELTYPE_ARRAY)
      return -1;

   if (container->nel)
      return -1;

   size_array = sizeof (int[nel]);

   container->p_data = malloc (size_array);
   if (!container->p_data)
      return -1;

   EASYDBUS_MEMCOPY (container->p_data, i32_array, size_array);

   container->nel = nel;
   container->elem_type = EASYDBUS_ELTYPE_INT32;

   return 0;
}

int
easydbus_array_add_ui32_array (EasyDbus_container * container,
                               unsigned int nel,
                               unsigned int *ui32_array)
{
   size_t size_array = 0;

   if (nel == 0 || !ui32_array || !container ||
       container->container_type != EASYDBUS_ELTYPE_ARRAY)
      return -1;

   if (container->nel)
      return -1;

   size_array = sizeof (int[nel]);

   container->p_data = malloc (size_array);
   if (!container->p_data)
      return -1;

   EASYDBUS_MEMCOPY (container->p_data, ui32_array, size_array);

   container->nel = nel;
   container->elem_type = EASYDBUS_ELTYPE_UINT32;

   return 0;
}

int
easydbus_array_add_i64_array (EasyDbus_container * container,
                              unsigned int nel, long long *i64_array)
{
   size_t size_array = 0;

   if (nel == 0 || !i64_array || !container ||
       container->container_type != EASYDBUS_ELTYPE_ARRAY)
      return -1;

   if (container->nel)
      return -1;

   size_array = sizeof (long long[nel]);

   container->p_data = malloc (size_array);
   if (!container->p_data)
      return -1;

   EASYDBUS_MEMCOPY (container->p_data, i64_array, size_array);
   container->nel = nel;
   container->elem_type = EASYDBUS_ELTYPE_INT64;

   return 0;
}

int
easydbus_array_add_ui64_array (EasyDbus_container * container,
                               unsigned int nel,
                               unsigned long long *ui64_array)
{
   size_t size_array = 0;

   if (nel == 0 || !ui64_array || !container ||
       container->container_type != EASYDBUS_ELTYPE_ARRAY)
      return -1;

   if (container->nel)
      return -1;

   size_array = sizeof (long long[nel]);

   container->p_data = malloc (size_array);
   if (!container->p_data)
      return -1;

   EASYDBUS_MEMCOPY (container->p_data, ui64_array, size_array);
   container->nel = nel;
   container->elem_type = EASYDBUS_ELTYPE_UINT64;

   return 0;
}

int
easydbus_array_add_double_array (EasyDbus_container * container,
                                 unsigned int nel,
                                 double *double_array)
{
   size_t size_array = 0;

   if (nel == 0 || !double_array || !container ||
       container->container_type != EASYDBUS_ELTYPE_ARRAY)
      return -1;

   if (container->nel)
      return -1;

   size_array = sizeof (double[nel]);

   container->p_data = malloc (size_array);
   if (!container->p_data)
      return -1;

   EASYDBUS_MEMCOPY (container->p_data, double_array, size_array);
   container->nel = nel;
   container->elem_type = EASYDBUS_ELTYPE_DOUBLE;

   return 0;
}

int
easydbus_array_add_string_array (EasyDbus_container * container,
                                 unsigned int nel,
                                 char **string_array)
{
   char **iterator, **iterator2 = NULL;
   int i = 0;

   if (nel == 0 || !string_array || !container ||
       container->container_type != EASYDBUS_ELTYPE_ARRAY)
      return -1;

   if (container->nel)
      return -1;

   container->p_data = malloc (sizeof (char *[nel]));
   if (!container->p_data)
      return -1;

   memset (container->p_data, 0, nel);

   iterator = string_array;
   iterator2 = (char **) container->p_data;

   for (i = 0; i < (int) nel; i++) {
      if (!iterator[i])
         goto error;
      iterator2[i] = (char *) malloc (strlen (iterator[i]) + 1);
      if (!iterator2[i])
         goto error;

      EASYDBUS_MEMCOPY (iterator2[i], iterator[i], 
                        strlen (iterator[i]) + 1);
      //memset (*iterator2, 0, strlen (*iterator)+1);
      //memcpy (iterator2[i], iterator[i], strlen (iterator[i]) + 1);
   }

   container->nel = nel;
   container->elem_type = EASYDBUS_ELTYPE_STRING;

   return 0;

 error:
   i--;
   for (; i > 0; i--) {

      if (iterator2[i])
         free (iterator2[i]);
   }
   free (container->p_data);
   return -1;
}

int
easydbus_array_add_obj_path_array (EasyDbus_container * container,
                                   unsigned int nel,
                                   char **obj_path_array)
{
   char **iterator, **iterator2 = NULL;
   int i = 0;

   if (nel == 0 || !obj_path_array || !container ||
       container->container_type != EASYDBUS_ELTYPE_ARRAY)
      return -1;

   if (container->nel)
      return -1;

   container->p_data = malloc (sizeof (char *[nel]));
   if (!container->p_data)
      return -1;

   memset (container->p_data, 0, nel);

   iterator = obj_path_array;
   iterator2 = (char **) container->p_data;

   for (i = 0; i < (int) nel; i++) {
      if (!iterator[i])
         goto error;
      iterator2[i] = (char *) malloc (strlen (iterator[i]) + 1);
      if (!iterator2[i])
         goto error;
      EASYDBUS_MEMCOPY (iterator2[i], iterator[i], 
                        strlen (iterator[i]) + 1);
      //memset (*iterator2, 0, strlen (*iterator)+1);
      //memcpy (iterator2[i], iterator[i], strlen (iterator[i]) + 1);
   }

   container->nel = nel;
   container->elem_type = EASYDBUS_ELTYPE_OBJECT_PATH;

   return 0;

 error:
   i--;
   for (; i > 0; i--) {

      if (iterator2[i])
         free (iterator2[i]);
   }
   free (container->p_data);
   return -1;
}

int
easydbus_array_add_signature_array (EasyDbus_container * container,
                                    unsigned int nel,
                                    char **signature_array)
{
   char **iterator, **iterator2 = NULL;
   int i = 0;

   if (nel == 0 || !signature_array || !container ||
       container->container_type != EASYDBUS_ELTYPE_ARRAY)
      return -1;

   if (container->nel)
      return -1;

   container->p_data = malloc (sizeof (char *[nel]));
   if (!container->p_data)
      return -1;

   memset (container->p_data, 0, nel);

   iterator = signature_array;
   iterator2 = (char **) container->p_data;

   for (i = 0; i < (int) nel; i++) {
      if (!iterator[i])
         goto error;
      iterator2[i] = (char *) malloc (strlen (iterator[i]) + 1);
      if (!iterator2[i])
         goto error;
      EASYDBUS_MEMCOPY (iterator2[i], iterator[i], 
                        strlen (iterator[i]) + 1);
      //memset (*iterator2, 0, strlen (*iterator)+1);
      //memcpy (iterator2[i], iterator[i], strlen (iterator[i]) + 1);
   }

   container->nel = nel;
   container->elem_type = EASYDBUS_ELTYPE_SIGNATURE;

   return 0;

 error:
   i--;
   for (; i > 0; i--) {

      if (iterator2[i])
         free (iterator2[i]);
   }
   free (container->p_data);
   return -1;
}

const EasyDbus_container *
easydbus_array_get_array (EasyDbus_container * array, unsigned int n)
{
   EasyDbus_elem *el = NULL;
   unsigned int i;

   if (!array || n == 0 || n > array->nel ||
       array->container_type != EASYDBUS_ELTYPE_ARRAY ||
       array->elem_type != EASYDBUS_ELTYPE_ARRAY)
      return NULL;

   // move to correct element
   for (i = 1, el = (struct EasyDbus_elem *) array->p_data;
        i < n; i++, el = el->next);

   return (el ? (const EasyDbus_container *) el->payload.p_container :
           NULL);
}

const EasyDbus_container *
easydbus_array_get_dict_entry (EasyDbus_container * array,
                               unsigned int n)
{
   EasyDbus_elem *el = NULL;
   unsigned int i;

   if (!array || n == 0 || n > array->nel ||
       array->container_type != EASYDBUS_ELTYPE_ARRAY ||
       array->elem_type != EASYDBUS_ELTYPE_DICT_ENTRY)
      return NULL;

   // move to correct element
   for (i = 1, el = (struct EasyDbus_elem *) array->p_data;
        i < n; i++, el = el->next);

   return (el ? (const EasyDbus_container *) el->payload.p_container :
           NULL);
}


const EasyDbus_container *
easydbus_array_get_variant (EasyDbus_container * array,
                            unsigned int n)
{
   EasyDbus_elem *el = NULL;
   unsigned int i;

   if (!array || n == 0 || n > array->nel ||
       array->container_type != EASYDBUS_ELTYPE_ARRAY ||
       array->elem_type != EASYDBUS_ELTYPE_VARIANT)
      return NULL;

   // move to correct element
   for (i = 1, el = (struct EasyDbus_elem *) array->p_data;
        i < n; i++, el = el->next);

   return (el ? (const EasyDbus_container *) el->payload.p_container :
           NULL);
}

const EasyDbus_container *
easydbus_array_get_struct (EasyDbus_container * array, unsigned int n)
{
   EasyDbus_elem *el = NULL;
   unsigned int i;

   if (!array || n == 0 || n > array->nel ||
       array->container_type != EASYDBUS_ELTYPE_ARRAY ||
       array->elem_type != EASYDBUS_ELTYPE_STRUCT)
      return NULL;

   // move to correct element
   for (i = 1, el = (struct EasyDbus_elem *) array->p_data;
        i < n; i++, el = el->next);

   return (el ?
           (const EasyDbus_container *) el->payload.p_container :
            NULL);
}

const char *
easydbus_array_get_byte_array (EasyDbus_container * array)
{
   if (!array ||
       array->container_type != EASYDBUS_ELTYPE_ARRAY ||
       array->elem_type != EASYDBUS_ELTYPE_BYTE)
      return NULL;

   return (const char *) array->p_data;
}

const char *
easydbus_array_get_boolean_array (EasyDbus_container * array)
{
   if (!array ||
       array->container_type != EASYDBUS_ELTYPE_ARRAY ||
       array->elem_type != EASYDBUS_ELTYPE_BOOLEAN)
      return NULL;

   return (const char *) array->p_data;
}

const short *
easydbus_array_get_i16_array (EasyDbus_container * array)
{
   if (!array ||
       array->container_type != EASYDBUS_ELTYPE_ARRAY ||
       array->elem_type != EASYDBUS_ELTYPE_INT16)
      return NULL;

   return (const short *) array->p_data;
}

const unsigned short *
easydbus_array_get_ui16_array (EasyDbus_container * array)
{
   if (!array ||
       array->container_type != EASYDBUS_ELTYPE_ARRAY ||
       array->elem_type != EASYDBUS_ELTYPE_UINT16)
      return NULL;

   return (const unsigned short *) array->p_data;
}


const int *
easydbus_array_get_i32_array (EasyDbus_container * array)
{
   if (!array ||
       array->container_type != EASYDBUS_ELTYPE_ARRAY ||
       array->elem_type != EASYDBUS_ELTYPE_INT32)
      return NULL;

   return (const int *) array->p_data;
}

const unsigned int *
easydbus_array_get_ui32_array (EasyDbus_container * array)
{
   if (!array ||
       array->container_type != EASYDBUS_ELTYPE_ARRAY ||
       array->elem_type != EASYDBUS_ELTYPE_UINT32)
      return NULL;

   return (const unsigned int *) array->p_data;
}

const long long *
easydbus_array_get_i64_array (EasyDbus_container * array)
{
   if (!array ||
       array->container_type != EASYDBUS_ELTYPE_ARRAY ||
       array->elem_type != EASYDBUS_ELTYPE_INT64)
      return NULL;

   return (const long long *) array->p_data;
}

const unsigned long long *
easydbus_array_get_ui64_array (EasyDbus_container * array)
{
   if (!array ||
       array->container_type != EASYDBUS_ELTYPE_ARRAY ||
       array->elem_type != EASYDBUS_ELTYPE_UINT64)
      return NULL;

   return (const unsigned long long *) array->p_data;
}

const double *
easydbus_array_get_double_array (EasyDbus_container * array)
{
   if (!array ||
       array->container_type != EASYDBUS_ELTYPE_ARRAY ||
       array->elem_type != EASYDBUS_ELTYPE_DOUBLE)
      return NULL;

   return (const double *) array->p_data;
}

const char **
easydbus_array_get_string_array (EasyDbus_container * array)
{
   if (!array ||
       array->container_type != EASYDBUS_ELTYPE_ARRAY ||
       array->elem_type != EASYDBUS_ELTYPE_STRING)
      return NULL;

   return (const char **) array->p_data;
}

const char **
easydbus_array_get_obj_path_array (EasyDbus_container * array)
{
   if (!array ||
       array->container_type != EASYDBUS_ELTYPE_ARRAY ||
       array->elem_type != EASYDBUS_ELTYPE_OBJECT_PATH)
      return NULL;

   return (const char **) array->p_data;
}

const char **
easydbus_array_get_signature_array (EasyDbus_container * array)
{
   if (!array ||
       array->container_type != EASYDBUS_ELTYPE_ARRAY ||
       array->elem_type != EASYDBUS_ELTYPE_SIGNATURE)
      return NULL;

   return (const char **) array->p_data;
}

// vim: ts=3 shiftwidth=3 expandtab

---