webserver: comparison src/server/plugins/postgresql/config.c

-:99a34860c105
+:d938228c382e
 return ret;
 }
 PgRepository* pg_init_repo(ServerConfiguration *cfg, pool_handle_t *pool, WSConfigNode *config) {
-UcxAllocator a = util_pool_allocator(pool);
+CxAllocator *a = pool_allocator(pool);
-ConfigNode *pg = serverconfig_get_node(config, CONFIG_NODE_OBJECT, SC("Postgresql"));
+ConfigNode *pg = serverconfig_get_node(config, CONFIG_NODE_OBJECT, cx_str("Postgresql"));
 if(!pg) {
 log_ereport(LOG_MISCONFIG, "pg_init_repo: missing postgresql config object");
 return NULL;
 }
-scstr_t cfg_respool = serverconfig_directive_value(pg, SC("ResourcePool"));
+cxstring cfg_respool = serverconfig_directive_value(pg, cx_str("ResourcePool"));
-scstr_t cfg_rootid = serverconfig_directive_value(pg, SC("RootId"));
+cxstring cfg_rootid = serverconfig_directive_value(pg, cx_str("RootId"));
-scstr_t cfg_rootnode = serverconfig_directive_value(pg, SC("RootNode"));
+cxstring cfg_rootnode = serverconfig_directive_value(pg, cx_str("RootNode"));
-scstr_t cfg_dav = serverconfig_directive_value(pg, SC("PGDavConfig"));
+cxstring cfg_dav = serverconfig_directive_value(pg, cx_str("PGDavConfig"));
 // minimum requirement is a resource pool
 if(cfg_respool.length == 0) {
 return NULL;
 }
 }
 PgRepository *repo = pool_malloc(pool, sizeof(PgRepository));
 ZERO(repo, sizeof(PgRepository));
