hal/hald/property.c

/***************************************************************************
 * CVSID: $Id$
 *
 * property.c : HalProperty methods
 *
 * Copyright (C) 2003 David Zeuthen, <david@fubar.dk>
 * Copyright (C) 2004 Novell, Inc.
 *
 * Licensed under the Academic Free License version 2.1
 *
 * 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 St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 **************************************************************************/

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include <string.h>
#include <glib.h>

#include "logger.h"
#include "property.h"

struct _HalProperty {
    char *key;

    int type;
    union {
        char *str_value;
        dbus_int32_t int_value;
        dbus_uint64_t uint64_value;
        dbus_bool_t bool_value;
        double double_value;
        GSList *strlist_value;
    } v;
    gboolean readonly;
    gboolean persistence;
    gboolean callout;
};

void
hal_property_free (HalProperty *prop)
{

    g_free (prop->key);

    if (prop->type == HAL_PROPERTY_TYPE_STRING) {
        g_free (prop->v.str_value);
    } else if (prop->type == HAL_PROPERTY_TYPE_STRLIST) {
        GSList *i;
        for (i = prop->v.strlist_value; i != NULL; i = g_slist_next (i)) {
            g_free (i->data);
        }
        g_slist_free (prop->v.strlist_value);
    }

    g_free (prop);
}

HalProperty *
hal_property_new_string (const char *key, const char *value)
{
    HalProperty *prop;
    char *endchar;
    gboolean validated = TRUE;

    prop = g_new0 (HalProperty, 1);

    prop->type = HAL_PROPERTY_TYPE_STRING;
    prop->key = g_strdup (key);
    prop->v.str_value = g_strdup (value != NULL ? value : "");

    while (!g_utf8_validate (prop->v.str_value, -1,
                 (const char **) &endchar)) {
        validated = FALSE;
        *endchar = '?';
    }

    if (!validated) {
        HAL_WARNING (("Key '%s' has invalid UTF-8 string '%s'",
                  key, prop->v.str_value));
    }

    return prop;
}

HalProperty *
hal_property_new_int (const char *key, dbus_int32_t value)
{
    HalProperty *prop;

    prop = g_new0 (HalProperty, 1);

    prop->type = HAL_PROPERTY_TYPE_INT32;
    prop->key = g_strdup (key);
    prop->v.int_value = value;

    return prop;
}

HalProperty *
hal_property_new_uint64 (const char *key, dbus_uint64_t value)
{
    HalProperty *prop;

    prop = g_new0 (HalProperty, 1);

    prop->type = HAL_PROPERTY_TYPE_UINT64;
    prop->key = g_strdup (key);
    prop->v.uint64_value = value;

    return prop;
}

HalProperty *
hal_property_new_bool (const char *key, dbus_bool_t value)
{
    HalProperty *prop;

    prop = g_new0 (HalProperty, 1);

    prop->type = HAL_PROPERTY_TYPE_BOOLEAN;
    prop->key = g_strdup (key);
    prop->v.bool_value = value;

    return prop;
}

HalProperty *
hal_property_new_double (const char *key, double value)
{
    HalProperty *prop;

    prop = g_new0 (HalProperty, 1);

    prop->type = HAL_PROPERTY_TYPE_DOUBLE;
    prop->key = g_strdup (key);
    prop->v.double_value = value;

    return prop;
}

const char *
hal_property_get_key (HalProperty *prop)
{
    g_return_val_if_fail (prop != NULL, NULL);

    return prop->key;
}

int
hal_property_get_type (HalProperty *prop)
{
    g_return_val_if_fail (prop != NULL, HAL_PROPERTY_TYPE_INVALID);

    return prop->type;
}

const char *
hal_property_get_string (HalProperty *prop)
{
    g_return_val_if_fail (prop != NULL, NULL);
    g_return_val_if_fail (prop->type == HAL_PROPERTY_TYPE_STRING, NULL);

    return prop->v.str_value;
}

dbus_int32_t
hal_property_get_int (HalProperty *prop)
{
    g_return_val_if_fail (prop != NULL, -1);
    g_return_val_if_fail (prop->type == HAL_PROPERTY_TYPE_INT32, -1);

    return prop->v.int_value;
}

dbus_uint64_t
hal_property_get_uint64 (HalProperty *prop)
{
    g_return_val_if_fail (prop != NULL, -1);
    g_return_val_if_fail (prop->type == HAL_PROPERTY_TYPE_UINT64, -1);

    return prop->v.uint64_value;
}

