variant.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:  variant.c
 
  Description:  
 
  Version:  0.1
  Created:  06/10/07 20:17:05 CEST
  Revision:  none
 
  Author:   Daniele Rondina aka ge@@ru (geaaru@gmail.com) 
  License:  GPL 2.0
*/
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
// easydbus includes
#include "debug.h"
#include "utils.h"
#include "easydbus-core.h"

int
easydbus_variant_add_string (EasyDbus_container * container, 
                             char *string)
{
   int string_length = 0;

   if (container == NULL || string == NULL)
      return -1;

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

   if (container->nel)
      return -1;
   string_length = strlen (string) + 1;
   container->p_data = malloc (string_length);
   if (container->p_data == NULL)
      return -1;

   EASYDBUS_MEMCOPY (container->p_data, string, string_length);

   container->nel = 1;
   container->elem_type = EASYDBUS_ELTYPE_STRING;
   return 0;
}

int
easydbus_variant_add_obj_path (EasyDbus_container * container, 
                               char *string) 
{
   int string_length = 0;

   if (container == NULL || string == NULL)
      return -1;

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

   if (container->nel)
      return -1;
   string_length = strlen (string) + 1;
   container->p_data = malloc (string_length);
   if (container->p_data == NULL)
      return -1;

   EASYDBUS_MEMCOPY (container->p_data, string, string_length);

   container->nel = 1;
   container->elem_type = EASYDBUS_ELTYPE_OBJECT_PATH;
   return 0;
}


int
easydbus_variant_add_signature (EasyDbus_container * container, 
                                char *string) 
{
   int string_length = 0;

   if (container == NULL || string == NULL)
      return -1;

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

   if (container->nel)
      return -1;
   string_length = strlen (string) + 1;
   container->p_data = malloc (string_length);
   if (container->p_data == NULL)
      return -1;

   EASYDBUS_MEMCOPY (container->p_data, string, string_length);

   container->nel = 1;
   container->elem_type = EASYDBUS_ELTYPE_SIGNATURE;
   return 0;
}

int
easydbus_variant_add_i32 (EasyDbus_container * container, 
                          int i32) 
{
   int *temp;

   if (container == NULL)
      return -1;

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

   if (container->nel)
      return -1;
   temp = (int *) malloc (sizeof (int));
   if (temp == NULL)
      return -1;
   memset (temp, 0, sizeof (int));
   *temp = i32;
   container->p_data = (void *) temp;
   container->nel = 1;
   container->elem_type = EASYDBUS_ELTYPE_INT32;
   return 0;
}

int
easydbus_variant_add_ui32 (EasyDbus_container * container, 
                           unsigned int ui32) 
{
   unsigned int *temp;

   if (container == NULL)
      return -1;

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

   if (container->nel)
      return -1;
   temp = (unsigned int *) malloc (sizeof (int));
   if (temp == NULL)
      return -1;
   memset (temp, 0, sizeof (int));
   *temp = ui32;
   container->p_data = (void *) temp;
   container->nel = 1;
   container->elem_type = EASYDBUS_ELTYPE_UINT32;
   return 0;
}

int
easydbus_variant_add_i16 (EasyDbus_container * container, 
                          short i16)
{
   short *temp;

   if (container == NULL)
      return -1;

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

   if (container->nel)
      return -1;
   temp = (short *) malloc (sizeof (short));
   if (temp == NULL)
      return -1;
   memset (temp, 0, sizeof (short));
   *temp = i16;
   container->p_data = (void *) temp;
   container->nel = 1;
   container->elem_type = EASYDBUS_ELTYPE_INT16;
   return 0;
}

int
easydbus_variant_add_ui16 (EasyDbus_container * container,
                           unsigned short ui16)
{
   unsigned short *temp;

   if (container == NULL)
      return -1;

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

   if (container->nel)
      return -1;
   temp = (unsigned short *) malloc (sizeof (short));
   if (temp == NULL)
      return -1;
   memset (temp, 0, sizeof (short));
   *temp = ui16;
   container->p_data = (void *) temp;
   container->nel = 1;
   container->elem_type = EASYDBUS_ELTYPE_UINT16;
   return 0;
}

int
easydbus_variant_add_ui64 (EasyDbus_container * container,
                           unsigned long long ui64)
{
   unsigned long long *temp;

   if (container == NULL)
      return -1;

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

   if (container->nel)
      return -1;
   temp = (unsigned long long *) malloc (sizeof (long long));
   if (temp == NULL)
      return -1;
   memset (temp, 0, sizeof (long long));
   *temp = ui64;
   container->p_data = (void *) temp;
   container->nel = 1;
   container->elem_type = EASYDBUS_ELTYPE_UINT64;
   return 0;
}

int
easydbus_variant_add_i64 (EasyDbus_container * container,
                          long long i64)
{
   long long *temp;

   if (container == NULL)
      return -1;

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

   if (container->nel)
      return -1;
   temp = (long long *) malloc (sizeof (long long));
   if (temp == NULL)
      return -1;
   memset (temp, 0, sizeof (long long));
   *temp = i64;
   container->p_data = (void *) temp;
   container->nel = 1;
   container->elem_type = EASYDBUS_ELTYPE_INT64;
   return 0;
}


