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_ }