dbus_bool_t
hal_property_get_bool (HalProperty *prop)
{
    g_return_val_if_fail (prop != NULL, FALSE);
    g_return_val_if_fail (prop->type == HAL_PROPERTY_TYPE_BOOLEAN, FALSE);

    return prop->v.bool_value;
}

char *
hal_property_to_string (HalProperty *prop)
{
    g_return_val_if_fail (prop != NULL, NULL);

    switch (prop->type) {
    case HAL_PROPERTY_TYPE_STRING:
        return g_strdup (prop->v.str_value);
    case HAL_PROPERTY_TYPE_INT32:
        return g_strdup_printf ("%d", prop->v.int_value);
    case HAL_PROPERTY_TYPE_UINT64:
        return g_strdup_printf ("%llu", (long long unsigned int) prop->v.uint64_value);
    case HAL_PROPERTY_TYPE_BOOLEAN:
        /* FIXME: Maybe use 1 and 0 here instead? */
        return g_strdup (prop->v.bool_value ? "true" : "false");
    case HAL_PROPERTY_TYPE_DOUBLE:
        return g_strdup_printf ("%f", prop->v.double_value);
    case HAL_PROPERTY_TYPE_STRLIST:
    {
        GSList *iter;
        guint i;
        char buf[256];

        i = 0;
        buf[0] = '\0';
        for (iter = hal_property_get_strlist (prop);
             iter != NULL && i < sizeof(buf);
             iter = g_slist_next (iter)) {
            guint len;
            const char *str;

            str = (const char *) iter->data;
            len = strlen (str);
            strncpy (buf + i, str, sizeof(buf) - i);
            i += len;

            if (g_slist_next (iter) != NULL && i < sizeof(buf)) {
                buf[i] = '\t';
                i++;
            }
        }
        return g_strdup (buf);
    }

    default:
        return NULL;
    }
}

double
hal_property_get_double (HalProperty *prop)
{
    g_return_val_if_fail (prop != NULL, -1.0);
    g_return_val_if_fail (prop->type == HAL_PROPERTY_TYPE_DOUBLE, -1.0);

    return prop->v.double_value;
}

void
hal_property_set_string (HalProperty *prop, const char *value)
{
    char *endchar;
    gboolean validated = TRUE;

    g_return_if_fail (prop != NULL);
    g_return_if_fail (prop->type == HAL_PROPERTY_TYPE_STRING ||
              prop->type == HAL_PROPERTY_TYPE_INVALID);

    prop->type = HAL_PROPERTY_TYPE_STRING;
    if (prop->v.str_value != NULL)
        g_free (prop->v.str_value);
    prop->v.str_value = g_strdup (value);

    while (!g_utf8_validate (prop->v.str_value, -1,
                 (const char **) &endchar)) {
        validated = FALSE;
        *endchar = '?';
    }

    if (!validated) {
        HAL_WARNING (("Key '%s' has invalid UTF-8 string '%s'",
                  prop->key, value));
    }
}

void
hal_property_set_int (HalProperty *prop, dbus_int32_t value)
{
    g_return_if_fail (prop != NULL);
    g_return_if_fail (prop->type == HAL_PROPERTY_TYPE_INT32 ||
              prop->type == HAL_PROPERTY_TYPE_INVALID);

    prop->type = HAL_PROPERTY_TYPE_INT32;
    prop->v.int_value = value;
}

void
hal_property_set_uint64 (HalProperty *prop, dbus_uint64_t value)
{
    g_return_if_fail (prop != NULL);
    g_return_if_fail (prop->type == HAL_PROPERTY_TYPE_UINT64 ||
              prop->type == HAL_PROPERTY_TYPE_INVALID);

    prop->type = HAL_PROPERTY_TYPE_UINT64;
    prop->v.uint64_value = value;
}

void
hal_property_set_bool (HalProperty *prop, dbus_bool_t value)
{
    g_return_if_fail (prop != NULL);
    g_return_if_fail (prop->type == HAL_PROPERTY_TYPE_BOOLEAN ||
              prop->type == HAL_PROPERTY_TYPE_INVALID);

    prop->type = HAL_PROPERTY_TYPE_BOOLEAN;
    prop->v.bool_value = value;
}

void
hal_property_set_double (HalProperty *prop, double value)
{
    g_return_if_fail (prop != NULL);
    g_return_if_fail (prop->type == HAL_PROPERTY_TYPE_DOUBLE ||
              prop->type == HAL_PROPERTY_TYPE_INVALID);

    prop->type = HAL_PROPERTY_TYPE_DOUBLE;
    prop->v.double_value = value;
}

