signed char comps_objmrtree_cmp(COMPS_ObjMRTree *ort1, COMPS_ObjMRTree *ort2) {
COMPS_HSList *values1, *values2;
COMPS_HSListItem *it;
COMPS_Set *set1, *set2;
signed char ret;
values1 = comps_objmrtree_pairs(ort1);
values2 = comps_objmrtree_pairs(ort2);
set1 = comps_set_create();
comps_set_init(set1, NULL, NULL, NULL, &comps_objmrtree_paircmp);
set2 = comps_set_create();
comps_set_init(set2, NULL, NULL, NULL, &comps_objmrtree_paircmp);
for (it = values1->first; it != NULL; it = it->next) {
comps_set_add(set1, it->data);
}
for (it = values2->first; it != NULL; it = it->next) {
comps_set_add(set2, it->data);
}
ret = comps_set_cmp(set1, set2);
comps_set_destroy(&set1);
comps_set_destroy(&set2);
//printf("objmrtree cmp %d\n", !ret);
comps_hslist_destroy(&values1);
comps_hslist_destroy(&values2);
return !ret;
}
COMPS_RTree * comps_rtree_clone(COMPS_RTree *rt) {
COMPS_HSList *to_clone, *tmplist, *new_subnodes;
COMPS_RTree *ret;
COMPS_HSListItem *it, *it2;
COMPS_RTreeData *rtdata;//, *rtdata2;
void *new_data;
if (!rt) return NULL;
to_clone = comps_hslist_create();
comps_hslist_init(to_clone, NULL, NULL, NULL);
ret = comps_rtree_create(rt->data_constructor, rt->data_cloner,
rt->data_destructor);
for (it = rt->subnodes->first; it != NULL; it = it->next) {
rtdata = comps_rtree_data_create(rt,
((COMPS_RTreeData*)it->data)->key, NULL);
new_data = rt->data_cloner(((COMPS_RTreeData*)it->data)->data);
comps_hslist_destroy(&rtdata->subnodes);
rtdata->subnodes = ((COMPS_RTreeData*)it->data)->subnodes;
rtdata->data = new_data;
comps_hslist_append(ret->subnodes, rtdata, 0);
comps_hslist_append(to_clone, rtdata, 0);
}
while (to_clone->first) {
it2 = to_clone->first;
tmplist = ((COMPS_RTreeData*)it2->data)->subnodes;
comps_hslist_remove(to_clone, to_clone->first);
new_subnodes = comps_hslist_create();
comps_hslist_init(new_subnodes, NULL, NULL, &comps_rtree_data_destroy_v);
for (it = tmplist->first; it != NULL; it = it->next) {
rtdata = comps_rtree_data_create(rt,
((COMPS_RTreeData*)it->data)->key, NULL);
if (((COMPS_RTreeData*)it->data)->data != NULL)
new_data = rt->data_cloner(((COMPS_RTreeData*)it->data)->data);
else
new_data = NULL;
comps_hslist_destroy(&rtdata->subnodes);
rtdata->subnodes = ((COMPS_RTreeData*)it->data)->subnodes;
rtdata->data = new_data;
comps_hslist_append(new_subnodes, rtdata, 0);
comps_hslist_append(to_clone, rtdata, 0);
}
((COMPS_RTreeData*)it2->data)->subnodes = new_subnodes;
free(it2);
}
comps_hslist_destroy(&to_clone);
return ret;
}
void comps_objrtree_copy(COMPS_ObjRTree *rt1, COMPS_ObjRTree *rt2) {
COMPS_HSList *to_clone, *tmplist, *new_subnodes;
COMPS_HSListItem *it, *it2;
COMPS_ObjRTreeData *rtdata;
COMPS_Object *new_data;
rt1->subnodes = comps_hslist_create();
comps_hslist_init(rt1->subnodes, NULL, NULL, &comps_objrtree_data_destroy_v);
if (rt1->subnodes == NULL) {
COMPS_OBJECT_DESTROY(rt1);
return;
}
rt1->len = 0;
to_clone = comps_hslist_create();
comps_hslist_init(to_clone, NULL, NULL, NULL);
for (it = rt2->subnodes->first; it != NULL; it = it->next) {
rtdata = comps_objrtree_data_create(
((COMPS_ObjRTreeData*)it->data)->key, NULL);
if (((COMPS_ObjRTreeData*)it->data)->data != NULL)
new_data = comps_object_copy(((COMPS_ObjRTreeData*)it->data)->data);
else
new_data = NULL;
comps_hslist_destroy(&rtdata->subnodes);
rtdata->subnodes = ((COMPS_ObjRTreeData*)it->data)->subnodes;
rtdata->data = new_data;
comps_hslist_append(rt1->subnodes, rtdata, 0);
comps_hslist_append(to_clone, rtdata, 0);
}
while (to_clone->first) {
it2 = to_clone->first;
tmplist = ((COMPS_ObjRTreeData*)it2->data)->subnodes;
comps_hslist_remove(to_clone, to_clone->first);
new_subnodes = comps_hslist_create();
comps_hslist_init(new_subnodes, NULL, NULL, &comps_objrtree_data_destroy_v);
for (it = tmplist->first; it != NULL; it = it->next) {
rtdata = comps_objrtree_data_create(
((COMPS_ObjRTreeData*)it->data)->key, NULL);
if (((COMPS_ObjRTreeData*)it->data)->data != NULL)
new_data = comps_object_copy(((COMPS_ObjRTreeData*)it->data)->data);
else
new_data = NULL;
comps_hslist_destroy(&rtdata->subnodes);
rtdata->subnodes = ((COMPS_ObjRTreeData*)it->data)->subnodes;
rtdata->data = new_data;
comps_hslist_append(new_subnodes, rtdata, 0);
comps_hslist_append(to_clone, rtdata, 0);
}
((COMPS_ObjRTreeData*)it2->data)->subnodes = new_subnodes;
free(it2);
}
comps_hslist_destroy(&to_clone);
}
COMPS_ObjMRTree * comps_objmrtree_clone(COMPS_ObjMRTree * rt) {
COMPS_HSList * to_clone, *tmplist, *new_subnodes;
COMPS_ObjMRTree * ret;
COMPS_HSListItem *it, *it2;
COMPS_ObjMRTreeData *rtdata;
COMPS_ObjList *new_data_list;
to_clone = comps_hslist_create();
comps_hslist_init(to_clone, NULL, NULL, NULL);
ret = (COMPS_ObjMRTree*)comps_object_create(&COMPS_ObjMRTree_ObjInfo, NULL);
for (it = rt->subnodes->first; it != NULL; it = it->next) {
rtdata = comps_objmrtree_data_create(
((COMPS_ObjMRTreeData*)it->data)->key,
NULL);
new_data_list = (COMPS_ObjList*)
COMPS_OBJECT_COPY(((COMPS_ObjMRTreeData*)it->data)->data);
COMPS_OBJECT_DESTROY(&rtdata->data);
comps_hslist_destroy(&rtdata->subnodes);
rtdata->subnodes = ((COMPS_ObjMRTreeData*)it->data)->subnodes;
rtdata->data = new_data_list;
comps_hslist_append(ret->subnodes, rtdata, 0);
comps_hslist_append(to_clone, rtdata, 0);
}
while (to_clone->first) {
it2 = to_clone->first;
tmplist = ((COMPS_ObjMRTreeData*)it2->data)->subnodes;
comps_hslist_remove(to_clone, to_clone->first);
new_subnodes = comps_hslist_create();
comps_hslist_init(new_subnodes, NULL, NULL, &comps_objmrtree_data_destroy_v);
for (it = tmplist->first; it != NULL; it = it->next) {
rtdata = comps_objmrtree_data_create(
((COMPS_ObjMRTreeData*)it->data)->key,
NULL);
new_data_list = (COMPS_ObjList*)
COMPS_OBJECT_COPY(((COMPS_ObjMRTreeData*)it->data)->data);
comps_hslist_destroy(&rtdata->subnodes);
COMPS_OBJECT_DESTROY(rtdata->data);
rtdata->subnodes = ((COMPS_ObjMRTreeData*)it->data)->subnodes;
rtdata->data = new_data_list;
comps_hslist_append(new_subnodes, rtdata, 0);
comps_hslist_append(to_clone, rtdata, 0);
}
((COMPS_ObjMRTreeData*)it2->data)->subnodes = new_subnodes;
free(it2);
}
ret->len = rt->len;
comps_hslist_destroy(&to_clone);
return ret;
}
COMPS_DocGroup* comps_docgroup_intersect(COMPS_DocGroup *g1,
COMPS_DocGroup *g2) {
COMPS_DocGroup *res;
COMPS_ObjListIt *it;
COMPS_HSListItem *hsit;
COMPS_Set *set;
COMPS_DocGroupPackage *newpkg;
COMPS_HSList *pairs1, *pairs2;
res = COMPS_OBJECT_CREATE(COMPS_DocGroup, NULL);
set = comps_set_create();
//comps_objrtree_paircmp(void *obj1, void *obj2) {
comps_set_init(set, NULL, NULL, NULL, &comps_objrtree_paircmp);
pairs1 = comps_objdict_pairs(g1->properties);
for (hsit = pairs1->first; hsit != NULL; hsit = hsit->next) {
comps_set_add(set, hsit->data);
}
pairs2 = comps_objdict_pairs(g2->properties);
for (hsit = pairs2->first; hsit != NULL; hsit = hsit->next) {
if (comps_set_in(set, hsit->data)) {
comps_objdict_set(res->properties,
((COMPS_RTreePair*)hsit->data)->key,
((COMPS_RTreePair*)hsit->data)->data);
}
}
comps_hslist_destroy(&pairs1);
comps_hslist_destroy(&pairs2);
comps_set_clear(set);
//res->packages = (COMPS_ObjList*)comps_object_create(&COMPS_ObjList_ObjInfo,
// NULL);
//set = comps_set_create();
comps_set_init(set, NULL, NULL, NULL, &comps_docpackage_cmp_set);
for (it = g1->packages->first; it != NULL; it = it->next) {
comps_set_add(set, it->comps_obj);
}
for (it = g2->packages->first; it != NULL; it = it->next) {
if (comps_set_in(set, it->comps_obj)) {
newpkg = (COMPS_DocGroupPackage*)
comps_object_copy(it->comps_obj);
comps_docgroup_add_package(res, newpkg);
}
}
comps_set_destroy(&set);
return res;
}
COMPS_HSList * comps_rtree_values(COMPS_RTree * rt) {
COMPS_HSList *ret, *tmplist, *tmp_subnodes;
COMPS_HSListItem *it, *firstit;
ret = comps_hslist_create();
comps_hslist_init(ret, NULL, NULL, NULL);
tmplist = comps_hslist_create();
comps_hslist_init(tmplist, NULL, NULL, NULL);
comps_hslist_append(tmplist, rt->subnodes, 0);
while (tmplist->first != NULL) {
it = tmplist->first;
firstit = it;
comps_hslist_remove(tmplist, firstit);
tmp_subnodes = (COMPS_HSList*)it->data;
for (it = tmp_subnodes->first; it != NULL; it=it->next) {
if (((COMPS_RTreeData*)it->data)->subnodes->first) {
comps_hslist_append(tmplist,
((COMPS_RTreeData*)it->data)->subnodes, 0);
}
if (((COMPS_RTreeData*)it->data)->data != NULL) {
comps_hslist_append(ret,
((COMPS_RTreeData*)it->data)->data, 0);
}
}
free(firstit);
}
comps_hslist_destroy(&tmplist);
return ret;
}
void comps_mrtree_values_walk(COMPS_MRTree * rt, void* udata,
void (*walk_f)(void*, void*)) {
COMPS_HSList *tmplist, *tmp_subnodes;
COMPS_HSListItem *it, *it2;
tmplist = comps_hslist_create();
comps_hslist_init(tmplist, NULL, NULL, NULL);
comps_hslist_append(tmplist, rt->subnodes, 0);
while (tmplist->first != NULL) {
it = tmplist->first;
comps_hslist_remove(tmplist, tmplist->first);
tmp_subnodes = (COMPS_HSList*)it->data;
free(it);
for (it = tmp_subnodes->first; it != NULL; it=it->next) {
if (((COMPS_MRTreeData*)it->data)->subnodes->first) {
comps_hslist_append(tmplist,
((COMPS_MRTreeData*)it->data)->subnodes, 0);
}
for (it2 = (COMPS_HSListItem*)((COMPS_MRTreeData*)it->data)->data->first;
it2 != NULL; it2 = it2->next) {
walk_f(udata, it2->data);
}
}
}
comps_hslist_destroy(&tmplist);
}
void comps_rtree_data_destroy(COMPS_RTreeData * rtd) {
free(rtd->key);
if (*rtd->data_destructor)
(*rtd->data_destructor)(rtd->data);
comps_hslist_destroy(&rtd->subnodes);
free(rtd);
}
COMPS_DocCategory* comps_doccategory_intersect(COMPS_DocCategory *c1,
COMPS_DocCategory *c2) {
COMPS_DocCategory *res;
COMPS_ObjListIt *it;
COMPS_HSListItem *hsit;
COMPS_Set *set;
COMPS_HSList *pairs1, *pairs2;
res = COMPS_OBJECT_CREATE(COMPS_DocCategory, NULL);
set = comps_set_create();
comps_set_init(set, NULL, NULL, NULL, &comps_objrtree_paircmp);
pairs1 = comps_objdict_pairs(c1->properties);
for (hsit = pairs1->first; hsit != NULL; hsit = hsit->next) {
comps_set_add(set, hsit->data);
}
pairs2 = comps_objdict_pairs(c2->properties);
for (hsit = pairs2->first; hsit != NULL; hsit = hsit->next) {
if (comps_set_in(set, hsit->data)) {
comps_objdict_set(res->properties, ((COMPS_RTreePair*)hsit->data)->key,
((COMPS_RTreePair*)hsit->data)->data);
}
}
comps_hslist_destroy(&pairs1);
comps_hslist_destroy(&pairs2);
comps_set_clear(set);
comps_set_init(set, NULL, NULL, NULL, &__comps_docgroupid_cmp_set);
for (it = c1->group_ids->first; it != NULL; it = it->next) {
comps_set_add(set, it->comps_obj);
}
for (it = c2->group_ids->first; it != NULL; it = it->next) {
if (comps_set_in(set, it->comps_obj)) {
comps_doccategory_add_groupid(res,
(COMPS_DocGroupId*)comps_object_copy(it->comps_obj));
}
}
comps_set_destroy(&set);
return res;
}
signed char comps_objrtree_cmp(COMPS_ObjRTree *ort1, COMPS_ObjRTree *ort2) {
COMPS_HSList *values1, *values2;
COMPS_HSListItem *it;
COMPS_Set *set1, *set2;
signed char ret;
values1 = comps_objrtree_pairs(ort1);
values2 = comps_objrtree_pairs(ort2);
set1 = comps_set_create();
comps_set_init(set1, NULL, NULL, NULL, &comps_objrtree_paircmp);
set2 = comps_set_create();
comps_set_init(set2, NULL, NULL, NULL, &comps_objrtree_paircmp);
for (it = values1->first; it != NULL; it = it->next) {
comps_set_add(set1, it->data);
}
for (it = values2->first; it != NULL; it = it->next) {
comps_set_add(set2, it->data);
}
ret = comps_set_cmp(set1, set2);
comps_set_destroy(&set1);
comps_set_destroy(&set2);
//printf("objrtree cmp %d\n", !ret);
//char *str;
/*for (it = values1->first; it != NULL; it = it->next) {
str = comps_object_tostr(((COMPS_ObjRTreePair*)it->data)->data);
printf("dict item %s=%s\n", ((COMPS_ObjRTreePair*)it->data)->key, str);
free(str);
}
printf("----------\n");
for (it = values2->first; it != NULL; it = it->next) {
str = comps_object_tostr(((COMPS_ObjRTreePair*)it->data)->data);
printf("dict item %s=%s\n", ((COMPS_ObjRTreePair*)it->data)->key, str);
free(str);
}
printf("cmp objrtree ret:%d\n", ret);*/
comps_hslist_destroy(&values1);
comps_hslist_destroy(&values2);
return ret==0;
}
PyObject* PyCOMPSDict_values(PyObject * self, PyObject *args) {
(void)args;
PyObject *ret, *item;
COMPS_HSList *list = comps_objrtree_values(_DICT_->dict);
ret = PyList_New(0);
for (COMPS_HSListItem *it = list->first; it != NULL; it = it->next) {
item = _INFO_->out_convert_func(it->data);
PyList_Append(ret, item);
Py_DECREF(item);
}
comps_hslist_destroy(&list);
return ret;
}
PyObject* PyCOMPSDict_keys(PyObject * self, PyObject *args) {
(void)args;
PyObject *ret, *item;
COMPS_HSList *list = comps_objrtree_keys(_DICT_->dict);
ret = PyList_New(0);
for (COMPS_HSListItem *it = list->first; it != NULL; it = it->next) {
item = PyUnicode_FromString(it->data);
PyList_Append(ret, item);
Py_DECREF(item);
}
comps_hslist_destroy(&list);
return ret;
}
void print_all_str(COMPS_RTree *rt) {
COMPS_HSList *pairlist;
COMPS_HSListItem *it;
char *x;
printf("-------- print pairs --------------\n");
pairlist = comps_rtree_pairs(rt);
for (it = pairlist->first; it != NULL; it = it->next) {
x = ((COMPS_RTreePair*)it->data)->data;
printf("%s = %s \n", ((COMPS_RTreePair*)it->data)->key,
x);
}
comps_hslist_destroy(&pairlist);
printf("-----------------------------------\n");
}
PyObject* PyCOMPSDict_items(PyObject * self, PyObject *args) {
(void)args;
PyObject *ret, *k, *v, *tp;
COMPS_HSList *list = comps_objrtree_pairs(((PyCOMPS_Dict*)self)->dict);
ret = PyList_New(0);
for (COMPS_HSListItem *it = list->first; it != NULL; it = it->next) {
k = PyUnicode_FromString(((COMPS_ObjRTreePair*)it->data)->key);
v = _INFO_->out_convert_func(((COMPS_ObjRTreePair*)it->data)->data);
tp = PyTuple_Pack(2, k, v);
Py_DECREF(k);
Py_DECREF(v);
PyList_Append(ret, tp);
Py_DECREF(tp);
}
comps_hslist_destroy(&list);
return ret;
}
int PyCOMPSDict_print(PyObject *self, FILE *f, int flags) {
COMPS_HSList *pairlist;
COMPS_HSListItem *it;
char *tmpstr;
(void)flags;
fprintf(f, "{");
pairlist = comps_objdict_pairs(((PyCOMPS_Dict*)self)->dict);
for (it = pairlist->first; it != pairlist->last; it = it->next) {
//printf("x\n");
tmpstr = comps_object_tostr(((COMPS_ObjRTreePair*)it->data)->data);
fprintf(f, "%s = '%s', ", ((COMPS_RTreePair*)it->data)->key, tmpstr);
free(tmpstr);
}
if (it) {
tmpstr = comps_object_tostr(((COMPS_ObjRTreePair*)it->data)->data);
fprintf(f, "%s = '%s'", ((COMPS_RTreePair*)it->data)->key, tmpstr);
free(tmpstr);
}
fprintf(f, "}");
comps_hslist_destroy(&pairlist);
return 0;
}
static void comps_objrtree_destroy(COMPS_ObjRTree * rt) {
comps_hslist_destroy(&(rt->subnodes));
}
inline void comps_set_destroy_v(void *set) {
comps_hslist_destroy(&((COMPS_Set*)set)->data);
free((COMPS_Set*)set);
}
void comps_mrtree_destroy(COMPS_MRTree * rt) {
comps_hslist_destroy(&(rt->subnodes));
free(rt);
}
void comps_set_destroy(COMPS_Set **set) {
comps_hslist_destroy(&(*set)->data);
free(*set);
*set = NULL;
}
int main(int argc, char * argv[]) {
COMPS_MRTree *tree, *tree2, *cloned1, *cloned2;
COMPS_HSList * keyslist;
char * keys[] = {"some key", "some Cray", "some", "anything"};
int x1 = 10;
int x2 = 11;
int x3 = 12;
int y1 = 20;
int y2 = 21;
int y3 = 22;
int z1 = 30;
int z2 = 31;
int z3 = 32;
int udata = 9;
void * data;
tree = comps_mrtree_create(&int_cloner, &int_cloner, &free);
printf(">> Building tree\n");
/* Root
*/
comps_mrtree_set(tree,"some key",(void*)&x1);
comps_mrtree_set(tree,"some key",(void*)&x2);
printf(
" Root \n"
" ['some key']-->10,11 \n"
" \n"
"");
comps_mrtree_set(tree,"some Cray",(void*)&y1);
comps_mrtree_set(tree,"some Cray",(void*)&y2);
printf(
" Root \n"
" ['some']-->|-['Cray']-->20,21\n"
" |-['key']-->10,11 \n"
"");
comps_mrtree_set(tree,"some",(void*)&z1);
comps_mrtree_set(tree,"some",(void*)&z3);
printf(
" Root \n"
" ['some']-->|-['Cray']-->20,21\n"
" | |-['key']-->10,11 \n"
" V \n"
" 30,32 \n"
"");
comps_mrtree_set(tree,"anything",(void*)&z2);
printf(
" Root \n"
" [anythink]['some']-->|-['Cray']-->20,21\n"
" | | |-['key']-->10,11 \n"
" V V \n"
" 31 30,32 \n"
"");
printf(">> Incrementing all values by %d\n", udata);
comps_mrtree_values_walk(tree, &udata, &inc);
print_data4keys(tree, keys, 4);
data = comps_mrtree_get(tree, "sAme Cray");
print_intp_data(data, "sAme Cray");
printf("------------\n");
printf(">> Getting all keys for tree:\n");
keyslist = comps_mrtree_keys(tree);
print_keys(keyslist);
comps_hslist_destroy(&keyslist);
printf("------------\n");
printf(">> Adding %d to 'some key'\n", x3);
comps_mrtree_set(tree,"some key",(void*)&x3);
data = comps_mrtree_get(tree, "some key");
print_intp_data(data, "some key (modified)");
printf("------------\n");
printf(">> Removing 'some Cray'\n");
comps_mrtree_unset(tree, "some Cray");
print_data4keys(tree, keys, 4);
printf("------------\n");
printf(">> Clonning tree\n");
cloned1 = comps_mrtree_clone(tree);
printf(">> Incrementing all values in clonned tree by %d\n", udata);
comps_mrtree_values_walk(cloned1, &udata, &inc);
printf(">> Original tree data:\n");
data = comps_mrtree_get(cloned1, "some key");
print_data4keys(tree, keys, 4);
printf("\n");
printf(">> Cloned tree data:\n");
print_data4keys(cloned1, keys, 4);
printf("------------\n");
printf("\n");
printf(">> Clonning from clone\n");
cloned2 = comps_mrtree_clone(cloned1);
printf(">> Incrementing all values in clonned2 tree by %d\n", udata);
printf(">> Data for original clone\n");
comps_mrtree_values_walk(cloned1, &udata, &inc);
print_data4keys(cloned1, keys, 4);
printf("\n");
printf(">> Data for cloned clone\n");
comps_mrtree_values_walk(cloned1, &udata, &inc);
print_data4keys(cloned1, keys, 4);
comps_mrtree_destroy(cloned1);
comps_mrtree_destroy(cloned2);
printf("------------\n");
printf(">> Removing 'some'\n");
comps_mrtree_unset(tree, "some");
data = comps_mrtree_get(tree, "some key");
print_intp_data(data, "some key");
data = comps_mrtree_get(tree, "some");
print_intp_data(data, "some");
printf("------------\n");
printf(">> Adding %d to key 'anyones' shortened to len 6 [anyone]\n", x3);
comps_mrtree_set_n(tree,"anyones", 6,(void*)&x3);
data = comps_mrtree_get(tree, "anyones");
print_intp_data(data, "anyones");
data = comps_mrtree_get(tree, "anyone");
print_intp_data(data, "anyone");
tree2 = comps_mrtree_create(&int_cloner, &int_cloner, &free);
printf(">> Building tree2\n");
comps_mrtree_set(tree2,"foo",(void*)&x1);
//comps_mrtree_set(tree2,"bar",(void*)&x2);
printf(
" Root \n"
" ['foo']['bar'] \n"
" | | \n"
" V V \n"
" 109 100 \n"
"");
udata = 99;
//comps_mrtree_values_walk(tree2, &udata, &inc);
data = comps_mrtree_get(tree2, "foo");
print_intp_data(data, "foo");
data = comps_mrtree_get(tree2, "bar");
print_intp_data(data, "bar");
printf(">> Adding tree2 to tree1 (tree1 = tree1 + tree2)\n");
comps_mrtree_unite(tree, tree2);
printf("Keylist\n");
printf(">> Getting all keys for tree:\n");
keyslist = comps_mrtree_keys(tree);
print_keys(keyslist);
comps_hslist_destroy(&keyslist);
data = comps_mrtree_get(tree, "foo");
print_intp_data(data, "foo");
data = comps_mrtree_get(tree, "bar");
print_intp_data(data, "bar");
comps_mrtree_destroy(tree);
comps_mrtree_destroy(tree2);
return 0;
}
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_mrtree_set(COMPS_MRTree * rt, char * key, size_t len, void * data)
{
static COMPS_HSListItem *it;
COMPS_HSList *subnodes;
COMPS_MRTreeData *rtd;
static COMPS_MRTreeData *rtdata;
size_t _len, offset=0;
unsigned x, found = 0;
void *ndata;
char ended;//, tmpch;
if (rt->subnodes == NULL)
return;
if (rt->data_constructor)
ndata = rt->data_constructor(data);
else
ndata = data;
subnodes = rt->subnodes;
while (offset != len)
{
found = 0;
for (it = subnodes->first; it != NULL; it=it->next) {
if (((COMPS_MRTreeData*)it->data)->key[0] == key[offset]) {
found = 1;
break;
}
}
if (!found) { // not found in subnodes; create new subnode
rtd = comps_mrtree_data_create(rt, key+offset, ndata);
comps_hslist_append(subnodes, rtd, 0);
return;
} else {
rtdata = (COMPS_MRTreeData*)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; append new data
comps_hslist_append(rtdata->data, ndata, 0);
return;
} else if (ended == 2) { //global key ends first; make global leaf
comps_hslist_remove(subnodes, it);
it->next = NULL;
rtd = comps_mrtree_data_create(rt, key+offset, ndata);
comps_hslist_append(subnodes, rtd, 0);
((COMPS_MRTreeData*)subnodes->last->data)->subnodes->last = it;
((COMPS_MRTreeData*)subnodes->last->data)->subnodes->first = it;
_len = strlen(key + 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));
return;
} else if (ended == 1) { //local key ends first; go deeper
subnodes = rtdata->subnodes;
offset += x;
} else { /* keys differ */
void *tmpdata = rtdata->data;
COMPS_HSList *tmpnodes = rtdata->subnodes;
int cmpret = strcmp(key+offset+x, rtdata->key+x);
rtdata->subnodes = comps_hslist_create();
comps_hslist_init(rtdata->subnodes, NULL, NULL,
&comps_mrtree_data_destroy_v);
rtdata->data = NULL;
if (cmpret > 0) {
rtd = comps_mrtree_data_create(rt, rtdata->key+x, tmpdata);
comps_hslist_destroy(&rtd->subnodes);
rtd->subnodes = tmpnodes;
comps_hslist_append(rtdata->subnodes, rtd, 0);
rtd = comps_mrtree_data_create(rt, key+offset+x, ndata);
comps_hslist_append(rtdata->subnodes, rtd, 0);
} else {
rtd = comps_mrtree_data_create(rt, key+offset+x, ndata);
comps_hslist_append(rtdata->subnodes, rtd, 0);
rtd = comps_mrtree_data_create(rt, rtdata->key+x, tmpdata);
comps_hslist_destroy(&rtd->subnodes);
rtd->subnodes = tmpnodes;
comps_hslist_append(rtdata->subnodes, rtd, 0);
}
rtdata->key = realloc(rtdata->key, sizeof(char)*(x+1));
rtdata->key[x] = 0;
return;
}
}
}
}
void comps_rtree_destroy(COMPS_RTree * rt) {
if (!rt) return;
comps_hslist_destroy(&(rt->subnodes));
free(rt);
}
void comps_rtree_unset(COMPS_RTree * rt, const char * key) {
COMPS_HSList * subnodes;
COMPS_HSListItem * it;
COMPS_RTreeData * 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_RTreeData*)it->data)->key[0] == key[offset]) {
found = 1;
break;
}
}
if (!found)
return;
rtdata = (COMPS_RTreeData*)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_rtree_data_destroy(rtdata);
free(it);
}
else if (rtdata->data_destructor != NULL) {
printf("removing data only\n");
(*rtdata->data_destructor)(rtdata->data);
rtdata->is_leaf = 0;
rtdata->data = NULL;
}
if (path->last == NULL) {
comps_hslist_destroy(&path);
return;
}
rtdata = (COMPS_RTreeData*)
((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_rtree_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_RTreeData*)
((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_RTreeData*)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;
}
}
}
}
inline COMPS_HSList* __comps_objrtree_all(COMPS_ObjRTree * rt, char keyvalpair) {
COMPS_HSList *to_process, *ret;
COMPS_HSListItem *hsit, *oldit;
size_t x;
struct Pair {
char *key;
void *data;
COMPS_HSList *subnodes;
} *pair, *current_pair=NULL;//, *oldpair=NULL;
COMPS_ObjRTreePair *rtpair;
to_process = comps_hslist_create();
comps_hslist_init(to_process, NULL, NULL, &free);
ret = comps_hslist_create();
if (keyvalpair == 0)
comps_hslist_init(ret, NULL, NULL, &free);
else if (keyvalpair == 1)
comps_hslist_init(ret, NULL, NULL, NULL);
else
comps_hslist_init(ret, NULL, NULL, &comps_objrtree_pair_destroy_v);
for (hsit = rt->subnodes->first; hsit != NULL; hsit = hsit->next) {
pair = malloc(sizeof(struct Pair));
pair->key = __comps_strcpy(((COMPS_ObjRTreeData*)hsit->data)->key);
pair->data = ((COMPS_ObjRTreeData*)hsit->data)->data;
pair->subnodes = ((COMPS_ObjRTreeData*)hsit->data)->subnodes;
comps_hslist_append(to_process, pair, 0);
}
while (to_process->first) {
//oldpair = current_pair;
current_pair = to_process->first->data;
oldit = to_process->first;
comps_hslist_remove(to_process, to_process->first);
if (current_pair->data) {
if (keyvalpair == 0) {
comps_hslist_append(ret, __comps_strcpy(current_pair->key), 0);
} else if (keyvalpair == 1) {
comps_hslist_append(ret, current_pair->data, 0);
} else {
rtpair = malloc(sizeof(COMPS_ObjRTreePair));
rtpair->key = __comps_strcpy(current_pair->key);
rtpair->data = current_pair->data;
comps_hslist_append(ret, rtpair, 0);
}
}
for (hsit = current_pair->subnodes->first, x = 0;
hsit != NULL; hsit = hsit->next, x++) {
pair = malloc(sizeof(struct Pair));
pair->key = __comps_strcat(current_pair->key,
((COMPS_ObjRTreeData*)hsit->data)->key);
pair->data = ((COMPS_ObjRTreeData*)hsit->data)->data;
pair->subnodes = ((COMPS_ObjRTreeData*)hsit->data)->subnodes;
comps_hslist_insert_at(to_process, x, pair, 0);
}
free(current_pair->key);
free(current_pair);
free(oldit);
}
comps_hslist_destroy(&to_process);
return ret;
}
inline COMPS_HSList* __comps_rtree_all(COMPS_RTree * rt, char pairorkey) {
COMPS_HSList *tmplist, *tmp_subnodes, *ret;
COMPS_HSListItem *it;
struct Pair {
COMPS_HSList * subnodes;
char * key;
char added;
} *pair, *parent_pair;
COMPS_RTreePair *rtpair;
pair = malloc(sizeof(struct Pair));
pair->subnodes = rt->subnodes;
pair->key = NULL;
pair->added = 0;
tmplist = comps_hslist_create();
comps_hslist_init(tmplist, NULL, NULL, &free);
ret = comps_hslist_create();
if (pairorkey == 1)
comps_hslist_init(ret, NULL, NULL, &free);
else
comps_hslist_init(ret, NULL, NULL, &comps_rtree_pair_destroy_v);
comps_hslist_append(tmplist, pair, 0);
while (tmplist->first != NULL) {
it = tmplist->first;
comps_hslist_remove(tmplist, tmplist->first);
tmp_subnodes = ((struct Pair*)it->data)->subnodes;
parent_pair = (struct Pair*) it->data;
//printf("subkey:%s\n", ((struct Pair*)it->data)->key);
free(it);
//pair->added = 0;
for (it = tmp_subnodes->first; it != NULL; it=it->next) {
pair = malloc(sizeof(struct Pair));
pair->subnodes = ((COMPS_RTreeData*)it->data)->subnodes;
pair->added = 0;
if (parent_pair->key != NULL) {
pair->key =
malloc(sizeof(char)
* (strlen(((COMPS_RTreeData*)it->data)->key)
+ strlen(parent_pair->key) + 1));
memcpy(pair->key, parent_pair->key,
sizeof(char) * strlen(parent_pair->key));
memcpy(pair->key+strlen(parent_pair->key),
((COMPS_RTreeData*)it->data)->key,
sizeof(char)*(strlen(((COMPS_RTreeData*)it->data)->key)+1));
} else {
pair->key = malloc(sizeof(char)*
(strlen(((COMPS_RTreeData*)it->data)->key) +
1));
memcpy(pair->key, ((COMPS_RTreeData*)it->data)->key,
sizeof(char)*(strlen(((COMPS_RTreeData*)it->data)->key)+1));
}
//printf("%s|\n", pair->key);
/* current node has data */
if (((COMPS_RTreeData*)it->data)->data != NULL) {
//printf("data not null for |%s|\n", pair->key);
if (pairorkey == 1) {
comps_hslist_append(ret, pair->key, 0);
} else {
rtpair = malloc(sizeof(COMPS_RTreePair));
rtpair->key = pair->key;
rtpair->data = ((COMPS_RTreeData*)it->data)->data;
comps_hslist_append(ret, rtpair, 0);
}
pair->added = 1;
if (((COMPS_RTreeData*)it->data)->subnodes->first != NULL) {
// printf("subnodes found\b");
comps_hslist_append(tmplist, pair, 0);
} else {
free(pair);
}
/* current node hasn't data */
} else {
//printf("no data\n");
if (((COMPS_RTreeData*)it->data)->subnodes->first) {
comps_hslist_append(tmplist, pair, 0);
//added = 1;
} else {
free(pair->key);
free(pair);
}
}
}
if (parent_pair->added == 0)
free(parent_pair->key);
free(parent_pair);
}
comps_hslist_destroy(&tmplist);
return ret;
}
inline void comps_hslist_destroy_v(void ** hslist) {
comps_hslist_destroy((COMPS_HSList**) hslist);
}
void comps_objrtree_unite(COMPS_ObjRTree *rt1, COMPS_ObjRTree *rt2) {
COMPS_HSList *tmplist, *tmp_subnodes;
COMPS_HSListItem *it;
struct Pair {
COMPS_HSList * subnodes;
char * key;
char added;
} *pair, *parent_pair;
pair = malloc(sizeof(struct Pair));
pair->subnodes = rt2->subnodes;
pair->key = NULL;
tmplist = comps_hslist_create();
comps_hslist_init(tmplist, NULL, NULL, &free);
comps_hslist_append(tmplist, pair, 0);
while (tmplist->first != NULL) {
it = tmplist->first;
comps_hslist_remove(tmplist, tmplist->first);
tmp_subnodes = ((struct Pair*)it->data)->subnodes;
parent_pair = (struct Pair*) it->data;
//printf("key-part:%s\n", parent_pair->key);
free(it);
//pair->added = 0;
for (it = tmp_subnodes->first; it != NULL; it=it->next) {
pair = malloc(sizeof(struct Pair));
pair->subnodes = ((COMPS_ObjRTreeData*)it->data)->subnodes;
if (parent_pair->key != NULL) {
pair->key = malloc(sizeof(char)
* (strlen(((COMPS_ObjRTreeData*)it->data)->key)
+ strlen(parent_pair->key) + 1));
memcpy(pair->key, parent_pair->key,
sizeof(char) * strlen(parent_pair->key));
memcpy(pair->key + strlen(parent_pair->key),
((COMPS_ObjRTreeData*)it->data)->key,
sizeof(char)*(strlen(((COMPS_ObjRTreeData*)it->data)->key)+1));
} else {
pair->key = malloc(sizeof(char)*
(strlen(((COMPS_ObjRTreeData*)it->data)->key) +1));
memcpy(pair->key, ((COMPS_ObjRTreeData*)it->data)->key,
sizeof(char)*(strlen(((COMPS_ObjRTreeData*)it->data)->key)+1));
}
/* current node has data */
if (((COMPS_ObjRTreeData*)it->data)->data != NULL) {
comps_objrtree_set(rt1, pair->key,
(((COMPS_ObjRTreeData*)it->data)->data));
}
if (((COMPS_ObjRTreeData*)it->data)->subnodes->first) {
comps_hslist_append(tmplist, pair, 0);
} else {
free(pair->key);
free(pair);
}
}
free(parent_pair->key);
free(parent_pair);
}
comps_hslist_destroy(&tmplist);
}
int PyCOMPSGroup_print(PyObject *self, FILE *f, int flags) {
#define _group_ ((PyCOMPS_Group*)self)
COMPS_ObjListIt *it;
COMPS_HSList *pairlist;
COMPS_HSListItem *hsit;
char *id, *name, *desc, *lang, *def, *uservis, *disp_ord;
COMPS_Object* tmp_prop;
(void)flags;
tmp_prop = comps_docgroup_get_id(_group_->group);
id = (tmp_prop)?comps_object_tostr(tmp_prop):NULL;
tmp_prop = comps_docgroup_get_name(_group_->group);
name = (tmp_prop)?comps_object_tostr(tmp_prop):NULL;
tmp_prop = comps_docgroup_get_desc(_group_->group);
desc = (tmp_prop)?comps_object_tostr(tmp_prop):NULL;
tmp_prop = comps_docgroup_get_display_order(_group_->group);
disp_ord = (tmp_prop)?comps_object_tostr(tmp_prop):NULL;
tmp_prop = comps_docgroup_get_langonly(_group_->group);
lang = (tmp_prop)?comps_object_tostr(tmp_prop):NULL;
tmp_prop = comps_docgroup_get_def(_group_->group);
def = (tmp_prop)?comps_object_tostr(tmp_prop):NULL;
tmp_prop = comps_docgroup_get_uservisible(_group_->group);
uservis = (tmp_prop)?comps_object_tostr(tmp_prop):NULL;
fprintf(f, "<COMPS_Group: id='%s', name='%s', description='%s', "
"default='%s', uservisible='%s', lang_only='%s', display_order=%s ",
id, name, desc, def, uservis, lang, disp_ord);
free(id);
free(name);
free(desc);
free(lang);
free(def);
free(uservis);
free(disp_ord);
fprintf(f, "name_by_lang={");
pairlist = comps_objrtree_pairs(_group_->group->name_by_lang);
for (hsit = pairlist->first; hsit != pairlist->last; hsit = hsit->next) {
name = comps_object_tostr(((COMPS_ObjRTreePair*)hsit->data)->data);
printf("'%s': '%s', ", ((COMPS_ObjRTreePair*)hsit->data)->key, name);
free(name);
}
if (hsit) {
name = comps_object_tostr(((COMPS_ObjRTreePair*)hsit->data)->data);
printf("'%s': '%s'}", ((COMPS_ObjRTreePair*)hsit->data)->key, name);
free(name);
} else {
printf("}");
}
comps_hslist_destroy(&pairlist);
fprintf(f, ", desc_by_lang={");
pairlist = comps_objrtree_pairs(_group_->group->desc_by_lang);
for (hsit = pairlist->first; hsit != pairlist->last; hsit = hsit->next) {
name = comps_object_tostr(((COMPS_ObjRTreePair*)hsit->data)->data);
printf("'%s': '%s', ", ((COMPS_ObjRTreePair*)hsit->data)->key, name);
free(name);
}
if (hsit) {
name = comps_object_tostr(((COMPS_ObjRTreePair*)hsit->data)->data);
printf("'%s': '%s'}", ((COMPS_ObjRTreePair*)hsit->data)->key, name);
free(name);
} else {
printf("}");
}
comps_hslist_destroy(&pairlist);
fprintf(f, ", packages=[");
if (_group_->group->packages) {
for (it = _group_->group->packages->first;
it != _group_->group->packages->last; it = it->next){
id = comps_object_tostr(it->comps_obj);
fprintf(f,"%s, ", id);
free(id);
}
if (it) {
id = comps_object_tostr(it->comps_obj);
fprintf(f,"%s", id);
free(id);
}
}
fprintf(f, "]>");
return 0;
#undef _group_
}
