summaryrefslogtreecommitdiff
path: root/plugins/pychrysalide
diff options
context:
space:
mode:
Diffstat (limited to 'plugins/pychrysalide')
-rw-r--r--plugins/pychrysalide/glibext/singleton.c435
1 files changed, 422 insertions, 13 deletions
diff --git a/plugins/pychrysalide/glibext/singleton.c b/plugins/pychrysalide/glibext/singleton.c
index 2be1105..c4592ac 100644
--- a/plugins/pychrysalide/glibext/singleton.c
+++ b/plugins/pychrysalide/glibext/singleton.c
@@ -25,6 +25,7 @@
#include "singleton.h"
+#include <assert.h>
#include <pygobject.h>
@@ -43,15 +44,33 @@
/* Procède à l'initialisation de l'interface de candidature. */
static void py_singleton_candidate_interface_init(GSingletonCandidateIface *, gpointer *);
+/* Fournit une liste de candidats embarqués par un candidat. */
+static GSingletonCandidate **py_singleton_candidate_list_inner_instances_wrapper(const GSingletonCandidate *, size_t *);
+
+/* Met à jour une liste de candidats embarqués par un candidat. */
+static void py_singleton_candidate_update_inner_instances_wrapper(GSingletonCandidate *, GSingletonCandidate **, size_t);
+
/* Fournit l'empreinte d'un candidat à une centralisation. */
static guint py_singleton_candidate___hash__wrapper(const GSingletonCandidate *);
/* Détermine si deux candidats à l'unicité sont identiques. */
static gboolean py_singleton_candidate___eq__wrapper(const GSingletonCandidate *, const GSingletonCandidate *);
+/* Marque un candidat comme figé. */
+static void py_singleton_candidate_set_ro_wrapper(GSingletonCandidate *);
+
+/* Indique si le candidat est figé. */
+static bool py_singleton_candidate_is_ro_wrapper(GSingletonCandidate *);
+
/* Fournit l'empreinte d'un candidat à une centralisation. */
static PyObject *py_singleton_candidate_hash(PyObject *, PyObject *);
+/* Fournit une liste de candidats embarqués par un candidat. */
+static PyObject *py_singleton_candidate_get_inner_instances(PyObject *, void *);
+
+/* Indique si le candidat est figé. */
+static PyObject *py_singleton_candidate_get_read_only(PyObject *, void *);
+
/* Effectue une comparaison avec un objet 'SingletonCandidate'. */
static PyObject *py_singleton_candidate_richcompare(PyObject *, PyObject *, int);
@@ -92,8 +111,9 @@ static PyObject *py_singleton_factory_get_instance(PyObject *, PyObject *);
static void py_singleton_candidate_interface_init(GSingletonCandidateIface *iface, gpointer *unused)
{
#define SINGLETON_CANDIDATE_DOC \
- "The SingletonCandidate class is a required interface for types aiming" \
- " at becoming singleton instances.\n" \
+ "The SingletonCandidate class is a required interface for objects" \
+ " aiming at becoming singleton instances. All shared singletons are" \
+ " registered within a pychrysalide.glibext.SingletonFactory object.\n" \
"\n" \
"The main implemantations come with types derived from" \
" pychrysalide.analysis.DataType.\n" \
@@ -104,12 +124,188 @@ static void py_singleton_candidate_interface_init(GSingletonCandidateIface *ifac
" ...\n" \
"\n" \
"The following methods have to be defined for new implementations:\n" \
+ "* pychrysalide.glibext.SingletonCandidate._list_inner_instances();\n" \
+ "* pychrysalide.glibext.SingletonCandidate._update_inner_instances();\n"\
"* pychrysalide.glibext.SingletonCandidate.__hash__();\n" \
- "* pychrysalide.glibext.SingletonCandidate.__eq__()."
+ "* pychrysalide.glibext.SingletonCandidate.__eq__();\n" \
+ "* pychrysalide.glibext.SingletonCandidate._set_read_only();\n" \
+ "* pychrysalide.glibext.SingletonCandidate._is_read_only().\n"
+
+ iface->update_inner = py_singleton_candidate_update_inner_instances_wrapper;
+ iface->list_inner = py_singleton_candidate_list_inner_instances_wrapper;
iface->hash = py_singleton_candidate___hash__wrapper;
iface->is_equal = py_singleton_candidate___eq__wrapper;
+ iface->set_ro = py_singleton_candidate_set_ro_wrapper;
+ iface->is_ro = py_singleton_candidate_is_ro_wrapper;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : candidate = objet dont l'instance se veut unique. *
+* count = quantité d'instances à l'unicité internes. *
+* *
+* Description : Fournit une liste de candidats embarqués par un candidat. *
+* *
+* Retour : Liste de candidats internes ou NULL si aucun. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static GSingletonCandidate **py_singleton_candidate_list_inner_instances_wrapper(const GSingletonCandidate *candidate, size_t *count)
+{
+ GSingletonCandidate **result; /* Instances à retourner */
+ PyGILState_STATE gstate; /* Sauvegarde d'environnement */
+ PyObject *pyobj; /* Objet Python concerné */
+ PyObject *pyinstances; /* Liste en version Python */
+ int ret; /* Bilan d'un appel */
+ Py_ssize_t size; /* Taille de la liste */
+ Py_ssize_t i; /* Boucle de parcours #1 */
+ PyObject *pyinstance; /* Instance interne */
+ Py_ssize_t k; /* Boucle de parcours #2 */
+
+#define SINGLETON_CANDIDATE_LIST_INNER_INSTANCES_WRAPPER PYTHON_WRAPPER_DEF \
+( \
+ _list_inner_instances, "$self, /", \
+ METH_NOARGS, \
+ "Provide an internal access to the list of optional internal singleton" \
+ " candidate instances.\n" \
+ "\n" \
+ "The result has to be a tuple containing zero or more" \
+ " pychrysalide.glibext.SingletonCandidate instances." \
+)
+
+ result = NULL;
+ *count = 0;
+
+ gstate = PyGILState_Ensure();
+
+ pyobj = pygobject_new(G_OBJECT(candidate));
+
+ if (has_python_method(pyobj, "_list_inner_instances"))
+ {
+ pyinstances = run_python_method(pyobj, "_list_inner_instances", NULL);
+
+ if (pyinstances != NULL)
+ {
+ ret = PyTuple_Check(pyinstances);
+ if (!ret)
+ {
+ PyErr_SetString(PyExc_TypeError, "the _inner_instances attribute must be a tuple");
+ goto done;
+ }
+
+ size = PyTuple_GET_SIZE(pyinstances);
+
+ result = calloc(size, sizeof(GSingletonCandidate *));
+
+ for (i = 0; i < size; i++)
+ {
+ pyinstance = PyTuple_GET_ITEM(pyinstances, i);
+
+ ret = PyObject_IsInstance(pyinstance, (PyObject *)get_python_singleton_candidate_type());
+ if (ret != 1)
+ {
+ PyErr_SetString(PyExc_TypeError, "the _inner_instances attribute must only contain pychrysalide.glibext.SingletonCandidate instances");
+
+ for (k = 0; k < i; k++)
+ g_object_unref(G_OBJECT(result[k]));
+
+ free(result);
+ result = NULL;
+
+ goto done;
+
+ }
+
+ result[i] = G_SINGLETON_CANDIDATE(pygobject_get(pyinstance));
+ assert(result[i] != NULL);
+
+ g_object_ref(G_OBJECT(result[i]));
+
+ }
+
+ *count = size;
+
+ done:
+
+ Py_DECREF(pyinstances);
+
+ }
+
+ }
+
+ Py_DECREF(pyobj);
+
+ PyGILState_Release(gstate);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : candidate = objet dont l'instance se veut unique. *
+* instances = liste de candidats internes devenus singletons. *
+* count = quantité d'instances à l'unicité internes. *
+* *
+* Description : Met à jour une liste de candidats embarqués par un candidat. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void py_singleton_candidate_update_inner_instances_wrapper(GSingletonCandidate *candidate, GSingletonCandidate **instances, size_t count)
+{
+ PyGILState_STATE gstate; /* Sauvegarde d'environnement */
+ PyObject *pyobj; /* Objet Python concerné */
+ PyObject *args; /* Arguments pour l'appel */
+ PyObject *pyinstances; /* Liste d'instances converties*/
+ size_t i; /* Boucle de parcours */
+ PyObject *pyret; /* Bilan de consultation */
+
+#define SINGLETON_CANDIDATE_UPDATE_INNER_INSTANCES_WRAPPER PYTHON_WRAPPER_DEF \
+( \
+ _update_inner_instances, "$self, instances, /", \
+ METH_VARARGS, \
+ "Update the list of internal singleton candidate instances.\n" \
+ "\n" \
+ "The provided *instances* are a tuple of pychrysalide.glibext.SingletonCandidate" \
+ " objets promoted as singletons." \
+)
+
+ gstate = PyGILState_Ensure();
+
+ pyobj = pygobject_new(G_OBJECT(candidate));
+
+ if (has_python_method(pyobj, "_update_inner_instances"))
+ {
+ args = PyTuple_New(1);
+
+ pyinstances = PyTuple_New(count);
+ PyTuple_SetItem(args, 0, pyinstances);
+
+ for (i = 0; i < count; i++)
+ PyTuple_SetItem(pyinstances, i, pygobject_new(G_OBJECT(instances[i])));
+
+ pyret = run_python_method(pyobj, "_update_inner_instances", args);
+
+ Py_XDECREF(pyret);
+ Py_DECREF(args);
+
+ }
+
+ Py_DECREF(pyobj);
+
+ PyGILState_Release(gstate);
+
}
@@ -132,13 +328,18 @@ static guint py_singleton_candidate___hash__wrapper(const GSingletonCandidate *c
PyObject *pyobj; /* Objet Python concerné */
PyObject *pyret; /* Bilan de consultation */
-#define SINGLETON_CANDIDATE_HASH_WRAPPER PYTHON_WRAPPER_DEF \
-( \
- __hash__, "$self, /", \
- METH_NOARGS, \
- "Abstract method used to produce a hash of the object.\n" \
- "\n" \
- "The result must be an integer value up to 64 bits." \
+#define SINGLETON_CANDIDATE_HASH_WRAPPER PYTHON_WRAPPER_DEF \
+( \
+ __hash__, "$self, /", \
+ METH_NOARGS, \
+ "Abstract method used to produce a hash of the object.\n" \
+ "\n" \
+ "The result must be an integer value up to 64 bits." \
+ "\n" \
+ "Inner instances which are listed through the" \
+ " pychrysalide.glibext.SingletonCandidate._list_inner_instances()" \
+ " method do not need to get processed here as they are handled" \
+ " automatically by the interface core." \
)
result = 0;
@@ -239,6 +440,111 @@ static gboolean py_singleton_candidate___eq__wrapper(const GSingletonCandidate *
/******************************************************************************
* *
+* Paramètres : candidate = objet dont l'instance se veut unique. *
+* *
+* Description : Marque un candidat comme figé. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void py_singleton_candidate_set_ro_wrapper(GSingletonCandidate *candidate)
+{
+ PyGILState_STATE gstate; /* Sauvegarde d'environnement */
+ PyObject *pyobj; /* Objet Python concerné */
+ PyObject *pyret; /* Bilan de consultation */
+
+#define SINGLETON_CANDIDATE_SET_RO_WRAPPER PYTHON_WRAPPER_DEF \
+( \
+ _set_read_only, "$self, /", \
+ METH_NOARGS, \
+ "Abstract method used to mark the content of a singleton" \
+ " candidate as read-only.\n" \
+ "\n" \
+ "The read-only state is mandatory once the candidate is" \
+ " registered inside a pychrysalide.glibext.SingletonFactory"\
+ " instance as official singleton." \
+)
+
+ gstate = PyGILState_Ensure();
+
+ pyobj = pygobject_new(G_OBJECT(candidate));
+
+ if (has_python_method(pyobj, "_set_read_only"))
+ {
+ pyret = run_python_method(pyobj, "_set_read_only", NULL);
+
+ Py_XDECREF(pyret);
+
+ }
+
+ Py_DECREF(pyobj);
+
+ PyGILState_Release(gstate);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : candidate = objet dont l'instance se veut unique. *
+* *
+* Description : Indique si le candidat est figé. *
+* *
+* Retour : true si le contenu du candidat ne peut plus être modifié. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static bool py_singleton_candidate_is_ro_wrapper(GSingletonCandidate *candidate)
+{
+ bool result; /* Etat à retourner */
+ PyGILState_STATE gstate; /* Sauvegarde d'environnement */
+ PyObject *pyobj; /* Objet Python concerné */
+ PyObject *pyret; /* Bilan de consultation */
+
+#define SINGLETON_CANDIDATE_IS_RO_WRAPPER PYTHON_WRAPPER_DEF \
+( \
+ _is_read_only, "$self, /", \
+ METH_NOARGS, \
+ "Abstract method used to retrieve the status of the data" \
+ " contained by a singleton candidate.\n" \
+ "\n" \
+ "The retured value is *True* if the candidate is" \
+ " registered inside a pychrysalide.glibext.SingletonFactory"\
+ " instance as official singleton, *False* otherwise." \
+)
+
+ result = false;
+
+ gstate = PyGILState_Ensure();
+
+ pyobj = pygobject_new(G_OBJECT(candidate));
+
+ if (has_python_method(pyobj, "_is_read_only"))
+ {
+ pyret = run_python_method(pyobj, "_is_read_only", NULL);
+
+ result = (pyret == Py_True);
+
+ Py_XDECREF(pyret);
+
+ }
+
+ Py_DECREF(pyobj);
+
+ PyGILState_Release(gstate);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
* Paramètres : self = objet dont l'instance se veut unique. *
* args = adresse non utilisée ici. *
* *
@@ -262,6 +568,10 @@ static PyObject *py_singleton_candidate_hash(PyObject *self, PyObject *args)
METH_NOARGS, py_singleton_candidate, \
"Compute the hash value of the singleton candidate.\n" \
"\n" \
+ "The method relies on the interface core to include in the" \
+ " process the optional embedded instances which may become" \
+ " singletons.\n" \
+ "\n" \
"The result is an integer value.\n" \
"\n" \
"Even if the Python *hash()* method, relying on the" \
@@ -284,6 +594,99 @@ static PyObject *py_singleton_candidate_hash(PyObject *self, PyObject *args)
/******************************************************************************
* *
+* Paramètres : self = objet Python concerné par l'appel. *
+* closure = non utilisé ici. *
+* *
+* Description : Fournit une liste de candidats embarqués par un candidat. *
+* *
+* Retour : Liste de candidats internes, vide si aucun. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static PyObject *py_singleton_candidate_get_inner_instances(PyObject *self, void *closure)
+{
+ PyObject *result; /* Valeur à retourner */
+ GSingletonCandidate *candidate; /* Mécanismes natifs */
+ size_t count; /* Quantité d'objets internes */
+ GSingletonCandidate **instances; /* Liste des embarqués */
+ size_t i; /* Boucle de parcours */
+
+#define SINGLETON_CANDIDATE_INNER_INSTANCES_ATTRIB PYTHON_GET_DEF_FULL \
+( \
+ inner_instances, py_singleton_candidate, \
+ "List of optional internal singleton candidate instances.\n" \
+ "\n" \
+ "The result has to be a tuple containing zero or more" \
+ " pychrysalide.glibext.SingletonCandidate instances." \
+)
+
+ candidate = G_SINGLETON_CANDIDATE(pygobject_get(self));
+
+ instances = g_singleton_candidate_list_inner_instances(candidate, &count);
+
+ result = PyTuple_New(count);
+
+ for (i = 0; i < count; i++)
+ {
+ PyTuple_SetItem(result, i, pygobject_new(G_OBJECT(instances[i])));
+ g_object_unref(G_OBJECT(instances[i]));
+ }
+
+ if (instances != NULL)
+ free(instances);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : self = objet Python concerné par l'appel. *
+* closure = non utilisé ici. *
+* *
+* Description : Indique si le candidat est figé. *
+* *
+* Retour : true si le contenu du candidat ne peut plus être modifié. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static PyObject *py_singleton_candidate_get_read_only(PyObject *self, void *closure)
+{
+ PyObject *result; /* Valeur à retourner */
+ GSingletonCandidate *candidate; /* Mécanismes natifs */
+ bool status; /* Etat de l'élément consulté */
+
+#define SINGLETON_CANDIDATE_READ_ONLY_ATTRIB PYTHON_GET_DEF_FULL \
+( \
+ read_only, py_singleton_candidate, \
+ "State of the singleton candidate content.\n" \
+ "\n" \
+ "The result is a boolean: *True* if the object is registered" \
+ " as singleton, *False* otherwise.\n" \
+ "\n" \
+ "Once a singleton, the object must not change its content as" \
+ " it is a shared instance." \
+)
+
+ candidate = G_SINGLETON_CANDIDATE(pygobject_get(self));
+
+ status = g_singleton_candidate_is_read_only(candidate);
+
+ result = status ? Py_True : Py_False;
+ Py_INCREF(result);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
* Paramètres : a = premier object Python à consulter. *
* b = second object Python à consulter. *
* op = type de comparaison menée. *
@@ -300,8 +703,8 @@ static PyObject *py_singleton_candidate_richcompare(PyObject *a, PyObject *b, in
{
PyObject *result; /* Bilan à retourner */
int ret; /* Bilan de lecture des args. */
- const GSingletonCandidate *cand_a; /* Premier élément à traiter */
- const GSingletonCandidate *cand_b; /* Second élément à traiter */
+ GSingletonCandidate *cand_a; /* Premier élément à traiter */
+ GSingletonCandidate *cand_b; /* Second élément à traiter */
gboolean status; /* Résultat d'une comparaison */
if (op != Py_EQ)
@@ -348,13 +751,19 @@ static PyObject *py_singleton_candidate_richcompare(PyObject *a, PyObject *b, in
PyTypeObject *get_python_singleton_candidate_type(void)
{
static PyMethodDef py_singleton_candidate_methods[] = {
+ SINGLETON_CANDIDATE_LIST_INNER_INSTANCES_WRAPPER,
+ SINGLETON_CANDIDATE_UPDATE_INNER_INSTANCES_WRAPPER,
SINGLETON_CANDIDATE_HASH_WRAPPER,
SINGLETON_CANDIDATE_EQ_WRAPPER,
+ SINGLETON_CANDIDATE_SET_RO_WRAPPER,
+ SINGLETON_CANDIDATE_IS_RO_WRAPPER,
SINGLETON_CANDIDATE_HASH_METHOD,
{ NULL }
};
static PyGetSetDef py_singleton_candidate_getseters[] = {
+ SINGLETON_CANDIDATE_INNER_INSTANCES_ATTRIB,
+ SINGLETON_CANDIDATE_READ_ONLY_ATTRIB,
{ NULL }
};
@@ -689,7 +1098,7 @@ PyTypeObject *get_python_singleton_factory_type(void)
bool ensure_python_singleton_factory_is_registered(void)
{
- PyTypeObject *type; /* Type Python 'ObjectSingleton' */
+ PyTypeObject *type; /* Type 'SingletonFactory' */
PyObject *module; /* Module à recompléter */
PyObject *dict; /* Dictionnaire du module */
generated by cgit v0.11.2-87-g4458 at 2024-12-27 13:29:55 (GMT)