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         if (type == BEAGLE_PROPERTY_TYPE_TEXT)
  54                 prop->is_searched = TRUE;
  55         else
  56                 prop->is_searched = FALSE;
  57
  58         prop->is_stored = TRUE;
  59
  60         return prop;
  61 }
  62
  63 /**
  64  * beagle_property_free:
  65  * @prop: a #BeagleProperty
  66  *
  67  * Frees the memory allocated for the #BeagleProperty.
  68  **/
  69 void
  70 beagle_property_free (BeagleProperty *prop)
  71 {
  72         g_return_if_fail (prop != NULL);
  73
  74         g_free (prop->key);
  75         g_free (prop->value);
  76         g_free (prop);
  77 }
  78
  79 /**
  80  * beagle_property_get_type:
  81  * @prop: a #BeagleProperty
  82  *
  83  * Fetches the type of the #BeagleProperty.
  84  *
  85  * Return value: the #BeaglePropertyType of the #BeagleProperty.
  86  **/
  87 BeaglePropertyType
  88 beagle_property_get_type (BeagleProperty *prop)
  89 {
  90         g_return_val_if_fail (prop != NULL, BEAGLE_PROPERTY_TYPE_UNKNOWN);
  91
  92         return prop->type;
  93 }
  94
  95 /**
  96  * beagle_property_set_type:
  97  * @prop: a #BeagleProperty
  98  * @type: a #BeaglePropertyType
  99  *
 100  * Sets the type of the given #BeagleProperty to @type.
 101  **/
 102 void
 103 beagle_property_set_type (BeagleProperty *prop, BeaglePropertyType type)
 104 {
 105         g_return_if_fail (prop != NULL);
 106
 107         prop->type = type;
 108 }
 109
 110 /**
 111  * beagle_property_get_key:
 112  * @prop: a #BeagleProperty
 113  *
 114  * Fetches the key of the #BeagleProperty.
 115  *
 116  * Return value: the key name of the #BeagleProperty.
 117  **/
 118 G_CONST_RETURN char *
 119 beagle_property_get_key (BeagleProperty *prop)
 120 {
 121         g_return_val_if_fail (prop != NULL, NULL);
 122
 123         return prop->key;
 124 }
 125
 126 /**
 127  * beagle_property_set_key:
 128  * @prop: a #BeagleProperty
 129  * @key: a string
 130  *
 131  * Sets the key of the given #BeagleProperty to @key.
 132  **/
 133 void
 134 beagle_property_set_key (BeagleProperty *prop, const char *key)
 135 {
 136         g_return_if_fail (prop != NULL);
 137
 138         g_free (prop->key);
 139         prop->key = g_strdup (key);
 140 }
 141
 142 /**
 143  * beagle_property_get_value:
 144  * @prop: a #BeagleProperty
 145  *
 146  * Fetches the value of the given #BeagleProperty.
 147  *
 148  * Return Value: the value of the #BeagleProperty.
 149  **/
 150 G_CONST_RETURN char *
 151 beagle_property_get_value (BeagleProperty *prop)
 152 {
 153         g_return_val_if_fail (prop != NULL, NULL);
 154
 155         return prop->value;
 156 }
 157
 158 /**
 159  * beagle_property_set_value:
 160  * @prop: a #BeagleProperty
 161  * @value: a string
 162  *
 163  * Sets the value of the given #BeagleProperty to @value.
 164  **/
 165 void
 166 beagle_property_set_value (BeagleProperty *prop, const char *value)
 167 {
 168         g_return_if_fail (prop != NULL);
 169
 170         g_free (prop->value);
 171         prop->key = g_strdup (value);
 172 }
 173
 174 /**
 175  * beagle_property_get_is_searched:
 176  * @prop: a #BeagleProperty
 177  *
 178  * Fetches whether the given #BeagleProperty is searched.
 179  *
 180  * Return value: whether the #BeagleProperty is searched.
 181  **/
 182 gboolean
 183 beagle_property_get_is_searched (BeagleProperty *prop)
 184 {
 185         g_return_val_if_fail (prop != NULL, FALSE);
 186
 187         return prop->is_searched;
 188 }
 189
 190 /**
 191  * beagle_property_set_is_searched:
 192  * @prop: a #BeagleProperty
 193  * @is_searched: a boolean
 194  *
 195  * Sets whether the given #BeagleProperty is searched.  By default, text properties
 196  * are searched and keyword properties are not searched.
 197  **/
 198 void
 199 beagle_property_set_is_searched (BeagleProperty *prop, gboolean is_searched)
 200 {
 201         g_return_if_fail (prop != NULL);
 202
 203         prop->is_searched = is_searched != FALSE;
 204 }
 205
 206 /**
 207  * beagle_property_get_is_mutable:
 208  * @prop: a #BeagleProperty
 209  *
 210  * Fetches whether the given #BeagleProperty is mutable.
 211  *
 212  * Return value: whether the #BeagleProperty is mutable.
 213  **/
 214 gboolean
 215 beagle_property_get_is_mutable (BeagleProperty *prop)
 216 {
 217         g_return_val_if_fail (prop != NULL, FALSE);
 218
 219         return prop->is_mutable;
 220 }
 221
 222 /**
 223  * beagle_property_set_is_mutable:
 224  * @prop: a #BeagleProperty
 225  * @is_mutable: a boolean
 226  *
 227  * Sets whether the given #BeagleProperty is mutable.
 228  **/
 229 void
 230 beagle_property_set_is_mutable (BeagleProperty *prop, gboolean is_mutable)
 231 {
 232         g_return_if_fail (prop != NULL);
 233
 234         prop->is_mutable = is_mutable != FALSE;
 235 }
 236
 237 /**
 238  * beagle_property_get_is_stored:
 239  * @prop: a #BeagleProperty
 240  *
 241  * Fetches whether the given #BeagleProperty is stored in the index, or just a
 242  * hint to filters.
 243  *
 244  * Return value: whether the #BeagleProperty is stored.
 245  **/
 246 gboolean
 247 beagle_property_get_is_stored (BeagleProperty *prop)
 248 {
 249         g_return_val_if_fail (prop != NULL, FALSE);
 250
 251         return prop->is_stored;
 252 }
 253
 254 /**
 255  * beagle_property_set_is_stored:
 256  * @prop: a #BeagleProperty
 257  * @is_stored: a boolean
 258  *
 259  * Sets whether the given #BeagleProperty is stored in the index, or just a
 260  * hint to filters.  By default, properties are stored.
 261  **/
 262 void
 263 beagle_property_set_is_stored (BeagleProperty *prop, gboolean is_stored)
 264 {
 265         g_return_if_fail (prop != NULL);
 266
 267         prop->is_stored = is_stored != FALSE;
 268 }
 269
 270 /**
 271  * Compares two BeagleProperty based on their keys.
 272  */
 273 int
 274 _beagle_property_compare (BeagleProperty *prop_a, BeagleProperty *prop_b)
 275 {
 276     return strcmp (prop_a->key, prop_b->key);
 277 }
 278
 279 /**
 280  * Compares a BeagleProperty (wrt its key) and another given key.
 281  * Useful when trying to search for a property with a given key
 282  * in a list of BeagleProperty elements.
 283  */
 284 int _beagle_property_key_compare (BeagleProperty *prop_a, char *key)
 285 {
 286     return strcmp (prop_a->key, key);
 287 }
 288
 289 static const char * const property_types[] = {
 290         NULL,
 291         "Text",
 292         "Keyword",
 293         "Date"
 294 };
 295
 296 static void
 297 prop_to_xml (gpointer value, gpointer user_data)
 298 {
 299         BeagleProperty *prop = value;
 300         char *tmp;
 301         GString *data = user_data;
 302
 303         if (prop->type <= BEAGLE_PROPERTY_TYPE_UNKNOWN ||
 304             prop->type >= BEAGLE_PROPERTY_TYPE_LAST)
 305                 return;
 306
 307         g_string_append (data, "<Property ");
 308
 309         tmp = g_markup_printf_escaped ("Type=\"%s\" IsSearched=\"%s\" IsMutable=\"%s\" "
 310                                        "IsStored=\"%s\" Key=\"%s\" Value=\"%s\"/>",
 311                                        property_types[prop->type],
 312                                        prop->is_searched ? "true" : "false",
 313                                        prop->is_mutable ? "true" : "false",
 314                                        prop->is_stored ? "true" : "false",
 315                                        prop->key, prop->value);
 316
 317         g_string_append (data, tmp);
 318         g_free (tmp);
 319 }
 320
 321 void
 322 _beagle_properties_to_xml (GSList *properties, GString *data)
 323 {
 324         g_string_append (data, "<Properties>");
 325
 326         if (properties != NULL)
 327                 g_slist_foreach (properties, prop_to_xml, data);
 328
 329         g_string_append (data, "</Properties>");
 330
 331 }