int
easydbus_variant_add_double (EasyDbus_container * container, double d)
{
   double *temp;

   if (container == NULL)
      return -1;

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

   if (container->nel)
      return -1;
   temp = (double *) malloc (sizeof (double));
   if (temp == NULL)
      return -1;
   memset (temp, 0, sizeof (double));
   *temp = d;
   container->p_data = (void *) temp;
   container->nel = 1;
   container->elem_type = EASYDBUS_ELTYPE_DOUBLE;
   return 0;
}

int
easydbus_variant_add_byte (EasyDbus_container * container, 
                           char byte)
{
   if (container == NULL)
      return -1;

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

   if (container->nel)
      return -1;
   container->p_data = malloc (1);
   if (container->p_data == NULL)
      return -1;
   memset (container->p_data, 0, 1);
   memcpy (container->p_data, &byte, 1);
   container->nel = 1;
   container->elem_type = EASYDBUS_ELTYPE_BYTE;
   return 0;
}

int
easydbus_variant_add_boolean (EasyDbus_container * container,
                              char boolean)
{
   if (container == NULL)
      return -1;

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

   if (container->nel)
      return -1;
   container->p_data = malloc (1);
   if (container->p_data == NULL)
      return -1;
   EASYDBUS_MEMCOPY (container->p_data, &boolean, 1);
   container->nel = 1;
   container->elem_type = EASYDBUS_ELTYPE_BOOLEAN;
   return 0;
}

const char *
easydbus_variant_get_string (EasyDbus_container * variant)
{
   if (variant == NULL ||
       variant->container_type != EASYDBUS_ELTYPE_VARIANT ||
       variant->elem_type != EASYDBUS_ELTYPE_STRING)
      return NULL;
   return (const char *) variant->p_data;
}

const char *
easydbus_variant_get_obj_path (EasyDbus_container * variant)
{
   if (variant == NULL ||
       variant->container_type != EASYDBUS_ELTYPE_VARIANT ||
       variant->elem_type != EASYDBUS_ELTYPE_OBJECT_PATH)
      return NULL;
   return (const char *) variant->p_data;
}

const char *
easydbus_variant_get_signature (EasyDbus_container * variant)
{
   if (variant == NULL ||
       variant->container_type != EASYDBUS_ELTYPE_VARIANT ||
       variant->elem_type != EASYDBUS_ELTYPE_SIGNATURE)
      return NULL;
   return (const char *) variant->p_data;
}

int
easydbus_variant_get_i32 (EasyDbus_container * variant)
{
   if (variant == NULL ||
       variant->container_type != EASYDBUS_ELTYPE_VARIANT ||
       variant->elem_type != EASYDBUS_ELTYPE_INT32)
      return -1;

   return (int) *((int *) variant->p_data);
}

unsigned int
easydbus_variant_get_ui32 (EasyDbus_container * variant)
{
   if (variant == NULL ||
       variant->container_type != EASYDBUS_ELTYPE_VARIANT ||
       variant->elem_type != EASYDBUS_ELTYPE_UINT32)
      return -1;

   return (unsigned int) *((unsigned int *) variant->p_data);
}

short
easydbus_variant_get_i16 (EasyDbus_container * variant)
{
   if (variant == NULL ||
       variant->container_type != EASYDBUS_ELTYPE_VARIANT ||
       variant->elem_type != EASYDBUS_ELTYPE_INT16)
      return -1;

   return (short) *((short *) variant->p_data);
}

unsigned short
easydbus_variant_get_ui16 (EasyDbus_container * variant)
{
   if (variant == NULL ||
       variant->container_type != EASYDBUS_ELTYPE_VARIANT ||
       variant->elem_type != EASYDBUS_ELTYPE_UINT16)
      return -1;

   return (unsigned short) *((unsigned short *) variant->p_data);
}

unsigned long long
easydbus_variant_get_ui64 (EasyDbus_container * variant)
{
   if (variant == NULL ||
       variant->container_type != EASYDBUS_ELTYPE_VARIANT ||
       variant->elem_type != EASYDBUS_ELTYPE_UINT64)
      return -1;

   return (unsigned long long)
      *((unsigned long long *) variant->p_data);
}

long long
easydbus_variant_get_i64 (EasyDbus_container * variant)
{
   if (variant == NULL ||
       variant->container_type != EASYDBUS_ELTYPE_VARIANT ||
       variant->elem_type != EASYDBUS_ELTYPE_INT64)
      return -1;

   return (long long)
      *((long long *) variant->p_data);
}

double
easydbus_variant_get_double (EasyDbus_container * variant)
{
   if (variant == NULL ||
       variant->container_type != EASYDBUS_ELTYPE_VARIANT ||
       variant->elem_type != EASYDBUS_ELTYPE_DOUBLE)
      return -1;

   return (double) *((double *) variant->p_data);
}

char
easydbus_variant_get_boolean (EasyDbus_container * variant)
{
   if (variant == NULL ||
       variant->container_type != EASYDBUS_ELTYPE_VARIANT ||
       variant->elem_type != EASYDBUS_ELTYPE_BOOLEAN)
      return -1;

   return (char) *((char *) variant->p_data);
}

char
easydbus_variant_get_byte (EasyDbus_container * variant)
{
   if (variant == NULL ||
       variant->container_type != EASYDBUS_ELTYPE_VARIANT ||
       variant->elem_type != EASYDBUS_ELTYPE_BYTE)
      return -1;

   return (char) *((char *) variant->p_data);
}
// vim: ts=3 shiftwidth=3 expandtab

---