Defined lock mechanism for buffer caches.

1 files changed, 99 insertions, 40 deletions

diff --git a/src/glibext/buffercache.c b/src/glibext/buffercache.c
index 2913409..ebe8a7f 100644
--- a/src/glibext/buffercache.c
+++ b/src/glibext/buffercache.c
@@ -547,6 +547,7 @@ static void g_buffer_cache_init(GBufferCache *cache)
     cache->lines = NULL;
     cache->count = 0;
     cache->used = 0;
+    g_rw_lock_init(&cache->access);
 
     cache->tracker = NULL;
 
@@ -624,6 +625,8 @@ static void g_buffer_cache_finalize(GBufferCache *cache)
     if (cache->lines != NULL)
         free(cache->lines);
 
+    g_rw_lock_clear(&cache->access);
+
     G_OBJECT_CLASS(g_buffer_cache_parent_class)->finalize(G_OBJECT(cache));
 
 }
@@ -666,21 +669,24 @@ GBufferCache *g_buffer_cache_new(GBinContent *content, size_t col_count, size_t
 *                                                                             *
 *  Paramètres  : cache = tampon de lignes à consulter.                        *
 *                                                                             *
-*  Description : Fournit la hauteur d'impression d'une ligne visualisée.      *
+*  Description : Indique l'éventuel contenu binaire associé au cache.         *
 *                                                                             *
-*  Retour      : Hauteur de ligne en pixels.                                  *
+*  Retour      : Eventuel contenu renseigné ou NULL.                          *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-gint g_buffer_cache_get_line_height(const GBufferCache *cache)
+GBinContent *g_buffer_cache_get_content(const GBufferCache *cache)
 {
-    GBufferCacheClass *class;               /* Classe des tampons          */
+    GBinContent *result;                    /* Contenu à retourner         */
 
-    class = G_BUFFER_CACHE_GET_CLASS(cache);
+    result = cache->content;
 
-    return class->line_height;
+    if (result != NULL)
+        g_object_ref(G_OBJECT(result));
+
+    return result;
 
 }
 
@@ -689,24 +695,21 @@ gint g_buffer_cache_get_line_height(const GBufferCache *cache)
 *                                                                             *
 *  Paramètres  : cache = tampon de lignes à consulter.                        *
 *                                                                             *
-*  Description : Indique l'éventuel contenu binaire associé au cache.         *
+*  Description : Fournit la hauteur d'impression d'une ligne visualisée.      *
 *                                                                             *
-*  Retour      : Eventuel contenu renseigné ou NULL.                          *
+*  Retour      : Hauteur de ligne en pixels.                                  *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GBinContent *g_buffer_cache_get_content(const GBufferCache *cache)
+gint g_buffer_cache_get_line_height(const GBufferCache *cache)
 {
-    GBinContent *result;                    /* Contenu à retourner         */
-
-    result = cache->content;
+    GBufferCacheClass *class;               /* Classe des tampons          */
 
-    if (result != NULL)
-        g_object_ref(G_OBJECT(result));
+    class = G_BUFFER_CACHE_GET_CLASS(cache);
 
-    return result;
+    return class->line_height;
 
 }
 
@@ -759,44 +762,78 @@ gint g_buffer_cache_get_text_position(const GBufferCache *cache)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : cache = instance GLib à consulter.                           *
+*  Paramètres  : cache = composant GLib à consulter.                          *
 *                                                                             *
-*  Description : Compte le nombre de lignes rassemblées dans un tampon.       *
+*  Description : Fournit un lien vers la structure de suivi de largeurs.      *
 *                                                                             *
-*  Retour      : Nombre de lignes constituant le tampon.                      *
+*  Retour      : Gestionnaire de largeurs de lignes.                          *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-size_t g_buffer_cache_count_lines(const GBufferCache *cache)
+GWidthTracker *g_buffer_cache_get_width_tracker(const GBufferCache *cache)
 {
-    // TODO check lock
+    GWidthTracker *result;                  /* Instance à retourner    *   */
 
-    return cache->used;
+    result = cache->tracker;
+
+    g_object_ref(G_OBJECT(result));
+
+    return result;
 
 }
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : cache = composant GLib à consulter.                          *
+*  Paramètres  : cache = cache de lignes à mettre à jour.                     *
+*                write = précise le type d'accès prévu (lecture/écriture).    *
+*                lock  = indique le sens du verrouillage à mener.             *
 *                                                                             *
-*  Description : Fournit un lien vers la structure de suivi de largeurs.      *
+*  Description : Met à disposition un encadrement des accès aux lignes.       *
 *                                                                             *
-*  Retour      : Gestionnaire de largeurs de lignes.                          *
+*  Retour      : -                                                            *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GWidthTracker *g_buffer_cache_get_width_tracker(const GBufferCache *cache)
+void g_buffer_cache_lock_unlock(GBufferCache *cache, bool write, bool lock)
 {
-    GWidthTracker *result;                  /* Instance à retourner    *   */
+    if (write)
+    {
+        if (lock) g_rw_lock_writer_lock(&cache->access);
+        else g_rw_lock_writer_unlock(&cache->access);
+    }
+    else
+    {
+        if (lock) g_rw_lock_reader_lock(&cache->access);
+        else g_rw_lock_reader_unlock(&cache->access);
+    }
 
-    result = cache->tracker;
+}
 
-    g_object_ref(G_OBJECT(result));
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : cache = instance GLib à consulter.                           *
+*                                                                             *
+*  Description : Compte le nombre de lignes rassemblées dans un tampon.       *
+*                                                                             *
+*  Retour      : Nombre de lignes constituant le tampon.                      *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+size_t g_buffer_cache_count_lines(GBufferCache *cache)
+{
+    size_t result;                          /* Quantité à retourner        */
+
+    assert(!g_rw_lock_writer_trylock(&cache->access));
+
+    result = cache->used;
 
     return result;
 
@@ -878,6 +915,8 @@ void g_buffer_cache_insert_at(GBufferCache *cache, size_t index, GLineGenerator
     size_t needed;                          /* Emplacements nécessaires    */
     size_t i;                               /* Boucle de parcours          */
 
+    assert(!g_rw_lock_writer_trylock(&cache->access));
+
     assert(index < cache->used);
 
     assert(!(before && after));
@@ -1000,6 +1039,8 @@ void g_buffer_cache_delete_at(GBufferCache *cache, size_t index)
 {
     cache_info *info;                       /* Accès direct à une ligne    */
 
+    assert(!g_rw_lock_writer_trylock(&cache->access));
+
     assert(index < cache->used);
 
     info = &cache->lines[index];
@@ -1044,6 +1085,8 @@ GLineGenerator *g_buffer_cache_delete_type_at(GBufferCache *cache, size_t index,
     size_t count;                           /* Emplacements occupés        */
     size_t delete;                          /* Indice de suppression       */
 
+    assert(!g_rw_lock_writer_trylock(&cache->access));
+
     assert(index < cache->used);
 
     assert(!(before && after));
@@ -1165,6 +1208,8 @@ void g_buffer_cache_append(GBufferCache *cache, GLineGenerator *generator, Buffe
     size_t i;                               /* Boucle de parcours          */
     cache_info *info;                       /* Accès direct à une ligne    */
 
+    assert(!g_rw_lock_writer_trylock(&cache->access));
+
     count = g_line_generator_count_lines(generator);
 
     assert(count > 0);
@@ -1226,6 +1271,8 @@ void g_buffer_cache_extend_with(GBufferCache *cache, size_t count, GLineGenerato
     cache_info *info;                       /* Accès direct à une ligne    */
     size_t added;                           /* Nombre d'ajouts effectués   */
 
+    assert(!g_rw_lock_writer_trylock(&cache->access));
+
     assert(count >= cache->used);
 
     if (count > cache->count)
@@ -1286,6 +1333,8 @@ void g_buffer_cache_truncate(GBufferCache *cache, size_t max)
     size_t j;                               /* Boucle de parcours #2       */
     size_t removed;                         /* Nombre de retraits effectués*/
 
+    assert(!g_rw_lock_writer_trylock(&cache->access));
+
     for (i = max; i < cache->used; i++)
     {
         info = &cache->lines[i];
@@ -1336,8 +1385,10 @@ void g_buffer_cache_truncate(GBufferCache *cache, size_t max)
 *                                                                             *
 ******************************************************************************/
 
-void g_buffer_cache_get_line_cursor(const GBufferCache *cache, size_t index, gint x, GLineCursor **cursor)
+void g_buffer_cache_get_line_cursor(GBufferCache *cache, size_t index, gint x, GLineCursor **cursor)
 {
+    assert(!g_rw_lock_writer_trylock(&cache->access));
+
     assert(index < cache->used);
 
     get_cache_info_cursor(&cache->lines[index], index, x, cursor);
@@ -1363,7 +1414,7 @@ void g_buffer_cache_add_line_flag(GBufferCache *cache, size_t index, BufferLineF
 {
     cache_info *info;                       /* Accès direct à une ligne    */
 
-    // TODO : check lock
+    assert(!g_rw_lock_writer_trylock(&cache->access));
 
     assert(index < cache->used);
 
@@ -1396,14 +1447,14 @@ void g_buffer_cache_add_line_flag(GBufferCache *cache, size_t index, BufferLineF
 *                                                                             *
 ******************************************************************************/
 
-BufferLineFlags g_buffer_cache_get_line_flags(const GBufferCache *cache, size_t index)
+BufferLineFlags g_buffer_cache_get_line_flags(GBufferCache *cache, size_t index)
 {
     BufferLineFlags result;                 /* Somme à renvoyer            */
     cache_info *info;                       /* Accès direct à une ligne    */
     const generator_link *generator;        /* Générateur retenu           */
     size_t i;                               /* Boucle de parcours          */
 
-    // TODO : check lock
+    assert(!g_rw_lock_writer_trylock(&cache->access));
 
     assert(index < cache->used);
 
@@ -1447,7 +1498,7 @@ void g_buffer_cache_remove_line_flag(GBufferCache *cache, size_t index, BufferLi
 {
     cache_info *info;                       /* Accès direct à une ligne    */
 
-    // TODO : check lock
+    assert(!g_rw_lock_writer_trylock(&cache->access));
 
     assert(index < cache->used);
 
@@ -1484,7 +1535,7 @@ void g_buffer_cache_refresh_line(GBufferCache *cache, size_t index)
 {
     cache_info *info;                       /* Accès direct à une ligne    */
 
-    // TODO : check lock
+    assert(!g_rw_lock_writer_trylock(&cache->access));
 
     assert(index < cache->used);
 
@@ -1510,10 +1561,12 @@ void g_buffer_cache_refresh_line(GBufferCache *cache, size_t index)
 *                                                                             *
 ******************************************************************************/
 
-GBufferLine *g_buffer_cache_find_line_by_index(const GBufferCache *cache, size_t index)
+GBufferLine *g_buffer_cache_find_line_by_index(GBufferCache *cache, size_t index)
 {
     GBufferLine *result;                    /* Ligne trouvée à retourner   */
 
+    assert(!g_rw_lock_writer_trylock(&cache->access));
+
     if (index < cache->used)
         result = get_cache_info_line(&cache->lines[index], cache->tracker, index, cache->content);
     else
@@ -1634,11 +1687,13 @@ void g_buffer_cache_draw(const GBufferCache *cache, cairo_t *cr, size_t first, s
 *                                                                             *
 ******************************************************************************/
 
-size_t _g_buffer_cache_find_index_by_cursor(const GBufferCache *cache, const GLineCursor *cursor, bool first, size_t start, size_t end)
+size_t _g_buffer_cache_find_index_by_cursor(GBufferCache *cache, const GLineCursor *cursor, bool first, size_t start, size_t end)
 {
     size_t result;                          /* Indice à retourner          */
     cache_info *found;                      /* Eventuel élément trouvé     */
 
+    assert(!g_rw_lock_writer_trylock(&cache->access));
+
     int find_containing_generator(const GLineCursor *c, const cache_info *i)
     {
         const generator_link *generator;    /* Générateur retenu           */
@@ -1707,10 +1762,12 @@ size_t _g_buffer_cache_find_index_by_cursor(const GBufferCache *cache, const GLi
 *                                                                             *
 ******************************************************************************/
 
-size_t g_buffer_cache_find_index_by_cursor(const GBufferCache *cache, const GLineCursor *cursor, bool first)
+size_t g_buffer_cache_find_index_by_cursor(GBufferCache *cache, const GLineCursor *cursor, bool first)
 {
     size_t result;                          /* Indice à retourner          */
 
+    assert(!g_rw_lock_writer_trylock(&cache->access));
+
     if (cache->used == 0)
         result = 0;
     else
@@ -1735,7 +1792,7 @@ size_t g_buffer_cache_find_index_by_cursor(const GBufferCache *cache, const GLin
 *                                                                             *
 ******************************************************************************/
 
-size_t g_buffer_cache_look_for_flag(const GBufferCache *cache, size_t start, BufferLineFlags flag)
+size_t g_buffer_cache_look_for_flag(GBufferCache *cache, size_t start, BufferLineFlags flag)
 {
     size_t result;                          /* Indice de ligne à retourner */
     GLineCursor *init;                      /* Localisation de départ      */
@@ -1743,7 +1800,7 @@ size_t g_buffer_cache_look_for_flag(const GBufferCache *cache, size_t start, Buf
     GLineCursor *next;                      /* Localisation suivante       */
     int ret;                                /* Bilan de comparaison        */
 
-    // TODO : check lock
+    assert(!g_rw_lock_writer_trylock(&cache->access));
 
     assert(start < cache->used);
 
@@ -1795,7 +1852,7 @@ size_t g_buffer_cache_look_for_flag(const GBufferCache *cache, size_t start, Buf
 *                                                                             *
 ******************************************************************************/
 
-bool g_buffer_cache_get_cursor_coordinates(const GBufferCache *cache, const GLineCursor *cursor, size_t first, size_t last, bool code, gint *x, gint *y)
+bool g_buffer_cache_get_cursor_coordinates(GBufferCache *cache, const GLineCursor *cursor, size_t first, size_t last, bool code, gint *x, gint *y)
 {
     bool result;                            /* Bilan à retourner           */
     size_t index;                           /* Indice de correspondance    */
@@ -1803,6 +1860,8 @@ bool g_buffer_cache_get_cursor_coordinates(const GBufferCache *cache, const GLin
     const cache_info *info;                 /* Infos sur une ligne donnée  */
     const generator_link *generator;        /* Générateur retenu           */
 
+    assert(!g_rw_lock_writer_trylock(&cache->access));
+
     index = _g_buffer_cache_find_index_by_cursor(cache, cursor, true, first, last);
 
     result = (index < cache->used);