archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity

Improvements in error handling at Python-C++ boundaries.

Browse Source 
Also exported the Operators.chain() function.
This commit is contained in:
Tamito Kajiyama
2009-03-20 22:42:59 +00:00
parent 0c7e5323e8
commit 85291f0fea
1 changed files with 164 additions and 72 deletions
Download Patch File Download Diff File Expand all files Collapse all files

236
source/blender/freestyle/intern/python/BPy_Operators.cpp
View File

@@ -19,6 +19,7 @@ extern "C" {
static void Operators___dealloc__(BPy_Operators *self);
static PyObject * Operators_select(BPy_Operators* self, PyObject *args);
static PyObject * Operators_chain(BPy_Operators* self, PyObject *args);
static PyObject * Operators_bidirectionalChain(BPy_Operators* self, PyObject *args);
static PyObject * Operators_sequentialSplit(BPy_Operators* self, PyObject *args);
static PyObject * Operators_recursiveSplit(BPy_Operators* self, PyObject *args);
@@ -32,6 +33,8 @@ static PyObject * Operators_getStrokesSize( BPy_Operators* self);
static PyMethodDef BPy_Operators_methods[] = {
{"select", ( PyCFunction ) Operators_select, METH_VARARGS | METH_STATIC,
"select operator"},
{"chain", ( PyCFunction ) Operators_chain, METH_VARARGS | METH_STATIC,
"chain operator"},
{"bidirectionalChain", ( PyCFunction ) Operators_bidirectionalChain, METH_VARARGS | METH_STATIC,
"bidirectionalChain operator"},
{"sequentialSplit", ( PyCFunction ) Operators_sequentialSplit, METH_VARARGS | METH_STATIC,
@@ -157,13 +160,18 @@ PyObject * Operators_select(BPy_Operators* self, PyObject *args)
{
PyObject *obj = 0;
if(!( PyArg_ParseTuple(args, "O", &obj) &&
BPy_UnaryPredicate1D_Check(obj) && ((BPy_UnaryPredicate1D *) obj)->up1D )) {
cout << "ERROR: Operators_select" << endl;
Py_RETURN_NONE;
if ( !PyArg_ParseTuple(args, "O!", &UnaryPredicate1D_Type, &obj) )
return NULL;
if ( !((BPy_UnaryPredicate1D *) obj)->up1D ) {
PyErr_SetString(PyExc_TypeError, "Operators.select(): 1st argument: invalid UnaryPredicate1D object");
return NULL;
}
Operators::select(*( ((BPy_UnaryPredicate1D *) obj)->up1D ));
if (Operators::select(*( ((BPy_UnaryPredicate1D *) obj)->up1D )) < 0) {
if (!PyErr_Occurred())
PyErr_SetString(PyExc_RuntimeError, "Operators.select() failed");
return NULL;
}
Py_RETURN_NONE;
}
@@ -174,24 +182,41 @@ PyObject * Operators_chain(BPy_Operators* self, PyObject *args)
{
PyObject *obj1 = 0, *obj2 = 0, *obj3 = 0;
if(!( PyArg_ParseTuple(args, "OO|O", &obj1, &obj2, &obj3) &&
BPy_ChainingIterator_Check(obj1) && ((BPy_ChainingIterator *) obj1)->c_it &&
BPy_UnaryPredicate1D_Check(obj2) && ((BPy_UnaryPredicate1D *) obj2)->up1D )) {
cout << "ERROR: Operators_chain" << endl;
Py_RETURN_NONE;
if ( !PyArg_ParseTuple(args, "O!O!|O!", &ChainingIterator_Type, &obj1,
&UnaryPredicate1D_Type, &obj2,
&UnaryFunction1DVoid_Type, &obj3) )
return NULL;
if ( !((BPy_ChainingIterator *) obj1)->c_it ) {
PyErr_SetString(PyExc_TypeError, "Operators.chain(): 1st argument: invalid ChainingIterator object");
return NULL;
}
if ( !((BPy_UnaryPredicate1D *) obj2)->up1D ) {
PyErr_SetString(PyExc_TypeError, "Operators.chain(): 2nd argument: invalid UnaryPredicate1D object");
return NULL;
}
if( !obj3 ) {
Operators::chain( *( ((BPy_ChainingIterator *) obj1)->c_it ),
*( ((BPy_UnaryPredicate1D *) obj2)->up1D ) );
if (Operators::chain( *( ((BPy_ChainingIterator *) obj1)->c_it ),
*( ((BPy_UnaryPredicate1D *) obj2)->up1D ) ) < 0) {
if (!PyErr_Occurred())
PyErr_SetString(PyExc_RuntimeError, "Operators.chain() failed");
return NULL;
}
} else if( BPy_UnaryFunction1DVoid_Check(obj3) && ((BPy_UnaryFunction1DVoid *) obj3)->uf1D_void ) {
} else {
Operators::chain( *( ((BPy_ChainingIterator *) obj1)->c_it ),
*( ((BPy_UnaryPredicate1D *) obj2)->up1D ),
*( ((BPy_UnaryFunction1DVoid *) obj3)->uf1D_void ) );
if ( !((BPy_UnaryFunction1DVoid *) obj3)->uf1D_void ) {
PyErr_SetString(PyExc_TypeError, "Operators.chain(): 3rd argument: invalid UnaryFunction1DVoid object");
return NULL;
}
if (Operators::chain( *( ((BPy_ChainingIterator *) obj1)->c_it ),
*( ((BPy_UnaryPredicate1D *) obj2)->up1D ),
*( ((BPy_UnaryFunction1DVoid *) obj3)->uf1D_void ) ) < 0) {
if (!PyErr_Occurred())
PyErr_SetString(PyExc_RuntimeError, "Operators.chain() failed");
return NULL;
}
}
@@ -202,20 +227,33 @@ PyObject * Operators_bidirectionalChain(BPy_Operators* self, PyObject *args)
{
PyObject *obj1 = 0, *obj2 = 0;
if(!( PyArg_ParseTuple(args, "O|O", &obj1, &obj2) &&
BPy_ChainingIterator_Check(obj1) && ((BPy_ChainingIterator *) obj1)->c_it )) {
cout << "ERROR: Operators_bidirectionalChain" << endl;
Py_RETURN_NONE;
if( !PyArg_ParseTuple(args, "O!|O!", &ChainingIterator_Type, &obj1, &UnaryPredicate1D_Type, &obj2) )
return NULL;
if ( !((BPy_ChainingIterator *) obj1)->c_it ) {
PyErr_SetString(PyExc_TypeError, "Operators.bidirectionalChain(): 1st argument: invalid ChainingIterator object");
return NULL;
}
if( !obj2 ) {
Operators::bidirectionalChain( *( ((BPy_ChainingIterator *) obj1)->c_it ) );
if (Operators::bidirectionalChain( *( ((BPy_ChainingIterator *) obj1)->c_it ) ) < 0) {
if (!PyErr_Occurred())
PyErr_SetString(PyExc_RuntimeError, "Operators.bidirectionalChain() failed");
return NULL;
}
} else if( BPy_UnaryPredicate1D_Check(obj2) && ((BPy_UnaryPredicate1D *) obj2)->up1D ) {
Operators::bidirectionalChain( *( ((BPy_ChainingIterator *) obj1)->c_it ),
*( ((BPy_UnaryPredicate1D *) obj2)->up1D ) );
} else {
if ( !((BPy_UnaryPredicate1D *) obj2)->up1D ) {
PyErr_SetString(PyExc_TypeError, "Operators.bidirectionalChain(): 2nd argument: invalid UnaryPredicate1D object");
return NULL;
}
if (Operators::bidirectionalChain( *( ((BPy_ChainingIterator *) obj1)->c_it ),
*( ((BPy_UnaryPredicate1D *) obj2)->up1D ) ) < 0) {
if (!PyErr_Occurred())
PyErr_SetString(PyExc_RuntimeError, "Operators.bidirectionalChain() failed");
return NULL;
}
}
@@ -225,25 +263,43 @@ PyObject * Operators_bidirectionalChain(BPy_Operators* self, PyObject *args)
PyObject * Operators_sequentialSplit(BPy_Operators* self, PyObject *args)
{
PyObject *obj1 = 0, *obj2 = 0;
float f3 = 0.0;
float f = 0.0;
if(!( PyArg_ParseTuple(args, "O|Of", &obj1, &obj2, &f3) &&
BPy_UnaryPredicate0D_Check(obj1) && ((BPy_UnaryPredicate0D *) obj1)->up0D )) {
cout << "ERROR: Operators_sequentialSplit" << endl;
Py_RETURN_NONE;
if( !PyArg_ParseTuple(args, "O!|Of", &UnaryPredicate0D_Type, &obj1, &obj2, &f) )
return NULL;
if ( !((BPy_UnaryPredicate0D *) obj1)->up0D ) {
PyErr_SetString(PyExc_TypeError, "Operators.sequentialSplit(): 1st argument: invalid UnaryPredicate0D object");
return NULL;
}
if( obj2 && BPy_UnaryPredicate0D_Check(obj2) ) {
Operators::sequentialSplit( *( ((BPy_UnaryPredicate0D *) obj1)->up0D ),
if ( !((BPy_UnaryPredicate0D *) obj2)->up0D ) {
PyErr_SetString(PyExc_TypeError, "Operators.sequentialSplit(): 2nd argument: invalid UnaryPredicate0D object");
return NULL;
}
if (Operators::sequentialSplit( *( ((BPy_UnaryPredicate0D *) obj1)->up0D ),
*( ((BPy_UnaryPredicate0D *) obj2)->up0D ),
f3 );
f ) < 0) {
if (!PyErr_Occurred())
PyErr_SetString(PyExc_RuntimeError, "Operators.sequentialSplit() failed");
return NULL;
}
} else {
float f = ( obj2 && PyFloat_Check(obj2) ) ? PyFloat_AsDouble(obj2) : 0.0;
Operators::sequentialSplit( *( ((BPy_UnaryPredicate0D *) obj1)->up0D ), f );
if ( obj2 ) {
if ( !PyFloat_Check(obj2) ) {
PyErr_SetString(PyExc_TypeError, "Operators.sequentialSplit(): invalid 2nd argument");
return NULL;
}
f = PyFloat_AsDouble(obj2);
}
if (Operators::sequentialSplit( *( ((BPy_UnaryPredicate0D *) obj1)->up0D ), f ) < 0) {
if (!PyErr_Occurred())
PyErr_SetString(PyExc_RuntimeError, "Operators.sequentialSplit() failed");
return NULL;
}
}
@@ -253,29 +309,54 @@ PyObject * Operators_sequentialSplit(BPy_Operators* self, PyObject *args)
PyObject * Operators_recursiveSplit(BPy_Operators* self, PyObject *args)
{
PyObject *obj1 = 0, *obj2 = 0, *obj3 = 0;
float f4 = 0.0;
float f = 0.0;
if(!( PyArg_ParseTuple(args, "OO|Of", &obj1, &obj2, &obj3, &f4) &&
BPy_UnaryFunction0DDouble_Check(obj1) && ((BPy_UnaryFunction0DDouble *) obj1)->uf0D_double )) {
cout << "ERROR: Operators_recursiveSplit" << endl;
Py_RETURN_NONE;
if ( !PyArg_ParseTuple(args, "O!O|Of", &UnaryFunction0DDouble_Type, &obj1, &obj2, &obj3, &f) )
return NULL;
if ( !((BPy_UnaryFunction0DDouble *) obj1)->uf0D_double ) {
PyErr_SetString(PyExc_TypeError, "Operators.recursiveSplit(): 1st argument: invalid UnaryFunction0DDouble object");
return NULL;
}
if( BPy_UnaryPredicate1D_Check(obj2) && ((BPy_UnaryPredicate1D *) obj2)->up1D ) {
float f = ( obj3 && PyFloat_Check(obj3) ) ? PyFloat_AsDouble(obj3) : 0.0;
Operators::recursiveSplit( *( ((BPy_UnaryFunction0DDouble *) obj1)->uf0D_double ),
*( ((BPy_UnaryPredicate1D *) obj2)->up1D ),
f );
if ( BPy_UnaryPredicate1D_Check(obj2) ) {
if ( !((BPy_UnaryPredicate1D *) obj2)->up1D ) {
PyErr_SetString(PyExc_TypeError, "Operators.recursiveSplit(): 2nd argument: invalid UnaryPredicate1D object");
return NULL;
}
if ( obj3 ) {
if ( !PyFloat_Check(obj3) ) {
PyErr_SetString(PyExc_TypeError, "Operators.recursiveSplit(): invalid 3rd argument");
return NULL;
}
f = PyFloat_AsDouble(obj3);
}
if (Operators::recursiveSplit( *( ((BPy_UnaryFunction0DDouble *) obj1)->uf0D_double ),
*( ((BPy_UnaryPredicate1D *) obj2)->up1D ),
f ) < 0) {
if (!PyErr_Occurred())
PyErr_SetString(PyExc_RuntimeError, "Operators.recursiveSplit() failed");
return NULL;
}
} else if( BPy_UnaryPredicate0D_Check(obj2) && ((BPy_UnaryPredicate0D *) obj2)->up0D &&
BPy_UnaryPredicate1D_Check(obj3) && ((BPy_UnaryPredicate1D *) obj3)->up1D ) {
Operators::recursiveSplit( *( ((BPy_UnaryFunction0DDouble *) obj1)->uf0D_double ),
*( ((BPy_UnaryPredicate0D *) obj2)->up0D ),
*( ((BPy_UnaryPredicate1D *) obj3)->up1D ),
f4 );
} else {
if ( !BPy_UnaryPredicate0D_Check(obj2) || !((BPy_UnaryPredicate0D *) obj2)->up0D ) {
PyErr_SetString(PyExc_TypeError, "Operators.recursiveSplit(): invalid 2nd argument");
return NULL;
}
if ( !BPy_UnaryPredicate1D_Check(obj3) || !((BPy_UnaryPredicate1D *) obj3)->up1D ) {
PyErr_SetString(PyExc_TypeError, "Operators.recursiveSplit(): invalid 3rd argument");
return NULL;
}
if (Operators::recursiveSplit( *( ((BPy_UnaryFunction0DDouble *) obj1)->uf0D_double ),
*( ((BPy_UnaryPredicate0D *) obj2)->up0D ),
*( ((BPy_UnaryPredicate1D *) obj3)->up1D ),
f ) < 0) {
if (!PyErr_Occurred())
PyErr_SetString(PyExc_RuntimeError, "Operators.recursiveSplit() failed");
return NULL;
}
}
@@ -286,14 +367,18 @@ PyObject * Operators_sort(BPy_Operators* self, PyObject *args)
{
PyObject *obj = 0;
if(!( PyArg_ParseTuple(args, "O", &obj) &&
BPy_BinaryPredicate1D_Check(obj) && ((BPy_BinaryPredicate1D *) obj)->bp1D )) {
cout << "ERROR: Operators_sort" << endl;
Py_RETURN_NONE;
if ( !PyArg_ParseTuple(args, "O!", &BinaryPredicate1D_Type, &obj) )
return NULL;
if ( !((BPy_BinaryPredicate1D *) obj)->bp1D ) {
PyErr_SetString(PyExc_TypeError, "Operators.sort(): 1st argument: invalid BinaryPredicate1D object");
return NULL;
}
Operators::sort(*( ((BPy_BinaryPredicate1D *) obj)->bp1D ));
if (Operators::sort(*( ((BPy_BinaryPredicate1D *) obj)->bp1D )) < 0) {
if (!PyErr_Occurred())
PyErr_SetString(PyExc_RuntimeError, "Operators.sort() failed");
return NULL;
}
Py_RETURN_NONE;
}
@@ -301,22 +386,29 @@ PyObject * Operators_create(BPy_Operators* self, PyObject *args)
{
PyObject *obj1 = 0, *obj2 = 0;
if(!( PyArg_ParseTuple(args, "OO", &obj1, &obj2) &&
BPy_UnaryPredicate1D_Check(obj1) && ((BPy_UnaryPredicate1D *) obj1)->up1D &&
PyList_Check(obj2) && PyList_Size(obj2) > 0 )) {
cout << "ERROR: Operators_create" << endl;
Py_RETURN_NONE;
if ( !PyArg_ParseTuple(args, "O!O!", &UnaryPredicate1D_Type, &obj1, &PyList_Type, &obj2) )
return NULL;
if ( !((BPy_UnaryPredicate1D *) obj1)->up1D ) {
PyErr_SetString(PyExc_TypeError, "Operators.create(): 1st argument: invalid UnaryPredicate1D object");
return NULL;
}
vector<StrokeShader *> shaders;
for( int i = 0; i < PyList_Size(obj2); i++) {
PyObject *py_ss = PyList_GetItem(obj2,i);
if( BPy_StrokeShader_Check(py_ss) )
shaders.push_back( ((BPy_StrokeShader *) py_ss)->ss );
if ( !BPy_StrokeShader_Check(py_ss) ) {
PyErr_SetString(PyExc_TypeError, "Operators.create() 2nd argument must be a list of StrokeShader objects");
return NULL;
}
shaders.push_back( ((BPy_StrokeShader *) py_ss)->ss );
}
Operators::create( *( ((BPy_UnaryPredicate1D *) obj1)->up1D ), shaders);
if (Operators::create( *( ((BPy_UnaryPredicate1D *) obj1)->up1D ), shaders) < 0) {
if (!PyErr_Occurred())
PyErr_SetString(PyExc_RuntimeError, "Operators.create() failed");
return NULL;
}
Py_RETURN_NONE;
}