static int Euler_ass_subscript(EulerObject *self, PyObject *item, PyObject *value)
{
if (PyIndex_Check(item)) {
Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
if (i == -1 && PyErr_Occurred())
return -1;
if (i < 0)
i += EULER_SIZE;
return Euler_ass_item(self, i, value);
}
else if (PySlice_Check(item)) {
Py_ssize_t start, stop, step, slicelength;
if (PySlice_GetIndicesEx(item, EULER_SIZE, &start, &stop, &step, &slicelength) < 0)
return -1;
if (step == 1)
return Euler_ass_slice(self, start, stop, value);
else {
PyErr_SetString(PyExc_IndexError,
"slice steps not supported with euler");
return -1;
}
}
else {
PyErr_Format(PyExc_TypeError,
"euler indices must be integers, not %.200s",
Py_TYPE(item)->tp_name);
return -1;
}
}
static Py_ssize_t
BufferAsSubscript(PyObject *self, PyObject* idx, PyObject* val)
{
if (PyLong_Check(idx)) {
long n = PyLong_AsLong(idx);
return RBAsItem((BufferObject *)(self), n, val, 1,
(Py_ssize_t)((BufferObject *)(self))->buf->b_ml.ml_line_count,
NULL);
} else if (PySlice_Check(idx)) {
Py_ssize_t start, stop, step, slicelen;
if (PySlice_GetIndicesEx((PySliceObject *)idx,
(Py_ssize_t)((BufferObject *)(self))->buf->b_ml.ml_line_count+1,
&start, &stop,
&step, &slicelen) < 0) {
return -1;
}
return RBAsSlice((BufferObject *)(self), start, stop, val, 1,
(PyInt)((BufferObject *)(self))->buf->b_ml.ml_line_count,
NULL);
} else {
PyErr_SetString(PyExc_IndexError, "Index must be int or slice");
return -1;
}
}
static PyObject*
tuplesubscript(PyTupleObject* self, PyObject* item)
{
if (PyIndex_Check(item)) {
Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
if (i == -1 && PyErr_Occurred())
return NULL;
if (i < 0)
i += PyTuple_GET_SIZE(self);
return tupleitem(self, i);
}
else if (PySlice_Check(item)) {
Py_ssize_t start, stop, step, slicelength, cur, i;
PyObject* result;
PyObject* it;
PyObject **src, **dest;
if (PySlice_GetIndicesEx(item,
PyTuple_GET_SIZE(self),
&start, &stop, &step, &slicelength) < 0) {
return NULL;
}
if (slicelength <= 0) {
return PyTuple_New(0);
}
else if (start == 0 && step == 1 &&
slicelength == PyTuple_GET_SIZE(self) &&
PyTuple_CheckExact(self)) {
Py_INCREF(self);
return (PyObject *)self;
}
else {
result = PyTuple_New(slicelength);
if (!result) return NULL;
src = self->ob_item;
dest = ((PyTupleObject *)result)->ob_item;
for (cur = start, i = 0; i < slicelength;
cur += step, i++) {
it = src[cur];
Py_INCREF(it);
dest[i] = it;
}
return result;
}
}
else {
PyErr_Format(PyExc_TypeError,
"tuple indices must be integers, not %.200s",
Py_TYPE(item)->tp_name);
return NULL;
}
}
static PyObject *
buffer_subscript(PyBufferObject *self, PyObject *item)
{
void *p;
Py_ssize_t size;
if (!get_buf(self, &p, &size, ANY_BUFFER))
return NULL;
if (PyIndex_Check(item)) {
Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
if (i == -1 && PyErr_Occurred())
return NULL;
if (i < 0)
i += size;
return buffer_item(self, i);
}
else if (PySlice_Check(item)) {
Py_ssize_t start, stop, step, slicelength, cur, i;
if (PySlice_GetIndicesEx((PySliceObject*)item, size,
&start, &stop, &step, &slicelength) < 0) {
return NULL;
}
if (slicelength <= 0)
return PyString_FromStringAndSize("", 0);
else if (step == 1)
return PyString_FromStringAndSize((char *)p + start,
stop - start);
else {
PyObject *result;
char *source_buf = (char *)p;
char *result_buf = (char *)PyMem_Malloc(slicelength);
if (result_buf == NULL)
return PyErr_NoMemory();
for (cur = start, i = 0; i < slicelength;
cur += step, i++) {
result_buf[i] = source_buf[cur];
}
result = PyString_FromStringAndSize(result_buf,
slicelength);
PyMem_Free(result_buf);
return result;
}
}
else {
PyErr_SetString(PyExc_TypeError,
"sequence index must be integer");
return NULL;
}
}
static PyObject *
GMPy_XMPZ_Method_SubScript(XMPZ_Object* self, PyObject* item)
{
CTXT_Object *context = NULL;
CHECK_CONTEXT(context);
if (PyIndex_Check(item)) {
Py_ssize_t i;
i = PyIntOrLong_AsSsize_t(item);
if (i == -1 && PyErr_Occurred()) {
INDEX_ERROR("argument too large to be converted to an index");
return NULL;
}
if (i < 0) {
i += mpz_sizeinbase(self->z, 2);
}
return PyIntOrLong_FromLong(mpz_tstbit(self->z, i));
}
else if (PySlice_Check(item)) {
Py_ssize_t start, stop, step, slicelength, cur, i;
MPZ_Object *result;
#if PY_VERSION_HEX > 0x030200A4
if (PySlice_GetIndicesEx(item,
#else
if (PySlice_GetIndicesEx((PySliceObject*)item,
#endif
mpz_sizeinbase(self->z, 2),
&start, &stop, &step, &slicelength) < 0) {
return NULL;
}
if ((step < 0 && start < stop) || (step > 0 && start > stop)) {
stop = start;
}
if (!(result = GMPy_MPZ_New(context))) {
return NULL;
}
mpz_set_ui(result->z, 0);
if (slicelength > 0) {
for (cur = start, i = 0; i < slicelength; cur += step, i++) {
if (mpz_tstbit(self->z, cur)) {
mpz_setbit(result->z, i);
}
}
}
return (PyObject*)result;
}
else {
static PyObject *
mmap_subscript(mmap_object *self, PyObject *item)
{
CHECK_VALID(NULL);
if (PyIndex_Check(item)) {
Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
if (i == -1 && PyErr_Occurred())
return NULL;
if (i < 0)
i += self->size;
if (i < 0 || i >= self->size) {
PyErr_SetString(PyExc_IndexError,
"mmap index out of range");
return NULL;
}
return PyLong_FromLong(Py_CHARMASK(self->data[i]));
}
else if (PySlice_Check(item)) {
Py_ssize_t start, stop, step, slicelen;
if (PySlice_GetIndicesEx(item, self->size,
&start, &stop, &step, &slicelen) < 0) {
return NULL;
}
if (slicelen <= 0)
return PyBytes_FromStringAndSize("", 0);
else if (step == 1)
return PyBytes_FromStringAndSize(self->data + start,
slicelen);
else {
char *result_buf = (char *)PyMem_Malloc(slicelen);
Py_ssize_t cur, i;
PyObject *result;
if (result_buf == NULL)
return PyErr_NoMemory();
for (cur = start, i = 0; i < slicelen;
cur += step, i++) {
result_buf[i] = self->data[cur];
}
result = PyBytes_FromStringAndSize(result_buf,
slicelen);
PyMem_Free(result_buf);
return result;
}
}
else {
PyErr_SetString(PyExc_TypeError,
"mmap indices must be integers");
return NULL;
}
}
static PyObj
array_subscript(PyObj self, PyObj arg)
{
Py_ssize_t len = py_array_length(self);
if (PyIndex_Check(arg))
{
Py_ssize_t i = PyNumber_AsSsize_t(arg, PyExc_IndexError);
if (i == -1 && PyErr_Occurred())
return(NULL);
if (i < 0)
i += py_array_length(self);
return(array_item(self, i));
}
else if (PySlice_Check(arg))
{
Py_ssize_t start, stop, step, slicelength;
int r;
r = PySlice_GetIndicesEx(arg, len,
&start, &stop, &step, &slicelength);
if (r < 0)
return(NULL);
if (step != 1)
{
/* TODO: implement custom step values for array subscript */
PyErr_Format(PyExc_NotImplementedError,
"unsupported step value in array subscript");
return(NULL);
}
if (slicelength == len && start == 0)
{
Py_INCREF(self);
return(self);
}
return(array_slice(self, start, stop));
}
else
{
PyErr_Format(PyExc_TypeError, "array indexes must be integers, not %.200s",
Py_TYPE(arg)->tp_name);
return(NULL);
}
}
// range can not be directly converted from slice (slice is more complex)
// convert from python slice and int (interpreted are slice(i,i+1,1))
triqs::arrays::range range_from_slice(PyObject *ob, long len) {
if (PyInt_Check(ob)) {
long i = PyInt_AsLong(ob);
if ((i < -len) || (i >= len)) TRIQS_RUNTIME_ERROR << "Integer index out of range : expected [0," << len << "], got " << i;
if (i < 0) i += len;
// std::cerr << " range int "<< i << std::endl;
return {i, i + 1, 1};
}
Py_ssize_t start, stop, step, slicelength;
if (!PySlice_Check(ob) || (PySlice_GetIndicesEx((PySliceObject *)ob, len, &start, &stop, &step, &slicelength) < 0))
TRIQS_RUNTIME_ERROR << "Can not converted the slice to C++";
// std::cerr << "range ( "<< start << " "<< stop << " " << step<<std::endl;
return {start, stop, step};
}
static boost::python::list getSlice( Set &s, boost::python::slice sl )
{
Py_ssize_t start, stop, step, length;
if( PySlice_GetIndicesEx( (PySliceObject *)sl.ptr(), s.size(), &start, &stop, &step, &length ) )
{
boost::python::throw_error_already_set();
}
boost::python::list result;
for( Py_ssize_t i = start; i < stop; i++ )
{
result.append( Set::MemberPtr( s.member( i ) ) );
}
return result;
}
static PyObject *
structseq_subscript(PyStructSequence *self, PyObject *item)
{
if (PyIndex_Check(item)) {
Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
if (i == -1 && PyErr_Occurred())
return NULL;
if (i < 0)
i += VISIBLE_SIZE(self);
if (i < 0 || i >= VISIBLE_SIZE(self)) {
PyErr_SetString(PyExc_IndexError,
"tuple index out of range");
return NULL;
}
Py_INCREF(self->ob_item[i]);
return self->ob_item[i];
}
else if (PySlice_Check(item)) {
Py_ssize_t start, stop, step, slicelen, cur, i;
PyObject *result;
if (PySlice_GetIndicesEx((PySliceObject *)item,
VISIBLE_SIZE(self), &start, &stop,
&step, &slicelen) < 0) {
return NULL;
}
if (slicelen <= 0)
return PyTuple_New(0);
result = PyTuple_New(slicelen);
if (result == NULL)
return NULL;
for (cur = start, i = 0; i < slicelen;
cur += step, i++) {
PyObject *v = self->ob_item[cur];
Py_INCREF(v);
PyTuple_SET_ITEM(result, i, v);
}
return result;
}
else {
PyErr_SetString(PyExc_TypeError,
"structseq index must be integer");
return NULL;
}
}
static PyObject*
slice_indices(PySliceObject* self, PyObject* len)
{
Py_ssize_t ilen, start, stop, step, slicelength;
ilen = PyNumber_AsSsize_t(len, PyExc_OverflowError);
if (ilen == -1 && PyErr_Occurred()) {
return NULL;
}
if (PySlice_GetIndicesEx(self, ilen, &start, &stop,
&step, &slicelength) < 0) {
return NULL;
}
return Py_BuildValue("(nnn)", start, stop, step);
}
static PyObject *listvalue_mapping_subscript(PyObject *self, PyObject *key)
{
CListValue *list= static_cast<CListValue *>(BGE_PROXY_REF(self));
if (list==NULL) {
PyErr_SetString(PyExc_SystemError, "value = CList[i], "BGE_PROXY_ERROR_MSG);
return NULL;
}
if (PyUnicode_Check(key)) {
CValue *item = ((CListValue*) list)->FindValue(_PyUnicode_AsString(key));
if (item) {
PyObject *pyobj = item->ConvertValueToPython();
if (pyobj)
return pyobj;
else
return item->GetProxy();
}
}
else if (PyIndex_Check(key)) {
Py_ssize_t index = PyLong_AsSsize_t(key);
return listvalue_buffer_item(self, index); /* wont add a ref */
}
else if (PySlice_Check(key)) {
Py_ssize_t start, stop, step, slicelength;
if (PySlice_GetIndicesEx(key, list->GetCount(), &start, &stop, &step, &slicelength) < 0)
return NULL;
if (slicelength <= 0) {
return PyList_New(0);
}
else if (step == 1) {
return listvalue_buffer_slice(list, start, stop);
}
else {
PyErr_SetString(PyExc_TypeError, "CList[slice]: slice steps not supported");
return NULL;
}
}
PyErr_Format(PyExc_KeyError,
"CList[key]: '%R' key not in list", key);
return NULL;
}
static PyObject *
Pyxmpz_subscript(PyxmpzObject* self, PyObject* item)
{
if (PyIndex_Check(item)) {
Py_ssize_t i;
i = PyNumber_AsSsize_t(item, PyExc_IndexError);
if (i == -1 && PyErr_Occurred())
return NULL;
if (i < 0)
i += mpz_sizeinbase(self->z, 2);
return PyIntOrLong_FromLong(mpz_tstbit(self->z, i));
}
else if (PySlice_Check(item)) {
Py_ssize_t start, stop, step, slicelength, cur, i;
PyObject* result;
#if PY_VERSION_HEX > 0x030200A4
if (PySlice_GetIndicesEx(item,
#else
if (PySlice_GetIndicesEx((PySliceObject*)item,
#endif
mpz_sizeinbase(self->z, 2),
&start, &stop, &step, &slicelength) < 0) {
return NULL;
}
if ((step < 0 && start < stop) ||
(step > 0 && start > stop))
stop = start;
if (!(result = (PyObject*)Pympz_new()))
return NULL;
mpz_set_ui(Pympz_AS_MPZ(result), 0);
if (slicelength > 0) {
for (cur = start, i = 0; i < slicelength; cur += step, i++) {
if (mpz_tstbit(self->z, cur)) {
mpz_setbit(Pympz_AS_MPZ(result), i);
}
}
}
return result;
}
else {
static PyObject *
RangeSubscript(PyObject *self, PyObject* idx)
{
if (PyLong_Check(idx)) {
long _idx = PyLong_AsLong(idx);
return RangeItem(self,_idx);
} else if (PySlice_Check(idx)) {
Py_ssize_t start, stop, step, slicelen;
if (PySlice_GetIndicesEx((PySliceObject *)idx,
((RangeObject *)(self))->end-((RangeObject *)(self))->start+1,
&start, &stop,
&step, &slicelen) < 0) {
return NULL;
}
return RangeSlice(self,start,stop+1);
} else {
PyErr_SetString(PyExc_IndexError, "Index must be int or slice");
return NULL;
}
}
static Py_ssize_t
RangeAsSubscript(PyObject *self, PyObject *idx, PyObject *val)
{
if (PyLong_Check(idx)) {
long n = PyLong_AsLong(idx);
return RangeAsItem(self, n, val);
} else if (PySlice_Check(idx)) {
Py_ssize_t start, stop, step, slicelen;
if (PySlice_GetIndicesEx((PySliceObject_T *)idx,
((RangeObject *)(self))->end-((RangeObject *)(self))->start+1,
&start, &stop,
&step, &slicelen) < 0) {
return -1;
}
return RangeAsSlice(self, start, stop, val);
} else {
RAISE_INVALID_INDEX_TYPE(idx);
return -1;
}
}
static PyObject *
RangeSubscript(PyObject *self, PyObject* idx)
{
if (PyLong_Check(idx)) {
long _idx = PyLong_AsLong(idx);
return RangeItem((RangeObject *)(self), _idx);
} else if (PySlice_Check(idx)) {
Py_ssize_t start, stop, step, slicelen;
if (PySlice_GetIndicesEx((PySliceObject_T *)idx,
((RangeObject *)(self))->end-((RangeObject *)(self))->start+1,
&start, &stop,
&step, &slicelen) < 0) {
return NULL;
}
return RangeSlice((RangeObject *)(self), start, stop);
} else {
RAISE_INVALID_INDEX_TYPE(idx);
return NULL;
}
}
static PyObject *
BufferSubscript(PyObject *self, PyObject* idx)
{
if (PyLong_Check(idx)) {
long _idx = PyLong_AsLong(idx);
return BufferItem(self,_idx);
} else if (PySlice_Check(idx)) {
Py_ssize_t start, stop, step, slicelen;
if (PySlice_GetIndicesEx((PySliceObject *)idx,
(Py_ssize_t)((BufferObject *)(self))->buf->b_ml.ml_line_count+1,
&start, &stop,
&step, &slicelen) < 0) {
return NULL;
}
return BufferSlice(self,start,stop+1);
} else {
PyErr_SetString(PyExc_IndexError, "Index must be int or slice");
return NULL;
}
}
static int pyjlist_set_subscript(PyObject* self, PyObject* item, PyObject* value) {
if(PyInt_Check(item)) {
long i = PyInt_AS_LONG(item);
if (i < 0)
i += (long) PyObject_Size(self);
return pyjlist_setitem(self, (Py_ssize_t) i, value);
}
else if(PyLong_Check(item)) {
long i = PyLong_AsLong(item);
if (i == -1 && PyErr_Occurred())
return -1;
if (i < 0)
i += (long) PyObject_Size(self);
return pyjlist_setitem(self, (Py_ssize_t) i, value);
} else if(PySlice_Check(item)) {
Py_ssize_t start, stop, step, slicelength;
/*
* ignore compile warning on the next line, they fixed the
* method signature in python 3.2
*/
if(PySlice_GetIndicesEx(item, PyObject_Size(self), &start, &stop, &step, &slicelength) < 0) {
// error will already be set
return -1;
}
if(slicelength <= 0) {
return 0;
} else if(step != 1) {
PyErr_SetString(PyExc_TypeError, "pyjlist slices must have step of 1");
return -1;
} else {
return pyjlist_setslice(self, start, stop, value);
}
} else {
PyErr_SetString(PyExc_TypeError, "list indices must be integers, longs, or slices");
return -1;
}
}
static PyObject*
path_subscript(PyPathObject* self, PyObject* item) {
if (PyIndex_Check(item)) {
Py_ssize_t i;
i = PyNumber_AsSsize_t(item, PyExc_IndexError);
if (i == -1 && PyErr_Occurred())
return NULL;
return path_getitem(self, i);
}
if (PySlice_Check(item)) {
int len = 4;
Py_ssize_t start, stop, step, slicelength;
if (PySlice_GetIndicesEx((PyObject*)item, len, &start, &stop, &step, &slicelength) < 0)
return NULL;
if (slicelength <= 0) {
double *xy = alloc_array(0);
return (PyObject*) path_new(0, xy, 0);
}
else if (step == 1) {
return path_getslice(self, start, stop);
}
else {
PyErr_SetString(PyExc_TypeError, "slice steps not supported");
return NULL;
}
}
else {
PyErr_Format(PyExc_TypeError,
"Path indices must be integers, not %.200s",
#ifdef PY3
Py_TYPE(&item)->tp_name);
#else
item->ob_type->tp_name);
#endif
return NULL;
}
}
static PyObject *Color_subscript(ColorObject *self, PyObject *item)
{
if (PyIndex_Check(item)) {
Py_ssize_t i;
i = PyNumber_AsSsize_t(item, PyExc_IndexError);
if (i == -1 && PyErr_Occurred())
return NULL;
if (i < 0)
i += COLOR_SIZE;
return Color_item(self, i);
}
else if (PySlice_Check(item)) {
Py_ssize_t start, stop, step, slicelength;
if (PySlice_GetIndicesEx((void *)item, COLOR_SIZE, &start, &stop, &step, &slicelength) < 0)
return NULL;
if (slicelength <= 0) {
return PyTuple_New(0);
}
else if (step == 1) {
return Color_slice(self, start, stop);
}
else {
PyErr_SetString(PyExc_IndexError,
"slice steps not supported with color");
return NULL;
}
}
else {
PyErr_Format(PyExc_TypeError,
"color indices must be integers, not %.200s",
Py_TYPE(item)->tp_name);
return NULL;
}
}
static PyObject *
BufferSubscript(PyObject *self, PyObject* idx)
{
if (PyLong_Check(idx)) {
long _idx = PyLong_AsLong(idx);
return BufferItem((BufferObject *)(self), _idx);
} else if (PySlice_Check(idx)) {
Py_ssize_t start, stop, step, slicelen;
if (CheckBuffer((BufferObject *) self))
return NULL;
if (PySlice_GetIndicesEx((PySliceObject_T *)idx,
(Py_ssize_t)((BufferObject *)(self))->buf->b_ml.ml_line_count,
&start, &stop,
&step, &slicelen) < 0) {
return NULL;
}
return BufferSlice((BufferObject *)(self), start, stop);
} else {
RAISE_INVALID_INDEX_TYPE(idx);
return NULL;
}
}
CvRect PySlice_to_CvRect(CvArr * src, PyObject * idx_object){
CvSize sz = cvGetSize(src);
//printf("Size %dx%d\n", sz.height, sz.width);
int lower[2], upper[2];
Py_ssize_t len, start, stop, step, slicelength;
if(PyInt_Check(idx_object) || PyLong_Check(idx_object)){
// if array is a row vector, assume index into columns
if(sz.height>1){
lower[0] = PyLong_AsIndex( idx_object, sz.height );
upper[0] = lower[0] + 1;
lower[1] = 0;
upper[1] = sz.width;
}
else{
lower[0] = 0;
upper[0] = sz.height;
lower[1] = PyLong_AsIndex( idx_object, sz.width );
upper[1] = lower[1]+1;
}
}
// 1. Slice
else if(PySlice_Check(idx_object)){
len = sz.height;
if(PySlice_GetIndicesEx( (PySliceObject*)idx_object, len, &start, &stop, &step, &slicelength )!=0){
printf("Error in PySlice_GetIndicesEx: returning NULL");
PyErr_SetString(PyExc_Exception, "Error");
return cvRect(0,0,0,0);
}
// if array is a row vector, assume index bounds are into columns
if(sz.height>1){
lower[0] = (int) start; // use c convention of start index = 0
upper[0] = (int) stop; // use c convention
lower[1] = 0;
upper[1] = sz.width;
}
else{
lower[1] = (int) start; // use c convention of start index = 0
upper[1] = (int) stop; // use c convention
lower[0] = 0;
upper[0] = sz.height;
}
}
// 2. Tuple
else if(PyTuple_Check(idx_object)){
//printf("PyTuple{\n");
if(PyObject_Length(idx_object)!=2){
//printf("Expected a sequence of length 2: returning NULL");
PyErr_SetString(PyExc_ValueError, "Expected a sequence with 2 elements");
return cvRect(0,0,0,0);
}
for(int i=0; i<2; i++){
PyObject *o = PyTuple_GetItem(idx_object, i);
// 2a. Slice -- same as above
if(PySlice_Check(o)){
//printf("PySlice\n");
len = (i==0 ? sz.height : sz.width);
if(PySlice_GetIndicesEx( (PySliceObject*)o, len, &start, &stop, &step, &slicelength )!=0){
PyErr_SetString(PyExc_Exception, "Error");
printf("Error in PySlice_GetIndicesEx: returning NULL");
return cvRect(0,0,0,0);
}
//printf("PySlice_GetIndecesEx(%d, %d, %d, %d, %d)\n", len, start, stop, step, slicelength);
lower[i] = start;
upper[i] = stop;
}
// 2b. Integer
else if(PyInt_Check(o) || PyLong_Check(o)){
//printf("PyInt\n");
lower[i] = PyLong_AsIndex(o, i==0 ? sz.height : sz.width);
upper[i] = lower[i]+1;
}
else {
PyErr_SetString(PyExc_TypeError, "Expected a sequence of slices or integers");
printf("Expected a slice or int as sequence item: returning NULL");
return cvRect(0,0,0,0);
}
}
}
else {
PyErr_SetString( PyExc_TypeError, "Expected a slice or sequence");
printf("Expected a slice or sequence: returning NULL");
return cvRect(0,0,0,0);
}
//lower[0] = MAX(0, lower[0]);
//lower[1] = MAX(0, lower[1]);
//upper[0] = MIN(sz.height, upper[0]);
//upper[1] = MIN(sz.width, upper[1]);
//printf("Slice=%d %d %d %d\n", lower[0], upper[0], lower[1], upper[1]);
return cvRect(lower[1],lower[0], upper[1]-lower[1], upper[0]-lower[0]);
}
static int
buffer_ass_subscript(PyBufferObject *self, PyObject *item, PyObject *value)
{
PyBufferProcs *pb;
void *ptr1, *ptr2;
Py_ssize_t selfsize;
Py_ssize_t othersize;
if ( self->b_readonly ) {
PyErr_SetString(PyExc_TypeError,
"buffer is read-only");
return -1;
}
pb = value ? value->ob_type->tp_as_buffer : NULL;
if ( pb == NULL ||
pb->bf_getreadbuffer == NULL ||
pb->bf_getsegcount == NULL )
{
PyErr_BadArgument();
return -1;
}
if ( (*pb->bf_getsegcount)(value, NULL) != 1 )
{
/* ### use a different exception type/message? */
PyErr_SetString(PyExc_TypeError,
"single-segment buffer object expected");
return -1;
}
if (!get_buf(self, &ptr1, &selfsize, ANY_BUFFER))
return -1;
if (PyIndex_Check(item)) {
Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
if (i == -1 && PyErr_Occurred())
return -1;
if (i < 0)
i += selfsize;
return buffer_ass_item(self, i, value);
}
else if (PySlice_Check(item)) {
Py_ssize_t start, stop, step, slicelength;
if (PySlice_GetIndicesEx((PySliceObject *)item, selfsize,
&start, &stop, &step, &slicelength) < 0)
return -1;
if ((othersize = (*pb->bf_getreadbuffer)(value, 0, &ptr2)) < 0)
return -1;
if (othersize != slicelength) {
PyErr_SetString(
PyExc_TypeError,
"right operand length must match slice length");
return -1;
}
if (slicelength == 0)
return 0;
else if (step == 1) {
memcpy((char *)ptr1 + start, ptr2, slicelength);
return 0;
}
else {
Py_ssize_t cur, i;
for (cur = start, i = 0; i < slicelength;
cur += step, i++) {
((char *)ptr1)[cur] = ((char *)ptr2)[i];
}
return 0;
}
} else {
PyErr_SetString(PyExc_TypeError,
"buffer indices must be integers");
return -1;
}
}
static int slot_QPolygonF___setitem__(PyObject *sipSelf,PyObject *sipArgs)
{
QPolygonF *sipCpp = reinterpret_cast<QPolygonF *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QPolygonF));
if (!sipCpp)
return -1;
PyObject *sipParseErr = NULL;
{
int a0;
const QPointF* a1;
int a1State = 0;
if (sipParseArgs(&sipParseErr, sipArgs, "iJ1", &a0, sipType_QPointF, &a1, &a1State))
{
int sipIsErr = 0;
#line 412 "C:\\Users\\marcus\\Downloads\\PyQt-gpl-5.4\\PyQt-gpl-5.4\\sip/QtGui/qpolygon.sip"
int len;
len = sipCpp->count();
if ((a0 = (int)sipConvertFromSequenceIndex(a0, len)) < 0)
sipIsErr = 1;
else
(*sipCpp)[a0] = *a1;
#line 1140 "C:\\Users\\marcus\\Downloads\\PyQt-gpl-5.4\\PyQt-gpl-5.4\\QtGui/sipQtGuiQPolygonF.cpp"
sipReleaseType(const_cast<QPointF *>(a1),sipType_QPointF,a1State);
if (sipIsErr)
return -1;
return 0;
}
}
{
PyObject * a0;
const QPolygonF* a1;
if (sipParseArgs(&sipParseErr, sipArgs, "TJ9", &PySlice_Type, &a0, sipType_QPolygonF, &a1))
{
int sipIsErr = 0;
#line 424 "C:\\Users\\marcus\\Downloads\\PyQt-gpl-5.4\\PyQt-gpl-5.4\\sip/QtGui/qpolygon.sip"
SIP_SSIZE_T len, start, stop, step, slicelength, i;
len = sipCpp->count();
#if PY_VERSION_HEX >= 0x03020000
if (PySlice_GetIndicesEx(a0, len, &start, &stop, &step, &slicelength) < 0)
#else
if (PySlice_GetIndicesEx((PySliceObject *)a0, len, &start, &stop, &step, &slicelength) < 0)
#endif
sipIsErr = 1;
else
{
int vlen = a1->count();
if (vlen != slicelength)
{
sipBadLengthForSlice(vlen, slicelength);
sipIsErr = 1;
}
else
{
QVector<QPointF>::const_iterator it = a1->begin();
for (i = 0; i < slicelength; ++i)
{
(*sipCpp)[start] = *it;
start += step;
++it;
}
}
}
#line 1190 "C:\\Users\\marcus\\Downloads\\PyQt-gpl-5.4\\PyQt-gpl-5.4\\QtGui/sipQtGuiQPolygonF.cpp"
if (sipIsErr)
return -1;
return 0;
}
}
/* Raise an exception if the arguments couldn't be parsed. */
sipNoMethod(sipParseErr, sipName_QPolygonF, sipName___setitem__, NULL);
return -1;
}
static PyObject *slot_QPolygonF___getitem__(PyObject *sipSelf,PyObject *sipArg)
{
QPolygonF *sipCpp = reinterpret_cast<QPolygonF *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QPolygonF));
if (!sipCpp)
return 0;
PyObject *sipParseErr = NULL;
{
int a0;
if (sipParseArgs(&sipParseErr, sipArg, "1i", &a0))
{
QPointF*sipRes = 0;
int sipIsErr = 0;
#line 400 "C:\\Users\\marcus\\Downloads\\PyQt-gpl-5.4\\PyQt-gpl-5.4\\sip/QtGui/qpolygon.sip"
SIP_SSIZE_T idx = sipConvertFromSequenceIndex(a0, sipCpp->count());
if (idx < 0)
sipIsErr = 1;
else
sipRes = new QPointF(sipCpp->operator[]((int)idx));
#line 1231 "C:\\Users\\marcus\\Downloads\\PyQt-gpl-5.4\\PyQt-gpl-5.4\\QtGui/sipQtGuiQPolygonF.cpp"
if (sipIsErr)
return 0;
return sipConvertFromType(sipRes,sipType_QPointF,NULL);
}
}
{
PyObject * a0;
if (sipParseArgs(&sipParseErr, sipArg, "1T", &PySlice_Type, &a0))
{
QPolygonF*sipRes = 0;
int sipIsErr = 0;
#line 491 "C:\\Users\\marcus\\Downloads\\PyQt-gpl-5.4\\PyQt-gpl-5.4\\sip/QtGui/qpolygon.sip"
SIP_SSIZE_T len, start, stop, step, slicelength, i;
len = sipCpp->count();
#if PY_VERSION_HEX >= 0x03020000
if (PySlice_GetIndicesEx(a0, len, &start, &stop, &step, &slicelength) < 0)
#else
if (PySlice_GetIndicesEx((PySliceObject *)a0, len, &start, &stop, &step, &slicelength) < 0)
#endif
sipIsErr = 1;
else
{
sipRes = new QPolygonF();
for (i = 0; i < slicelength; ++i)
{
(*sipRes) += (*sipCpp)[start];
start += step;
}
}
#line 1269 "C:\\Users\\marcus\\Downloads\\PyQt-gpl-5.4\\PyQt-gpl-5.4\\QtGui/sipQtGuiQPolygonF.cpp"
if (sipIsErr)
return 0;
return sipConvertFromType(sipRes,sipType_QPolygonF,NULL);
}
}
/* Raise an exception if the arguments couldn't be parsed. */
sipNoMethod(sipParseErr, sipName_QPolygonF, sipName___getitem__, NULL);
return 0;
}
static PyObject *PY_pdbdata_mp_subscript(PyObject *_self, PyObject *key)
{Py_ssize_t nitems;
PY_pdbdata *self;
PyObject *rv = NULL;
PP_form *form;
self = (PY_pdbdata *) _self;
/* find length of available data */
if (self->data == NULL)
nitems = 0;
else if (self->dims == NULL)
nitems = 1;
else
nitems = self->dims->number;
if (PyIndex_Check(key)) {
Py_ssize_t i;
i = PyNumber_AsSsize_t(key, PyExc_IndexError);
if (i < 0)
i += nitems;
if (i >= nitems) {
if (indexerr == NULL)
indexerr = PY_STRING_STRING("pdbdata index out of range");
PyErr_SetObject(PyExc_IndexError, indexerr);
}
else {
form = &PP_global_form;
/* special case indexing a scalar item */
if (nitems == 1 && form->scalar_kind == AS_PDBDATA) {
Py_INCREF(self);
rv = (PyObject *) self;
} else {
void *vr;
vr = ((char *) self->data) + i * self->dp->size;
rv = PP_form_object(vr, self->type, 1, NULL,
self->dp, self->fileinfo, self->dpobj,
(PyObject *) self, form);
}
}
} else if (PySlice_Check(key)) {
Py_ssize_t start, stop, step, length;
void *vr;
dimdes *dims;
if (PySlice_GetIndicesEx(
#if PY_MAJOR_VERSION >= 3
key,
#else
(PySliceObject*)key,
#endif
nitems, &start, &stop,
&step, &length) == 0) {
form = &PP_global_form;
vr = ((char *) self->data) + start * self->dp->size;
dims = _PD_mk_dimensions(0, length);
SC_mark(dims, 1);
rv = PP_form_object(vr, self->type, length, dims,
self->dp, self->fileinfo, self->dpobj,
(PyObject *) self, form);
_PD_rl_dimensions(dims);
}
} else {
PyErr_Format(PyExc_TypeError,
"pdbdata indices must be integers, not %.200s",
key->ob_type->tp_name);
}
return rv;
}
/* This function is based on list_ass_subscript from Python source listobject.c.
But it uses LDAPValueList's setslice and setitem functions instead of memory opertation.
It is probably a much more slower, but cleaner solution.
*/
static int
LVL_ass_subscript(LDAPValueList *self, PyObject *item, PyObject *value) {
size_t cur;
Py_ssize_t i;
Py_ssize_t start, stop, step, slicelength;
PyObject *seq;
PyObject **seqitems;
if (PyIndex_Check(item)) {
i = PyNumber_AsSsize_t(item, PyExc_IndexError);
if (i == -1 && PyErr_Occurred()) return -1;
if (i < 0) i += PyList_GET_SIZE(self);
return LVL_ass_item(self, i, value);
} else if (PySlice_Check(item)) {
if (PySlice_GetIndicesEx(item, Py_SIZE(self), &start, &stop, &step, &slicelength) < 0) {
return -1;
}
if (step == 1) return LDAPValueList_SetSlice(self, start, stop, value);
/* Make sure s[5:2] = [..] inserts at the right place:
before 5, not before 2. */
if ((step < 0 && start < stop) || (step > 0 && start > stop)) {
stop = start;
}
if (value == NULL) {
/* delete slice */
if (slicelength <= 0) return 0;
if (step < 0) {
stop = start + 1;
start = stop + step*(slicelength - 1) - 1;
step = -step;
}
for (cur = start, i = 0; cur < (size_t)stop; cur += step, i++) {
if (LDAPValueList_SetSlice(self, cur-i, cur+1-i, (PyObject *)NULL) != 0) {
return -1;
}
}
return 0;
} else {
/* assign slice */
/* protect against a[::-1] = a */
if (self == (LDAPValueList*)value) {
seq = PyList_GetSlice(value, 0, PyList_GET_SIZE(value));
} else {
seq = PySequence_Fast(value, "must assign iterable to extended slice");
}
if (!seq) return -1;
if (PySequence_Fast_GET_SIZE(seq) != slicelength) {
PyErr_Format(PyExc_ValueError, "attempt to assign sequence of size %zd to extended slice of "
"size %zd", PySequence_Fast_GET_SIZE(seq), slicelength);
Py_DECREF(seq);
return -1;
}
if (!slicelength) {
Py_DECREF(seq);
return 0;
}
seqitems = PySequence_Fast_ITEMS(seq);
for (cur = start, i = 0; i < slicelength; cur += (size_t)step, i++) {
if (LDAPValueList_SetItem(self, cur, seqitems[i]) != 0) {
return -1;
}
}
Py_DECREF(seq);
return 0;
}
} else {
PyErr_Format(PyExc_TypeError, "list indices must be integers, not %.200s", item->ob_type->tp_name);
return -1;
}
}
static int slot_QPolygonF___delitem__(PyObject *sipSelf,PyObject *sipArg)
{
QPolygonF *sipCpp = reinterpret_cast<QPolygonF *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QPolygonF));
if (!sipCpp)
return -1;
PyObject *sipParseErr = NULL;
{
int a0;
if (sipParseArgs(&sipParseErr, sipArg, "1i", &a0))
{
int sipIsErr = 0;
#line 459 "C:\\Users\\marcus\\Downloads\\PyQt-gpl-5.4\\PyQt-gpl-5.4\\sip/QtGui/qpolygon.sip"
int len;
len = sipCpp->count();
if ((a0 = (int)sipConvertFromSequenceIndex(a0, len)) < 0)
sipIsErr = 1;
else
sipCpp->remove(a0);
#line 1063 "C:\\Users\\marcus\\Downloads\\PyQt-gpl-5.4\\PyQt-gpl-5.4\\QtGui/sipQtGuiQPolygonF.cpp"
if (sipIsErr)
return -1;
return 0;
}
}
{
PyObject * a0;
if (sipParseArgs(&sipParseErr, sipArg, "1T", &PySlice_Type, &a0))
{
int sipIsErr = 0;
#line 471 "C:\\Users\\marcus\\Downloads\\PyQt-gpl-5.4\\PyQt-gpl-5.4\\sip/QtGui/qpolygon.sip"
SIP_SSIZE_T len, start, stop, step, slicelength, i;
len = sipCpp->count();
#if PY_VERSION_HEX >= 0x03020000
if (PySlice_GetIndicesEx(a0, len, &start, &stop, &step, &slicelength) < 0)
#else
if (PySlice_GetIndicesEx((PySliceObject *)a0, len, &start, &stop, &step, &slicelength) < 0)
#endif
sipIsErr = 1;
else
for (i = 0; i < slicelength; ++i)
{
sipCpp->remove(start);
start += step - 1;
}
#line 1096 "C:\\Users\\marcus\\Downloads\\PyQt-gpl-5.4\\PyQt-gpl-5.4\\QtGui/sipQtGuiQPolygonF.cpp"
if (sipIsErr)
return -1;
return 0;
}
}
/* Raise an exception if the arguments couldn't be parsed. */
sipNoMethod(sipParseErr, sipName_QPolygonF, sipName___delitem__, NULL);
return -1;
}
static PyObject *
record_subscript(ApgRecordObject* o, PyObject* item)
{
if (PyIndex_Check(item)) {
Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
if (i == -1 && PyErr_Occurred())
return NULL;
if (i < 0) {
i += Py_SIZE(o);
}
return record_item(o, i);
}
else if (PySlice_Check(item)) {
Py_ssize_t start, stop, step, slicelength, cur, i;
PyObject* result;
PyObject* it;
PyObject **src, **dest;
if (PySlice_GetIndicesEx(
item,
Py_SIZE(o),
&start, &stop, &step, &slicelength) < 0)
{
return NULL;
}
if (slicelength <= 0) {
return PyTuple_New(0);
}
else {
result = PyTuple_New(slicelength);
if (!result) return NULL;
src = o->ob_item;
dest = ((PyTupleObject *)result)->ob_item;
for (cur = start, i = 0; i < slicelength; cur += step, i++) {
it = src[cur];
Py_INCREF(it);
dest[i] = it;
}
return result;
}
}
else {
PyObject *mapped;
mapped = PyObject_GetItem(o->mapping, item);
if (mapped != NULL) {
Py_ssize_t i;
PyObject *result;
if (!PyIndex_Check(mapped)) {
Py_DECREF(mapped);
goto noitem;
}
i = PyNumber_AsSsize_t(mapped, PyExc_IndexError);
Py_DECREF(mapped);
if (i < 0) {
if (PyErr_Occurred()) {
PyErr_Clear();
}
goto noitem;
}
result = record_item(o, i);
if (result == NULL) {
PyErr_Clear();
goto noitem;
}
return result;
}
else {
goto noitem;
}
}
noitem:
_PyErr_SetKeyError(item);
return NULL;
}
/**
* \ingroup python_interface_edgeseq
* \brief Selects a subset of the edge sequence based on some criteria
*/
PyObject* igraphmodule_EdgeSeq_select(igraphmodule_EdgeSeqObject *self, PyObject *args) {
igraphmodule_EdgeSeqObject *result;
igraphmodule_GraphObject *gr;
long i, j, n, m;
gr=self->gref;
result=igraphmodule_EdgeSeq_copy(self);
if (result == 0)
return NULL;
/* First, filter by positional arguments */
n = PyTuple_Size(args);
for (i=0; i<n; i++) {
PyObject *item = PyTuple_GET_ITEM(args, i);
if (item == Py_None) {
/* None means: select nothing */
igraph_es_destroy(&result->es);
igraph_es_none(&result->es);
/* We can simply bail out here */
return (PyObject*)result;
} else if (PyCallable_Check(item)) {
/* Call the callable for every edge in the current sequence to
* determine what's up */
igraph_bool_t was_excluded = 0;
igraph_vector_t v;
if (igraph_vector_init(&v, 0)) {
igraphmodule_handle_igraph_error();
return 0;
}
m = PySequence_Size((PyObject*)result);
for (j=0; j<m; j++) {
PyObject *edge = PySequence_GetItem((PyObject*)result, j);
PyObject *call_result;
if (edge == 0) {
Py_DECREF(result);
igraph_vector_destroy(&v);
return NULL;
}
call_result = PyObject_CallFunctionObjArgs(item, edge, NULL);
if (call_result == 0) {
Py_DECREF(edge); Py_DECREF(result);
igraph_vector_destroy(&v);
return NULL;
}
if (PyObject_IsTrue(call_result))
igraph_vector_push_back(&v,
igraphmodule_Edge_get_index_long((igraphmodule_EdgeObject*)edge));
else was_excluded=1;
Py_DECREF(call_result);
Py_DECREF(edge);
}
if (was_excluded) {
igraph_es_destroy(&result->es);
if (igraph_es_vector_copy(&result->es, &v)) {
Py_DECREF(result);
igraph_vector_destroy(&v);
igraphmodule_handle_igraph_error();
return NULL;
}
}
igraph_vector_destroy(&v);
} else if (PyInt_Check(item)) {
/* Integers are treated specially: from now on, all remaining items
* in the argument list must be integers and they will be used together
* to restrict the edge set. Integers are interpreted as indices on the
* edge set and NOT on the original, untouched edge sequence of the
* graph */
igraph_vector_t v, v2;
if (igraph_vector_init(&v, 0)) {
igraphmodule_handle_igraph_error();
return 0;
}
if (igraph_vector_init(&v2, 0)) {
igraph_vector_destroy(&v);
igraphmodule_handle_igraph_error();
return 0;
}
if (igraph_es_as_vector(&gr->g, self->es, &v2)) {
igraph_vector_destroy(&v);
igraph_vector_destroy(&v2);
igraphmodule_handle_igraph_error();
return 0;
}
m = igraph_vector_size(&v2);
for (; i<n; i++) {
PyObject *item2 = PyTuple_GET_ITEM(args, i);
long idx;
if (!PyInt_Check(item2)) {
Py_DECREF(result);
PyErr_SetString(PyExc_TypeError, "edge indices expected");
igraph_vector_destroy(&v);
igraph_vector_destroy(&v2);
return NULL;
}
idx = PyInt_AsLong(item2);
if (idx >= m || idx < 0) {
PyErr_SetString(PyExc_ValueError, "edge index out of range");
igraph_vector_destroy(&v);
igraph_vector_destroy(&v2);
return NULL;
}
if (igraph_vector_push_back(&v, VECTOR(v2)[idx])) {
Py_DECREF(result);
igraphmodule_handle_igraph_error();
igraph_vector_destroy(&v);
igraph_vector_destroy(&v2);
return NULL;
}
}
igraph_vector_destroy(&v2);
igraph_es_destroy(&result->es);
if (igraph_es_vector_copy(&result->es, &v)) {
Py_DECREF(result);
igraphmodule_handle_igraph_error();
igraph_vector_destroy(&v);
return NULL;
}
igraph_vector_destroy(&v);
} else {
/* Iterators and everything that was not handled directly */
PyObject *iter, *item2;
igraph_vector_t v, v2;
/* Allocate stuff */
if (igraph_vector_init(&v, 0)) {
igraphmodule_handle_igraph_error();
return 0;
}
if (igraph_vector_init(&v2, 0)) {
igraph_vector_destroy(&v);
igraphmodule_handle_igraph_error();
return 0;
}
if (igraph_es_as_vector(&gr->g, self->es, &v2)) {
igraph_vector_destroy(&v);
igraph_vector_destroy(&v2);
igraphmodule_handle_igraph_error();
return 0;
}
m = igraph_vector_size(&v2);
/* Create an appropriate iterator */
if (PySlice_Check(item)) {
/* Create an iterator from the slice (which is not iterable by default )*/
Py_ssize_t start, stop, step, sl;
PyObject* range;
igraph_bool_t ok;
/* Casting to void* because Python 2.x expects PySliceObject*
* but Python 3.x expects PyObject* */
ok = (PySlice_GetIndicesEx((void*)item, igraph_vector_size(&v2),
&start, &stop, &step, &sl) == 0);
if (ok) {
range = igraphmodule_PyRange_create(start, stop, step);
ok = (range != 0);
}
if (ok) {
iter = PyObject_GetIter(range);
Py_DECREF(range);
ok = (iter != 0);
}
if (!ok) {
igraph_vector_destroy(&v);
igraph_vector_destroy(&v2);
PyErr_SetString(PyExc_TypeError, "error while converting slice to iterator");
Py_DECREF(result);
return 0;
}
} else {
/* Simply create the iterator corresponding to the object */
iter = PyObject_GetIter(item);
}
/* Did we manage to get an iterator? */
if (iter == 0) {
igraph_vector_destroy(&v);
igraph_vector_destroy(&v2);
PyErr_SetString(PyExc_TypeError, "invalid edge filter among positional arguments");
Py_DECREF(result);
return 0;
}
/* Do the iteration */
while ((item2=PyIter_Next(iter)) != 0) {
if (PyInt_Check(item2)) {
long idx = PyInt_AsLong(item2);
Py_DECREF(item2);
if (idx >= m || idx < 0) {
PyErr_SetString(PyExc_ValueError, "edge index out of range");
Py_DECREF(result);
Py_DECREF(iter);
igraph_vector_destroy(&v);
igraph_vector_destroy(&v2);
return NULL;
}
if (igraph_vector_push_back(&v, VECTOR(v2)[idx])) {
Py_DECREF(result);
Py_DECREF(iter);
igraphmodule_handle_igraph_error();
igraph_vector_destroy(&v);
igraph_vector_destroy(&v2);
return NULL;
}
} else {
/* We simply ignore elements that we don't know */
Py_DECREF(item2);
}
}
/* Deallocate stuff */
igraph_vector_destroy(&v2);
Py_DECREF(iter);
if (PyErr_Occurred()) {
igraph_vector_destroy(&v);
Py_DECREF(result);
return 0;
}
igraph_es_destroy(&result->es);
if (igraph_es_vector_copy(&result->es, &v)) {
Py_DECREF(result);
igraphmodule_handle_igraph_error();
igraph_vector_destroy(&v);
return NULL;
}
igraph_vector_destroy(&v);
}
}
return (PyObject*)result;
}