-repo->resourcepool = sstrdup_a(&a, cfg_respool);
+repo->resourcepool = cx_strdup_a(a, cfg_respool);
 repo->root_resource_id = root_id;
 // check for extended pg dav config
 if(cfg_dav.length > 0) {
 // load extended config from config file
 ServerConfiguration *cfg,
 pool_handle_t *pool,
 PgRepository *repo,
 const char *file_path)
 {
-UcxAllocator a = util_pool_allocator(pool);
+CxAllocator *a = pool_allocator(pool);
 // check if the file exists and can be accessed
 struct stat s;
 if(stat(file_path, &s)) {
 if(errno == ENOENT) {
 return 1;
 }
 // prepare PgRepository
-repo->prop_ext = ucx_map_new_a(&a, 8);
+repo->prop_ext = cxHashMapCreate(a, 8);
 if(!repo->prop_ext) {
 log_ereport(LOG_FAILURE, "pg: cannot load config file: OOM");
 return 1;
 }
 {
 xmlNode *node = root->children;
 int ret = 0;
 PgExtParser parserData;
-parserData.table_lookup = ucx_map_new(8);
+parserData.table_lookup = cxHashMapCreate(cxDefaultAllocator, 8);
-parserData.tables = NULL;
+parserData.tables = cxLinkedListCreate(cxDefaultAllocator, cx_cmp_ptr, sizeof(PgExtTable));
 while(node && !ret) {
 // currently, the only possible config element is <extension>
 if(node->type == XML_ELEMENT_NODE) {
 if(xstreq(node->name, "extension")) {
 node = node->next;
 }
 // convert parserData
 if(!ret) {
-size_t ntables = ucx_list_size(parserData.tables);
+size_t ntables = parserData.tables->size;
 repo->ntables = ntables;
 repo->tables = pool_calloc(pool, ntables, sizeof(PgExtTable));
 if(repo->tables) {
 int i = 0;
-UCX_FOREACH(elm, parserData.tables) {
+CxIterator iter = cxListIterator(parserData.tables, 0);
-PgExtTable *tab = elm->data;
+cx_foreach(PgExtTable *, tab, iter) {
 repo->tables[i++] = *tab;
 }
 } else {
 ret = 1;
 }
 }
 // cleanup parser
-ucx_list_free_content(parserData.tables, free);
+cxListDestroy(parserData.tables);
-ucx_list_free(parserData.tables);
+cxMapDestroy(parserData.table_lookup);
-ucx_map_free(parserData.table_lookup);
 return ret;
 }
 static int pg_ext_get_extension(
 pool_handle_t *pool,
 PgRepository *repo,
 const char *file_path,
 xmlNode *ext_node)
 {
-UcxAllocator a = util_pool_allocator(pool);
+CxAllocator *a = pool_allocator(pool);
 xmlNode *node = ext_node->children;
 const char *table = NULL;
-UcxList *properties = NULL;
+CxList *properties = cxPointerLinkedListCreate(a, cx_cmp_ptr);
 while(node) {
 if(node->type == XML_ELEMENT_NODE) {
 if(xstreq(node->name, "table")) {
 const char *value = pg_util_xml_get_text(node);
 const char *value = pg_util_xml_get_text(ps);
 if(!value) {
 log_ereport(LOG_MISCONFIG, "pg: config %s: no column specified for property %s", file_path, ps->name);
 return 1;
 }
-properties = ucx_list_append_a(&a, properties, ps);
+cxListAdd(properties, ps);
 }
 ps = ps->next;
 }
 }
 }
 log_ereport(LOG_MISCONFIG, "pg: config %s: no properties configured for extension", file_path);
 return 1;
 }
 // check if the table was already specified
-if(ucx_map_cstr_get(ext->table_lookup, table)) {
+if(cxMapGet(ext->table_lookup, cx_hash_key_str(table))) {
 log_ereport(LOG_MISCONFIG, "pg: config %s: extension table %s not unique", file_path, table);
 return 1;
 }
 // mark table as used
 // tabname will be used later, so ist must be allocated in the pool
 char *tabname = pool_strdup(pool, table);
 if(!tabname) return 1;
 // exttable is only used temporarily
-PgExtTable *exttable = malloc(sizeof(PgExtTable));
+PgExtTable exttable;
-if(!exttable) return 1;
+exttable.table = tabname;
-exttable->table = tabname;
+exttable.isused = 0; // not relevant in config
-exttable->isused = 0; // not relevant in config
+int tableindex = (int)ext->tables->size;
-int tableindex = (int)ucx_list_size(ext->tables);
+cxListAdd(ext->tables, &exttable);
-ext->tables = ucx_list_append(ext->tables, exttable);
+if(cxMapPut(ext->table_lookup, cx_hash_key_str(table), (void*)table)) {
-if(ucx_map_cstr_put(ext->table_lookup, table, table)) {
 return 1;
 }
-UCX_FOREACH(elm, properties) {
+CxIterator iter = cxListIterator(properties, 0);
-xmlNode *ps = elm->data;
+cx_foreach(xmlNode *, ps, iter) {
 const char *value = pg_util_xml_get_text(ps);
 PgPropertyStoreExt *ext_col = pool_malloc(pool, sizeof(PgPropertyStoreExt));
 if(!ext_col) {
 return 1;
 ext_col->column = pool_strdup(pool, (const char*)value);
 if(!ext_col->ns || !ext_col->name || !ext_col->column) {
 return 1;
 }
-UcxKey key = webdav_property_key(ext_col->ns, ext_col->name);
+CxHashKey key = webdav_property_key(ext_col->ns, ext_col->name);
-int err = ucx_map_put(repo->prop_ext, key, ext_col);
+int err = cxMapPut(repo->prop_ext, key, ext_col);
-free((void*)key.data);
+free(key.data.bytes);
 if(err) {
 return 1;
 }
 }

Mercurial > hg > webserver / file comparison

comparison: src/server/plugins/postgresql/config.c

src/server/plugins/postgresql/config.c