container.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:  container.c
 
  Description:  
 
  Version:  0.1
  Created:  06/10/07 17:08:57 CEST
  Revision:  
    0 - created
    1 - insert doxygen documentation 07/10/30 (Ge@@ru)
 
  Author:   Daniele Rondina aka Ge@@ru (geaaru@gmial.com) 
  License:  GPL 2.0
*/

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

void
easydbus_container_free (EasyDbus_container * container)
{
   unsigned int i = 0;
   char **temp, **p_char;
   struct EasyDbus_elem *el, *el2;

   if (container == NULL)
      return;

   el = el2 = NULL;
   temp = p_char = NULL;

   switch (container->container_type) {
      case EASYDBUS_ELTYPE_ARRAY:
         switch (container->elem_type) {
            case EASYDBUS_ELTYPE_STRING:
            case EASYDBUS_ELTYPE_OBJECT_PATH:
            case EASYDBUS_ELTYPE_SIGNATURE:
               /* see if use p_data instead of temp */
               p_char = (char **) container->p_data;
               temp = p_char;
               for (i = 0; i < container->nel; i++) {
                  p_char++;
                  free (*temp);
                  temp = p_char;
               }
               free (container->p_data);
               break;
            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_BYTE:
            case EASYDBUS_ELTYPE_BOOLEAN:
            case EASYDBUS_ELTYPE_DOUBLE:
               free (container->p_data);
               break;
            case EASYDBUS_ELTYPE_VARIANT:
               el = el2 = (struct EasyDbus_elem *) container->p_data;
               while (el != NULL) {
                  el = el2->next;
                  EasyDbusDebug ("Free of variant element on array");
                  easydbus_elem_free (el2);
               }
               break;
            case EASYDBUS_ELTYPE_ARRAY:
               el = el2 = (struct EasyDbus_elem *) container->p_data;
               for (i = 0; i < container->nel; i++) {
                  el2++;
                  free_array_from_container (el);
                  el = el2;
               }
               free (container->p_data);
               break;
            case EASYDBUS_ELTYPE_STRUCT:
               el = el2 = (struct EasyDbus_elem *) container->p_data;
               i = 1;
               while (el != NULL) {
                  el = el2->next;
                  easydbus_elem_free (el2);
                  EasyDbusDebug ("Free of struct element %d", i++);
               }
               break;
            case EASYDBUS_ELTYPE_INVALID:
               EasyDbusDebug ("Error or empty array");
               break;
            case EASYDBUS_ELTYPE_DICT_ENTRY:
               el = (struct EasyDbus_elem *) container->p_data;
               if (el != NULL) {
                  if (el->next != NULL)
                     easydbus_elem_free (el->next);
                  easydbus_elem_free (el);
               }
               break;
         }
         break;
      case EASYDBUS_ELTYPE_VARIANT:
         switch (container->elem_type) {
            case EASYDBUS_ELTYPE_STRING:
            case EASYDBUS_ELTYPE_OBJECT_PATH:
            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_BYTE:
            case EASYDBUS_ELTYPE_BOOLEAN:
            case EASYDBUS_ELTYPE_DOUBLE:
            case EASYDBUS_ELTYPE_SIGNATURE:
               free (container->p_data);
               break;
            case EASYDBUS_ELTYPE_VARIANT:
            case EASYDBUS_ELTYPE_ARRAY:
            case EASYDBUS_ELTYPE_STRUCT:
            case EASYDBUS_ELTYPE_DICT_ENTRY:
            case EASYDBUS_ELTYPE_INVALID:
               EasyDbusDebug ("Error");
               break;
         }
         EasyDbusDebug ("Free of variant container");
         break;
      case EASYDBUS_ELTYPE_STRUCT:
         el = el2 = (struct EasyDbus_elem *) container->p_data;
         i = 1;
         while (el != NULL) {
            el = el2->next;
            easydbus_elem_free (el2);
            el2 = el;
            EasyDbusDebug ("Free of struct element %d", i++);
         }
         break;
      case EASYDBUS_ELTYPE_DICT_ENTRY:
         el = (struct EasyDbus_elem *) container->p_data;
         if (el != NULL) {
            if (el->next != NULL)
               easydbus_elem_free (el->next);
            easydbus_elem_free (el);
         }
         break;
      default:
         break;
   }
   if (container->signature != NULL)
      free (container->signature);
   free (container);
}

