Annotation of gpl/axl/py-axl/py_axl_doc.c, revision 1.1.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_doc.h>
39:
40: #define LOG_DOMAIN "py-axl-doc"
41:
42: struct _PyAxlDoc {
43: /* header required to initialize python required bits for
44: every python object */
45: PyObject_HEAD
46:
47: /* pointer to the axl doc */
48: axlDoc * doc;
49: /* release the document on gc */
50: axl_bool finish_on_gc;
51: };
52:
53: static int py_axl_doc_init_type (PyAxlDoc *self, PyObject *args, PyObject *kwds)
54: {
55: return 0;
56: }
57:
58: /**
59: * @brief Function used to allocate memory required by the object
60: * axl.Doc
61: */
62: static PyObject * py_axl_doc_new (PyTypeObject *type, PyObject *args, PyObject *kwds)
63: {
64: PyAxlDoc * self;
65: const char * version = NULL;
66: const char * encoding = NULL;
67: axl_bool stand_alone = axl_true;
68:
69: /* now parse arguments */
70: static char *kwlist[] = {"version", "encoding", "standalone", NULL};
71:
72: /* create the object */
73: self = (PyAxlDoc *)type->tp_alloc(type, 0);
74:
75: /* in the case the constructor was called with arguments,
76: * check them */
77: if (! PyArg_ParseTupleAndKeywords(args, kwds, "|ssi", kwlist, &version, &encoding, &stand_alone))
78: return NULL;
79:
80: /* create the document */
81: self->finish_on_gc = axl_true;
82: self->doc = axl_doc_create (version, encoding, stand_alone);
83:
84: /* return reference created */
85: return (PyObject *)self;
86: }
87:
88: /**
89: * @brief Function used to finish and dealloc memory used by the
90: * object axl.Doc
91: */
92: static void py_axl_doc_dealloc (PyAxlDoc* self)
93: {
94: /* free document and nullfy pointer */
95: if (self->finish_on_gc)
96: axl_doc_free (self->doc);
97: self->doc = NULL;
98:
99: /* free the node it self */
100: self->ob_type->tp_free ((PyObject*)self);
101:
102: return;
103: }
104:
105: /**
106: * @brief This function implements the generic attribute getting that
107: * allows to perform complex member resolution (not merely direct
108: * member access).
109: */
110: PyObject * py_axl_doc_get_attr (PyObject *o, PyObject *attr_name) {
111: const char * attr = NULL;
112: PyObject * result;
113: PyAxlDoc * self = (PyAxlDoc *) o;
114:
115: /* now implement other attributes */
116: if (! PyArg_Parse (attr_name, "s", &attr))
117: return NULL;
118:
119: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "received request to report doc attr name %s (self: %p)",
120: attr, o);
121: if (axl_cmp (attr, "encoding")) {
122: /* encoding */
123: return Py_BuildValue ("s", axl_doc_get_encoding (self->doc));
124: } else if (axl_cmp (attr, "standalone") || axl_cmp (attr, "stand_alone")) {
125: /* standalone */
126: return Py_BuildValue ("i", axl_doc_get_standalone (self->doc));
127: } else if (axl_cmp (attr, "root")) {
128: if (axl_doc_get_root (self->doc) == NULL) {
129: Py_INCREF (Py_None);
130: return Py_None;
131: }
132:
133: /* return root axl node: signaling to not finish the
134: * internal copy once it is collected the reference */
135: return py_axl_node_create (axl_doc_get_root (self->doc), axl_false);
136: }
137:
138: /* first implement generic attr already defined */
139: result = PyObject_GenericGetAttr (o, attr_name);
140: if (result)
141: return result;
142:
143: return NULL;
144: }
145:
146: /**
147: * @brief Implements attribute set operation.
148: */
149: int py_axl_doc_set_attr (PyObject *o, PyObject *attr_name, PyObject *v)
150: {
151: const char * attr = NULL;
152: PyAxlDoc * self = (PyAxlDoc *) o;
153: PyObject * py_node = NULL;
154:
155: /* now implement other attributes */
156: if (! PyArg_Parse (attr_name, "s", &attr))
157: return -1;
158:
159: if (axl_cmp (attr, "root")) {
160: if (! PyArg_Parse (v, "O", &py_node))
161: return -1;
162:
163: /* configure the node */
164: axl_doc_set_root (self->doc, py_axl_node_get (py_node));
165: return 0;
166: }
167:
168: /* now implement generic setter */
169: return PyObject_GenericSetAttr (o, attr_name, v);
170: }
171:
172: static PyObject * py_axl_doc_get_node (PyObject * _self, PyObject * args)
173: {
174: PyAxlDoc * self = (PyAxlDoc *) _self;
175: const char * path = NULL;
176: axlNode * node = NULL;
177:
178: /* parse and check result */
179: if (! PyArg_ParseTuple (args, "s", &path))
180: return NULL;
181:
182: /* get next called */
183: node = axl_doc_get (self->doc, path);
184: if (node == NULL) {
185: Py_INCREF (Py_None);
186: return Py_None;
187: } /* end if */
188:
189: /* create node result */
190: return py_axl_node_create (node, axl_false);
191: }
192:
193: static PyObject * py_axl_doc_dump (PyObject * _self, PyObject * args, PyObject * kwds)
194: {
195: PyAxlDoc * self = (PyAxlDoc *) _self;
196: int tabular = 0;
197: char * content = NULL;
198: int size = 0;
199: PyObject * result;
200:
201:
202: /* parse and check result */
203: if (PyTuple_Size (args) == 0) {
204: /* simple dump operation */
205: /* dump content */
206: if (! axl_doc_dump (self->doc, &content, &size)) {
207: /* failed to dump */
208: PyErr_SetString (PyExc_TypeError, "axl_doc_dump operation failed, unable to produce dumped content");
209: return NULL;
210: } /* end if */
211:
212: /* create the tuple */
213: result = PyTuple_New (2);
214: PyTuple_SetItem (result, 0, Py_BuildValue ("s", content));
215: axl_free (content);
216: PyTuple_SetItem (result, 1, Py_BuildValue ("i", size));
217: } else {
218: /* dump with tabular configuration */
219: if (! PyArg_ParseTuple (args, "i", &tabular))
220: return NULL;
221:
222: /* check tabular value */
223: if (tabular < 0) {
224: PyErr_SetString (PyExc_ValueError, "failed to produce dump operation, received a non-positive (including 0) tabular value");
225: return NULL;
226: } /* end if */
227:
228: /* dump content with tabular configured */
229: if (! axl_doc_dump_pretty (self->doc, &content, &size, tabular)) {
230: /* failed to dump */
231: PyErr_SetString (PyExc_TypeError, "axl_doc_dump operation failed, unable to produce dumped content");
232: return NULL;
233: } /* end if */
234:
235: /* create the tuple */
236: result = PyTuple_New (2);
237: PyTuple_SetItem (result, 0, Py_BuildValue ("s", content));
238: axl_free (content);
239: PyTuple_SetItem (result, 1, Py_BuildValue ("i", size));
240: } /* end if */
241:
242: /* return tuple */
243: return result;
244: }
245:
246: static PyObject * py_axl_doc_file_dump (PyObject * _self, PyObject * args, PyObject * kwds)
247: {
248: PyAxlDoc * self = (PyAxlDoc *) _self;
249: int tabular = 0;
250: char * file = NULL;
251:
252: /* parse and check result */
253: if (PyTuple_Size (args) == 1) {
254:
255: /* dump with tabular configuration */
256: if (! PyArg_ParseTuple (args, "s", &file))
257: return NULL;
258:
259: /* simple dump operation */
260: /* dump content */
261: if (! axl_doc_dump_to_file (self->doc, file)) {
262: /* failed to dump */
263: PyErr_SetString (PyExc_TypeError, "axl_doc_dump_to_file operation failed, unable to produce dumped content");
264: return NULL;
265: } /* end if */
266:
267: } else if (PyTuple_Size (args) == 2) {
268:
269: /* dump with tabular configuration */
270: if (! PyArg_ParseTuple (args, "si", &file, &tabular))
271: return NULL;
272:
273: /* simple dump operation */
274: /* dump content */
275: if (! axl_doc_dump_pretty_to_file (self->doc, file, tabular)) {
276: /* failed to dump */
277: PyErr_SetString (PyExc_TypeError, "axl_doc_dump_pretty_to_file operation failed, unable to produce dumped content");
278: return NULL;
279: } /* end if */
280:
281: } /* end if */
282:
283: /* return ok operation */
284: return Py_BuildValue ("i", 1);
285: }
286:
287: static PyObject * py_axl_doc_has_pi (PyObject * _self, PyObject * args)
288: {
289: PyAxlDoc * self = (PyAxlDoc *) _self;
290: char * pi_name = NULL;
291:
292: /* parse and check result */
293: if (! PyArg_ParseTuple (args, "s", &pi_name))
294: return NULL;
295:
296: return Py_BuildValue ("i", axl_doc_has_pi_target (self->doc, pi_name));
297: }
298:
299: static PyObject * py_axl_doc_pi_value (PyObject * _self, PyObject * args)
300: {
301: PyAxlDoc * self = (PyAxlDoc *) _self;
302: char * pi_name = NULL;
303:
304: /* parse and check result */
305: if (! PyArg_ParseTuple (args, "s", &pi_name))
306: return NULL;
307:
308: return Py_BuildValue ("z", axl_doc_get_pi_target_content (self->doc, pi_name));
309: }
310:
311: static PyMethodDef py_axl_doc_methods[] = {
312: /* next_called */
313: {"get", (PyCFunction) py_axl_doc_get_node, METH_VARARGS,
314: "Allows to get a node found at a particular path (method wrapper of axl_doc_get)"},
315: /* next_called */
316: {"dump", (PyCFunction) py_axl_doc_dump, METH_VARARGS | METH_KEYWORDS,
317: "Allows to perform a dump operation returning the content and the size that result in a tuple."},
318: {"file_dump", (PyCFunction) py_axl_doc_file_dump, METH_VARARGS | METH_KEYWORDS,
319: "Allows to perform a dump operation sending the content to a file."},
320: /* has_pi */
321: {"has_pi", (PyCFunction) py_axl_doc_has_pi, METH_VARARGS,
322: "Allows to check if the provided doc has the given process instruction."},
323: /* pi */
324: {"pi", (PyCFunction) py_axl_doc_pi_value, METH_VARARGS,
325: "Allows to get the value of the given process instruction on the provided doc."},
326: {NULL, NULL, 0, NULL}
327: };
328:
329: static PyTypeObject PyAxlDocType = {
330: PyObject_HEAD_INIT(NULL)
331: 0, /* ob_size*/
332: "axl.Doc", /* tp_name*/
333: sizeof(PyAxlDoc), /* tp_basicsize*/
334: 0, /* tp_itemsize*/
335: (destructor)py_axl_doc_dealloc, /* tp_dealloc*/
336: 0, /* tp_print*/
337: 0, /* tp_getattr*/
338: 0, /* tp_setattr*/
339: 0, /* tp_compare*/
340: 0, /* tp_repr*/
341: 0, /* tp_as_number*/
342: 0, /* tp_as_sequence*/
343: 0, /* tp_as_mapping*/
344: 0, /* tp_hash */
345: 0, /* tp_call*/
346: 0, /* tp_str*/
347: py_axl_doc_get_attr, /* tp_getattro*/
348: py_axl_doc_set_attr, /* tp_setattro*/
349: 0, /* tp_as_buffer*/
350: Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags*/
351: "Document object; wrapper of axlDoc API type", /* tp_doc */
352: 0, /* tp_traverse */
353: 0, /* tp_clear */
354: 0, /* tp_richcompare */
355: 0, /* tp_weaklistoffset */
356: 0, /* tp_iter */
357: 0, /* tp_iternext */
358: py_axl_doc_methods, /* tp_methods */
359: 0, /* py_axl_doc_members, */ /* tp_members */
360: 0, /* tp_getset */
361: 0, /* tp_base */
362: 0, /* tp_dict */
363: 0, /* tp_descr_get */
364: 0, /* tp_descr_set */
365: 0, /* tp_dictoffset */
366: (initproc)py_axl_doc_init_type, /* tp_init */
367: 0, /* tp_alloc */
368: py_axl_doc_new, /* tp_new */
369:
370: };
371:
372:
373: /**
374: * @brief Allows to check if the PyObject received represents a
375: * PyAxlDoc reference.
376: */
377: axl_bool py_axl_doc_check (PyObject * obj)
378: {
379: /* check null references */
380: if (obj == NULL)
381: return axl_false;
382:
383: /* return check result */
384: return PyObject_TypeCheck (obj, &PyAxlDocType);
385: }
386:
387: PyObject * py_axl_doc_create (axlDoc * doc, axl_bool finish_on_gc)
388: {
389: /* return a new instance */
390: PyAxlDoc * obj = (PyAxlDoc *) PyObject_CallObject ((PyObject *) &PyAxlDocType, NULL);
391:
392: /* check ref created */
393: if (obj == NULL) {
394: __axl_log (LOG_DOMAIN, AXL_LEVEL_CRITICAL, "Failed to create PyAxlDoc object, returning NULL");
395: return NULL;
396: } /* end if */
397:
398: /* configure finish handling */
399: obj->finish_on_gc = finish_on_gc;
400:
401: /* set doc if defined */
402: if (doc) {
403: /* clear previous reference */
404: axl_doc_free (obj->doc);
405: obj->doc = doc;
406: }
407:
408: return __PY_OBJECT (obj);
409: }
410:
411: axlDoc * py_axl_doc_get (PyObject * doc)
412: {
413: PyAxlDoc * _doc = (PyAxlDoc *) doc;
414:
415: if (! py_axl_doc_check (doc))
416: return NULL;
417: /* return doc reference */
418: return _doc->doc;
419: }
420:
421: void init_axl_doc (PyObject * module)
422: {
423: /* register type */
424: if (PyType_Ready(&PyAxlDocType) < 0)
425: return;
426:
427: Py_INCREF (&PyAxlDocType);
428: PyModule_AddObject(module, "Doc", (PyObject *)&PyAxlDocType);
429:
430: }
431:
432:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to py_axl_doc.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