/* Chrysalide - Outil d'analyse de fichiers binaires
* singleton.c - réduction du nombre d'instances d'un même type
*
* Copyright (C) 2021 Cyrille Bagard
*
* This file is part of Chrysalide.
*
* Chrysalide is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* Chrysalide is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Foobar. If not, see .
*/
#include "singleton.h"
#include
#include "singleton-int.h"
/* ------------------ INTERFACE POUR CANDIDAT A UNE CENTRALISATION ------------------ */
/* Procède à l'initialisation de l'interface de rassemblement. */
static void g_singleton_candidate_default_init(GSingletonCandidateInterface *);
/* ------------------------- COLLECTION D'INSTANCES UNIQUES ------------------------- */
/* Définition d'un compacteur d'instances de types (instance) */
struct _GSingletonFactory
{
GObject parent; /* A laisser en premier */
GHashTable *table; /* Suivi des conservations */
GMutex access; /* Verrou pour la concurrence */
};
/* Définition d'un compacteur d'instances de types (classe) */
struct _GSingletonFactoryClass
{
GObjectClass parent; /* A laisser en premier */
};
/* Initialise la classe des compacteurs d'instances de types. */
static void g_singleton_factory_class_init(GSingletonFactoryClass *);
/* Initialise une instance de compacteur d'instances de types. */
static void g_singleton_factory_init(GSingletonFactory *);
/* Supprime toutes les références externes. */
static void g_singleton_factory_dispose(GSingletonFactory *);
/* Procède à la libération totale de la mémoire. */
static void g_singleton_factory_finalize(GSingletonFactory *);
/* ---------------------------------------------------------------------------------- */
/* INTERFACE POUR CANDIDAT A UNE CENTRALISATION */
/* ---------------------------------------------------------------------------------- */
/* Détermine le type d'une interface pour la lecture de binaire. */
G_DEFINE_INTERFACE(GSingletonCandidate, g_singleton_candidate, G_TYPE_OBJECT)
/******************************************************************************
* *
* Paramètres : iface = interface GLib à initialiser. *
* *
* Description : Procède à l'initialisation de l'interface de rassemblement. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_singleton_candidate_default_init(GSingletonCandidateInterface *iface)
{
}
/******************************************************************************
* *
* Paramètres : candidate = objet dont l'instance se veut unique. *
* *
* Description : Fournit l'empreinte d'un candidat à une centralisation. *
* *
* Retour : Empreinte de l'élément représenté. *
* *
* Remarques : - *
* *
******************************************************************************/
guint g_singleton_candidate_hash(const GSingletonCandidate *candidate)
{
guint result; /* Valeur à retourner */
GSingletonCandidateIface *iface; /* Interface utilisée */
iface = G_SINGLETON_CANDIDATE_GET_IFACE(candidate);
result = iface->hash(candidate);
return result;
}
/******************************************************************************
* *
* Paramètres : candidate = objet dont l'instance se veut unique. *
* other = second élément à analyser. *
* *
* Description : Détermine si deux candidats à l'unicité sont identiques. *
* *
* Retour : Bilan de la comparaison. *
* *
* Remarques : - *
* *
******************************************************************************/
gboolean g_singleton_candidate_is_equal(const GSingletonCandidate *candidate, const GSingletonCandidate *other)
{
gboolean result; /* Bilan à renvoyer */
GSingletonCandidateIface *iface; /* Interface utilisée */
iface = G_SINGLETON_CANDIDATE_GET_IFACE(candidate);
result = iface->is_equal(candidate, other);
return result;
}
/******************************************************************************
* *
* Paramètres : candidate = objet dont l'instance se veut unique. *
* soon = indique un traitement démarré et en cours. *
* *
* Description : Marque un candidat comme traité ou en cours de traitement. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_singleton_candidate_mark_as_processed(GSingletonCandidate *candidate, bool soon)
{
GSingletonCandidateIface *iface; /* Interface utilisée */
iface = G_SINGLETON_CANDIDATE_GET_IFACE(candidate);
iface->mark(candidate, soon);
}
/******************************************************************************
* *
* Paramètres : candidate = objet dont l'instance se veut unique. *
* soon = indique un traitement démarré et en cours. *
* *
* Description : Indique si un objet marqué comme unique. *
* *
* Retour : true si l'objet est traité ou en phase de l'être, ou false. *
* *
* Remarques : - *
* *
******************************************************************************/
bool g_singleton_candidate_is_processed(const GSingletonCandidate *candidate, bool soon)
{
bool result; /* Statut à retourner */
GSingletonCandidateIface *iface; /* Interface utilisée */
iface = G_SINGLETON_CANDIDATE_GET_IFACE(candidate);
result = iface->is_processed(candidate, soon);
return result;
}
/* ---------------------------------------------------------------------------------- */
/* COLLECTION D'INSTANCES UNIQUES */
/* ---------------------------------------------------------------------------------- */
/* Indique le type défini pour une mémoire de types d'objets. */
G_DEFINE_TYPE(GSingletonFactory, g_singleton_factory, G_TYPE_OBJECT);
/******************************************************************************
* *
* Paramètres : klass = classe à initialiser. *
* *
* Description : Initialise la classe des compacteurs d'instances de types. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_singleton_factory_class_init(GSingletonFactoryClass *klass)
{
GObjectClass *object; /* Autre version de la classe */
object = G_OBJECT_CLASS(klass);
object->dispose = (GObjectFinalizeFunc/* ! */)g_singleton_factory_dispose;
object->finalize = (GObjectFinalizeFunc)g_singleton_factory_finalize;
}
/******************************************************************************
* *
* Paramètres : factory = instance à initialiser. *
* *
* Description : Initialise une instance de compacteur d'instances de types. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_singleton_factory_init(GSingletonFactory *factory)
{
factory->table = g_hash_table_new_full((GHashFunc)g_singleton_candidate_hash,
(GEqualFunc)g_singleton_candidate_is_equal,
g_object_unref, NULL);
g_mutex_init(&factory->access);
}
/******************************************************************************
* *
* Paramètres : factory = instance d'objet GLib à traiter. *
* *
* Description : Supprime toutes les références externes. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_singleton_factory_dispose(GSingletonFactory *factory)
{
if (factory->table != NULL)
{
g_hash_table_unref(factory->table);
factory->table = NULL;
}
G_OBJECT_CLASS(g_singleton_factory_parent_class)->dispose(G_OBJECT(factory));
}
/******************************************************************************
* *
* Paramètres : factory = instance d'objet GLib à traiter. *
* *
* Description : Procède à la libération totale de la mémoire. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_singleton_factory_finalize(GSingletonFactory *factory)
{
g_mutex_clear(&factory->access);
G_OBJECT_CLASS(g_singleton_factory_parent_class)->finalize(G_OBJECT(factory));
}
/******************************************************************************
* *
* Paramètres : - *
* *
* Description : Crée un compacteur d'instances de types. *
* *
* Retour : Instance mise en place. *
* *
* Remarques : - *
* *
******************************************************************************/
GSingletonFactory *g_singleton_factory_new(void)
{
GSingletonFactory *result; /* Structure à retourner */
result = g_object_new(G_TYPE_SINGLETON_FACTORY, NULL);
return result;
}
/******************************************************************************
* *
* Paramètres : factory = gestionnaire d'instances uniques à consulter. *
* candidate = instance à conserver ou oublier. *
* *
* Description : Fournit l'instance unique correspondant à un objet. *
* *
* Retour : Instance unique à utiliser. *
* *
* Remarques : - *
* *
******************************************************************************/
GSingletonCandidate *g_singleton_factory_get_instance(GSingletonFactory *factory, GSingletonCandidate *candidate)
{
GSingletonCandidate *result; /* Instance unique à retourner */
#ifndef NDEBUG
gboolean status; /* Validation d'une opération */
#endif
g_mutex_lock(&factory->access);
if (g_hash_table_contains(factory->table, candidate))
{
#ifndef NDEBUG
status = g_hash_table_lookup_extended(factory->table, candidate, (void **)&result, NULL);
assert(status);
#else
g_hash_table_lookup_extended(factory->table, candidate, (void **)&result, NULL);
#endif
}
else
{
g_object_ref(G_OBJECT(candidate));
#ifndef NDEBUG
status = g_hash_table_add(factory->table, candidate);
assert(status);
#else
g_hash_table_add(factory->table, candidate);
#endif
result = candidate;
}
g_object_ref(G_OBJECT(result));
g_mutex_unlock(&factory->access);
return result;
}