inline void
free_array_from_container (EasyDbus_elem * el)
{
   if (el == NULL)
      return;
   if (el->type == EASYDBUS_ELTYPE_ARRAY) {
      if (el->payload.p_container != NULL) {
         easydbus_container_free (el->payload.p_container);
      }
   }
}

EasyDbus_container *
easydbus_container_create_skeleton (enum el_type type)
{
   struct EasyDbus_container *container = NULL;

   switch (type) {
      case EASYDBUS_ELTYPE_VARIANT:
      case EASYDBUS_ELTYPE_ARRAY:
      case EASYDBUS_ELTYPE_STRUCT:
      case EASYDBUS_ELTYPE_DICT_ENTRY:
         container = (struct EasyDbus_container *)
            malloc (sizeof (struct EasyDbus_container));
         break;
      default:
         return NULL;
         break;
   }

   if (container != NULL) {
      memset (container, 0, sizeof (struct EasyDbus_container));
      container->container_type = type;
      container->elem_type = EASYDBUS_ELTYPE_INVALID;
      container->p_data = NULL;
      container->signature = NULL;
   }

   return container;
}



int 
easydbus_container_add_signature_to_empty_container
   (EasyDbus_container * container, ...) 
{
   va_list ap;
   enum el_type elem = EASYDBUS_ELTYPE_INVALID;
   struct easydbus_signature_elem_stack *list_elem;
   struct easydbus_signature_elem_stack *tmp_elem;
   char *signature = NULL;
   int i = 0;

   if (container == NULL)
      return -1;

   list_elem = tmp_elem = NULL;
   va_start (ap, container);

   /* recover data from input params list */
   elem = va_arg (ap, enum el_type);

   while (elem != EASYDBUS_ELTYPE_INVALID) {
      EasyDbusDebug ("elem %d", elem);
      i++;
      list_elem = easydbus_add_elem_to_stack (elem, list_elem);
      elem = va_arg (ap, enum el_type);
   }

   va_end (ap);

   while (list_elem != NULL) {
      if (easydbus_manage_list_signature (list_elem, &signature,
                                          EASYDBUS_SIGNATURE_NORMAL))
         goto error;
      tmp_elem = list_elem->next;
      easydbus_free_elem_from_stack (list_elem);
      list_elem = tmp_elem;
   }

   container->signature = signature;
   EasyDbusDebug ("signature added = %s\n", container->signature);
   EasyDbusDebug ("Elements founded = %d", i);

   return 0;
 error:
   EasyDbusDebug ("Error on create signature for" " empty container");
   if (signature != NULL)
      free (signature);
   while (list_elem != NULL) {
      tmp_elem = list_elem;
      list_elem = list_elem->next;
      easydbus_free_elem_from_stack (tmp_elem);
   }
   return -1;
}

inline enum el_type
easydbus_container_get_type (const EasyDbus_container * container)
{
   if (container == NULL)
      return EASYDBUS_ELTYPE_INVALID;
   return container->container_type;
}

inline enum el_type
easydbus_container_get_elem_type 
  (const EasyDbus_container * container)
{
   if (container == NULL)
      return EASYDBUS_ELTYPE_INVALID;
   return container->elem_type;
}

inline unsigned int
easydbus_container_get_nel (const EasyDbus_container * container)
{
   if (container == NULL)
      return -1;
   return container->nel;
}
// vim: ts=3 shiftwidth=3 expandtab

---