_item_compare(avl_tree_Object * compare_arg, const void *lhs,
const void *rhs)
{
PyObject *lo = objectAt(lhs), *ro = objectAt(rhs);
PyObject *arglist;
int rv = 0;
if (compare_arg->compare_func == Py_None) {
/* on error, the return value of PyObject_Compare() is undefined */
rv = PyObject_Compare(lo, ro);
compare_arg->compare_err = (PyErr_Occurred() != NULL);
} else if ((arglist = Py_BuildValue("(OO)", lo, ro)) == NULL) {
compare_arg->compare_err = 1;
} else {
PyObject *pyres;
pyres = PyObject_CallObject(compare_arg->compare_func, arglist);
Py_DECREF(arglist);
if (pyres == NULL)
compare_arg->compare_err = 1;
else {
rv = PyInt_AsLong(pyres);
Py_DECREF(pyres);
compare_arg->compare_err = 0;
}
}
return rv;
}
_item_compare_custom(avl_tree_Object * compare_arg, const void *lhs,
const void *rhs)
{
PyObject *arglist;
int rv = 0;
if ((arglist =
Py_BuildValue("(OO)", objectAt(lhs), objectAt(rhs))) == NULL) {
/* an exception has been raised */
compare_arg->compare_err = 1;
} else {
PyObject *pyres;
pyres = PyObject_CallObject(compare_arg->compare_func, arglist);
Py_DECREF(arglist);
if (pyres == NULL)
compare_arg->compare_err = 1;
else {
rv = PyInt_AsLong(pyres);
Py_DECREF(pyres);
compare_arg->compare_err = 0;
}
}
return rv;
}
_item_compare_default(avl_tree_Object * compare_arg, const void *lhs,
const void *rhs)
{
int rv;
rv = PyObject_Compare(objectAt(lhs), objectAt(rhs));
compare_arg->compare_err = (PyErr_Occurred() != NULL);
return rv;
}
DatabaseView::DatabaseView(QWidget *parent) :
QTableView(parent)
{
setContextMenuPolicy(Qt::ActionsContextMenu);
setAlternatingRowColors( true );
setEditTriggers( QAbstractItemView::DoubleClicked
| QAbstractItemView::EditKeyPressed );
QAction* editTagsAction = new QAction( this );
addAction( editTagsAction );
editTagsAction->setText(tr("Edit Tags"));
editTagsAction->setShortcut(QKeySequence("Ctrl+T"));
editTagsAction->setIcon(QIcon(":/oldIcons/oldIcons/tag-2.png"));
connect(editTagsAction, &QAction::triggered, [this]()
{
QModelIndexList list = selectionModel()->selectedIndexes();
if (!list.isEmpty())
{
Taggable* t = objectAt(list.first());
if (t != 0)
{
TagDialog d(t->tags(), this);
if (d.exec() == QDialog::Accepted)
{
app().pushCommand( new EditTagsCommand( t, d.tags() ) );
}
}
}
});
}
QVariant EPSignalsController::data(const QModelIndex &index, int role) const
{
if (!index.isValid() || index.row() >= count())
return QVariant();
EPSignal *signal = (EPSignal *)objectAt(index.row());
if (role == Qt::DisplayRole) {
switch (index.column()) {
case NameColumn:
return tr("%1%2").arg(signal->hasChanged() ? "*" : "")
.arg(signal->name());
case LengthColumn:
return APUtils::formattedTime(signal->length(), "%hh %mm %ss");
}
} else if (role == Qt::FontRole) {
if (index.column() == NameColumn) {
QFont font;
font.setBold(signal == activeSignal());
return font;
}
}
return QVariant();
}
bool SqliteDb::insertTable(const std::string &tableName, Map *keyValueDict)
{
std::string sql = "insert into ";
sql.append(tableName);
std::string keyStr = "(";
std::string valueStr = "(";
auto keyArray = keyValueDict->allKeys();
int count = keyArray->getLength();
for (int i = 0; i < count; ++i)
{
RefString *key = (RefString*)keyArray->objectAt(i);
RefString *value = (RefString*)keyValueDict->objectForKey(key->getCString());
keyStr.append(key->getCString());
valueStr.append("'");
valueStr.append(value->getCString());
valueStr.append("'");
if (i != count - 1)
{
keyStr.append(",");
valueStr.append(",");
}
}
keyStr.append(")");
valueStr.append(")");
sql.append(keyStr);
sql.append(" values ");
sql.append(valueStr);
return this->executeSql(sql);
}
Py_LOCAL(PyObject *) avl_tree_pickle_dump(avl_tree_Object * self,
PyObject * pickler_object)
{
if (!PyObject_HasAttrString(pickler_object, "dump")) {
PyErr_SetString(PyExc_AttributeError,
"Couln't pickle avl_tree: missing 'dump' attr");
return NULL;
} else {
PyObject *dump_method = NULL;
PyObject *rv = NULL;
avl_iterator iter;
void *cur_item;
dump_method = PyObject_GetAttrString(pickler_object, "dump");
if (!PyCallable_Check(dump_method)) {
PyErr_SetString(PyExc_TypeError,
"Couln't pickle avl_tree: 'dump' attr must be callable");
goto finally;
}
iter = avl_iterator_new(self->tree, AVL_ITERATOR_INI_PRE);
if (iter == NULL) {
PyErr_SetString(avlErrorObject,
"Sorry, couldn't allocate native iterator");
goto finally;
}
/* dump the objects count */
rv = PyObject_CallFunction(dump_method, "O",
PyInt_FromLong(avl_size(self->tree)));
if (rv == NULL);
else
rv = PyObject_CallFunction(dump_method, "O",
self->compare_func);
while (1) {
if (rv == NULL) {
/* pass the exception on */
break;
}
Py_DECREF(rv);
cur_item = avl_iterator_next(iter);
if (cur_item == NULL) {
rv = Py_None;
Py_INCREF(rv);
break;
}
rv = PyObject_CallFunction(dump_method, "(O)",
objectAt(cur_item));
}
avl_iterator_kill(iter);
finally:
Py_DECREF(dump_method);
return rv;
}
}
/* result = (*iter->ob_type->tp_iternext)(iter) */
Py_LOCAL(PyObject *) avl_iter_next(avl_iter_Object * iter_obj)
{
void *p;
if ((p = avl_iterator_next(iter_obj->iter)) != NULL) {
PyObject *obj = objectAt(p);
Py_INCREF(obj);
return obj;
}
PyErr_SetObject(PyExc_StopIteration, (PyObject *) iter_obj);
return NULL;
}
/* Return new reference to a[i] */
Py_LOCAL(PyObject *) avl_tree_get(avl_tree_Object * self, Py_ssize_t idx)
{
/* The interpreter passes idx after incrementation by len(self) */
void *rv = avl_find_index((avl_size_t) (idx + 1), self->tree);
if (rv == NULL) {
PyErr_SetString(PyExc_IndexError, "avl_tree index out of range");
return NULL;
} else {
PyObject *ref = objectAt(rv);
Py_INCREF(ref);
return ref;
}
}
Py_LOCAL(PyObject *) avl_iter_cur(avl_iter_Object * iter_obj,
PyObject * unused)
{
void *p;
if ((p = avl_iterator_cur(iter_obj->iter)) != NULL) {
PyObject *obj = objectAt(p);
Py_INCREF(obj);
return obj;
}
PyErr_SetString(avlErrorObject,
"avl_iterator currently out-of-bounds");
return NULL;
}
Py_LOCAL(PyObject *) avl_tree_repr(avl_tree_Object * self)
{
PyObject *result = NULL;
avl_size_t len;
int rc;
len = avl_size(self->tree);
rc = Py_ReprEnter((PyObject *) self);
if (rc != 0)
return rc > 0 ? PyString_FromString("[...]") : NULL;
if (len == 0) {
result = PyString_FromString("[]");
goto finish;
}
{
avl_iterator iter;
PyObject *list, *ob;
Py_ssize_t i = 0;
iter = avl_iterator_new(self->tree, AVL_ITERATOR_INI_PRE);
if (iter == NULL)
goto finish;
list = PyList_New(len);
if (list == NULL)
goto finish;
do {
ob = objectAt(avl_iterator_next(iter));
Py_INCREF(ob);
PyList_SET_ITEM(list, i, ob);
++i;
} while (--len);
avl_iterator_kill(iter);
result = PyObject_Repr(list);
list->ob_type->tp_dealloc(list);
}
finish:
Py_ReprLeave((PyObject *) self);
return result;
}
Py_LOCAL(PyObject *) avl_tree_at_most(avl_tree_Object * self,
PyObject * val)
{
void *res;
PyObject *rv;
self->compare_err = 0;
res = avl_find_atmost((const void *) val, self->tree);
if (res == NULL) {
if (self->compare_err == 0)
PyErr_SetObject(PyExc_ValueError, val);
return NULL;
}
rv = objectAt(res);
Py_INCREF(rv);
return rv;
}
Py_LOCAL(PyObject *) avl_tree_max(avl_tree_Object * self, PyObject * args)
{
void *res;
PyObject *rv;
if (!PyArg_ParseTuple(args, "")) {
return NULL;
}
if ((res = avl_last(self->tree)) == NULL) {
PyErr_SetString(PyExc_ValueError,
"Attempted to get max of empty tree");
return NULL;
}
rv = objectAt(res);
Py_INCREF(rv);
return rv;
}
Py_LOCAL(PyObject *) avl_iter_rem(avl_iter_Object * iter_object,
PyObject * unused)
{
void *p;
if ((p = avl_iterator_cur(iter_object->iter)) != NULL) {
PyObject *obj = objectAt(p);
Py_INCREF(obj);
(void) avl_iterator_del(iter_object->iter, (void *) NULL);
Py_DECREF(obj);
Py_INCREF(Py_None);
return Py_None;
}
PyErr_SetString(avlErrorObject,
"avl_iterator currently out-of-bounds");
return NULL;
}
Py_LOCAL(PyObject *) avl_tree_lookup(avl_tree_Object * self,
PyObject * val)
{
void *res;
PyObject *rv;
/* Py_XINCREF(val); */
self->compare_err = 0;
res = avl_find((const void *) val, self->tree);
/*Py_XDECREF(val); */
if (res == NULL) {
if (self->compare_err == 0)
PyErr_SetObject(PyExc_LookupError, val);
return NULL;
}
rv = objectAt(res);
Py_INCREF(rv);
return rv;
}
void SortedArray::add( Object& toAdd )
{
if( toAdd.isSortable() )
{
if( lastElementIndex == upperbound )
{
reallocate( arraySize() + 1 );
}
int insertionPoint = lowerbound;
while( insertionPoint <= lastElementIndex &&
(Sortable&)objectAt( insertionPoint ) < (Sortable&)toAdd
)
insertionPoint++;
insertEntry( insertionPoint );
setData( insertionPoint, &toAdd );
itemsInContainer++;
lastElementIndex++;
}
else
ClassLib_error( __ENOTSORT );
}
