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 #include        "glib.h"
  23
  24
  25 /* --- defines --- */
  26 #define G_HOOKS_PREALLOC        (16)
  27
  28
  29 /* --- functions --- */
  30 void
  31 g_hook_list_init (GHookList *hook_list,
  32                   guint      hook_size)
  33 {
  34   g_return_if_fail (hook_list != NULL);
  35   g_return_if_fail (hook_size >= sizeof (GHook));
  36
  37   hook_list->seq_id = 1;
  38   hook_list->hook_size = hook_size;
  39   hook_list->is_setup = TRUE;
  40   hook_list->hooks = NULL;
  41   hook_list->hook_memchunk = g_mem_chunk_new ("GHook Memchunk",
  42                                               hook_size,
  43                                               hook_size * G_HOOKS_PREALLOC,
  44                                               G_ALLOC_AND_FREE);
  45 }
  46
  47 void
  48 g_hook_list_clear (GHookList *hook_list)
  49 {
  50   g_return_if_fail (hook_list != NULL);
  51
  52   if (hook_list->is_setup)
  53     {
  54       GHook *hook;
  55
  56       hook_list->is_setup = FALSE;
  57
  58       hook = hook_list->hooks;
  59       if (!hook)
  60         {
  61           g_mem_chunk_destroy (hook_list->hook_memchunk);
  62           hook_list->hook_memchunk = NULL;
  63         }
  64       else
  65         do
  66           {
  67             register GHook *tmp;
  68
  69             g_hook_ref (hook_list, hook);
  70             g_hook_destroy_link (hook_list, hook);
  71             tmp = hook->next;
  72             g_hook_unref (hook_list, hook);
  73             hook = tmp;
  74           }
  75         while (hook);
  76     }
  77 }
  78
  79 GHook*
  80 g_hook_alloc (GHookList *hook_list)
  81 {
  82   GHook *hook;
  83
  84   g_return_val_if_fail (hook_list != NULL, NULL);
  85   g_return_val_if_fail (hook_list->is_setup, NULL);
  86
  87   hook = g_chunk_new0 (GHook, hook_list->hook_memchunk);
  88   hook->data = NULL;
  89   hook->next = NULL;
  90   hook->prev = NULL;
  91   hook->flags = G_HOOK_ACTIVE;
  92   hook->ref_count = 0;
  93   hook->id = 0;
  94   hook->func = NULL;
  95   hook->destroy = NULL;
  96
  97   return hook;
  98 }
  99
 100 void
 101 g_hook_free (GHookList *hook_list,
 102              GHook     *hook)
 103 {
 104   g_return_if_fail (hook_list != NULL);
 105   g_return_if_fail (hook_list->is_setup);
 106   g_return_if_fail (hook != NULL);
 107   g_return_if_fail (G_HOOK_IS_UNLINKED (hook));
 108
 109   g_chunk_free (hook, hook_list->hook_memchunk);
 110 }
 111
 112 void
 113 g_hook_destroy_link (GHookList *hook_list,
 114                      GHook     *hook)
 115 {
 116   g_return_if_fail (hook_list != NULL);
 117   g_return_if_fail (hook != NULL);
 118
 119   if (hook->id)
 120     {
 121       hook->id = 0;
 122       hook->flags &= ~G_HOOK_ACTIVE;
 123       if (hook->destroy)
 124         {
 125           register GDestroyNotify destroy;
 126
 127           destroy = hook->destroy;
 128           hook->destroy = NULL;
 129           destroy (hook->data);
 130         }
 131       g_hook_unref (hook_list, hook); /* counterpart to g_hook_insert_before */
 132     }
 133 }
 134
 135 gboolean
 136 g_hook_destroy (GHookList   *hook_list,
 137                 guint        id)
 138 {
 139   GHook *hook;
 140
 141   g_return_val_if_fail (hook_list != NULL, FALSE);
 142   g_return_val_if_fail (id > 0, FALSE);
 143
 144   hook = g_hook_get (hook_list, id);
 145   if (hook)
 146     {
 147       g_hook_destroy_link (hook_list, hook);
 148       return TRUE;
 149     }
 150
 151   return FALSE;
 152 }
 153
 154 void
 155 g_hook_unref (GHookList *hook_list,
 156               GHook     *hook)
 157 {
 158   g_return_if_fail (hook_list != NULL);
 159   g_return_if_fail (hook != NULL);
 160   g_return_if_fail (hook->ref_count > 0);
 161
 162   hook->ref_count--;
 163   if (!hook->ref_count)
 164     {
 165       g_return_if_fail (hook->id == 0);
 166       g_return_if_fail (!G_HOOK_IS_IN_CALL (hook));
 167
 168       if (hook->prev)
 169         hook->prev->next = hook->next;
 170       else
 171         hook_list->hooks = hook->next;
 172       if (hook->next)
 173         {
 174           hook->next->prev = hook->prev;
 175           hook->next = NULL;
 176         }
 177       hook->prev = NULL;
 178
 179       g_chunk_free (hook, hook_list->hook_memchunk);
 180
 181       if (!hook_list->hooks &&
 182           !hook_list->is_setup)
 183         {
 184           g_mem_chunk_destroy (hook_list->hook_memchunk);
 185           hook_list->hook_memchunk = NULL;
 186         }
 187     }
 188 }
 189
 190 void
 191 g_hook_ref (GHookList *hook_list,
 192             GHook     *hook)
 193 {
 194   g_return_if_fail (hook_list != NULL);
 195   g_return_if_fail (hook != NULL);
 196   g_return_if_fail (hook->ref_count > 0);
 197
 198   hook->ref_count++;
 199 }
 200
 201 void
 202 g_hook_prepend (GHookList *hook_list,
 203                 GHook     *hook)
 204 {
 205   g_return_if_fail (hook_list != NULL);
 206
 207   g_hook_insert_before (hook_list, hook_list->hooks, hook);
 208 }
 209
 210 void
 211 g_hook_insert_before (GHookList *hook_list,
 212                       GHook     *sibling,
 213                       GHook     *hook)
 214 {
 215   g_return_if_fail (hook_list != NULL);
 216   g_return_if_fail (hook_list->is_setup);
 217   g_return_if_fail (hook != NULL);
 218   g_return_if_fail (G_HOOK_IS_UNLINKED (hook));
 219   g_return_if_fail (hook->func != NULL);
 220
 221   hook->id = hook_list->seq_id++;
 222   hook->ref_count = 1; /* counterpart to g_hook_destroy_link */
 223
 224   if (sibling)
 225     {
 226       if (sibling->prev)
 227         {
 228           hook->prev = sibling->prev;
 229           hook->prev->next = hook;
 230           hook->next = sibling;
 231           sibling->prev = hook;
 232         }
 233       else
 234         {
 235           hook_list->hooks = hook;
 236           hook->next = sibling;
 237           sibling->prev = hook;
 238         }
 239     }
 240   else
 241     {
 242       if (hook_list->hooks)
 243         {
 244           sibling = hook_list->hooks;
 245           while (sibling->next)
 246             sibling = sibling->next;
 247           hook->prev = sibling;
 248           sibling->next = hook;
 249         }
 250       else
 251         hook_list->hooks = hook;
 252     }
 253 }
 254
 255 void
 256 g_hook_list_invoke (GHookList *hook_list,
 257                     gboolean   may_recurse)
 258 {
 259   GHook *hook;
 260
 261   g_return_if_fail (hook_list != NULL);
 262   g_return_if_fail (hook_list->is_setup);
 263
 264   hook = g_hook_first_valid (hook_list);
 265   while (hook)
 266     {
 267       register GHook *tmp;
 268       register GHookFunc func;
 269       gboolean was_in_call;
 270
 271       g_hook_ref (hook_list, hook);
 272       func = hook->func;
 273
 274       was_in_call = G_HOOK_IS_IN_CALL (hook);
 275       hook->flags |= G_HOOK_IN_CALL;
 276       func (hook->data);
 277       if (!was_in_call)
 278         hook->flags &= ~G_HOOK_IN_CALL;
 279
 280       if (may_recurse)
 281         tmp = g_hook_next_valid (hook);
 282       else
 283         do
 284           tmp = g_hook_next_valid (hook);
 285         while (tmp && G_HOOK_IS_IN_CALL (tmp));
 286
 287       g_hook_unref (hook_list, hook);
 288       hook = tmp;
 289     }
 290 }
 291
 292 void
 293 g_hook_list_invoke_check (GHookList *hook_list,
 294                           gboolean   may_recurse)
 295 {
 296   GHook *hook;
 297
 298   g_return_if_fail (hook_list != NULL);
 299   g_return_if_fail (hook_list->is_setup);
 300
 301   hook = g_hook_first_valid (hook_list);
 302   while (hook)
 303     {
 304       register GHook *tmp;
 305       register GHookCheckFunc func;
 306       gboolean was_in_call;
 307       register gboolean need_destroy;
 308
 309       g_hook_ref (hook_list, hook);
 310       func = hook->func;
 311
 312       was_in_call = G_HOOK_IS_IN_CALL (hook);
 313       hook->flags |= G_HOOK_IN_CALL;
 314       need_destroy = !func (hook->data);
 315       if (!was_in_call)
 316         hook->flags &= ~G_HOOK_IN_CALL;
 317       if (need_destroy)
 318         g_hook_destroy_link (hook_list, hook);
 319
 320       if (may_recurse)
 321         tmp = g_hook_next_valid (hook);
 322       else
 323         do
 324           tmp = g_hook_next_valid (hook);
 325         while (tmp && G_HOOK_IS_IN_CALL (tmp));
 326
 327       g_hook_unref (hook_list, hook);
 328       hook = tmp;
 329     }
 330 }
 331
 332 void
 333 g_hook_list_marshall (GHookList              *hook_list,
 334                       gboolean                may_recurse,
 335                       GHookMarshaller         marshaller,
 336                       gpointer                data)
 337 {
 338   GHook *hook;
 339
 340   g_return_if_fail (hook_list != NULL);
 341   g_return_if_fail (hook_list->is_setup);
 342   g_return_if_fail (marshaller != NULL);
 343
 344   hook = g_hook_first_valid (hook_list);
 345   while (hook)
 346     {
 347       register GHook *tmp;
 348       gboolean was_in_call;
 349
 350       g_hook_ref (hook_list, hook);
 351
 352       was_in_call = G_HOOK_IS_IN_CALL (hook);
 353       hook->flags |= G_HOOK_IN_CALL;
 354       marshaller (hook, data);
 355       if (!was_in_call)
 356         hook->flags &= ~G_HOOK_IN_CALL;
 357
 358       if (may_recurse)
 359         tmp = g_hook_next_valid (hook);
 360       else
 361         do
 362           tmp = g_hook_next_valid (hook);
 363         while (tmp && G_HOOK_IS_IN_CALL (tmp));
 364
 365       g_hook_unref (hook_list, hook);
 366       hook = tmp;
 367     }
 368 }
 369
 370 GHook*
 371 g_hook_first_valid (GHookList *hook_list)
 372 {
 373   g_return_val_if_fail (hook_list != NULL, NULL);
 374
 375   if (hook_list->is_setup)
 376     {
 377       GHook *hook;
 378
 379       hook = hook_list->hooks;
 380       if (hook)
 381         {
 382           if (G_HOOK_IS_VALID (hook))
 383             return hook;
 384           else
 385             return g_hook_next_valid (hook);
 386         }
 387     }
 388
 389   return NULL;
 390 }
 391
 392 GHook*
 393 g_hook_next_valid (GHook *hook)
 394 {
 395   if (!hook)
 396     return NULL;
 397
 398   hook = hook->next;
 399   while (hook)
 400     {
 401       if (G_HOOK_IS_VALID (hook))
 402         return hook;
 403       hook = hook->next;
 404     }
 405
 406   return NULL;
 407 }
 408
 409 GHook*
 410 g_hook_get (GHookList *hook_list,
 411             guint      id)
 412 {
 413   GHook *hook;
 414
 415   g_return_val_if_fail (hook_list != NULL, NULL);
 416   g_return_val_if_fail (id > 0, NULL);
 417
 418   hook = hook_list->hooks;
 419   while (hook)
 420     {
 421       if (hook->id == id)
 422         return hook;
 423       hook = hook->next;
 424     }
 425
 426   return NULL;
 427 }
 428
 429 GHook*
 430 g_hook_find (GHookList    *hook_list,
 431              gboolean      need_valids,
 432              GHookFindFunc func,
 433              gpointer      data)
 434 {
 435   GHook *hook;
 436
 437   g_return_val_if_fail (hook_list != NULL, NULL);
 438   g_return_val_if_fail (func != NULL, NULL);
 439
 440   hook = g_hook_first_valid (hook_list);
 441   while (hook)
 442     {
 443       register GHook *tmp;
 444
 445       g_hook_ref (hook_list, hook);
 446
 447       if (func (hook, data) && hook->id && (!need_valids || G_HOOK_IS_ACTIVE (hook)))
 448         {
 449           g_hook_unref (hook_list, hook);
 450
 451           return hook;
 452         }
 453       tmp = g_hook_next_valid (hook);
 454       g_hook_unref (hook_list, hook);
 455       hook = tmp;
 456     }
 457
 458   return NULL;
 459 }
 460
 461 GHook*
 462 g_hook_find_data (GHookList *hook_list,
 463                   gboolean   need_valids,
 464                   gpointer   data)
 465 {
 466   register GHook *hook;
 467
 468   g_return_val_if_fail (hook_list != NULL, NULL);
 469
 470   hook = g_hook_first_valid (hook_list);
 471   while (hook)
 472     {
 473       if (hook->data == data && hook->id && (!need_valids || G_HOOK_IS_ACTIVE (hook)))
 474         return hook;
 475
 476       hook = g_hook_next_valid (hook);
 477     }
 478
 479   return NULL;
 480 }
 481
 482 GHook*
 483 g_hook_find_func (GHookList *hook_list,
 484                   gboolean   need_valids,
 485                   gpointer   func)
 486 {
 487   register GHook *hook;
 488
 489   g_return_val_if_fail (hook_list != NULL, NULL);
 490   g_return_val_if_fail (func != NULL, NULL);
 491
 492   hook = g_hook_first_valid (hook_list);
 493   while (hook)
 494     {
 495       if (hook->func == func && hook->id && (!need_valids || G_HOOK_IS_ACTIVE (hook)))
 496         return hook;
 497
 498       hook = g_hook_next_valid (hook);
 499     }
 500
 501   return NULL;
 502 }
 503
 504 GHook*
 505 g_hook_find_func_data (GHookList *hook_list,
 506                        gboolean   need_valids,
 507                        gpointer   func,
 508                        gpointer   data)
 509 {
 510   register GHook *hook;
 511
 512   g_return_val_if_fail (hook_list != NULL, NULL);
 513   g_return_val_if_fail (func != NULL, NULL);
 514
 515   hook = g_hook_first_valid (hook_list);
 516   while (hook)
 517     {
 518       if (hook->data == data && hook->func == func && hook->id && (!need_valids || G_HOOK_IS_ACTIVE (hook)))
 519         return hook;
 520
 521       hook = g_hook_next_valid (hook);
 522     }
 523
 524   return NULL;
 525 }
 526
 527 void
 528 g_hook_insert_sorted (GHookList       *hook_list,
 529                       GHook           *hook,
 530                       GHookCompareFunc func)
 531 {
 532   GHook *sibling;
 533
 534   g_return_if_fail (hook_list != NULL);
 535   g_return_if_fail (hook_list->is_setup);
 536   g_return_if_fail (hook != NULL);
 537   g_return_if_fail (G_HOOK_IS_UNLINKED (hook));
 538   g_return_if_fail (hook->func != NULL);
 539   g_return_if_fail (func != NULL);
 540
 541   sibling = g_hook_first_valid (hook_list);
 542
 543   while (sibling)
 544     {
 545       register GHook *tmp;
 546
 547       g_hook_ref (hook_list, sibling);
 548       if (func (hook, sibling) <= 0 && sibling->id)
 549         {
 550           g_hook_unref (hook_list, sibling);
 551           break;
 552         }
 553       tmp = g_hook_next_valid (sibling);
 554       g_hook_unref (hook_list, sibling);
 555       sibling = tmp;
 556     }
 557
 558   g_hook_insert_before (hook_list, sibling, hook);
 559 }
 560
 561 gint
 562 g_hook_compare_ids (GHook *new_hook,
 563                     GHook *sibling)
 564 {
 565   return ((glong) new_hook->id) - ((glong) sibling->id);
 566 }