lsup_rdf/cpython/py_term.h

#ifndef _PY_TERM_OBJ_H
#define _PY_TERM_OBJ_H

#define PY_SSIZE_T_CLEAN

#include <Python.h>
#include <structmember.h>

#include "term.h"


typedef struct {
    PyObject_HEAD
    LSUP_Term * ob_struct;
} TermObject;


static int
Term_init (TermObject *self, PyObject *args, PyObject *kwargs)
{
    unsigned char term_type;
    char *data = NULL, *datatype = NULL, *lang = NULL;

    static char *kwlist[] = {"", "", "datatype", "lang", NULL};

    if (!PyArg_ParseTupleAndKeywords (
            args, kwargs, "bs|zz", kwlist,
            &term_type, &data, &datatype, &lang))
        return -1;

    char *metadata = datatype ? datatype : lang;

    self->ob_struct = LSUP_term_new (
            (LSUP_TermType) term_type, data, metadata);
    if (!self->ob_struct) {
        PyErr_SetString (PyExc_ValueError, "Could not create term.");
        return -1;
    }

    return 0;
}

static void
Term_dealloc (TermObject *self)
{
    LSUP_term_free (self->ob_struct);
    Py_TYPE (self)->tp_free ((PyObject *) self);
}


static PyObject *
Term_get_type (TermObject *self, void *closure)
{
    PyObject *type = PyLong_FromLong (self->ob_struct->type);

    Py_INCREF (type);
    return type;
}


static PyObject *
Term_get_data (TermObject *self, void *closure)
{
    PyObject *data = PyUnicode_FromString (self->ob_struct->data);

    Py_INCREF (data);
    return data;
}


static PyObject *
Term_get_datatype (TermObject *self, void *closure)
{
    if (!self->ob_struct->datatype) Py_RETURN_NONE;

    const LSUP_Term *dtype = LSUP_tcache_get (self->ob_struct->datatype);
    if (!dtype) Py_RETURN_NONE;

    PyObject *datatype = PyUnicode_FromString (dtype->data);

    Py_INCREF (datatype);
    return datatype;
}

static PyObject *
Term_get_lang (TermObject *self, void *closure)
{
    if (
            !self->ob_struct->datatype || !self->ob_struct->lang ||
            strlen (self->ob_struct->lang) == 0)
        Py_RETURN_NONE;

    PyObject *lang = PyUnicode_FromString (self->ob_struct->lang);

    Py_INCREF (lang);
    return lang;
}


static PyGetSetDef Term_getsetters[] = {
    {"type", (getter) Term_get_type, NULL, "Term type.", NULL},
    {"data", (getter) Term_get_data, NULL, "Term data.", NULL},
    {
        "datatype", (getter) Term_get_datatype,
        NULL, "Literal term data type.", NULL
    },
    {
        "lang", (getter) Term_get_lang,
        NULL, "Literal term language tag.", NULL
    },
    {NULL}
};


static PyObject *
Term_richcmp (PyObject *obj1, PyObject *obj2, int op);


static Py_hash_t
Term_hash (PyObject *self)
{ return LSUP_term_hash (((TermObject *)self)->ob_struct); }


PyTypeObject TermType = {
    PyVarObject_HEAD_INIT(NULL, 0)
    .tp_name = "term.Term",
    .tp_doc = "RDF term",
    .tp_basicsize = sizeof (TermObject),
    .tp_itemsize = 0,
    .tp_flags = Py_TPFLAGS_DEFAULT,
    .tp_new = PyType_GenericNew,
    .tp_init = (initproc) Term_init,
    .tp_dealloc = (destructor) Term_dealloc,
    .tp_getset = Term_getsetters,
    .tp_richcompare = Term_richcmp,
    .tp_hash = Term_hash,
};


static PyObject *
Term_richcmp (PyObject *obj1, PyObject *obj2, int op)
{
    PyObject *result = NULL;

    if (
        ! PyObject_TypeCheck (obj1, &TermType) ||
        ! PyObject_TypeCheck (obj2, &TermType)
    ) return NULL;

    int c = 0;
    LSUP_Term *t1 = ((TermObject *) obj1)->ob_struct;
    LSUP_Term *t2 = ((TermObject *) obj2)->ob_struct;

    switch (op) {
        case Py_LT: result = Py_NotImplemented; break;
        case Py_LE: result = Py_NotImplemented; break;
        case Py_EQ: c = LSUP_term_equals (t1, t2); break;
        case Py_NE: c = ! LSUP_term_equals (t1, t2); break;
        case Py_GT: result = Py_NotImplemented; break;
        case Py_GE: result = Py_NotImplemented; break;
    }

    if (!result) result = c ? Py_True : Py_False;

    Py_INCREF(result);
    return result;
 }

// END _PY_TERM_OBJ_H
#endif