glib/ghook.c

   1 /* GLIB - Library of useful routines for C programming
   2  * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * GHook: Callback maintenance functions
   5  * Copyright (C) 1998 Tim Janik
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23 /*
  24  * MT safe
  25  */
  26
  27 #include        "glib.h"
  28
  29
  30 /* --- defines --- */
  31 #define G_HOOKS_PREALLOC        (16)
  32
  33
  34 /* --- functions --- */
  35 void
  36 g_hook_list_init (GHookList *hook_list,
  37                   guint      hook_size)
  38 {
  39   g_return_if_fail (hook_list != NULL);
  40   g_return_if_fail (hook_size >= sizeof (GHook));
  41
  42   hook_list->seq_id = 1;
  43   hook_list->hook_size = hook_size;
  44   hook_list->is_setup = TRUE;
  45   hook_list->hooks = NULL;
  46   hook_list->hook_memchunk = g_mem_chunk_new ("GHook Memchunk",
  47                                               hook_size,
  48                                               hook_size * G_HOOKS_PREALLOC,
  49                                               G_ALLOC_AND_FREE);
  50   hook_list->hook_free = NULL;
  51   hook_list->hook_destroy = NULL;
  52 }
  53
  54 void
  55 g_hook_list_clear (GHookList *hook_list)
  56 {
  57   g_return_if_fail (hook_list != NULL);
  58
  59   if (hook_list->is_setup)
  60     {
  61       GHook *hook;
  62
  63       hook_list->is_setup = FALSE;
  64
  65       hook = hook_list->hooks;
  66       if (!hook)
  67         {
  68           g_mem_chunk_destroy (hook_list->hook_memchunk);
  69           hook_list->hook_memchunk = NULL;
  70         }
  71       else
  72         do
  73           {
  74             GHook *tmp;
  75
  76             g_hook_ref (hook_list, hook);
  77             g_hook_destroy_link (hook_list, hook);
  78             tmp = hook->next;
  79             g_hook_unref (hook_list, hook);
  80             hook = tmp;
  81           }
  82         while (hook);
  83     }
  84 }
  85
  86 GHook*
  87 g_hook_alloc (GHookList *hook_list)
  88 {
  89   GHook *hook;
  90
  91   g_return_val_if_fail (hook_list != NULL, NULL);
  92   g_return_val_if_fail (hook_list->is_setup, NULL);
  93
  94   hook = g_chunk_new0 (GHook, hook_list->hook_memchunk);
  95   hook->data = NULL;
  96   hook->next = NULL;
  97   hook->prev = NULL;
  98   hook->flags = G_HOOK_FLAG_ACTIVE;
  99   hook->ref_count = 0;
 100   hook->hook_id = 0;
 101   hook->func = NULL;
 102   hook->destroy = NULL;
 103
 104   return hook;
 105 }
 106
 107 void
 108 g_hook_free (GHookList *hook_list,
 109              GHook     *hook)
 110 {
 111   g_return_if_fail (hook_list != NULL);
 112   g_return_if_fail (hook_list->is_setup);
 113   g_return_if_fail (hook != NULL);
 114   g_return_if_fail (G_HOOK_IS_UNLINKED (hook));
 115
 116   if (hook_list->hook_free)
 117     hook_list->hook_free (hook_list, hook);
 118
 119   g_chunk_free (hook, hook_list->hook_memchunk);
 120 }
 121
 122 void
 123 g_hook_destroy_link (GHookList *hook_list,
 124                      GHook     *hook)
 125 {
 126   g_return_if_fail (hook_list != NULL);
 127   g_return_if_fail (hook != NULL);
 128
 129   if (hook->hook_id)
 130     {
 131       hook->hook_id = 0;
 132       hook->flags &= ~G_HOOK_FLAG_ACTIVE;
 133       if (hook_list->hook_destroy)
 134         {
 135           hook_list->hook_destroy (hook_list, hook);
 136           hook->destroy = NULL;
 137         }
 138       else if (hook->destroy)
 139         {
 140           GDestroyNotify destroy;
 141
 142           destroy = hook->destroy;
 143           hook->destroy = NULL;
 144           destroy (hook->data);
 145         }
 146       g_hook_unref (hook_list, hook); /* counterpart to g_hook_insert_before */
 147     }
 148 }
 149
 150 gboolean
 151 g_hook_destroy (GHookList   *hook_list,
 152                 guint        hook_id)
 153 {
 154   GHook *hook;
 155
 156   g_return_val_if_fail (hook_list != NULL, FALSE);
 157   g_return_val_if_fail (hook_id > 0, FALSE);
 158
 159   hook = g_hook_get (hook_list, hook_id);
 160   if (hook)
 161     {
 162       g_hook_destroy_link (hook_list, hook);
 163       return TRUE;
 164     }
 165
 166   return FALSE;
 167 }
 168
 169 void
 170 g_hook_unref (GHookList *hook_list,
 171               GHook     *hook)
 172 {
 173   g_return_if_fail (hook_list != NULL);
 174   g_return_if_fail (hook != NULL);
 175   g_return_if_fail (hook->ref_count > 0);
 176
 177   hook->ref_count--;
 178   if (!hook->ref_count)
 179     {
 180       g_return_if_fail (hook->hook_id == 0);
 181       g_return_if_fail (!G_HOOK_IN_CALL (hook));
 182
 183       if (hook->prev)
 184         hook->prev->next = hook->next;
 185       else
 186         hook_list->hooks = hook->next;
 187       if (hook->next)
 188         {
 189           hook->next->prev = hook->prev;
 190           hook->next = NULL;
 191         }
 192       hook->prev = NULL;
 193
 194       g_hook_free (hook_list, hook);
 195
 196       if (!hook_list->hooks &&
 197           !hook_list->is_setup)
 198         {
 199           g_mem_chunk_destroy (hook_list->hook_memchunk);
 200           hook_list->hook_memchunk = NULL;
 201         }
 202     }
 203 }
 204
 205 void
 206 g_hook_ref (GHookList *hook_list,
 207             GHook     *hook)
 208 {
 209   g_return_if_fail (hook_list != NULL);
 210   g_return_if_fail (hook != NULL);
 211   g_return_if_fail (hook->ref_count > 0);
 212
 213   hook->ref_count++;
 214 }
 215
 216 void
 217 g_hook_prepend (GHookList *hook_list,
 218                 GHook     *hook)
 219 {
 220   g_return_if_fail (hook_list != NULL);
 221
 222   g_hook_insert_before (hook_list, hook_list->hooks, hook);
 223 }
 224
 225 void
 226 g_hook_insert_before (GHookList *hook_list,
 227                       GHook     *sibling,
 228                       GHook     *hook)
 229 {
 230   g_return_if_fail (hook_list != NULL);
 231   g_return_if_fail (hook_list->is_setup);
 232   g_return_if_fail (hook != NULL);
 233   g_return_if_fail (G_HOOK_IS_UNLINKED (hook));
 234   g_return_if_fail (hook->func != NULL);
 235
 236   hook->hook_id = hook_list->seq_id++;
 237   hook->ref_count = 1; /* counterpart to g_hook_destroy_link */
 238
 239   if (sibling)
 240     {
 241       if (sibling->prev)
 242         {
 243           hook->prev = sibling->prev;
 244           hook->prev->next = hook;
 245           hook->next = sibling;
 246           sibling->prev = hook;
 247         }
 248       else
 249         {
 250           hook_list->hooks = hook;
 251           hook->next = sibling;
 252           sibling->prev = hook;
 253         }
 254     }
 255   else
 256     {
 257       if (hook_list->hooks)
 258         {
 259           sibling = hook_list->hooks;
 260           while (sibling->next)
 261             sibling = sibling->next;
 262           hook->prev = sibling;
 263           sibling->next = hook;
 264         }
 265       else
 266         hook_list->hooks = hook;
 267     }
 268 }
 269
 270 void
 271 g_hook_list_invoke (GHookList *hook_list,
 272                     gboolean   may_recurse)
 273 {
 274   GHook *hook;
 275
 276   g_return_if_fail (hook_list != NULL);
 277   g_return_if_fail (hook_list->is_setup);
 278
 279   hook = g_hook_first_valid (hook_list, may_recurse);
 280   while (hook)
 281     {
 282       GHookFunc func;
 283       gboolean was_in_call;
 284
 285       func = (GHookFunc) hook->func;
 286
 287       was_in_call = G_HOOK_IN_CALL (hook);
 288       hook->flags |= G_HOOK_FLAG_IN_CALL;
 289       func (hook->data);
 290       if (!was_in_call)
 291         hook->flags &= ~G_HOOK_FLAG_IN_CALL;
 292
 293       hook = g_hook_next_valid (hook_list, hook, may_recurse);
 294     }
 295 }
 296
 297 void
 298 g_hook_list_invoke_check (GHookList *hook_list,
 299                           gboolean   may_recurse)
 300 {
 301   GHook *hook;
 302
 303   g_return_if_fail (hook_list != NULL);
 304   g_return_if_fail (hook_list->is_setup);
 305
 306   hook = g_hook_first_valid (hook_list, may_recurse);
 307   while (hook)
 308     {
 309       GHookCheckFunc func;
 310       gboolean was_in_call;
 311       gboolean need_destroy;
 312
 313       func = (GHookCheckFunc) hook->func;
 314
 315       was_in_call = G_HOOK_IN_CALL (hook);
 316       hook->flags |= G_HOOK_FLAG_IN_CALL;
 317       need_destroy = !func (hook->data);
 318       if (!was_in_call)
 319         hook->flags &= ~G_HOOK_FLAG_IN_CALL;
 320       if (need_destroy)
 321         g_hook_destroy_link (hook_list, hook);
 322
 323       hook = g_hook_next_valid (hook_list, hook, may_recurse);
 324     }
 325 }
 326
 327 void
 328 g_hook_list_marshal_check (GHookList           *hook_list,
 329                            gboolean             may_recurse,
 330                            GHookCheckMarshaller marshaller,
 331                            gpointer             data)
 332 {
 333   GHook *hook;
 334
 335   g_return_if_fail (hook_list != NULL);
 336   g_return_if_fail (hook_list->is_setup);
 337   g_return_if_fail (marshaller != NULL);
 338
 339   hook = g_hook_first_valid (hook_list, may_recurse);
 340   while (hook)
 341     {
 342       gboolean was_in_call;
 343       gboolean need_destroy;
 344
 345       was_in_call = G_HOOK_IN_CALL (hook);
 346       hook->flags |= G_HOOK_FLAG_IN_CALL;
 347       need_destroy = !marshaller (hook, data);
 348       if (!was_in_call)
 349         hook->flags &= ~G_HOOK_FLAG_IN_CALL;
 350       if (need_destroy)
 351         g_hook_destroy_link (hook_list, hook);
 352
 353       hook = g_hook_next_valid (hook_list, hook, may_recurse);
 354     }
 355 }
 356
 357 void
 358 g_hook_list_marshal (GHookList               *hook_list,
 359                      gboolean                 may_recurse,
 360                      GHookMarshaller          marshaller,
 361                      gpointer                 data)
 362 {
 363   GHook *hook;
 364
 365   g_return_if_fail (hook_list != NULL);
 366   g_return_if_fail (hook_list->is_setup);
 367   g_return_if_fail (marshaller != NULL);
 368
 369   hook = g_hook_first_valid (hook_list, may_recurse);
 370   while (hook)
 371     {
 372       gboolean was_in_call;
 373
 374       was_in_call = G_HOOK_IN_CALL (hook);
 375       hook->flags |= G_HOOK_FLAG_IN_CALL;
 376       marshaller (hook, data);
 377       if (!was_in_call)
 378         hook->flags &= ~G_HOOK_FLAG_IN_CALL;
 379
 380       hook = g_hook_next_valid (hook_list, hook, may_recurse);
 381     }
 382 }
 383
 384 GHook*
 385 g_hook_first_valid (GHookList *hook_list,
 386                     gboolean   may_be_in_call)
 387 {
 388   g_return_val_if_fail (hook_list != NULL, NULL);
 389
 390   if (hook_list->is_setup)
 391     {
 392       GHook *hook;
 393
 394       hook = hook_list->hooks;
 395       if (hook)
 396         {
 397           g_hook_ref (hook_list, hook);
 398           if (G_HOOK_IS_VALID (hook) && (may_be_in_call || !G_HOOK_IN_CALL (hook)))
 399             return hook;
 400           else
 401             return g_hook_next_valid (hook_list, hook, may_be_in_call);
 402         }
 403     }
 404
 405   return NULL;
 406 }
 407
 408 GHook*
 409 g_hook_next_valid (GHookList *hook_list,
 410                    GHook     *hook,
 411                    gboolean   may_be_in_call)
 412 {
 413   GHook *ohook = hook;
 414
 415   g_return_val_if_fail (hook_list != NULL, NULL);
 416
 417   if (!hook)
 418     return NULL;
 419
 420   hook = hook->next;
 421   while (hook)
 422     {
 423       if (G_HOOK_IS_VALID (hook) && (may_be_in_call || !G_HOOK_IN_CALL (hook)))
 424         {
 425           g_hook_ref (hook_list, hook);
 426           g_hook_unref (hook_list, ohook);
 427
 428           return hook;
 429         }
 430       hook = hook->next;
 431     }
 432   g_hook_unref (hook_list, ohook);
 433
 434   return NULL;
 435 }
 436
 437 GHook*
 438 g_hook_get (GHookList *hook_list,
 439             guint      hook_id)
 440 {
 441   GHook *hook;
 442
 443   g_return_val_if_fail (hook_list != NULL, NULL);
 444   g_return_val_if_fail (hook_id > 0, NULL);
 445
 446   hook = hook_list->hooks;
 447   while (hook)
 448     {
 449       if (hook->hook_id == hook_id)
 450         return hook;
 451       hook = hook->next;
 452     }
 453
 454   return NULL;
 455 }
 456
 457 GHook*
 458 g_hook_find (GHookList    *hook_list,
 459              gboolean      need_valids,
 460              GHookFindFunc func,
 461              gpointer      data)
 462 {
 463   GHook *hook;
 464
 465   g_return_val_if_fail (hook_list != NULL, NULL);
 466   g_return_val_if_fail (func != NULL, NULL);
 467
 468   hook = hook_list->hooks;
 469   while (hook)
 470     {
 471       GHook *tmp;
 472
 473       /* test only non-destroyed hooks */
 474       if (!hook->hook_id)
 475         {
 476           hook = hook->next;
 477           continue;
 478         }
 479
 480       g_hook_ref (hook_list, hook);
 481
 482       if (func (hook, data) && hook->hook_id && (!need_valids || G_HOOK_ACTIVE (hook)))
 483         {
 484           g_hook_unref (hook_list, hook);
 485
 486           return hook;
 487         }
 488
 489       tmp = hook->next;
 490       g_hook_unref (hook_list, hook);
 491       hook = tmp;
 492     }
 493
 494   return NULL;
 495 }
 496
 497 GHook*
 498 g_hook_find_data (GHookList *hook_list,
 499                   gboolean   need_valids,
 500                   gpointer   data)
 501 {
 502   GHook *hook;
 503
 504   g_return_val_if_fail (hook_list != NULL, NULL);
 505
 506   hook = hook_list->hooks;
 507   while (hook)
 508     {
 509       /* test only non-destroyed hooks */
 510       if (hook->data == data &&
 511           hook->hook_id &&
 512           (!need_valids || G_HOOK_ACTIVE (hook)))
 513         return hook;
 514
 515       hook = hook->next;
 516     }
 517
 518   return NULL;
 519 }
 520
 521 GHook*
 522 g_hook_find_func (GHookList *hook_list,
 523                   gboolean   need_valids,
 524                   gpointer   func)
 525 {
 526   GHook *hook;
 527
 528   g_return_val_if_fail (hook_list != NULL, NULL);
 529   g_return_val_if_fail (func != NULL, NULL);
 530
 531   hook = hook_list->hooks;
 532   while (hook)
 533     {
 534       /* test only non-destroyed hooks */
 535       if (hook->func == func &&
 536           hook->hook_id &&
 537           (!need_valids || G_HOOK_ACTIVE (hook)))
 538         return hook;
 539
 540       hook = hook->next;
 541     }
 542
 543   return NULL;
 544 }
 545
 546 GHook*
 547 g_hook_find_func_data (GHookList *hook_list,
 548                        gboolean   need_valids,
 549                        gpointer   func,
 550                        gpointer   data)
 551 {
 552   GHook *hook;
 553
 554   g_return_val_if_fail (hook_list != NULL, NULL);
 555   g_return_val_if_fail (func != NULL, NULL);
 556
 557   hook = hook_list->hooks;
 558   while (hook)
 559     {
 560       /* test only non-destroyed hooks */
 561       if (hook->data == data &&
 562           hook->func == func &&
 563           hook->hook_id &&
 564           (!need_valids || G_HOOK_ACTIVE (hook)))
 565         return hook;
 566
 567       hook = hook->next;
 568     }
 569
 570   return NULL;
 571 }
 572
 573 void
 574 g_hook_insert_sorted (GHookList       *hook_list,
 575                       GHook           *hook,
 576                       GHookCompareFunc func)
 577 {
 578   GHook *sibling;
 579
 580   g_return_if_fail (hook_list != NULL);
 581   g_return_if_fail (hook_list->is_setup);
 582   g_return_if_fail (hook != NULL);
 583   g_return_if_fail (G_HOOK_IS_UNLINKED (hook));
 584   g_return_if_fail (hook->func != NULL);
 585   g_return_if_fail (func != NULL);
 586
 587   /* first non-destroyed hook */
 588   sibling = hook_list->hooks;
 589   while (sibling && !sibling->hook_id)
 590     sibling = sibling->next;
 591
 592   while (sibling)
 593     {
 594       GHook *tmp;
 595
 596       g_hook_ref (hook_list, sibling);
 597       if (func (hook, sibling) <= 0 && sibling->hook_id)
 598         {
 599           g_hook_unref (hook_list, sibling);
 600           break;
 601         }
 602
 603       /* next non-destroyed hook */
 604       tmp = sibling->next;
 605       while (tmp && !tmp->hook_id)
 606         tmp = tmp->next;
 607
 608       g_hook_unref (hook_list, sibling);
 609       sibling = tmp;
 610     }
 611
 612   g_hook_insert_before (hook_list, sibling, hook);
 613 }
 614
 615 gint
 616 g_hook_compare_ids (GHook *new_hook,
 617                     GHook *sibling)
 618 {
 619   return ((glong) new_hook->hook_id) - ((glong) sibling->hook_id);
 620 }