/**
* \ingroup python_interface_edgeseq
* \brief Copies an edge sequence object
* \return the copied PyObject
*/
igraphmodule_EdgeSeqObject*
igraphmodule_EdgeSeq_copy(igraphmodule_EdgeSeqObject* o) {
igraphmodule_EdgeSeqObject *copy;
copy=(igraphmodule_EdgeSeqObject*)PyType_GenericNew(Py_TYPE(o), 0, 0);
if (copy == NULL) return NULL;
if (igraph_es_type(&o->es) == IGRAPH_ES_VECTOR) {
igraph_vector_t v;
if (igraph_vector_copy(&v, o->es.data.vecptr)) {
igraphmodule_handle_igraph_error();
return 0;
}
if (igraph_es_vector_copy(©->es, &v)) {
igraphmodule_handle_igraph_error();
igraph_vector_destroy(&v);
return 0;
}
igraph_vector_destroy(&v);
} else {
copy->es = o->es;
}
copy->gref = o->gref;
if (o->gref) Py_INCREF(o->gref);
RC_ALLOC("EdgeSeq(copy)", copy);
return copy;
}
/**
* \ingroup python_interface_edgeseq
* \brief Initialize a new edge sequence object for a given graph
* \return the initialized PyObject
*/
int igraphmodule_EdgeSeq_init(igraphmodule_EdgeSeqObject *self,
PyObject *args, PyObject *kwds) {
static char *kwlist[] = { "graph", "edges", NULL };
PyObject *g, *esobj=Py_None;
igraph_es_t es;
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!|O", kwlist,
&igraphmodule_GraphType, &g, &esobj))
return -1;
if (esobj == Py_None) {
/* If es is None, we are selecting all the edges */
igraph_es_all(&es, IGRAPH_EDGEORDER_ID);
} else if (PyInt_Check(esobj)) {
/* We selected a single edge */
long int idx = PyInt_AsLong(esobj);
if (idx < 0 || idx >= igraph_ecount(&((igraphmodule_GraphObject*)g)->g)) {
PyErr_SetString(PyExc_ValueError, "edge index out of range");
return -1;
}
igraph_es_1(&es, (igraph_integer_t)idx);
} else {
/* We selected multiple edges */
igraph_vector_t v;
igraph_integer_t n = igraph_ecount(&((igraphmodule_GraphObject*)g)->g);
if (igraphmodule_PyObject_to_vector_t(esobj, &v, 1))
return -1;
if (!igraph_vector_isininterval(&v, 0, n-1)) {
igraph_vector_destroy(&v);
PyErr_SetString(PyExc_ValueError, "edge index out of range");
return -1;
}
if (igraph_es_vector_copy(&es, &v)) {
igraphmodule_handle_igraph_error();
igraph_vector_destroy(&v);
return -1;
}
igraph_vector_destroy(&v);
}
self->es = es;
Py_INCREF(g);
self->gref = (igraphmodule_GraphObject*)g;
return 0;
}
/**
* \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;
}
EdgeSelector::EdgeSelector(const VectorView &vector) {
SafeCall(igraph_es_vector_copy(ptr(), vector.ptr()));
}
EdgeSelector::EdgeSelector(std::initializer_list<double> list) {
Vector vector(list);
SafeCall(igraph_es_vector_copy(ptr(), vector.ptr()));
}
