libbeagle/beagle/beagle-indexable.c

   1 /*
   2  * beagle-indexable.c
   3  *
   4  * Copyright (C) 2005 Novell, Inc.
   5  *
   6  */
   7
   8 /*
   9  * Permission is hereby granted, free of charge, to any person obtaining a
  10  * copy of this software and associated documentation files (the "Software"),
  11  * to deal in the Software without restriction, including without limitation
  12  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  13  * and/or sell copies of the Software, and to permit persons to whom the
  14  * Software is furnished to do so, subject to the following conditions:
  15  *
  16  * The above copyright notice and this permission notice shall be included in
  17  * all copies or substantial portions of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  20  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  22  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  23  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  24  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  25  * DEALINGS IN THE SOFTWARE.
  26  */
  27
  28 #include "beagle-indexable.h"
  29 #include "beagle-private.h"
  30 #include "beagle-timestamp.h"
  31
  32 struct _BeagleIndexable {
  33         BeagleIndexableType type;
  34
  35         char *uri;
  36         char *parent_uri;
  37         char *content_uri;
  38         char *hot_content_uri;
  39
  40         BeagleTimestamp *timestamp;
  41
  42         gboolean delete_content;
  43         gboolean crawled;
  44         gboolean no_content;
  45         gboolean cache_content;
  46
  47         BeagleIndexableFiltering filtering;
  48
  49         char *hit_type;
  50         char *mime_type;
  51         char *source;
  52
  53         GSList *properties;
  54 };
  55
  56 /**
  57  * beagle_indexable_new:
  58  * @uri: a string
  59  *
  60  * Creates a new #BeagleIndexable for the given @uri.
  61  *
  62  * Return value: the newly created #BeagleIndexable.
  63  **/
  64 BeagleIndexable *
  65 beagle_indexable_new (const char *uri)
  66 {
  67         BeagleIndexable *indexable;
  68
  69         g_return_val_if_fail (uri != NULL, NULL);
  70
  71         indexable = g_new0 (BeagleIndexable, 1);
  72         indexable->uri = g_strdup (uri);
  73
  74         // Use current time as the indexable timestamp, similar to C# API
  75         indexable->timestamp = beagle_timestamp_new_from_unix_time (time (NULL));
  76
  77         indexable->delete_content = FALSE;
  78         indexable->crawled = TRUE;
  79         indexable->no_content = FALSE;
  80         indexable->cache_content = TRUE;
  81
  82         indexable->properties = NULL;
  83
  84         indexable->hit_type = g_strdup ("File");
  85         indexable->type = BEAGLE_INDEXABLE_TYPE_ADD;
  86         indexable->filtering = BEAGLE_INDEXABLE_FILTERING_AUTOMATIC;
  87
  88         return indexable;
  89 }
  90
  91 /**
  92  * beagle_indexable_free:
  93  * @indexable: a #BeagleIndexable
  94  *
  95  * Frees the memory allocated by the #BeagleIndexable.
  96  **/
  97 void
  98 beagle_indexable_free (BeagleIndexable *indexable)
  99 {
 100         g_return_if_fail (indexable != NULL);
 101
 102         if (indexable->timestamp)
 103                 beagle_timestamp_free (indexable->timestamp);
 104
 105         g_free (indexable->uri);
 106         g_free (indexable->parent_uri);
 107         g_free (indexable->content_uri);
 108         g_free (indexable->hot_content_uri);
 109
 110         g_free (indexable->hit_type);
 111         g_free (indexable->mime_type);
 112         g_free (indexable->source);
 113
 114         if (indexable->properties) {
 115                 g_slist_foreach (indexable->properties, (GFunc) beagle_property_free, NULL);
 116                 g_slist_free (indexable->properties);
 117         }
 118
 119         g_free (indexable);
 120 }
 121
 122 /**
 123  * beagle_indexable_add_property:
 124  * @indexable: a #BeagleIndexable
 125  * @prop: a #BeagleProperty
 126  *
 127  * Adds the #BeagleProperty to the given #BeagleIndexable.
 128  **/
 129 void
 130 beagle_indexable_add_property (BeagleIndexable *indexable, BeagleProperty *prop)
 131 {
 132         g_return_if_fail (indexable != NULL);
 133         g_return_if_fail (prop != NULL);
 134
 135         indexable->properties = g_slist_insert_sorted (indexable->properties, prop, (GCompareFunc) _beagle_property_compare);
 136 }
 137
 138 /**
 139  * beagle_indexable_get_uri:
 140  * @indexable: a #BeagleIndexable
 141  *
 142  * Fetches the URI for the given #BeagleIndexable.
 143  *
 144  * Return value: the URI of the #BeagleIndexable.
 145  **/
 146 G_CONST_RETURN char *
 147 beagle_indexable_get_uri (BeagleIndexable *indexable)
 148 {
 149         g_return_val_if_fail (indexable != NULL, NULL);
 150
 151         return indexable->uri;
 152 }
 153
 154 /**
 155  * beagle_indexable_set_uri:
 156  * @indexable: a #BeagleIndexable
 157  * @uri: a string
 158  *
 159  * Sets the URI of the #BeagleIndexable to @uri.
 160  **/
 161 void
 162 beagle_indexable_set_uri (BeagleIndexable *indexable, const char *uri)
 163 {
 164         g_return_if_fail (indexable != NULL);
 165         g_return_if_fail (uri != NULL);
 166
 167         g_free (indexable->uri);
 168         indexable->uri = g_strdup (uri);
 169 }
 170
 171 /**
 172  * beagle_indexable_get_parent_uri:
 173  * @indexable: a #BeagleIndexable
 174  *
 175  * Fetches the URI for the given #BeagleIndexable.
 176  *
 177  * Return value: the parent URI of the #BeagleIndexable.
 178  **/
 179 G_CONST_RETURN char *
 180 beagle_indexable_get_parent_uri (BeagleIndexable *indexable)
 181 {
 182         g_return_val_if_fail (indexable != NULL, NULL);
 183
 184         return indexable->parent_uri;
 185 }
 186
 187 /**
 188  * beagle_indexable_set_parent_uri:
 189  * @indexable: a #BeagleIndexable
 190  * @parent_uri: a string
 191  *
 192  * Sets the parent URI of the #BeagleIndexable to @parent_uri.
 193  **/
 194 void
 195 beagle_indexable_set_parent_uri (BeagleIndexable *indexable, const char *parent_uri)
 196 {
 197         g_return_if_fail (indexable != NULL);
 198         g_return_if_fail (parent_uri != NULL);
 199
 200         g_free (indexable->parent_uri);
 201         indexable->parent_uri = g_strdup (parent_uri);
 202 }
 203
 204 /**
 205  * beagle_indexable_get_content_uri:
 206  * @indexable: a #BeagleIndexable
 207  *
 208  * Fetches the content URI for the given #BeagleIndexable.
 209  *
 210  * Return value: the content URI of the #BeagleIndexable.
 211  **/
 212 G_CONST_RETURN char *
 213 beagle_indexable_get_content_uri (BeagleIndexable *indexable)
 214 {
 215         g_return_val_if_fail (indexable != NULL, NULL);
 216
 217         return indexable->content_uri;
 218 }
 219
 220 /**
 221  * beagle_indexable_set_content_uri:
 222  * @indexable: a #BeagleIndexable
 223  * @content_uri: a string
 224  *
 225  * Sets the content URI of the given #BeagleIndexable to @content_uri.
 226  **/
 227 void
 228 beagle_indexable_set_content_uri (BeagleIndexable *indexable, const char *content_uri)
 229 {
 230         g_return_if_fail (indexable != NULL);
 231
 232         g_free (indexable->content_uri);
 233         indexable->content_uri = g_strdup (content_uri);
 234 }
 235
 236 /**
 237  * beagle_indexable_get_hot_content_uri:
 238  * @indexable: a #BeagleIndexable
 239  *
 240  * Fetches the hot content URI of the given #BeagleIndexable.
 241  *
 242  * Return value: the hot content URI of the #BeagleIndexable.
 243  **/
 244 G_CONST_RETURN char *
 245 beagle_indexable_get_hot_content_uri (BeagleIndexable *indexable)
 246 {
 247         g_return_val_if_fail (indexable != NULL, NULL);
 248
 249         return indexable->hot_content_uri;
 250 }
 251
 252 /**
 253  * beagle_indexable_set_hot_content_uri:
 254  * @indexable: a #BeagleIndexable
 255  * @hot_content_uri: a string
 256  *
 257  * Sets the hot content URI of the given #BeagleIndexable to @hot_content_uri.
 258  **/
 259 void
 260 beagle_indexable_set_hot_content_uri (BeagleIndexable *indexable, const char *hot_content_uri)
 261 {
 262         g_return_if_fail (indexable != NULL);
 263
 264         g_free (indexable->hot_content_uri);
 265         indexable->hot_content_uri = g_strdup (hot_content_uri);
 266 }
 267
 268 /**
 269  * beagle_indexable_get_delete_content:
 270  * @indexable: a #BeagleIndexable
 271  *
 272  * Fetches whether content of the given #BeagleIndexable should be deleted after it has been indexed.
 273  *
 274  * Return value: whether content should be deleted for the #BeagleIndexable.
 275  **/
 276 gboolean
 277 beagle_indexable_get_delete_content (BeagleIndexable *indexable)
 278 {
 279         g_return_val_if_fail (indexable != NULL, FALSE);
 280
 281         return indexable->delete_content;
 282 }
 283
 284 /**
 285  * beagle_indexable_set_delete_content:
 286  * @indexable: a #BeagleIndexable
 287  * @delete_content: a boolean
 288  *
 289  * Sets whether content of the given #BeagleIndexable should be deleted after it has been indexed.
 290  **/
 291 void
 292 beagle_indexable_set_delete_content (BeagleIndexable *indexable, gboolean delete_content)
 293 {
 294         g_return_if_fail (indexable != NULL);
 295
 296         indexable->delete_content = delete_content != FALSE;
 297 }
 298
 299 /**
 300  * beagle_indexable_get_crawled:
 301  * @indexable: a #BeagleIndexable
 302  *
 303  * Fetches whether the given #BeagleIndexable is in crawl mode.
 304  *
 305  * Return value: whether the #BeagleIndexable is crawled.
 306  **/
 307 gboolean
 308 beagle_indexable_get_crawled (BeagleIndexable *indexable)
 309 {
 310         g_return_val_if_fail (indexable != NULL, FALSE);
 311
 312         return indexable->crawled;
 313 }
 314
 315 /**
 316  * beagle_indexable_set_crawled:
 317  * @indexable: a #BeagleIndexable
 318  * @crawled: a boolean
 319  *
 320  * Sets whether the given #BeagleIndexable is in crawl mode.
 321  **/
 322 void
 323 beagle_indexable_set_crawled (BeagleIndexable *indexable, gboolean crawled)
 324 {
 325         g_return_if_fail (indexable != NULL);
 326
 327         indexable->crawled = crawled != FALSE;
 328 }
 329
 330 /**
 331  * beagle_indexable_get_no_content:
 332  * @indexable: a #BeagleIndexable
 333  *
 334  * Fetches whether the given #BeagleIndexable has no content.
 335  *
 336  * Return value: whether the #BeagleIndexable has no content.
 337  **/
 338 gboolean
 339 beagle_indexable_get_no_content (BeagleIndexable *indexable)
 340 {
 341         g_return_val_if_fail (indexable != NULL, FALSE);
 342
 343         return indexable->no_content;
 344 }
 345
 346 /**
 347  * beagle_indexable_set_no_content:
 348  * @indexable: a #BeagleIndexable
 349  * @no_content: a boolean
 350  *
 351  * Sets whether the given #BeagleIndexable has no content.
 352  **/
 353 void
 354 beagle_indexable_set_no_content (BeagleIndexable *indexable,
 355                                  gboolean         no_content)
 356 {
 357         g_return_if_fail (indexable != NULL);
 358
 359         indexable->no_content = no_content != FALSE;
 360 }
 361
 362
 363 /**
 364  * beagle_indexable_get_cache_content:
 365  * @indexable: a #BeagleIndexable
 366  *
 367  * Fetches whether the given #BeagleIndexable consists of cached contents.
 368  *
 369  * Return value: whether the #BeagleIndexable contains cached contents.
 370  **/
 371 gboolean
 372 beagle_indexable_get_cache_content (BeagleIndexable *indexable)
 373 {
 374         g_return_val_if_fail (indexable != NULL, FALSE);
 375
 376         return indexable->cache_content;
 377 }
 378
 379 /**
 380  * beagle_indexable_set_cache_content:
 381  * @indexable: a #BeagleIndexable
 382  * @cache_content: a boolean
 383  *
 384  * Sets whether the given #BeagleIndexable consists of cached contents.
 385  **/
 386 void
 387 beagle_indexable_set_cache_content (BeagleIndexable *indexable, gboolean cache_content)
 388 {
 389         g_return_if_fail (indexable != NULL);
 390
 391         indexable->cache_content = cache_content != FALSE;
 392 }
 393
 394 /**
 395  * beagle_indexable_get_type:
 396  * @indexable: a #BeagleIndexable
 397  *
 398  * Fetches the #BeagleIndexableType of the given #BeagleIndexable.
 399  *
 400  * Return value: Fetches the #BeagleIndexableType of the #BeagleIndexable.
 401  **/
 402 BeagleIndexableType
 403 beagle_indexable_get_type (BeagleIndexable *indexable)
 404 {
 405         g_return_val_if_fail (indexable != NULL, BEAGLE_INDEXABLE_TYPE_ADD);
 406
 407         return indexable->type;
 408 }
 409
 410 /**
 411  * beagle_indexable_set_type:
 412  * @indexable: a #BeagleIndexable
 413  * @filtering: a #BeagleIndexableType
 414  *
 415  * Sets the #BeagleIndexableType of the given #BeagleIndexable.
 416  **/
 417 void
 418 beagle_indexable_set_type (BeagleIndexable *indexable, BeagleIndexableType type)
 419 {
 420         g_return_if_fail (indexable != NULL);
 421         g_return_if_fail (type >= BEAGLE_INDEXABLE_TYPE_ADD && type <= BEAGLE_INDEXABLE_TYPE_PROPERTY_CHANGE);
 422
 423         indexable->type = type;
 424 }
 425
 426
 427 /**
 428  * beagle_indexable_get_filtering:
 429  * @indexable: a #BeagleIndexable
 430  *
 431  * Fetches the #BeagleIndexableFiltering of the given #BeagleIndexable.
 432  *
 433  * Return value: Fetches the #BeagleIndexableFiltering of the #BeagleIndexable.
 434  **/
 435 BeagleIndexableFiltering
 436 beagle_indexable_get_filtering (BeagleIndexable *indexable)
 437 {
 438         g_return_val_if_fail (indexable != NULL, BEAGLE_INDEXABLE_FILTERING_AUTOMATIC);
 439
 440         return indexable->filtering;
 441 }
 442
 443 /**
 444  * beagle_indexable_set_filtering:
 445  * @indexable: a #BeagleIndexable
 446  * @filtering: a #BeagleIndexableFiltering
 447  *
 448  * Sets the #BeagleIndexableFiltering of the given #BeagleIndexable.
 449  **/
 450 void
 451 beagle_indexable_set_filtering (BeagleIndexable *indexable, BeagleIndexableFiltering filtering)
 452 {
 453         g_return_if_fail (indexable != NULL);
 454         g_return_if_fail (filtering >= BEAGLE_INDEXABLE_FILTERING_AUTOMATIC && filtering <= BEAGLE_INDEXABLE_FILTERING_NEVER);
 455
 456         indexable->filtering = filtering;
 457 }
 458
 459 /**
 460  * beagle_indexable_get_hit_type:
 461  * @indexable: a #BeagleIndexable
 462  *
 463  * Fetches the hit type of the given #BeagleIndexable.
 464  *
 465  * Return value: the hit type of the #BeagleIndexable.
 466  **/
 467
 468 G_CONST_RETURN char *
 469 beagle_indexable_get_hit_type (BeagleIndexable *indexable)
 470 {
 471         g_return_val_if_fail (indexable != NULL, NULL);
 472
 473         return indexable->hit_type;
 474 }
 475
 476 /**
 477  * beagle_indexable_set_hit_type:
 478  * @indexable: a #BeagleIndexable
 479  * @hit_type: a string
 480  *
 481  * Sets the hit type of the given #BeagleIndexable to @hit_type.
 482  **/
 483 void
 484 beagle_indexable_set_hit_type (BeagleIndexable *indexable, const char *hit_type)
 485 {
 486         g_return_if_fail (indexable != NULL);
 487
 488         g_free (indexable->hit_type);
 489         indexable->hit_type = g_strdup (hit_type);
 490 }
 491
 492
 493 /**
 494  * beagle_indexable_get_mime_type:
 495  * @indexable: a #BeagleIndexable
 496  *
 497  * Fetches the mime type of the given #BeagleIndexable.
 498  *
 499  * Return value: the mime type of the #BeagleIndexable.
 500  **/
 501 G_CONST_RETURN char *
 502 beagle_indexable_get_mime_type (BeagleIndexable *indexable)
 503 {
 504         g_return_val_if_fail (indexable != NULL, NULL);
 505
 506         return indexable->mime_type;
 507 }
 508
 509 /**
 510  * beagle_indexable_set_mime_type:
 511  * @indexable: a #BeagleIndexable
 512  * @mime_type: a string
 513  *
 514  * Sets the mime type of the given #BeagleIndexable to @mime_type.
 515  **/
 516 void
 517 beagle_indexable_set_mime_type (BeagleIndexable *indexable, const char *mime_type)
 518 {
 519         g_return_if_fail (indexable != NULL);
 520
 521         g_free (indexable->mime_type);
 522         indexable->mime_type = g_strdup (mime_type);
 523 }
 524
 525 /**
 526  * beagle_indexable_get_source:
 527  * @indexable: a #BeagleIndexable
 528  *
 529  * Fetches the source of the given #BeagleIndexable.
 530  *
 531  * Return value: the source of the #BeagleIndexable.
 532  **/
 533 G_CONST_RETURN char *
 534 beagle_indexable_get_source (BeagleIndexable *indexable)
 535 {
 536         g_return_val_if_fail (indexable != NULL, NULL);
 537
 538         return indexable->source;
 539 }
 540
 541 /**
 542  * beagle_indexable_set_source:
 543  * @indexable: a #BeagleIndexable
 544  * @source: a string
 545  *
 546  * Sets the source of the given #BeagleIndexable to @source.
 547  **/
 548 void
 549 beagle_indexable_set_source (BeagleIndexable *indexable, const char *source)
 550 {
 551         g_return_if_fail (indexable != NULL);
 552
 553         g_free (indexable->source);
 554         indexable->source = g_strdup (source);
 555 }
 556
 557
 558 BeagleTimestamp *
 559 beagle_indexable_get_timestamp (BeagleIndexable *indexable)
 560 {
 561         g_return_val_if_fail (indexable != NULL, NULL);
 562
 563         return indexable->timestamp;
 564 }
 565
 566 void
 567 beagle_indexable_set_timestamp (BeagleIndexable *indexable,
 568                                 BeagleTimestamp *timestamp)
 569 {
 570         g_return_if_fail (indexable != NULL);
 571         g_return_if_fail (timestamp != NULL);
 572
 573         if (indexable->timestamp)
 574                 beagle_timestamp_free (indexable->timestamp);
 575
 576         indexable->timestamp = timestamp;
 577 }
 578
 579 void
 580 _beagle_indexable_to_xml (BeagleIndexable *indexable, GString *data)
 581 {
 582         char *tmp;
 583
 584         g_string_append_printf (data, "<Indexable");
 585
 586         if (indexable->timestamp) {
 587                 tmp = _beagle_timestamp_to_string (indexable->timestamp);
 588                 g_string_append_printf (data, " Timestamp=\"%s\"", tmp);
 589                 g_free (tmp);
 590         }
 591
 592         g_string_append_printf (data, " Uri=\"%s\"", indexable->uri);
 593
 594         if (indexable->parent_uri)
 595                 g_string_append_printf (data, " ParentUri=\"%s\"",
 596                                         indexable->parent_uri);
 597
 598         g_string_append_printf (data, " ContentUri=\"%s\" HotContentUri=\"%s\"",
 599                                 indexable->content_uri ? indexable->content_uri : indexable->uri,
 600                                 indexable->hot_content_uri ? indexable->hot_content_uri : "");
 601
 602         g_string_append_printf (data, " DeleteContent=\"%s\" Crawled=\"%s\" NoContent=\"%s\" "
 603                                 "CacheContent=\"%s\"",
 604                                 indexable->delete_content ? "true" : "false",
 605                                 indexable->crawled ? "true" : "false",
 606                                 indexable->no_content ? "true" : "false",
 607                                 indexable->cache_content ? "true" : "false");
 608
 609         switch (indexable->type) {
 610         case BEAGLE_INDEXABLE_TYPE_ADD:
 611                 tmp = "Add";
 612                 break;
 613         case BEAGLE_INDEXABLE_TYPE_REMOVE:
 614                 tmp = "Remove";
 615                 break;
 616         case BEAGLE_INDEXABLE_TYPE_PROPERTY_CHANGE:
 617                 tmp = "PropertyChange";
 618                 break;
 619         default:
 620                 g_assert_not_reached ();
 621         }
 622
 623         g_string_append_printf (data, " Type=\"%s\"", tmp);
 624
 625         switch (indexable->filtering) {
 626         case BEAGLE_INDEXABLE_FILTERING_ALWAYS:
 627                 tmp = "Always";
 628                 break;
 629         case BEAGLE_INDEXABLE_FILTERING_ALREADY_FILTERED:
 630                 tmp = "AlreadyFiltered";
 631                 break;
 632         case BEAGLE_INDEXABLE_FILTERING_AUTOMATIC:
 633                 tmp = "Automatic";
 634                 break;
 635         case BEAGLE_INDEXABLE_FILTERING_NEVER:
 636                 tmp = "Never";
 637                 break;
 638         default:
 639                 g_assert_not_reached ();
 640         }
 641
 642         g_string_append_printf (data, " Filtering=\"%s\"", tmp);
 643
 644         if (indexable->hit_type)
 645                 g_string_append_printf (data, " HitType=\"%s\"", indexable->hit_type);
 646
 647         if (indexable->mime_type)
 648                 g_string_append_printf (data, " MimeType=\"%s\"", indexable->mime_type);
 649
 650         if (indexable->source)
 651                 g_string_append_printf (data, " Source=\"%s\"", indexable->source);
 652
 653         g_string_append (data, ">");
 654
 655         _beagle_properties_to_xml (indexable->properties, data);
 656
 657         g_string_append (data, "</Indexable>");
 658 }