void
hal_property_set_attribute (HalProperty *prop,
                enum PropertyAttribute attr,
                gboolean val)
{
    g_return_if_fail (prop != NULL);

    switch (attr) {
    case READONLY:
        prop->readonly = val;
        break;
    case PERSISTENCE:
        prop->persistence = val;
        break;
    case CALLOUT:
        prop->callout = val;
        break;
    }
}

gboolean
hal_property_get_attribute (HalProperty *prop,
                enum PropertyAttribute attr)
{
    g_return_val_if_fail (prop != NULL, -1);

    switch (attr) {
    case READONLY:
        return prop->readonly;
    case PERSISTENCE:
        return prop->persistence;
    case CALLOUT:
        return prop->callout;
    default:
        return -1;
    }
}

HalProperty *
hal_property_new_strlist (const char *key)
{
    HalProperty *prop;

    prop = g_new0 (HalProperty, 1);

    prop->type = HAL_PROPERTY_TYPE_STRLIST;
    prop->key = g_strdup (key);
    prop->v.strlist_value = NULL;

    return prop;
}

GSList *
hal_property_get_strlist (HalProperty *prop)
{
    g_return_val_if_fail (prop != NULL, NULL);
    g_return_val_if_fail (prop->type == HAL_PROPERTY_TYPE_STRLIST, NULL);

    return prop->v.strlist_value;
}

gboolean
hal_property_strlist_append (HalProperty *prop, const char *value)
{
    g_return_val_if_fail (prop != NULL, FALSE);
    g_return_val_if_fail (prop->type == HAL_PROPERTY_TYPE_STRLIST, FALSE);

    prop->v.strlist_value = g_slist_append (prop->v.strlist_value, g_strdup (value));

    return TRUE;
}

gboolean
hal_property_strlist_prepend (HalProperty *prop, const char *value)
{
    g_return_val_if_fail (prop != NULL, FALSE);
    g_return_val_if_fail (prop->type == HAL_PROPERTY_TYPE_STRLIST, FALSE);

    prop->v.strlist_value = g_slist_prepend (prop->v.strlist_value, g_strdup (value));

    return TRUE;
}

gboolean
hal_property_strlist_remove_elem (HalProperty *prop, guint index)
{
    GSList *elem;

    g_return_val_if_fail (prop != NULL, FALSE);
    g_return_val_if_fail (prop->type == HAL_PROPERTY_TYPE_STRLIST, FALSE);

    if (prop->v.strlist_value == NULL)
        return FALSE;

    elem = g_slist_nth (prop->v.strlist_value, index);
    if (elem == NULL)
        return FALSE;

    g_free (elem->data);
    prop->v.strlist_value = g_slist_delete_link (prop->v.strlist_value, elem);
    return TRUE;
}


gboolean
hal_property_strlist_add (HalProperty  *prop, const char *value)
{
    GSList *elem;

    g_return_val_if_fail (prop != NULL, FALSE);
    g_return_val_if_fail (prop->type == HAL_PROPERTY_TYPE_STRLIST, FALSE);

    for (elem = prop->v.strlist_value; elem != NULL; elem = g_slist_next (elem)) {
        if (strcmp (elem->data, value) == 0) {
            return FALSE;
        }
    }

    return hal_property_strlist_append (prop, value);
}

gboolean
hal_property_strlist_remove (HalProperty *prop, const char *value)
{
    guint i;
    GSList *elem;

    g_return_val_if_fail (prop != NULL, FALSE);
    g_return_val_if_fail (prop->type == HAL_PROPERTY_TYPE_STRLIST, FALSE);

    for (elem = prop->v.strlist_value, i = 0; elem != NULL; elem = g_slist_next (elem), i++) {
        if (strcmp (elem->data, value) == 0) {
            return hal_property_strlist_remove_elem (prop, i);
        }
    }

    return FALSE;
}

gboolean
hal_property_strlist_clear (HalProperty *prop)
{
    GSList *elem;

    g_return_val_if_fail (prop != NULL, FALSE);
    g_return_val_if_fail (prop->type == HAL_PROPERTY_TYPE_STRLIST, FALSE);

    for (elem = prop->v.strlist_value; elem != NULL; elem = g_slist_next (elem)) {
        g_free (elem->data);
    }
    g_slist_free (prop->v.strlist_value);

    return FALSE;
}