libbeagle/beagle/beagle-property.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8; -*- */
   2
   3 /*
   4  * beagle-property.c
   5  *
   6  * Copyright (C) 2005 Novell, Inc.
   7  *
   8  */
   9
  10 /*
  11  * Permission is hereby granted, free of charge, to any person obtaining a
  12  * copy of this software and associated documentation files (the "Software"),
  13  * to deal in the Software without restriction, including without limitation
  14  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  15  * and/or sell copies of the Software, and to permit persons to whom the
  16  * Software is furnished to do so, subject to the following conditions:
  17  *
  18  * The above copyright notice and this permission notice shall be included in
  19  * all copies or substantial portions of the Software.
  20  *
  21  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  22  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  23  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  24  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  25  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  26  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  27  * DEALINGS IN THE SOFTWARE.
  28  */
  29
  30 #include <string.h>
  31
  32 #include "beagle-property.h"
  33 #include "beagle-private.h"
  34
  35 /**
  36  * beagle_property_new:
  37  * @key: a string
  38  * @value: a string
  39  *
  40  * Creates a new #BeagleProperty for the key and value.
  41  *
  42  * Return value: a newly allocated #BeagleProperty.
  43  **/
  44 BeagleProperty *
  45 beagle_property_new (BeaglePropertyType type, const char *key, const char *value)
  46 {
  47         BeagleProperty *prop = g_new0 (BeagleProperty, 1);
  48
  49         prop->type = type;
  50         prop->key = g_strdup (key);
  51         prop->value = g_strdup (value);
  52
  53         prop->is_searched = TRUE;
  54         prop->is_stored = TRUE;
  55
  56         return prop;
  57 }
  58
  59 /**
  60  * beagle_property_free:
  61  * @prop: a #BeagleProperty
  62  *
  63  * Frees the memory allocated for the #BeagleProperty.
  64  **/
  65 void
  66 beagle_property_free (BeagleProperty *prop)
  67 {
  68         g_return_if_fail (prop != NULL);
  69
  70         g_free (prop->key);
  71         g_free (prop->value);
  72         g_free (prop);
  73 }
  74
  75 /**
  76  * beagle_property_get_type:
  77  * @prop: a #BeagleProperty
  78  *
  79  * Fetches the type of the #BeagleProperty.
  80  *
  81  * Return value: the #BeaglePropertyType of the #BeagleProperty.
  82  **/
  83 BeaglePropertyType
  84 beagle_property_get_type (BeagleProperty *prop)
  85 {
  86         g_return_val_if_fail (prop != NULL, BEAGLE_PROPERTY_TYPE_UNKNOWN);
  87
  88         return prop->type;
  89 }
  90
  91 /**
  92  * beagle_property_set_type:
  93  * @prop: a #BeagleProperty
  94  * @type: a #BeaglePropertyType
  95  *
  96  * Sets the type of the given #BeagleProperty to @type.
  97  **/
  98 void
  99 beagle_property_set_type (BeagleProperty *prop, BeaglePropertyType type)
 100 {
 101         g_return_if_fail (prop != NULL);
 102
 103         prop->type = type;
 104 }
 105
 106 /**
 107  * beagle_property_get_key:
 108  * @prop: a #BeagleProperty
 109  *
 110  * Fetches the key of the #BeagleProperty.
 111  *
 112  * Return value: the key name of the #BeagleProperty.
 113  **/
 114 G_CONST_RETURN char *
 115 beagle_property_get_key (BeagleProperty *prop)
 116 {
 117         g_return_val_if_fail (prop != NULL, NULL);
 118
 119         return prop->key;
 120 }
 121
 122 /**
 123  * beagle_property_set_key:
 124  * @prop: a #BeagleProperty
 125  * @key: a string
 126  *
 127  * Sets the key of the given #BeagleProperty to @key.
 128  **/
 129 void
 130 beagle_property_set_key (BeagleProperty *prop, const char *key)
 131 {
 132         g_return_if_fail (prop != NULL);
 133
 134         g_free (prop->key);
 135         prop->key = g_strdup (key);
 136 }
 137
 138 /**
 139  * beagle_property_get_value:
 140  * @prop: a #BeagleProperty
 141  *
 142  * Fetches the value of the given #BeagleProperty.
 143  *
 144  * Return Value: the value of the #BeagleProperty.
 145  **/
 146 G_CONST_RETURN char *
 147 beagle_property_get_value (BeagleProperty *prop)
 148 {
 149         g_return_val_if_fail (prop != NULL, NULL);
 150
 151         return prop->value;
 152 }
 153
 154 /**
 155  * beagle_property_set_value:
 156  * @prop: a #BeagleProperty
 157  * @value: a string
 158  *
 159  * Sets the value of the given #BeagleProperty to @value.
 160  **/
 161 void
 162 beagle_property_set_value (BeagleProperty *prop, const char *value)
 163 {
 164         g_return_if_fail (prop != NULL);
 165
 166         g_free (prop->value);
 167         prop->key = g_strdup (value);
 168 }
 169
 170 /**
 171  * beagle_property_get_is_searched:
 172  * @prop: a #BeagleProperty
 173  *
 174  * Fetches whether the given #BeagleProperty is searched.
 175  *
 176  * Return value: whether the #BeagleProperty is searched.
 177  **/
 178 gboolean
 179 beagle_property_get_is_searched (BeagleProperty *prop)
 180 {
 181         g_return_val_if_fail (prop != NULL, FALSE);
 182
 183         return prop->is_searched;
 184 }
 185
 186 /**
 187  * beagle_property_set_is_searched:
 188  * @prop: a #BeagleProperty
 189  * @is_searched: a boolean
 190  *
 191  * Sets whether the given #BeagleProperty is searched.  By default, properties
 192  * are searched.
 193  **/
 194 void
 195 beagle_property_set_is_searched (BeagleProperty *prop, gboolean is_searched)
 196 {
 197         g_return_if_fail (prop != NULL);
 198
 199         prop->is_searched = is_searched != FALSE;
 200 }
 201
 202 /**
 203  * beagle_property_get_is_mutable:
 204  * @prop: a #BeagleProperty
 205  *
 206  * Fetches whether the given #BeagleProperty is mutable.
 207  *
 208  * Return value: whether the #BeagleProperty is mutable.
 209  **/
 210 gboolean
 211 beagle_property_get_is_mutable (BeagleProperty *prop)
 212 {
 213         g_return_val_if_fail (prop != NULL, FALSE);
 214
 215         return prop->is_mutable;
 216 }
 217
 218 /**
 219  * beagle_property_set_is_mutable:
 220  * @prop: a #BeagleProperty
 221  * @is_mutable: a boolean
 222  *
 223  * Sets whether the given #BeagleProperty is mutable.
 224  **/
 225 void
 226 beagle_property_set_is_mutable (BeagleProperty *prop, gboolean is_mutable)
 227 {
 228         g_return_if_fail (prop != NULL);
 229
 230         prop->is_mutable = is_mutable != FALSE;
 231 }
 232
 233 /**
 234  * beagle_property_get_is_stored:
 235  * @prop: a #BeagleProperty
 236  *
 237  * Fetches whether the given #BeagleProperty is stored in the index, or just a
 238  * hint to filters.
 239  *
 240  * Return value: whether the #BeagleProperty is stored.
 241  **/
 242 gboolean
 243 beagle_property_get_is_stored (BeagleProperty *prop)
 244 {
 245         g_return_val_if_fail (prop != NULL, FALSE);
 246
 247         return prop->is_stored;
 248 }
 249
 250 /**
 251  * beagle_property_set_is_stored:
 252  * @prop: a #BeagleProperty
 253  * @is_stored: a boolean
 254  *
 255  * Sets whether the given #BeagleProperty is stored in the index, or just a
 256  * hint to filters.  By default, properties are stored.
 257  **/
 258 void
 259 beagle_property_set_is_stored (BeagleProperty *prop, gboolean is_stored)
 260 {
 261         g_return_if_fail (prop != NULL);
 262
 263         prop->is_stored = is_stored != FALSE;
 264 }
 265
 266 /**
 267  * Compares two BeagleProperty based on their keys.
 268  */
 269 int
 270 _beagle_property_compare (BeagleProperty *prop_a, BeagleProperty *prop_b)
 271 {
 272     return strcmp (prop_a->key, prop_b->key);
 273 }
 274
 275 /**
 276  * Compares a BeagleProperty (wrt its key) and another given key.
 277  * Useful when trying to search for a property with a given key
 278  * in a list of BeagleProperty elements.
 279  */
 280 int _beagle_property_key_compare (BeagleProperty *prop_a, char *key)
 281 {
 282     return strcmp (prop_a->key, key);
 283 }
 284
 285 static const char * const property_types[] = {
 286         NULL,
 287         "Text",
 288         "Keyword",
 289         "Date"
 290 };
 291
 292 static void
 293 prop_to_xml (gpointer value, gpointer user_data)
 294 {
 295         BeagleProperty *prop = value;
 296         char *tmp;
 297         GString *data = user_data;
 298
 299         if (prop->type <= BEAGLE_PROPERTY_TYPE_UNKNOWN ||
 300             prop->type >= BEAGLE_PROPERTY_TYPE_LAST)
 301                 return;
 302
 303         g_string_append (data, "<Property ");
 304
 305         tmp = g_markup_printf_escaped ("Type=\"%s\" isSearched=\"%s\" isMutable=\"%s\" "
 306                                        "Key=\"%s\" Value=\"%s\"/>",
 307                                        property_types[prop->type],
 308                                        prop->is_searched ? "true" : "false",
 309                                        prop->is_mutable ? "true" : "false",
 310                                        prop->key, prop->value);
 311
 312         g_string_append (data, tmp);
 313         g_free (tmp);
 314 }
 315
 316 void
 317 _beagle_properties_to_xml (GSList *properties, GString *data)
 318 {
 319         g_string_append (data, "<Properties>");
 320
 321         if (properties != NULL)
 322                 g_slist_foreach (properties, prop_to_xml, data);
 323
 324         g_string_append (data, "</Properties>");
 325
 326 }