340 lines
12 KiB
C++
340 lines
12 KiB
C++
// -*- C++ -*-
|
|
//
|
|
// This file is part of the Coriolis Software.
|
|
// Copyright (c) UPMC 2014-2016, All Rights Reserved
|
|
//
|
|
// +-----------------------------------------------------------------+
|
|
// | C O R I O L I S |
|
|
// | I s o b a r - Hurricane / Python Interface |
|
|
// | |
|
|
// | Author : Jean-Paul CHAPUT |
|
|
// | E-mail : Jean-Paul.Chaput@asim.lip6.fr |
|
|
// | =============================================================== |
|
|
// | C++ Module : "./PyInterval.cpp" |
|
|
// +-----------------------------------------------------------------+
|
|
|
|
|
|
#include "hurricane/isobar/PyPoint.h"
|
|
#include "hurricane/isobar/PyInterval.h"
|
|
|
|
|
|
namespace Isobar {
|
|
|
|
using namespace Hurricane;
|
|
|
|
extern "C" {
|
|
|
|
|
|
#define METHOD_HEAD(function) GENERIC_METHOD_HEAD(Interval,interval,function)
|
|
|
|
|
|
// +=================================================================+
|
|
// | "PyInterval" Python Module Code Part |
|
|
// +=================================================================+
|
|
|
|
#if defined(__PYTHON_MODULE__)
|
|
|
|
|
|
// Standart Accessors (Attributes).
|
|
DirectGetLongAttribute(PyInterval_getVMin ,getVMin ,PyInterval,Interval)
|
|
DirectGetLongAttribute(PyInterval_getVMax ,getVMax ,PyInterval,Interval)
|
|
DirectGetLongAttribute(PyInterval_getCenter ,getCenter ,PyInterval,Interval)
|
|
DirectGetLongAttribute(PyInterval_getSize ,getSize ,PyInterval,Interval)
|
|
DirectGetLongAttribute(PyInterval_getHalfSize ,getHalfSize ,PyInterval,Interval)
|
|
|
|
// Standart Predicates (Attributes).
|
|
DirectGetBoolAttribute(PyInterval_isEmpty ,isEmpty ,PyInterval,Interval)
|
|
DirectGetBoolAttribute(PyInterval_isPonctual,isPonctual,PyInterval,Interval)
|
|
|
|
// Standart Destroy (Attribute).
|
|
DirectDestroyAttribute(PyInterval_destroy, PyInterval)
|
|
|
|
|
|
// ---------------------------------------------------------------
|
|
// Class Method : "PyInterval_NEW ()"
|
|
|
|
static PyObject* PyInterval_NEW (PyObject *module, PyObject *args) {
|
|
cdebug_log(20,0) << "PyInterval_NEW()" << endl;
|
|
|
|
Interval* interval = NULL;
|
|
|
|
HTRY
|
|
PyObject* arg0;
|
|
PyObject* arg1;
|
|
PyObject* arg2;
|
|
__cs.init ("Interval.Interval");
|
|
|
|
if (not PyArg_ParseTuple( args, "|O&O&O&:Interval.Interval"
|
|
, Converter, &arg0
|
|
, Converter, &arg1
|
|
, Converter, &arg2 ))
|
|
return NULL;
|
|
|
|
if (__cs.getObjectIds() == NO_ARG ) { interval = new Interval (); }
|
|
else if (__cs.getObjectIds() == INTS2_ARG) { interval = new Interval ( PyAny_AsLong(arg0) , PyAny_AsLong(arg1) ); }
|
|
else if (__cs.getObjectIds() == INTV_ARG ) { interval = new Interval ( *PYINTERVAL_O(arg0) ); }
|
|
else {
|
|
PyErr_SetString(ConstructorError, "invalid number of parameters for Interval constructor." );
|
|
return NULL;
|
|
}
|
|
HCATCH
|
|
|
|
return PyInterval_Link( interval );
|
|
}
|
|
|
|
|
|
static int PyInterval_Init ( PyInterval* self, PyObject* args, PyObject* kwargs )
|
|
{
|
|
cdebug_log(20,0) << "PyInterval_Init(): " << (void*)self << endl;
|
|
return 0;
|
|
}
|
|
|
|
|
|
static PyObject* PyInterval_getUnion ( PyInterval *self, PyObject* args ) {
|
|
cdebug_log(20,0) << "PyInterval_getUnion()" << endl;
|
|
|
|
METHOD_HEAD ( "Interval.getUnion()" )
|
|
|
|
Interval* uinterval = NULL;
|
|
PyInterval* otherPyInterval = NULL;
|
|
if (PyArg_ParseTuple(args,"O!:Interval.getUnion", &PyTypeInterval, &otherPyInterval)) {
|
|
HTRY
|
|
uinterval = new Interval ( interval->getUnion(*PYINTERVAL_O(otherPyInterval)));
|
|
HCATCH
|
|
return PyInterval_Link( uinterval );
|
|
} else {
|
|
PyErr_SetString ( ConstructorError, "invalid number of parameters for Interval.getUnion.");
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
static PyObject* PyInterval_getIntersection ( PyInterval *self, PyObject* args ) {
|
|
cdebug_log(20,0) << "PyInterval_getIntersection()" << endl;
|
|
|
|
METHOD_HEAD ( "Interval.getIntersection()" )
|
|
|
|
Interval* iinterval = NULL;
|
|
PyInterval* otherPyInterval = NULL;
|
|
if (PyArg_ParseTuple(args,"O!:Interval.getIntersection", &PyTypeInterval, &otherPyInterval)) {
|
|
HTRY
|
|
iinterval = new Interval(interval->getIntersection(*PYINTERVAL_O(otherPyInterval)));
|
|
HCATCH
|
|
return PyInterval_Link( iinterval );
|
|
} else {
|
|
PyErr_SetString(ConstructorError, "invalid number of parameters for Interval.getIntersection.");
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
static PyObject* PyInterval_contains ( PyInterval *self, PyObject* args ) {
|
|
cdebug_log(20,0) << "PyInterval_contains ()" << endl;
|
|
|
|
METHOD_HEAD( "Interval.contains()" )
|
|
|
|
PyObject* arg0;
|
|
bool result = false;
|
|
|
|
HTRY
|
|
__cs.init("Interval.contains");
|
|
if (not PyArg_ParseTuple(args,"|O&:Interval.contains",Converter,&arg0) )
|
|
return NULL;
|
|
|
|
if (__cs.getObjectIds() == INT_ARG ) { result = interval->contains ( PyAny_AsLong(arg0) ); }
|
|
else if (__cs.getObjectIds() == INTV_ARG) { result = interval->contains ( *PYINTERVAL_O(arg0) ); }
|
|
else {
|
|
PyErr_SetString ( ConstructorError, "invalid number of parameters for Interval.contains constructor." );
|
|
return NULL;
|
|
}
|
|
|
|
HCATCH
|
|
if (result) Py_RETURN_TRUE;
|
|
Py_RETURN_FALSE;
|
|
}
|
|
|
|
|
|
static PyObject* PyInterval_intersect ( PyInterval *self, PyObject* args ) {
|
|
cdebug_log(20,0) << "PyInterval_intersect ()" << endl;
|
|
|
|
bool result = false;
|
|
HTRY
|
|
PyInterval* pyInterval = NULL;
|
|
METHOD_HEAD ( "Interval.intersect()" )
|
|
|
|
if (PyArg_ParseTuple(args,"O!:Interval.intersects", &PyTypeInterval, &pyInterval)) {
|
|
result = interval->intersect( *PYINTERVAL_O(pyInterval) );
|
|
} else {
|
|
PyErr_SetString ( ConstructorError, "invalid number of parameters for Interval.intersect." );
|
|
return NULL;
|
|
}
|
|
|
|
HCATCH
|
|
if (result) Py_RETURN_TRUE;
|
|
Py_RETURN_FALSE;
|
|
}
|
|
|
|
|
|
static PyObject* PyInterval_makeEmpty ( PyInterval *self, PyObject* args ) {
|
|
cdebug_log(20,0) << "PyInterval_makeEmpty ()" << endl;
|
|
|
|
METHOD_HEAD( "Interval.makeEmpty()" )
|
|
interval->makeEmpty();
|
|
|
|
Py_INCREF( self );
|
|
return (PyObject*)self;
|
|
}
|
|
|
|
|
|
static PyObject* PyInterval_inflate ( PyInterval *self, PyObject* args ) {
|
|
cdebug_log(20,0) << "PyInterval_inflate ()" << endl;
|
|
|
|
METHOD_HEAD( "Interval.inflate()" )
|
|
|
|
PyObject* arg0;
|
|
PyObject* arg1;
|
|
|
|
HTRY
|
|
__cs.init( "Interval.inflate" );
|
|
if (not PyArg_ParseTuple(args,"|O&O&:Interval.inflate",Converter,&arg0,Converter,&arg1))
|
|
return NULL;
|
|
|
|
if (__cs.getObjectIds() == INT_ARG ) { interval->inflate( PyAny_AsLong(arg0) ); }
|
|
else if (__cs.getObjectIds() == INTS2_ARG) { interval->inflate( PyAny_AsLong(arg0), PyAny_AsLong(arg1) ); }
|
|
else {
|
|
PyErr_SetString ( ConstructorError, "invalid number of parameters for Interval.inflate()" );
|
|
return NULL;
|
|
}
|
|
HCATCH
|
|
|
|
Py_INCREF( self );
|
|
return (PyObject*)self;
|
|
}
|
|
|
|
|
|
static PyObject* PyInterval_merge ( PyInterval *self, PyObject* args ) {
|
|
cdebug_log(20,0) << "PyInterval_merge ()" << endl;
|
|
|
|
METHOD_HEAD( "Interval.merge()" )
|
|
|
|
PyObject* arg0;
|
|
PyObject* arg1;
|
|
|
|
HTRY
|
|
__cs.init( "Interval.merge" );
|
|
if (not PyArg_ParseTuple(args,"|O&O&:Interval.merge",Converter,&arg0,Converter,&arg1))
|
|
return NULL;
|
|
|
|
if (__cs.getObjectIds() == INT_ARG ) { interval->merge( PyAny_AsLong(arg0) ); }
|
|
else if (__cs.getObjectIds() == INTV_ARG) { interval->merge( *PYINTERVAL_O(arg0) ); }
|
|
else {
|
|
PyErr_SetString ( ConstructorError, "invalid number of parameters for Interval.merge()" );
|
|
return NULL;
|
|
}
|
|
HCATCH
|
|
|
|
Py_INCREF( self );
|
|
return (PyObject*)self;
|
|
}
|
|
|
|
|
|
static PyObject* PyInterval_intersection ( PyInterval *self, PyObject* args ) {
|
|
cdebug_log(20,0) << "PyInterval_intersection ()" << endl;
|
|
|
|
METHOD_HEAD( "Interval.intersection()" )
|
|
|
|
PyObject* arg0;
|
|
PyObject* arg1;
|
|
|
|
HTRY
|
|
__cs.init( "Interval.intersection" );
|
|
if (not PyArg_ParseTuple(args,"|O&O&:Interval.intersection",Converter,&arg0,Converter,&arg1))
|
|
return NULL;
|
|
|
|
if (__cs.getObjectIds() == INTV_ARG ) { interval->intersection( *PYINTERVAL_O(arg0) ); }
|
|
else if (__cs.getObjectIds() == INTS2_ARG) { interval->intersection( PyAny_AsLong(arg0), PyAny_AsLong(arg1) ); }
|
|
else {
|
|
PyErr_SetString ( ConstructorError, "invalid number of parameters for Interval.intersection()" );
|
|
return NULL;
|
|
}
|
|
HCATCH
|
|
|
|
Py_INCREF( self );
|
|
return (PyObject*)self;
|
|
}
|
|
|
|
|
|
static PyObject* PyInterval_translate ( PyInterval *self, PyObject* args ) {
|
|
cdebug_log(20,0) << "PyInterval_translate ()" << endl;
|
|
|
|
HTRY
|
|
METHOD_HEAD( "Interval.translate()" )
|
|
DbU::Unit delta = 0;
|
|
if (PyArg_ParseTuple(args,"l:Interval.translate", &delta)) {
|
|
interval->translate(delta);
|
|
} else {
|
|
PyErr_SetString( ConstructorError, "invalid number of parameters for Interval.translate()" );
|
|
return NULL;
|
|
}
|
|
HCATCH
|
|
|
|
Py_INCREF( self );
|
|
return (PyObject*)self;
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------
|
|
// PyInterval Attribute Method table.
|
|
|
|
PyMethodDef PyInterval_Methods[] =
|
|
{ { "getVMin" , (PyCFunction)PyInterval_getVMin , METH_NOARGS , "Return the VMin value." }
|
|
, { "getVMax" , (PyCFunction)PyInterval_getVMax , METH_NOARGS , "Return the VMax value." }
|
|
, { "getCenter" , (PyCFunction)PyInterval_getCenter , METH_NOARGS , "Return the interval center value." }
|
|
, { "getSize" , (PyCFunction)PyInterval_getSize , METH_NOARGS , "Return the interval length." }
|
|
, { "getHalfSize" , (PyCFunction)PyInterval_getHalfSize , METH_NOARGS , "Return the interval half length." }
|
|
, { "getUnion" , (PyCFunction)PyInterval_getUnion , METH_VARARGS, "Return the smallest enclosing interval." }
|
|
, { "getIntersection", (PyCFunction)PyInterval_getIntersection, METH_VARARGS, "Return the overlapping interval." }
|
|
, { "isEmpty" , (PyCFunction)PyInterval_isEmpty , METH_NOARGS , "Return true if the interval is empty." }
|
|
, { "isPonctual" , (PyCFunction)PyInterval_isPonctual , METH_NOARGS , "Return true if the interval reduced to a point." }
|
|
, { "contains" , (PyCFunction)PyInterval_contains , METH_VARARGS, "Return true if the interval contains the argument." }
|
|
, { "intersect" , (PyCFunction)PyInterval_intersect , METH_VARARGS, "Return true if two intervales overlap." }
|
|
, { "makeEmpty" , (PyCFunction)PyInterval_makeEmpty , METH_NOARGS , "Transform the interval in an empty one." }
|
|
, { "inflate" , (PyCFunction)PyInterval_inflate , METH_VARARGS, "Expand the interval of the given values." }
|
|
, { "merge" , (PyCFunction)PyInterval_merge , METH_VARARGS, "Expand or contract the interval to contains the arguments." }
|
|
, { "intersection" , (PyCFunction)PyInterval_intersection , METH_VARARGS, "Expand the interval to contains the arguments.." }
|
|
, { "translate" , (PyCFunction)PyInterval_translate , METH_VARARGS, "translate the interval." }
|
|
, { "destroy" , (PyCFunction)PyInterval_destroy , METH_NOARGS
|
|
, "Destroy associated hurricane object, the python object remains." }
|
|
, {NULL, NULL, 0, NULL} /* sentinel */
|
|
};
|
|
|
|
// x-------------------------------------------------------------x
|
|
// | "PyInterval" Object Methods |
|
|
// x-------------------------------------------------------------x
|
|
|
|
|
|
DirectDeleteMethod(PyInterval_DeAlloc,PyInterval)
|
|
PyTypeObjectLinkPyTypeNewInit(Interval)
|
|
//PyTypeObjectLinkPyType(Interval)
|
|
|
|
#else // End of Python Module Code Part.
|
|
|
|
|
|
// x=================================================================x
|
|
// | "PyInterval" Shared Library Code Part |
|
|
// x=================================================================x
|
|
|
|
|
|
// ---------------------------------------------------------------
|
|
// PyInterval Object Definitions.
|
|
|
|
LinkCreateMethod(Interval)
|
|
PyTypeObjectDefinitions(Interval)
|
|
|
|
# endif // End of Shared Library Code Part.
|
|
|
|
} // End of extern "C".
|
|
|
|
} // End of Isobar namespace.
|
|
|