Improved the way file formats are detected and loaded.

3 files changed, 100 insertions, 1 deletions

diff --git a/src/glibext/delayed-int.h b/src/glibext/delayed-int.h
index 2e1b4be..6ffff75 100644
--- a/src/glibext/delayed-int.h
+++ b/src/glibext/delayed-int.h
@@ -21,6 +21,10 @@
  */
 
 
+#ifndef _GLIBEXT_DELAYED_INT_H
+#define _GLIBEXT_DELAYED_INT_H
+
+
 #include "delayed.h"
 
 
@@ -65,3 +69,7 @@ struct _GDelayedWorkClass
 
 #define delayed_work_list_add_tail(new, head) dl_list_add_tail(new, head, GDelayedWork, link)
 #define delayed_work_list_del(item, head) dl_list_del(item, head, GDelayedWork, link)
+
+
+
+#endif  /* _GLIBEXT_DELAYED_INT_H */
diff --git a/src/glibext/delayed.c b/src/glibext/delayed.c
index b7793cd..78c8a10 100644
--- a/src/glibext/delayed.c
+++ b/src/glibext/delayed.c
@@ -123,6 +123,9 @@ static void g_work_group_schedule(GWorkGroup *, GDelayedWork *);
 /* Assure le traitement en différé. */
 static void *g_work_group_process(GWorkGroup *);
 
+/* Détermine si le groupe est vide de toute programmation. */
+static bool g_work_group_is_empty(GWorkGroup *);
+
 /* Attend que toutes les tâches d'un groupe soient traitées. */
 static void g_work_group_wait_for_completion(GWorkGroup *, GWorkQueue *);
 
@@ -607,6 +610,46 @@ static void *g_work_group_process(GWorkGroup *group)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : group = gestionnaire des actions à consulter.                *
+*                                                                             *
+*  Description : Détermine si le groupe est vide de toute programmation.      *
+*                                                                             *
+*  Retour      : Etat du groupe de travail.                                   *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool g_work_group_is_empty(GWorkGroup *group)
+{
+    bool result;                            /* Etat à retourner            */
+
+    /**
+     * Pour que le résultat soit exploitable, il ne doit pas varier
+     * en dehors de la zone couverte par le verrou du groupe avant
+     * son utilisation par l'appelant.
+     *
+     * Il doit donc logiquement y avoir un autre verrou en amont et,
+     * comme à priori on ne devrait pas bloquer le groupe principal
+     * pour un traitement particulier, on ajoute ici une simple vérification
+     * de bonne pratique.
+     */
+
+    assert(group->id != DEFAULT_WORK_GROUP);
+
+    g_mutex_lock(&group->mutex);
+
+    result = dl_list_empty(group->works);
+
+    g_mutex_unlock(&group->mutex);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : group = groupe dont les conclusions sont attendues.          *
 *                queue = queue d'appartenance pour les appels externes.       *
 *                                                                             *
@@ -911,6 +954,13 @@ wgroup_id_t g_work_queue_define_work_group(GWorkQueue *queue)
 void g_work_queue_delete_work_group(GWorkQueue *queue, wgroup_id_t id)
 {
     size_t i;                               /* Boucle de parcours          */
+#ifndef NDEBUG
+    bool found;                             /* Repérage du groupe visé     */
+#endif
+
+#ifndef NDEBUG
+    found = false;
+#endif
 
     g_mutex_lock(&queue->mutex);
 
@@ -924,11 +974,15 @@ void g_work_queue_delete_work_group(GWorkQueue *queue, wgroup_id_t id)
             queue->groups = (GWorkGroup **)realloc(queue->groups,
                                                    queue->groups_count * sizeof(GWorkGroup *));
 
+#ifndef NDEBUG
+            found = true;
+#endif
+
             break;
 
         }
 
-    assert(i < queue->groups_count);
+    assert(found);
 
     g_mutex_unlock(&queue->mutex);
 
@@ -1010,6 +1064,40 @@ static GWorkGroup *g_work_queue_find_group_for_id(GWorkQueue *queue, wgroup_id_t
 *  Paramètres  : queue = gestionnaire de l'ensemble des groupes de travail.   *
 *                id    = identifiant d'un groupe de travail.                  *
 *                                                                             *
+*  Description : Détermine si un groupe est vide de toute programmation.      *
+*                                                                             *
+*  Retour      : Etat du groupe de travail.                                   *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool g_work_queue_is_empty(GWorkQueue *queue, wgroup_id_t id)
+{
+    bool result;                            /* Etat à retourner            */
+    GWorkGroup *group;                      /* Groupe de travail à attendre*/
+
+    group = g_work_queue_find_group_for_id(queue, id);
+
+    if (group != NULL)
+    {
+        result = g_work_group_is_empty(group);
+        g_object_unref(G_OBJECT(group));
+    }
+
+    else
+        result = true;
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : queue = gestionnaire de l'ensemble des groupes de travail.   *
+*                id    = identifiant d'un groupe de travail.                  *
+*                                                                             *
 *  Description : Attend que toutes les tâches d'un groupe soient traitées.    *
 *                                                                             *
 *  Retour      : -                                                            *
diff --git a/src/glibext/delayed.h b/src/glibext/delayed.h
index 7c620e6..ab43640 100644
--- a/src/glibext/delayed.h
+++ b/src/glibext/delayed.h
@@ -101,6 +101,9 @@ void g_work_queue_delete_work_group(GWorkQueue *, wgroup_id_t);
 /* Place une nouvelle tâche en attente. */
 void g_work_queue_schedule_work(GWorkQueue *, GDelayedWork *, wgroup_id_t);
 
+/* Détermine si un groupe est vide de toute programmation. */
+bool g_work_queue_is_empty(GWorkQueue *, wgroup_id_t);
+
 /* Attend que toutes les tâches d'un groupe soient traitées. */
 void g_work_queue_wait_for_completion(GWorkQueue *, wgroup_id_t);