Annotation of gpl/axl/py-axl/py_axl_node.c, revision 1.1
1.1 ! misho 1: /**
! 2: * PyAxl: Axl Library python bindings
! 3: * Copyright (C) 2009 Advanced Software Production Line, S.L.
! 4: *
! 5: * This program is free software; you can redistribute it and/or
! 6: * modify it under the terms of the GNU Lesser General Public License
! 7: * as published by the Free Software Foundation; either version 2.1
! 8: * of the License, or (at your option) any later version.
! 9: *
! 10: * This program is distributed in the hope that it will be useful,
! 11: * but WITHOUT ANY WARRANTY; without even the implied warranty of
! 12: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
! 13: * Lesser General Public License for more details.
! 14: *
! 15: * You should have received a copy of the GNU Lesser General Public
! 16: * License along with this program; if not, write to the Free
! 17: * Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
! 18: * 02111-1307 USA
! 19: *
! 20: * You may find a copy of the license under this software is released
! 21: * at COPYING file. This is LGPL software: you are welcome to develop
! 22: * proprietary applications using this library without any royalty or
! 23: * fee but returning back any change, improvement or addition in the
! 24: * form of source code, project image, documentation patches, etc.
! 25: *
! 26: * For commercial support for XML enabled solutions contact us:
! 27: *
! 28: * Postal address:
! 29: * Advanced Software Production Line, S.L.
! 30: * C/ Antonio Suarez Nº 10,
! 31: * Edificio Alius A, Despacho 102
! 32: * Alcalá de Henares 28802 (Madrid)
! 33: * Spain
! 34: *
! 35: * Email address:
! 36: * info@aspl.es - http://www.aspl.es/axl
! 37: */
! 38: #include <py_axl_node.h>
! 39:
! 40: #define LOG_DOMAIN "py-axl-node"
! 41:
! 42: struct _PyAxlNode {
! 43: /* header required to initialize python required bits for
! 44: every python object */
! 45: PyObject_HEAD
! 46:
! 47: /* pointer to the axl node */
! 48: axlNode * node;
! 49: axl_bool finish_on_gc;
! 50: };
! 51:
! 52: static int py_axl_node_init_type (PyAxlNode *self, PyObject *args, PyObject *kwds)
! 53: {
! 54: return 0;
! 55: }
! 56:
! 57: /**
! 58: * @brief Function used to allocate memory required by the object
! 59: * axl.Node
! 60: */
! 61: static PyObject * py_axl_node_new (PyTypeObject *type, PyObject *args, PyObject *kwds)
! 62: {
! 63: PyAxlNode * self;
! 64: const char * name = NULL;
! 65:
! 66: /* create the object */
! 67: self = (PyAxlNode *)type->tp_alloc(type, 0);
! 68:
! 69: /* parse and get node name */
! 70: if (! PyArg_ParseTuple (args, "|s", &name))
! 71: return NULL;
! 72:
! 73: /* create the node if received a defined name */
! 74: if (name != NULL) {
! 75: self->node = axl_node_create (name);
! 76: self->finish_on_gc = axl_true;
! 77: }
! 78:
! 79: return (PyObject *)self;
! 80: }
! 81:
! 82: /**
! 83: * @brief Function used to finish and dealloc memory used by the
! 84: * object axl.Node
! 85: */
! 86: static void py_axl_node_dealloc (PyAxlNode* self)
! 87: {
! 88:
! 89: /* release node on if it is signaled to be released and it was
! 90: * not configured to be inside a document, which means the
! 91: * document will take care of this */
! 92: if (self->finish_on_gc && axl_node_get_doc (self->node) == NULL)
! 93: axl_node_free (self->node);
! 94: self->node = NULL;
! 95:
! 96: /* free the node it self */
! 97: self->ob_type->tp_free ((PyObject*)self);
! 98:
! 99: return;
! 100: }
! 101:
! 102: /**
! 103: * @brief This function implements the generic attribute getting that
! 104: * allows to perform complex member resolution (not merely direct
! 105: * member access).
! 106: */
! 107: PyObject * py_axl_node_get_attr (PyObject *o, PyObject *attr_name) {
! 108: const char * attr = NULL;
! 109: PyObject * result;
! 110: PyAxlNode * self = (PyAxlNode *) o;
! 111: PyObject * tuple;
! 112: int size = 0;
! 113:
! 114: /* now implement other attributes */
! 115: if (! PyArg_Parse (attr_name, "s", &attr))
! 116: return NULL;
! 117:
! 118: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "received request to report node attr name %s (self: %p)",
! 119: attr, o);
! 120:
! 121: if (axl_cmp (attr, "name")) {
! 122: /* name */
! 123: return Py_BuildValue ("s", axl_node_get_name (self->node));
! 124: } else if (axl_cmp (attr, "first_child")) {
! 125: /* first_child */
! 126: if (axl_node_get_first_child (self->node) == NULL) {
! 127: Py_INCREF (Py_None);
! 128: return Py_None;
! 129: }
! 130:
! 131: return Py_BuildValue ("O", py_axl_node_create (axl_node_get_first_child (self->node), axl_false));
! 132: } else if (axl_cmp (attr, "next")) {
! 133: /* next */
! 134: if (axl_node_get_next (self->node) == NULL) {
! 135: Py_INCREF (Py_None);
! 136: return Py_None;
! 137: }
! 138:
! 139: return Py_BuildValue ("O", py_axl_node_create (axl_node_get_next (self->node), axl_false));
! 140: } else if (axl_cmp (attr, "previous")) {
! 141: /* previous */
! 142: if (axl_node_get_previous (self->node) == NULL) {
! 143: Py_INCREF (Py_None);
! 144: return Py_None;
! 145: }
! 146:
! 147: return Py_BuildValue ("O", py_axl_node_create (axl_node_get_previous (self->node), axl_false));
! 148: } else if (axl_cmp (attr, "parent")) {
! 149: /* parent */
! 150: if (axl_node_get_parent (self->node) == NULL) {
! 151: Py_INCREF (Py_None);
! 152: return Py_None;
! 153: }
! 154:
! 155: return Py_BuildValue ("O", py_axl_node_create (axl_node_get_parent (self->node), axl_false));
! 156:
! 157: } else if (axl_cmp (attr, "content")) {
! 158: /* return a tuple with content and size */
! 159: tuple = PyTuple_New (2);
! 160:
! 161: PyTuple_SetItem (tuple, 0, Py_BuildValue ("z", axl_node_get_content (self->node, &size)));
! 162: PyTuple_SetItem (tuple, 1, Py_BuildValue ("i", size));
! 163:
! 164: return tuple;
! 165: } else if (axl_cmp (attr, "doc")) {
! 166:
! 167: /* check if the node has a document configured */
! 168: if (axl_node_get_doc (self->node) == NULL) {
! 169: /* return none */
! 170: Py_INCREF (Py_None);
! 171: return Py_None;
! 172: } /* end if */
! 173:
! 174: /* ok, return document holding the node */
! 175: return py_axl_doc_create (axl_node_get_doc (self->node), axl_false);
! 176: }
! 177:
! 178: /* first implement generic attr already defined */
! 179: result = PyObject_GenericGetAttr (o, attr_name);
! 180: if (result)
! 181: return result;
! 182:
! 183: return NULL;
! 184: }
! 185:
! 186: /**
! 187: * @brief Implements attribute set operation.
! 188: */
! 189: int py_axl_node_set_attr (PyObject *o, PyObject *attr_name, PyObject *v)
! 190: {
! 191: const char * attr = NULL;
! 192: /* PyAxlNode * self = (PyAxlNode *) o; */
! 193: /* axl_bool boolean_value = axl_false; */
! 194:
! 195: /* now implement other attributes */
! 196: if (! PyArg_Parse (attr_name, "s", &attr))
! 197: return -1;
! 198:
! 199: /* now implement generic setter */
! 200: return PyObject_GenericSetAttr (o, attr_name, v);
! 201: }
! 202:
! 203: static PyObject * py_axl_node_next_called (PyObject * _self, PyObject * args)
! 204: {
! 205: PyAxlNode * self = (PyAxlNode *) _self;
! 206: const char * node_name = NULL;
! 207: axlNode * node = NULL;
! 208:
! 209: /* parse and check result */
! 210: if (! PyArg_ParseTuple (args, "s", &node_name))
! 211: return NULL;
! 212:
! 213: /* get next called */
! 214: node = axl_node_get_next_called (self->node, node_name);
! 215: if (node == NULL) {
! 216: Py_INCREF (Py_None);
! 217: return Py_None;
! 218: } /* end if */
! 219:
! 220: /* create node result */
! 221: return py_axl_node_create (node, axl_false);
! 222: }
! 223:
! 224: static PyObject * py_axl_node_previous_called (PyObject * _self, PyObject * args)
! 225: {
! 226: PyAxlNode * self = (PyAxlNode *) _self;
! 227: const char * node_name = NULL;
! 228: axlNode * node = NULL;
! 229:
! 230: /* parse and check result */
! 231: if (! PyArg_ParseTuple (args, "s", &node_name))
! 232: return NULL;
! 233:
! 234: /* get previous called */
! 235: node = axl_node_get_previous_called (self->node, node_name);
! 236: if (node == NULL) {
! 237: Py_INCREF (Py_None);
! 238: return Py_None;
! 239: } /* end if */
! 240:
! 241: /* create node result */
! 242: return py_axl_node_create (node, axl_false);
! 243: }
! 244:
! 245: static PyObject * py_axl_node_child_called (PyObject * _self, PyObject * args)
! 246: {
! 247: PyAxlNode * self = (PyAxlNode *) _self;
! 248: const char * node_name = NULL;
! 249: axlNode * node = NULL;
! 250:
! 251: /* parse and check result */
! 252: if (! PyArg_ParseTuple (args, "s", &node_name))
! 253: return NULL;
! 254:
! 255: /* get previous called */
! 256: node = axl_node_get_child_called (self->node, node_name);
! 257: if (node == NULL) {
! 258: Py_INCREF (Py_None);
! 259: return Py_None;
! 260: } /* end if */
! 261:
! 262: /* create node result */
! 263: return py_axl_node_create (node, axl_false);
! 264: }
! 265:
! 266: static PyObject * py_axl_node_find_called (PyObject * _self, PyObject * args)
! 267: {
! 268: PyAxlNode * self = (PyAxlNode *) _self;
! 269: const char * node_name = NULL;
! 270: axlNode * node = NULL;
! 271:
! 272: /* parse and check result */
! 273: if (! PyArg_ParseTuple (args, "s", &node_name))
! 274: return NULL;
! 275:
! 276: /* get previous called */
! 277: node = axl_node_find_called (self->node, node_name);
! 278: if (node == NULL) {
! 279: Py_INCREF (Py_None);
! 280: return Py_None;
! 281: } /* end if */
! 282:
! 283: /* create node result */
! 284: return py_axl_node_create (node, axl_false);
! 285: }
! 286:
! 287: static PyObject * py_axl_node_nth_child (PyObject * _self, PyObject * args)
! 288: {
! 289: PyAxlNode * self = (PyAxlNode *) _self;
! 290: int position = -1;
! 291: axlNode * node = NULL;
! 292:
! 293: /* parse and check result */
! 294: if (! PyArg_ParseTuple (args, "i", &position))
! 295: return NULL;
! 296:
! 297: /* get previous called */
! 298: node = axl_node_get_child_nth (self->node, position);
! 299: if (node == NULL) {
! 300: Py_INCREF (Py_None);
! 301: return Py_None;
! 302: } /* end if */
! 303:
! 304: /* create node result */
! 305: return py_axl_node_create (node, axl_false);
! 306: }
! 307:
! 308: static PyObject * py_axl_node_has_attr (PyObject * _self, PyObject * args)
! 309: {
! 310: PyAxlNode * self = (PyAxlNode *) _self;
! 311: char * attr_name = NULL;
! 312: char * attr_value = NULL;
! 313:
! 314: /* parse and check result */
! 315: if (! PyArg_ParseTuple (args, "s|s", &attr_name, &attr_value))
! 316: return NULL;
! 317:
! 318: if (attr_value == NULL)
! 319: return Py_BuildValue ("i", HAS_ATTR (self->node, attr_name));
! 320: return Py_BuildValue ("i", HAS_ATTR_VALUE (self->node, attr_name, attr_value));
! 321: }
! 322:
! 323: static PyObject * py_axl_node_attr_value (PyObject * _self, PyObject * args)
! 324: {
! 325: PyAxlNode * self = (PyAxlNode *) _self;
! 326: char * attr_name = NULL;
! 327: char * attr_value = NULL;
! 328:
! 329: /* parse and check result */
! 330: if (! PyArg_ParseTuple (args, "s|s", &attr_name, &attr_value))
! 331: return NULL;
! 332:
! 333: /* check set operation */
! 334: if (PyTuple_Size (args) == 2) {
! 335: /* remove previous attribute if exists */
! 336: axl_node_remove_attribute (self->node, attr_name);
! 337:
! 338: /* found set operation */
! 339: axl_node_set_attribute (self->node, attr_name, attr_value);
! 340: Py_INCREF (Py_None);
! 341: return Py_None;
! 342: } /* end if */
! 343:
! 344: return Py_BuildValue ("z", ATTR_VALUE (self->node, attr_name));
! 345: }
! 346:
! 347: static PyObject * py_axl_node_set_child (PyObject * _self, PyObject * args)
! 348: {
! 349: PyAxlNode * self = (PyAxlNode *) _self;
! 350: PyObject * child = Py_None;
! 351:
! 352: /* parse and check result */
! 353: if (! PyArg_ParseTuple (args, "O", &child))
! 354: return NULL;
! 355:
! 356: /* check object received */
! 357: if (! py_axl_node_check (child)) {
! 358: /* set exception */
! 359: PyErr_SetString (PyExc_TypeError, "Expected to receive an axl.Node object but received something different");
! 360: return NULL;
! 361: }
! 362:
! 363: /* set the node as child */
! 364: axl_node_set_child (self->node, py_axl_node_get (child));
! 365:
! 366: /* return ok */
! 367: Py_INCREF (Py_None);
! 368: return Py_None;
! 369: }
! 370:
! 371: static PyObject * py_axl_node_attr_cursor_new (PyObject * _self, PyObject * args)
! 372: {
! 373: PyAxlNode * self = (PyAxlNode *) _self;
! 374:
! 375: /* create node cursor attr */
! 376: return py_axl_attr_cursor_create (axl_node_attr_cursor_new (self->node), axl_true);
! 377: }
! 378:
! 379:
! 380: static PyMethodDef py_axl_node_methods[] = {
! 381: /* next_called */
! 382: {"next_called", (PyCFunction) py_axl_node_next_called, METH_VARARGS,
! 383: "Gest the xml node found at the same level, but with the name provided."},
! 384: /* previous_called */
! 385: {"previous_called", (PyCFunction) py_axl_node_previous_called, METH_VARARGS,
! 386: "Gest the xml node found at the same level, but with the name provided."},
! 387: /* child_called */
! 388: {"child_called", (PyCFunction) py_axl_node_child_called, METH_VARARGS,
! 389: "Gets the xml child node called as provided. The child is looked up only on direct childs."},
! 390: /* find_called */
! 391: {"find_called", (PyCFunction) py_axl_node_find_called, METH_VARARGS,
! 392: "Gets the xml child node called as provided. The child is looked up in all childs found starting the parent node."},
! 393: /* nth_child */
! 394: {"nth_child", (PyCFunction) py_axl_node_nth_child, METH_VARARGS,
! 395: "Allows to get a reference to the child node located at the same level at the nth position"},
! 396: /* has_attr */
! 397: {"has_attr", (PyCFunction) py_axl_node_has_attr, METH_VARARGS,
! 398: "Allows to check if the provided node has the given attribute."},
! 399: /* attr */
! 400: {"attr", (PyCFunction) py_axl_node_attr_value, METH_VARARGS,
! 401: "Allows to get/set the given attribute on the provided node."},
! 402: /* set_child */
! 403: {"set_child", (PyCFunction) py_axl_node_set_child, METH_VARARGS,
! 404: "Allows to configure the provided node as the instance's child."},
! 405: /* attr_cursor_new */
! 406: {"attr_cursor_new", (PyCFunction) py_axl_node_attr_cursor_new, METH_NOARGS,
! 407: "Allows to create a new attribute cursor object used to iterate over all attributes of a node."},
! 408: {NULL}
! 409: };
! 410:
! 411: static PyTypeObject PyAxlNodeType = {
! 412: PyObject_HEAD_INIT(NULL)
! 413: 0, /* ob_size*/
! 414: "axl.Node", /* tp_name*/
! 415: sizeof(PyAxlNode), /* tp_basicsize*/
! 416: 0, /* tp_itemsize*/
! 417: (destructor)py_axl_node_dealloc, /* tp_dealloc*/
! 418: 0, /* tp_print*/
! 419: 0, /* tp_getattr*/
! 420: 0, /* tp_setattr*/
! 421: 0, /* tp_compare*/
! 422: 0, /* tp_repr*/
! 423: 0, /* tp_as_number*/
! 424: 0, /* tp_as_sequence*/
! 425: 0, /* tp_as_mapping*/
! 426: 0, /* tp_hash */
! 427: 0, /* tp_call*/
! 428: 0, /* tp_str*/
! 429: py_axl_node_get_attr, /* tp_getattro*/
! 430: py_axl_node_set_attr, /* tp_setattro*/
! 431: 0, /* tp_as_buffer*/
! 432: Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags*/
! 433: "Node object; wrapper of axlNode API type", /* tp_doc */
! 434: 0, /* tp_traverse */
! 435: 0, /* tp_clear */
! 436: 0, /* tp_richcompare */
! 437: 0, /* tp_weaklistoffset */
! 438: 0, /* tp_iter */
! 439: 0, /* tp_iternext */
! 440: py_axl_node_methods, /* tp_methods */
! 441: 0, /* py_axl_node_members, */ /* tp_members */
! 442: 0, /* tp_getset */
! 443: 0, /* tp_base */
! 444: 0, /* tp_dict */
! 445: 0, /* tp_descr_get */
! 446: 0, /* tp_descr_set */
! 447: 0, /* tp_dictoffset */
! 448: (initproc)py_axl_node_init_type, /* tp_init */
! 449: 0, /* tp_alloc */
! 450: py_axl_node_new, /* tp_new */
! 451:
! 452: };
! 453:
! 454:
! 455: /**
! 456: * @brief Allows to check if the PyObject received represents a
! 457: * PyAxlNode reference.
! 458: */
! 459: axl_bool py_axl_node_check (PyObject * obj)
! 460: {
! 461: /* check null references */
! 462: if (obj == NULL)
! 463: return axl_false;
! 464:
! 465: /* return check result */
! 466: return PyObject_TypeCheck (obj, &PyAxlNodeType);
! 467: }
! 468:
! 469: /**
! 470: * @brief Allows to create a new PyAxlNode instance using the copy
! 471: * provided.
! 472: *
! 473: * @param node The xml node that will represents the python instance.
! 474: *
! 475: * @param finish_on_gc Signal to finish or not the internal copy once
! 476: * the variable gets garbage collected.
! 477: */
! 478: PyObject * py_axl_node_create (axlNode * node,
! 479: axl_bool finish_on_gc)
! 480: {
! 481: /* return a new instance */
! 482: PyAxlNode * obj = (PyAxlNode *) PyObject_CallObject ((PyObject *) &PyAxlNodeType, NULL);
! 483:
! 484: /* check ref created */
! 485: if (obj == NULL) {
! 486: __axl_log (LOG_DOMAIN, AXL_LEVEL_CRITICAL, "Failed to create PyAxlNode object, returning NULL");
! 487: return NULL;
! 488: } /* end if */
! 489:
! 490: /* set node if defined */
! 491: if (node)
! 492: obj->node = node;
! 493: obj->finish_on_gc = finish_on_gc;
! 494:
! 495: return __PY_OBJECT (obj);
! 496: }
! 497:
! 498: /**
! 499: * @internal Allows to get the internal reference used by the provided
! 500: * PyAxlNode.
! 501: */
! 502: axlNode * py_axl_node_get (PyObject * obj)
! 503: {
! 504: /* check object received */
! 505: if (! py_axl_node_check (obj))
! 506: return NULL;
! 507:
! 508: /* return the node */
! 509: return ((PyAxlNode *)obj)->node;
! 510: }
! 511:
! 512: void init_axl_node (PyObject * module)
! 513: {
! 514: /* register type */
! 515: if (PyType_Ready(&PyAxlNodeType) < 0)
! 516: return;
! 517:
! 518: Py_INCREF (&PyAxlNodeType);
! 519: PyModule_AddObject(module, "Node", (PyObject *)&PyAxlNodeType);
! 520:
! 521: }
! 522:
! 523:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to py_axl_node.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / gpl / axl / py-axl