libbeagle/beagle/beagle-query.c

   1 /*
   2  * beagle-query.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 <stdlib.h>
  29 #include <sys/types.h>
  30 #include <sys/socket.h>
  31 #include <sys/un.h>
  32
  33 #include "beagle-finished-response.h"
  34 #include "beagle-hits-added-response.h"
  35 #include "beagle-hits-subtracted-response.h"
  36 #include "beagle-marshal.h"
  37 #include "beagle-query.h"
  38 #include "beagle-query-part.h"
  39 #include "beagle-query-part-human.h"
  40 #include "beagle-query-part-or.h"
  41 #include "beagle-query-part-property.h"
  42 #include "beagle-search-term-response.h"
  43 #include "beagle-private.h"
  44
  45 typedef struct {
  46         GSList *parts;      /* of BeagleQueryPart */
  47         GSList *mime_types; /* of string */
  48         GSList *hit_types;  /* of string */
  49         GSList *sources;    /* of string */
  50         int max_hits;
  51
  52         /* These are extracted from the BeagleSearchTermResponse */
  53         GSList *exact_text;   /* of string */
  54         GSList *stemmed_text; /* of string */
  55
  56         BeagleQueryDomain domain;
  57 } BeagleQueryPrivate;
  58
  59 #define BEAGLE_QUERY_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), BEAGLE_TYPE_QUERY, BeagleQueryPrivate))
  60
  61 enum {
  62         HITS_ADDED,
  63         HITS_SUBTRACTED,
  64         FINISHED,
  65         LAST_SIGNAL
  66 };
  67
  68 static GObjectClass *parent_class = NULL;
  69 static guint signals [LAST_SIGNAL] = { 0 };
  70
  71 static void
  72 query_set_search_terms (BeagleQuery *query, BeagleSearchTermResponse *response)
  73 {
  74         BeagleQueryPrivate *priv = BEAGLE_QUERY_GET_PRIVATE (query);
  75
  76         priv->exact_text = _beagle_search_term_response_get_exact_text (response);
  77         priv->stemmed_text = _beagle_search_term_response_get_stemmed_text (response);
  78 }
  79
  80 static GString *
  81 beagle_query_to_xml (BeagleRequest *request, GError **err)
  82 {
  83         BeagleQueryPrivate *priv = BEAGLE_QUERY_GET_PRIVATE (request);
  84         GString *data = g_string_new (NULL);
  85         GString *sub_data;
  86         BeagleQueryPartOr *or_part;
  87         GSList *iter;
  88         gboolean first = TRUE;
  89
  90         _beagle_request_append_standard_header (data, "Query");
  91
  92         g_string_append_len (data, "<Parts>", 7);
  93
  94         if (priv->mime_types != NULL) {
  95                 or_part = beagle_query_part_or_new ();
  96
  97                 for (iter = priv->mime_types; iter!= NULL; iter = iter->next) {
  98                         BeagleQueryPartProperty *prop_part = beagle_query_part_property_new ();
  99
 100                         beagle_query_part_property_set_property_type (prop_part, BEAGLE_PROPERTY_TYPE_KEYWORD);
 101                         beagle_query_part_property_set_key (prop_part, "beagle:MimeType");
 102                         beagle_query_part_property_set_value (prop_part, (const char *) iter->data);
 103
 104                         beagle_query_part_or_add_subpart (or_part, BEAGLE_QUERY_PART (prop_part));
 105                 }
 106
 107                 sub_data = _beagle_query_part_to_xml (BEAGLE_QUERY_PART (or_part));
 108                 g_string_append_len (data, sub_data->str, sub_data->len);
 109                 g_string_free (sub_data, TRUE);
 110                 g_object_unref (or_part);
 111         }
 112
 113         if (priv->hit_types != NULL) {
 114                 or_part = beagle_query_part_or_new ();
 115
 116                 for (iter = priv->hit_types; iter!= NULL; iter = iter->next) {
 117                         BeagleQueryPartProperty *prop_part = beagle_query_part_property_new ();
 118
 119                         beagle_query_part_property_set_property_type (prop_part, BEAGLE_PROPERTY_TYPE_KEYWORD);
 120                         beagle_query_part_property_set_key (prop_part, "beagle:HitType");
 121                         beagle_query_part_property_set_value (prop_part, (const char *) iter->data);
 122
 123                         beagle_query_part_or_add_subpart (or_part, BEAGLE_QUERY_PART (prop_part));
 124                 }
 125
 126                 sub_data = _beagle_query_part_to_xml (BEAGLE_QUERY_PART (or_part));
 127                 g_string_append_len (data, sub_data->str, sub_data->len);
 128                 g_string_free (sub_data, TRUE);
 129                 g_object_unref (or_part);
 130         }
 131
 132         if (priv->sources != NULL) {
 133                 or_part = beagle_query_part_or_new ();
 134
 135                 for (iter = priv->sources; iter!= NULL; iter = iter->next) {
 136                         BeagleQueryPartProperty *prop_part = beagle_query_part_property_new ();
 137
 138                         beagle_query_part_property_set_property_type (prop_part, BEAGLE_PROPERTY_TYPE_KEYWORD);
 139                         beagle_query_part_property_set_key (prop_part, "beagle:Source");
 140                         beagle_query_part_property_set_value (prop_part, (const char *) iter->data);
 141
 142                         beagle_query_part_or_add_subpart (or_part, BEAGLE_QUERY_PART (prop_part));
 143                 }
 144
 145                 sub_data = _beagle_query_part_to_xml (BEAGLE_QUERY_PART (or_part));
 146                 g_string_append_len (data, sub_data->str, sub_data->len);
 147                 g_string_free (sub_data, TRUE);
 148                 g_object_unref (or_part);
 149         }
 150
 151         for (iter = priv->parts; iter != NULL; iter = iter->next) {
 152                 BeagleQueryPart *part = (BeagleQueryPart *) iter->data;
 153
 154                 sub_data = _beagle_query_part_to_xml (part);
 155                 g_string_append_len (data, sub_data->str, sub_data->len);
 156                 g_string_free (sub_data, TRUE);
 157         }
 158
 159         g_string_append_len (data, "</Parts>", 8);
 160
 161         g_string_append_len (data, "<MimeTypes>", 11);
 162
 163         for (iter = priv->mime_types; iter != NULL; iter = iter->next) {
 164                 const char *mime_type = (const char *) iter->data;
 165
 166                 g_string_append_printf (data, "<MimeType>%s</MimeType>", mime_type);
 167         }
 168
 169         g_string_append_len (data, "</MimeTypes>", 12);
 170
 171         g_string_append_len (data, "<HitTypes>", 10);
 172
 173         for (iter = priv->hit_types; iter != NULL; iter = iter->next) {
 174                 const char *hit_type = (const char *) iter->data;
 175
 176                 g_string_append_printf (data, "<HitType>%s</HitType>", hit_type);
 177         }
 178
 179         g_string_append_len (data, "</HitTypes>", 11);
 180
 181         g_string_append_len (data, "<Sources>", 9);
 182
 183         for (iter = priv->sources; iter != NULL; iter = iter->next) {
 184                 const char *source = (const char *) iter->data;
 185
 186                 g_string_append_printf (data, "<Source>%s</Source>", source);
 187         }
 188
 189         g_string_append_len (data, "</Sources>", 10);
 190
 191         g_string_append_len (data, "<QueryDomain>", 13);
 192
 193         if (priv->domain & BEAGLE_QUERY_DOMAIN_LOCAL) {
 194                 g_string_append_len (data, "Local", 5);
 195                 first = FALSE;
 196         }
 197
 198         if (priv->domain & BEAGLE_QUERY_DOMAIN_SYSTEM) {
 199                 if (!first)
 200                         g_string_append_c (data, ' ');
 201
 202                 g_string_append_len (data, "System", 6);
 203                 first = FALSE;
 204         }
 205
 206         if (priv->domain & BEAGLE_QUERY_DOMAIN_NEIGHBORHOOD) {
 207                 if (!first)
 208                         g_string_append_c (data, ' ');
 209
 210                 g_string_append_len (data, "Neighborhood", 12);
 211                 first = FALSE;
 212         }
 213
 214         if (priv->domain & BEAGLE_QUERY_DOMAIN_GLOBAL) {
 215                 if (!first)
 216                         g_string_append_c (data, ' ');
 217
 218                 g_string_append_len (data, "Global", 6);
 219         }
 220
 221         g_string_append_len (data, "</QueryDomain>", 14);
 222
 223         g_string_append_printf (data, "<MaxHits>%d</MaxHits>", priv->max_hits);
 224
 225         _beagle_request_append_standard_footer (data);
 226
 227         return data;
 228 }
 229
 230 static void
 231 beagle_query_response (BeagleRequest *request, BeagleResponse *response)
 232 {
 233         if (BEAGLE_IS_SEARCH_TERM_RESPONSE (response)) {
 234                 query_set_search_terms (BEAGLE_QUERY (request),
 235                                         BEAGLE_SEARCH_TERM_RESPONSE (response));
 236         } else if (BEAGLE_IS_HITS_ADDED_RESPONSE (response))
 237                 g_signal_emit (request, signals[HITS_ADDED], 0, response);
 238         else if (BEAGLE_IS_HITS_SUBTRACTED_RESPONSE (response))
 239                 g_signal_emit (request, signals[HITS_SUBTRACTED], 0, response);
 240         else if (BEAGLE_IS_FINISHED_RESPONSE (response))
 241                 g_signal_emit (request, signals[FINISHED], 0, response);
 242
 243 }
 244
 245
 246 G_DEFINE_TYPE (BeagleQuery, beagle_query, BEAGLE_TYPE_REQUEST)
 247
 248 static void
 249 beagle_query_finalize (GObject *obj)
 250 {
 251         BeagleQueryPrivate *priv = BEAGLE_QUERY_GET_PRIVATE (obj);
 252
 253         g_slist_foreach (priv->parts, (GFunc) g_object_unref, NULL);
 254         g_slist_free (priv->parts);
 255
 256         g_slist_foreach (priv->mime_types, (GFunc) g_free, NULL);
 257         g_slist_free (priv->mime_types);
 258
 259         g_slist_foreach (priv->hit_types, (GFunc) g_free, NULL);
 260         g_slist_free (priv->hit_types);
 261
 262         g_slist_foreach (priv->sources, (GFunc) g_free, NULL);
 263         g_slist_free (priv->sources);
 264
 265         g_slist_foreach (priv->exact_text, (GFunc) g_free, NULL);
 266         g_slist_free (priv->exact_text);
 267
 268         g_slist_foreach (priv->stemmed_text, (GFunc) g_free, NULL);
 269         g_slist_free (priv->stemmed_text);
 270
 271
 272         if (G_OBJECT_CLASS (parent_class)->finalize)
 273                 G_OBJECT_CLASS (parent_class)->finalize (obj);
 274 }
 275
 276 static void
 277 beagle_query_class_init (BeagleQueryClass *klass)
 278 {
 279         GObjectClass *obj_class = G_OBJECT_CLASS (klass);
 280         BeagleRequestClass *request_class = BEAGLE_REQUEST_CLASS (klass);
 281
 282         parent_class = g_type_class_peek_parent (klass);
 283
 284         obj_class->finalize = beagle_query_finalize;
 285         request_class->to_xml = beagle_query_to_xml;
 286
 287         request_class->response = beagle_query_response;
 288
 289         signals [HITS_ADDED] =
 290                 g_signal_new ("hits_added",
 291                               G_TYPE_FROM_CLASS (klass),
 292                               G_SIGNAL_RUN_LAST,
 293                               G_STRUCT_OFFSET (BeagleQueryClass, hits_added),
 294                               NULL, NULL,
 295                               g_cclosure_marshal_VOID__OBJECT,
 296                               G_TYPE_NONE, 1,
 297                               BEAGLE_TYPE_HITS_ADDED_RESPONSE);
 298
 299         signals [HITS_SUBTRACTED] =
 300                 g_signal_new ("hits_subtracted",
 301                               G_TYPE_FROM_CLASS (klass),
 302                               G_SIGNAL_RUN_LAST,
 303                               G_STRUCT_OFFSET (BeagleQueryClass, hits_subtracted),
 304                               NULL, NULL,
 305                               g_cclosure_marshal_VOID__OBJECT,
 306                               G_TYPE_NONE, 1,
 307                               BEAGLE_TYPE_HITS_SUBTRACTED_RESPONSE);
 308
 309         signals [FINISHED] =
 310                 g_signal_new ("finished",
 311                               G_TYPE_FROM_CLASS (klass),
 312                               G_SIGNAL_RUN_LAST,
 313                               G_STRUCT_OFFSET (BeagleQueryClass, finished),
 314                               NULL, NULL,
 315                               g_cclosure_marshal_VOID__OBJECT,
 316                               G_TYPE_NONE, 1,
 317                               BEAGLE_TYPE_FINISHED_RESPONSE);
 318
 319         g_type_class_add_private (klass, sizeof (BeagleQueryPrivate));
 320
 321         _beagle_request_class_set_response_types (request_class,
 322                                                   "HitsAddedResponse",
 323                                                   BEAGLE_TYPE_HITS_ADDED_RESPONSE,
 324                                                   "HitsSubtractedResponse",
 325                                                   BEAGLE_TYPE_HITS_SUBTRACTED_RESPONSE,
 326                                                   "FinishedResponse",
 327                                                   BEAGLE_TYPE_FINISHED_RESPONSE,
 328                                                   "SearchTermResponse",
 329                                                   BEAGLE_TYPE_SEARCH_TERM_RESPONSE,
 330                                                   NULL);
 331 }
 332
 333 static void
 334 beagle_query_init (BeagleQuery *query)
 335 {
 336         BeagleQueryPrivate *priv = BEAGLE_QUERY_GET_PRIVATE (query);
 337
 338         priv->max_hits = 100;
 339
 340         /* FIXME: This is a good default when on an airplane. */
 341         priv->domain = BEAGLE_QUERY_DOMAIN_LOCAL | BEAGLE_QUERY_DOMAIN_SYSTEM;
 342 }
 343
 344 /**
 345  * beagle_query_new:
 346  *
 347  * Creates a new #BeagleQuery.
 348  *
 349  * Return value: the newly created #BeagleQuery.
 350  **/
 351 BeagleQuery *
 352 beagle_query_new (void)
 353 {
 354         BeagleQuery *query = g_object_new (BEAGLE_TYPE_QUERY, 0);
 355
 356         return query;
 357 }
 358
 359 /**
 360  * beagle_query_add_part:
 361  * @query: a #BeagleQuery
 362  * @part: a #BeagleQueryPart
 363  *
 364  * Adds a #BeagleQueryPart to the given #BeagleQuery.
 365  **/
 366 void
 367 beagle_query_add_part (BeagleQuery *query, BeagleQueryPart *part)
 368 {
 369         BeagleQueryPrivate *priv = BEAGLE_QUERY_GET_PRIVATE (query);
 370
 371         g_return_if_fail (BEAGLE_IS_QUERY (query));
 372
 373         priv->parts = g_slist_append (priv->parts, part);
 374 }
 375
 376 /**
 377  * beagle_query_add_text:
 378  * @query: a #BeagleQuery
 379  * @str: a string
 380  *
 381  * Adds a text part to the given #BeagleQuery.
 382  **/
 383 void
 384 beagle_query_add_text (BeagleQuery *query, const char *str)
 385 {
 386         BeagleQueryPartHuman *part;
 387
 388         g_return_if_fail (BEAGLE_IS_QUERY (query));
 389
 390         part = beagle_query_part_human_new ();
 391         beagle_query_part_human_set_string (part, str);
 392         beagle_query_part_set_logic (BEAGLE_QUERY_PART (part),
 393                                      BEAGLE_QUERY_PART_LOGIC_REQUIRED);
 394
 395         beagle_query_add_part (query, BEAGLE_QUERY_PART (part));
 396 }
 397
 398
 399 /**
 400  * beagle_query_add_mime_type:
 401  * @query: a #BeagleQuery
 402  * @mime_type: a mime type
 403  *
 404  * Adds an allowed mime type to the given #BeagleQuery.
 405  **/
 406 void
 407 beagle_query_add_mime_type (BeagleQuery *query,
 408                             const char  *mime_type)
 409 {
 410         BeagleQueryPrivate *priv;
 411
 412         g_return_if_fail (BEAGLE_IS_QUERY (query));
 413         g_return_if_fail (mime_type != NULL);
 414
 415         priv = BEAGLE_QUERY_GET_PRIVATE (query);
 416
 417         priv->mime_types = g_slist_prepend (priv->mime_types, g_strdup (mime_type));
 418 }
 419
 420 /**
 421  * beagle_query_add_hit_type:
 422  * @query: a #BeagleQuery
 423  * @hit_type: a hit type
 424  *
 425  * Adds an allowed hit type to the given #BeagleQuery.
 426  **/
 427 void
 428 beagle_query_add_hit_type (BeagleQuery *query,
 429                            const char  *hit_type)
 430 {
 431         BeagleQueryPrivate *priv;
 432
 433         g_return_if_fail (BEAGLE_IS_QUERY (query));
 434         g_return_if_fail (hit_type != NULL);
 435
 436         priv = BEAGLE_QUERY_GET_PRIVATE (query);
 437
 438         priv->hit_types = g_slist_prepend (priv->hit_types, g_strdup (hit_type));
 439 }
 440
 441 /**
 442  * beagle_query_add_source:
 443  * @query: a #BeagleQuery
 444  * @source: a source
 445  *
 446  * Adds an allowed source to the given #BeagleQuery.
 447  **/
 448 void
 449 beagle_query_add_source (BeagleQuery *query,
 450                          const char  *source)
 451 {
 452         BeagleQueryPrivate *priv;
 453
 454         g_return_if_fail (BEAGLE_IS_QUERY (query));
 455         g_return_if_fail (source != NULL);
 456
 457         priv = BEAGLE_QUERY_GET_PRIVATE (query);
 458
 459         priv->sources = g_slist_prepend (priv->sources, g_strdup (source));
 460 }
 461
 462 /**
 463  * beagle_query_set_domain:
 464  * @query: a #BeagleQuery
 465  * @domain: a #BeagleQueryDomain
 466  *
 467  * Sets the search domain for a given #BeagleQuery.  This limits the scope of
 468  * a search to certain backends.
 469  **/
 470 void
 471 beagle_query_set_domain (BeagleQuery *query,
 472                          BeagleQueryDomain domain)
 473 {
 474         BeagleQueryPrivate *priv;
 475
 476         g_return_if_fail (BEAGLE_IS_QUERY (query));
 477
 478         priv = BEAGLE_QUERY_GET_PRIVATE (query);
 479
 480         priv->domain = domain;
 481 }
 482
 483 /**
 484  * beagle_query_add_domain:
 485  * @query: a #BeagleQuery
 486  * @domain: a #BeagleQueryDomain
 487  *
 488  * Adds a search domain to the list of domains to search.
 489  **/
 490 void
 491 beagle_query_add_domain (BeagleQuery *query,
 492                          BeagleQueryDomain domain)
 493 {
 494         BeagleQueryPrivate *priv;
 495
 496         g_return_if_fail (BEAGLE_IS_QUERY (query));
 497
 498         priv = BEAGLE_QUERY_GET_PRIVATE (query);
 499
 500         priv->domain |= domain;
 501 }
 502
 503 /**
 504  * beagle_query_remove_domain:
 505  * @query: a #BeagleQuery
 506  * @domain: a #BeagleQueryDomain
 507  *
 508  * Removes a search domain.
 509  **/
 510 void
 511 beagle_query_remove_domain (BeagleQuery *query,
 512                             BeagleQueryDomain domain)
 513 {
 514         BeagleQueryPrivate *priv;
 515
 516         g_return_if_fail (BEAGLE_IS_QUERY (query));
 517
 518         priv = BEAGLE_QUERY_GET_PRIVATE (query);
 519
 520         priv->domain &= ~domain;
 521 }
 522
 523 /**
 524  * beagle_query_set_max_hits
 525  * @query: a #BeagleQuery
 526  * @max_hits: Max number of hits
 527  *
 528  * Sets the max number of hits a given #BeagleQuery should return.
 529  **/
 530 void
 531 beagle_query_set_max_hits (BeagleQuery *query,
 532                            int max_hits)
 533 {
 534         BeagleQueryPrivate *priv;
 535
 536         g_return_if_fail (BEAGLE_IS_QUERY (query));
 537
 538         priv = BEAGLE_QUERY_GET_PRIVATE (query);
 539
 540         priv->max_hits = max_hits;
 541 }
 542
 543
 544 /**
 545  * beagle_query_get_max_hits
 546  * @query: a #BeagleQuery
 547  *
 548  * Returns the max number of hits a given #BeagleQuery should return.
 549  *
 550  * Return value: Max number of hits
 551  **/
 552 int
 553 beagle_query_get_max_hits (BeagleQuery *query)
 554 {
 555         BeagleQueryPrivate *priv;
 556
 557         g_return_val_if_fail (BEAGLE_IS_QUERY (query), 0);
 558
 559         priv = BEAGLE_QUERY_GET_PRIVATE (query);
 560
 561         return priv->max_hits;
 562 }
 563
 564 /**
 565  * beagle_query_get_exact_text
 566  * @query: a #BeagleQuery
 567  *
 568  * Returns a list of strings which contain the exact text processed by the
 569  * query.  The list should not be modified or freed.
 570  *
 571  * Return value: A list of strings containing the exact text
 572  **/
 573 GSList *
 574 beagle_query_get_exact_text (BeagleQuery *query)
 575 {
 576         BeagleQueryPrivate *priv;
 577
 578         g_return_val_if_fail (BEAGLE_IS_QUERY (query), 0);
 579
 580         priv = BEAGLE_QUERY_GET_PRIVATE (query);
 581
 582         return priv->exact_text;
 583 }
 584
 585 /**
 586  * beagle_query_get_stemmed_text
 587  * @query: a #BeagleQuery
 588  *
 589  * Returns a list of strings which contain the stemmed text processed by the
 590  * query.  The list should not be modified or freed.
 591  *
 592  * Return value: A list of strings containing the stemmed text
 593  **/
 594 GSList *
 595 beagle_query_get_stemmed_text (BeagleQuery *query)
 596 {
 597         BeagleQueryPrivate *priv;
 598
 599         g_return_val_if_fail (BEAGLE_IS_QUERY (query), 0);
 600
 601         priv = BEAGLE_QUERY_GET_PRIVATE (query);
 602
 603         return priv->stemmed_text;
 604 }