void comps_objrtree_clear(COMPS_ObjRTree * rt) {
COMPS_HSListItem *it, *oldit;
if (rt==NULL) return;
if (rt->subnodes == NULL) return;
oldit = rt->subnodes->first;
it = (oldit)?oldit->next:NULL;
for (; it != NULL; it=it->next) {
comps_object_destroy(oldit->data);
free(oldit);
oldit = it;
}
if (oldit) {
comps_object_destroy(oldit->data);
free(oldit);
}
}
PyObject* PyCOMPSPack_repr(PyObject *self) {
char *x;
COMPS_Object *name;
PyObject *ret;
name = comps_docpackage_get_name(((PyCOMPS_Package*)self)->package);
x = comps_object_tostr(name);
ret = PyUnicode_FromFormat("<libcomps.Package object '%s' at %p>", x, self);
free(x);
comps_object_destroy(name);
return ret;
}
PyObject* PyCOMPSGroup_repr(PyObject *self) {
char *x;
COMPS_Object *id;
PyObject *ret;
id = comps_docgroup_get_id(((PyCOMPS_Group*)self)->group);
x = comps_object_tostr(id);
ret = PyUnicode_FromFormat("<libcomps.Group object '%s' at %p>", x, self);
free(x);
comps_object_destroy(id);
return ret;
}
PyObject* PyCOMPSEnv_repr(PyObject *self) {
char *x;
COMPS_Object *id;
PyObject *ret;
id = comps_docenv_get_id(((PyCOMPS_Env*)self)->c_obj);
x = comps_object_tostr(id);
ret = PyUnicode_FromFormat("<libcomps.Environment object '%s' at %p>", x, self);
free(x);
comps_object_destroy(id);
return ret;
}
PyObject* PyCOMPSEnv_str(PyObject *self) {
char *x;
COMPS_Object *id;
PyObject *ret;
id = comps_docenv_get_id(((PyCOMPS_Env*)self)->c_obj);
x = comps_object_tostr(id);
ret = PyUnicode_FromFormat("%s", x);
free(x);
comps_object_destroy(id);
return ret;
}
COMPS_DocGroup* comps_docgroup_union(COMPS_DocGroup *g1, COMPS_DocGroup *g2) {
COMPS_DocGroup *res;
COMPS_ObjListIt *it;
COMPS_Set *set;
COMPS_DocGroupPackage *pkg;
res = COMPS_OBJECT_CREATE(COMPS_DocGroup, NULL);
COMPS_OBJECT_DESTROY(res->properties);
res->properties = comps_objdict_union(g1->properties, g2->properties);
set = comps_set_create();
comps_set_init(set, NULL, NULL, (void(*)(void*))&comps_object_destroy,
&comps_docpackage_cmp_set);
it = g1->packages?g1->packages->first:NULL;
for (; it != NULL; it = it->next) {
pkg = (COMPS_DocGroupPackage*) comps_object_copy(it->comps_obj);
comps_set_add(set, (void*)comps_object_incref((COMPS_Object*)pkg));
comps_docgroup_add_package(res, pkg);
}
void *data;
int index;
it = g2->packages?g2->packages->first:NULL;
for (; it != NULL; it = it->next) {
if ((data = comps_set_data_at(set, (void*)it->comps_obj)) != NULL) {
index = comps_objlist_index(res->packages, (COMPS_Object*)data);
comps_objlist_remove_at(res->packages, index);
comps_objlist_insert_at_x(res->packages, index,
comps_object_copy(it->comps_obj));
} else {
comps_docgroup_add_package(res, (COMPS_DocGroupPackage*)
comps_object_copy(it->comps_obj));
}
}
comps_set_destroy(&set);
comps_object_destroy((COMPS_Object*)res->name_by_lang);
comps_object_destroy((COMPS_Object*)res->desc_by_lang);
res->name_by_lang = comps_objdict_union(g1->name_by_lang, g2->name_by_lang);
res->desc_by_lang = comps_objdict_union(g1->desc_by_lang, g2->desc_by_lang);
return res;
}
COMPS_ObjList* comps_groups_union(COMPS_ObjList *groups1,
COMPS_ObjList *groups2) {
COMPS_HSListItem *hsit;
COMPS_Set *set;
COMPS_ObjList *ret;
COMPS_DocGroup *tmpgroup;
COMPS_ObjListIt *it;
void *tmpdata;
ret = (COMPS_ObjList*)comps_object_create(&COMPS_ObjList_ObjInfo, NULL);
set = comps_set_create();
comps_set_init(set, NULL, NULL, NULL, &__comps_docgroup_idcmp);
for (it = groups1 ? groups1->first : NULL; it != NULL; it = it->next) {
comps_set_add(set, comps_object_copy(it->comps_obj));
}
for (it = groups2 ? groups2->first : NULL; it != NULL; it = it->next) {
if (comps_set_in(set, it->comps_obj)) {
tmpgroup = comps_docgroup_union(
(COMPS_DocGroup*)it->comps_obj,
(COMPS_DocGroup*)comps_set_data_at(set,
it->comps_obj));
tmpdata = comps_set_data_at(set, it->comps_obj);
comps_set_remove(set, it->comps_obj);
comps_object_destroy((COMPS_Object*)tmpdata);
comps_set_add(set, tmpgroup);
} else {
comps_set_add(set, comps_object_copy(it->comps_obj));
}
}
for (hsit = set->data->first; hsit != NULL; hsit = hsit->next) {
comps_objlist_append_x(ret, (COMPS_Object*)hsit->data);
}
comps_set_destroy(&set);
return ret;
}
void comps_objrtree_unset(COMPS_ObjRTree * rt, const char * key) {
COMPS_HSList * subnodes;
COMPS_HSListItem * it;
COMPS_ObjRTreeData * rtdata;
unsigned int offset, len, x;
char found, ended;
COMPS_HSList * path;
struct Relation {
COMPS_HSList * parent_nodes;
COMPS_HSListItem * child_it;
} *relation;
path = comps_hslist_create();
comps_hslist_init(path, NULL, NULL, &free);
len = strlen(key);
offset = 0;
subnodes = rt->subnodes;
while (offset != len) {
found = 0;
for (it = subnodes->first; it != NULL; it=it->next) {
if (((COMPS_ObjRTreeData*)it->data)->key[0] == key[offset]) {
found = 1;
break;
}
}
if (!found)
return;
rtdata = (COMPS_ObjRTreeData*)it->data;
for (x=1; ; x++) {
ended=0;
if (rtdata->key[x] == 0) ended += 1;
if (x == len - offset) ended += 2;
if (ended != 0) break;
if (key[offset+x] != rtdata->key[x]) break;
}
if (ended == 3) {
/* remove node from tree only if there's no descendant*/
if (rtdata->subnodes->last == NULL) {
//printf("removing all\n");
comps_hslist_remove(subnodes, it);
comps_objrtree_data_destroy(rtdata);
free(it);
}
else {
//printf("removing data only\n");
comps_object_destroy(rtdata->data);
rtdata->is_leaf = 0;
rtdata->data = NULL;
}
if (path->last == NULL) {
comps_hslist_destroy(&path);
return;
}
rtdata = (COMPS_ObjRTreeData*)
((struct Relation*)path->last->data)->child_it->data;
/*remove all predecessor of deleted node (recursive) with no childs*/
while (rtdata->subnodes->last == NULL) {
//printf("removing '%s'\n", rtdata->key);
comps_objrtree_data_destroy(rtdata);
comps_hslist_remove(
((struct Relation*)path->last->data)->parent_nodes,
((struct Relation*)path->last->data)->child_it);
free(((struct Relation*)path->last->data)->child_it);
it = path->last;
comps_hslist_remove(path, path->last);
free(it);
rtdata = (COMPS_ObjRTreeData*)
((struct Relation*)path->last->data)->child_it->data;
}
comps_hslist_destroy(&path);
return;
}
else if (ended == 1) offset+=x;
else return;
if ((relation = malloc(sizeof(struct Relation))) == NULL) {
comps_hslist_destroy(&path);
return;
}
subnodes = ((COMPS_ObjRTreeData*)it->data)->subnodes;
relation->parent_nodes = subnodes;
relation->child_it = it;
comps_hslist_append(path, (void*)relation, 0);
}
comps_hslist_destroy(&path);
return;
}
void __comps_objrtree_set(COMPS_ObjRTree *rt, char *key, size_t len,
COMPS_Object *ndata) {
COMPS_HSListItem *it, *lesser;
COMPS_HSList *subnodes;
COMPS_ObjRTreeData *rtd;
static COMPS_ObjRTreeData *rtdata;
size_t _len, offset=0;
unsigned x, found = 0;
char ended;
//len = strlen(key);
if (rt->subnodes == NULL)
return;
subnodes = rt->subnodes;
while (offset != len)
{
found = 0;
lesser = NULL;
for (it = subnodes->first; it != NULL; it=it->next) {
if (((COMPS_ObjRTreeData*)it->data)->key[0] == key[offset]) {
found = 1;
break;
} else if (((COMPS_ObjRTreeData*)it->data)->key[0] < key[offset]) {
lesser = it;
}
}
if (!found) { // not found in subnodes; create new subnode
rtd = comps_objrtree_data_create_n(key+offset, len-offset, ndata);
if (!lesser) {
comps_hslist_prepend(subnodes, rtd, 0);
} else {
comps_hslist_insert_after(subnodes, lesser, rtd, 0);
}
rt->len++;
return;
} else {
rtdata = (COMPS_ObjRTreeData*)it->data;
ended = 0;
for (x=1; ; x++) {
if (rtdata->key[x] == 0) ended += 1;
if (x == len - offset) ended += 2;
if (ended != 0) break;
if (key[offset+x] != rtdata->key[x]) break;
}
if (ended == 3) { //keys equals; data replacement
comps_object_destroy(rtdata->data);
rtdata->data = ndata;
return;
} else if (ended == 2) { //global key ends first; make global leaf
//printf("ended2\n");
comps_hslist_remove(subnodes, it);
it->next = NULL;
rtd = comps_objrtree_data_create_n(key+offset, len-offset, ndata);
comps_hslist_append(subnodes, rtd, 0);
((COMPS_ObjRTreeData*)subnodes->last->data)->subnodes->last = it;
((COMPS_ObjRTreeData*)subnodes->last->data)->subnodes->first = it;
_len = len - offset;
memmove(rtdata->key,rtdata->key+_len,
strlen(rtdata->key) - _len);
rtdata->key[strlen(rtdata->key) - _len] = 0;
rtdata->key = realloc(rtdata->key,
sizeof(char)* (strlen(rtdata->key)+1));
rt->len++;
return;
} else if (ended == 1) { //local key ends first; go deeper
subnodes = rtdata->subnodes;
offset += x;
} else {
COMPS_Object *tmpdata = rtdata->data;
COMPS_HSList *tmphslist = rtdata->subnodes;
//tmpch = rtdata->key[x]; // split mutual key
rtdata->subnodes = comps_hslist_create();
comps_hslist_init(rtdata->subnodes, NULL, NULL,
&comps_objrtree_data_destroy_v);
int cmpret = strcmp(key+offset+x, rtdata->key+x);
rtdata->data = NULL;
if (cmpret > 0) {
rtd = comps_objrtree_data_create(rtdata->key+x, tmpdata);
comps_hslist_destroy(&rtd->subnodes);
rtd->subnodes = tmphslist;
comps_hslist_append(rtdata->subnodes,rtd, 0);
rtd = comps_objrtree_data_create(key+offset+x, ndata);
comps_hslist_append(rtdata->subnodes, rtd, 0);
} else {
rtd = comps_objrtree_data_create(key+offset+x, ndata);
comps_hslist_append(rtdata->subnodes, rtd, 0);
rtd = comps_objrtree_data_create(rtdata->key+x, tmpdata);
comps_hslist_destroy(&rtd->subnodes);
rtd->subnodes = tmphslist;
comps_hslist_append(rtdata->subnodes, rtd, 0);
}
rtdata->key = realloc(rtdata->key, sizeof(char)*(x+1));
rtdata->key[x] = 0;
rt->len++;
return;
}
}
}
}
void comps_objrtree_data_destroy(COMPS_ObjRTreeData * rtd) {
free(rtd->key);
comps_object_destroy(rtd->data);
comps_hslist_destroy(&rtd->subnodes);
free(rtd);
}
void comps_docpackage_set_requires(COMPS_DocGroupPackage *pkg, char *requires, char copy) {
(void)copy;
if (pkg->requires)
comps_object_destroy((COMPS_Object*)pkg->requires);
pkg->requires = comps_str(requires);
}
void comps_docpackage_set_name(COMPS_DocGroupPackage *pkg, char *name, char copy) {
(void)copy;
if (pkg->name)
comps_object_destroy((COMPS_Object*)pkg->name);
pkg->name = comps_str(name);
}
static void comps_docpackage_destroy(COMPS_DocGroupPackage *pkg) {
comps_object_destroy((COMPS_Object*)pkg->name);
comps_object_destroy((COMPS_Object*)pkg->requires);
comps_object_destroy((COMPS_Object*)pkg->basearchonly);
comps_object_destroy((COMPS_Object*)pkg->arches);
}
