/* - list1 and list2 containts strings - if one of the strings in list2 is contained ( partial match, strstr() ) in one of the strings in list1 the function returns true... */ bool nlt_namelist_intersect( const KNamelist *list1, const KNamelist *list2 ) { uint32_t count1; bool res = false; if ( list1 == NULL || list2 == NULL ) return res; if ( KNamelistCount( list1, &count1 ) == 0 ) { uint32_t idx1; for ( idx1 = 0; idx1 < count1 && res == false; ++idx1 ) { const char *string1; if ( KNamelistGet( list1, idx1, &string1 ) == 0 ) { uint32_t count2; if ( KNamelistCount( list2, &count2 ) == 0 ) { uint32_t idx2; for ( idx2 = 0; idx2 < count2 && res == false; ++idx2 ) { const char *string2; if ( KNamelistGet( list2, idx2, &string2 ) == 0 ) { if ( strstr( string1, string2 ) != NULL ) res = true; } } } } } } return res; }
/* read the mapping out of the region-types out of a string... */ rc_t rgn_extract_type_mappings( const KNamelist *rgn_names, region_type_mapping *mapping, bool check_completenes ) { rc_t rc = 0; uint32_t count, idx; mapping->rgn_type_adapter = -1; mapping->rgn_type_insert = -1; mapping->rgn_type_hq = -1; mapping->rgn_type_ga = -1; rc = KNamelistCount ( rgn_names, &count ); for ( idx = 0; idx < count && rc == 0; ++idx ) { const char *name; rc = KNamelistGet ( rgn_names, idx, &name ); if ( rc == 0 ) rgn_type_string( name, idx, mapping ); } if ( rc == 0 && check_completenes ) { if ( mapping->rgn_type_adapter == -1 || mapping->rgn_type_insert == -1 || mapping->rgn_type_hq == -1 ) rc = RC( rcExe, rcNoTarg, rcLoading, rcName, rcIncomplete ); } mapping->count_of_unknown_rgn_types = 0; return rc; }
static rc_t make_schema( const KNamelist * schema_list, VDBManager *my_manager, VSchema ** schema ) { rc_t rc = VDBManagerMakeSchema ( my_manager, schema ); if ( rc != 0 ) LogErr( klogInt, rc, "VDBManagerMakeSchema() failed\n" ); else { uint32_t count; rc = KNamelistCount ( schema_list, &count ); if ( rc !=0 ) LogErr( klogInt, rc, "KNamelistCount(schema-list) failed\n" ); else { uint32_t i; for ( i = 0; i < count && rc == 0; ++i ) { const char * name; rc = KNamelistGet ( schema_list, i, &name ); if ( rc !=0 ) LogErr( klogInt, rc, "KNamelistGet(schema-list) failed\n" ); else { rc = VSchemaParseFile ( *schema, name ); if ( rc !=0 ) LogErr( klogInt, rc, "VSchemaParseFile() failed\n" ); } } } } return rc; }
bool nlt_compare_namelists( const KNamelist *nl1, const KNamelist *nl2, uint32_t * found ) { bool res = false; if ( nl1 != NULL && nl2 != NULL ) { uint32_t count_1; rc_t rc = KNamelistCount( nl1, &count_1 ); if ( rc == 0 ) { uint32_t count_2; rc = KNamelistCount( nl2, &count_2 ); if ( rc == 0 && count_1 == count_2 ) { uint32_t idx; uint32_t in_nl2 = 0; for ( idx = 0; idx < count_1 && rc == 0; ++idx ) { const char *s; rc = KNamelistGet( nl1, idx, &s ); if ( rc == 0 && s != NULL && nlt_is_name_in_namelist( nl2, s ) ) in_nl2++; } res = ( rc == 0 && in_nl2 == count_1 ); if ( found != NULL ) *found = in_nl2; } } } return res; }
rc_t nlt_remove_names_from_namelist( const KNamelist *source, const KNamelist **dest, const KNamelist *to_remove ) { rc_t rc = 0; uint32_t count; if ( source == NULL || dest == NULL || to_remove == NULL ) return RC( rcVDB, rcNoTarg, rcConstructing, rcParam, rcNull ); *dest = NULL; rc = KNamelistCount( source, &count ); if ( rc == 0 && count > 0 ) { VNamelist *cleaned; rc = VNamelistMake ( &cleaned, count ); if ( rc == 0 ) { uint32_t idx; for ( idx = 0; idx < count && rc == 0; ++idx ) { const char *s; rc = KNamelistGet( source, idx, &s ); if ( rc == 0 ) { if ( !nlt_is_name_in_namelist( to_remove, s ) ) rc = VNamelistAppend ( cleaned, s ); } rc = VNamelistToConstNamelist ( cleaned, dest ); } } } return rc; }
/* ----------------------------------------------------------------------------- */ static bool has_col( const VTable * tab, const char * colname ) { bool res = false; struct KNamelist * columns; rc_t rc = VTableListReadableColumns( tab, &columns ); if ( rc == 0 ) { uint32_t count; rc = KNamelistCount( columns, &count ); if ( rc == 0 && count > 0 ) { uint32_t idx; size_t colname_size = string_size( colname ); for ( idx = 0; idx < count && rc == 0 && !res; ++idx ) { const char * a_name; rc = KNamelistGet ( columns, idx, &a_name ); if ( rc == 0 ) { int cmp; size_t a_name_size = string_size( a_name ); uint32_t max_chars = ( uint32_t )colname_size; if ( a_name_size > max_chars ) max_chars = ( uint32_t )a_name_size; cmp = strcase_cmp ( colname, colname_size, a_name, a_name_size, max_chars ); res = ( cmp == 0 ); } } } KNamelistRelease( columns ); } return res; }
rc_t nlt_copy_namelist( const KNamelist *src, const KNamelist ** dst ) { VNamelist *v_names; rc_t rc = VNamelistMake ( &v_names, 5 ); if ( rc == 0 ) { uint32_t count; rc = KNamelistCount( src, &count ); if ( rc == 0 ) { uint32_t idx; for ( idx = 0; idx < count && rc == 0; ++idx ) { const char *s; rc = KNamelistGet( src, idx, &s ); if ( rc == 0 && s != NULL ) rc = VNamelistAppend ( v_names, s ); } } if ( rc == 0 ) rc = VNamelistToConstNamelist ( v_names, dst ); VNamelistRelease( v_names ); } return rc; }
bool namelist_contains( const KNamelist *names, const char * a_name ) { bool res = false; uint32_t count; rc_t rc = KNamelistCount( names, &count ); if ( rc == 0 && count > 0 ) { uint32_t idx; size_t a_name_len = string_size( a_name ); for ( idx = 0; idx < count && rc == 0 && !res; ++idx ) { const char * s; rc = KNamelistGet( names, idx, &s ); if ( rc == 0 && s != NULL ) { size_t s_len = string_size( s ); size_t max_len = a_name_len > s_len ? a_name_len : s_len; int cmp = string_cmp( a_name, a_name_len, s, s_len, max_len ); if ( cmp == 0 ) res = true; } } } return res; }
rc_t CopyDirectoryFiles( const KDirectory *source, KDirectory *dest ) { rc_t rc; KNamelist *list; const char *name; int i; uint32_t count; char resolved[1024]; rc = KDirectoryList( source, &list, PathIsFile, NULL, "."); if (rc != 0) { /* This doesn't do what I thought. */ KDirectoryResolvePath( source, false, resolved, 1024, "."); LOGERR ( klogInt, rc, resolved ); return rc; } KNamelistCount(list, &count); for (i=0; i<count; i++) { KNamelistGet(list, i, &name); if (test) { fprintf(stderr, "Will copy %s\n", name); } else { CopyFileToFile( source, name, dest, (char *)name ); } } return 0; }
bool vdcd_extract_from_phys_table( col_defs* defs, const VTable *my_table ) { bool col_defs_found = false; KNamelist *names; rc_t rc = VTableListPhysColumns( my_table, &names ); DISP_RC( rc, "VTableListPhysColumns() failed" ); if ( rc == 0 ) { uint32_t n; uint32_t found = 0; rc = KNamelistCount( names, &n ); DISP_RC( rc, "KNamelistCount() failed" ); if ( rc == 0 ) { uint32_t i; for ( i = 0; i < n && rc == 0; ++i ) { const char *col_name; rc = KNamelistGet( names, i, &col_name ); DISP_RC( rc, "KNamelistGet() failed" ); if ( rc == 0 ) { vdcd_append_col( defs, col_name ); found++; } } col_defs_found = ( found > 0 ); } rc = KNamelistRelease( names ); DISP_RC( rc, "KNamelistRelease() failed" ); } return col_defs_found; }
static rc_t copy_metadata_attribs ( const KMDataNode *snode, KMDataNode *dnode, const char *node_path, const bool show_meta ) { KNamelist *attrs; uint32_t i, count; rc_t rc = KMDataNodeListAttr ( snode, & attrs ); DISP_RC( rc, "copy_metadata_child:KMDataNodeListAttr(src) failed" ); if ( rc != 0 ) return rc; rc = KNamelistCount ( attrs, & count ); for ( i = 0; rc == 0 && i < count; ++ i ) { const char *attr; rc = KNamelistGet ( attrs, i, & attr ); if ( rc == 0 ) { char buffer [ 1024 ]; size_t bytes; /* test for attr existence */ rc = KMDataNodeReadAttr ( dnode, attr, buffer, sizeof buffer, & bytes ); if ( rc != 0 ) { rc = KMDataNodeReadAttr ( snode, attr, buffer, sizeof buffer, & bytes ); if ( rc == 0 ) { if ( show_meta ) KOutMsg( "copy atr %s : %s\n", node_path, attr ); rc = KMDataNodeWriteAttr ( dnode, attr, buffer ); } } } DISP_RC( rc, "copy_metadata_child:failed to copy attribute" ); } KNamelistRelease ( attrs ); return rc; }
static rc_t for_each_v_name( VNamelist *names, void *data, const name_fkt f ) { KNamelist *knames; uint32_t count, idx; rc_t rc = VNamelistToNamelist( names, (KNamelist **)&knames ); display_rescode( rc, "VNamelistToNamelist failed", NULL ); if ( rc == 0 ) { rc = KNamelistCount( knames, &count ); display_rescode( rc, "KNamelistCount failed", NULL ); if ( rc == 0 ) { for ( idx=0; idx<count; ++idx ) { const char *my_path; rc = KNamelistGet( knames, idx, &my_path ); display_rescode( rc, "KNamelistGet failed", NULL ); if ( rc == 0 ) rc = f( data, my_path ); } } KNamelistRelease( knames ); } return rc; }
rc_t nlt_build_intersect( const KNamelist *nl1, const KNamelist *nl2, const KNamelist ** dst ) { VNamelist *v_names; rc_t rc = VNamelistMake ( &v_names, 5 ); if ( rc == 0 ) { /* loop through nl1: if a entry is found in nl2 -> add it to dst */ uint32_t count; rc = KNamelistCount( nl1, &count ); if ( rc == 0 ) { uint32_t idx; for ( idx = 0; idx < count && rc == 0; ++idx ) { const char *s; rc = KNamelistGet( nl1, idx, &s ); if ( rc == 0 && s != NULL ) { if ( nlt_is_name_in_namelist( nl2, s ) ) rc = VNamelistAppend ( v_names, s ); } } } if ( rc == 0 ) rc = VNamelistToConstNamelist ( v_names, dst ); VNamelistRelease( v_names ); } return rc; }
static rc_t ShowFiles(const KConfig* cfg, const Params* prm) { rc_t rc = 0; bool hasAny = false; uint32_t count = 0; KNamelist* names = NULL; rc = KConfigListIncluded(cfg, &names); if (rc == 0) { rc = KNamelistCount(names, &count); } if (rc == 0) { uint32_t i = 0; if (prm->showMultiple) { OUTMSG(("<!-- Configuration files -->\n")); hasAny = true; } for (i = 0; i < count && rc == 0; ++i) { const char* name = NULL; if (rc == 0) { rc = KNamelistGet(names, i, &name); } if (rc == 0) { OUTMSG(("%s\n", name)); hasAny = true; } } } if (rc == 0 && hasAny) { OUTMSG(("\n")); } RELEASE(KNamelist, names); return rc; }
static rc_t CC _LoadKartScanPath ( struct XFSKartCollectionNode * Node ) { rc_t RCt; struct KDirectory * Directory; KNamelist * List; const char * Name; uint32_t Idx; uint32_t ListCount; RCt = 0; Directory = NULL; List = NULL; Name = NULL; Idx = 0; ListCount = 0; if ( Node == NULL ) { return XFS_RC ( rcNull ); } if ( Node -> path == NULL ) { return XFS_RC ( rcInvalid ); } RCt = KDirectoryNativeDir ( & Directory ); if ( RCt == 0 ) { RCt = KDirectoryList ( Directory, & List, NULL, NULL, Node -> path ); if ( RCt == 0 ) { RCt = KNamelistCount ( List, & ListCount ); if ( RCt == 0 ) { for ( Idx = 0; Idx < ListCount; Idx ++ ) { RCt = KNamelistGet ( List, Idx, & Name ); if ( RCt == 0 ) { RCt = _LoadKartItem ( Directory, Node, Name ); } if ( RCt != 0 ) { break; } } } KNamelistRelease ( List ); } KDirectoryRelease ( Directory ); } return RCt; } /* _LoadKartScanPath () */
static rc_t ConfigRepoSet(DLList* repos, KConfig * kfg, const char* kfgPath, const char *dflt, uint8_t type) { const KConfigNode *node; rc_t rc = KConfigOpenNodeRead ( kfg, & node, kfgPath ); if ( rc == 0 ) { KNamelist* children; rc = KConfigNodeListChild ( node, &children ); if ( rc == 0 ) { uint32_t count; rc = KNamelistCount ( children, &count ); if ( rc == 0 ) { uint32_t i; for (i = 0; i < count; ++i) { const char* name; rc = KNamelistGet ( children, i, &name ); if ( rc == 0 ) { #define BufSize 4096 char buf[ BufSize ]; size_t bSize = string_size(kfgPath); string_copy(buf, BufSize, kfgPath, bSize); if (bSize + string_size(name) < sizeof(buf)) { NCBIRepository* repo; string_copy(buf + bSize, sizeof(buf) - bSize, name, string_size(name) + 1); rc = ConfigRepo( kfg, dflt, buf, buf, type, &repo ); DLListPushTail( repos, (DLNode*) repo ); } #undef BufSize } else { rc = RC ( rcSRA, rcMgr, rcConstructing, rcString, rcExcessive ); } if ( rc != 0 ) { break; } } } KNamelistRelease ( children ); } KConfigNodeRelease ( node ); } if (GetRCState(rc) == rcNotFound) { return 0; } return rc; }
bool vdcd_extract_from_table( col_defs* defs, const VTable *my_table ) { bool col_defs_found = false; KNamelist *names; rc_t rc = VTableListCol( my_table, &names ); DISP_RC( rc, "VTableListCol() failed" ); if ( rc == 0 ) { const VCursor *my_cursor; rc = VTableCreateCursorRead( my_table, &my_cursor ); DISP_RC( rc, "VTableCreateCursorRead() failed" ); if ( rc == 0 ) { uint32_t n; uint32_t found = 0; rc = KNamelistCount( names, &n ); DISP_RC( rc, "KNamelistCount() failed" ); if ( rc == 0 ) { uint32_t i; for ( i = 0; i < n && rc ==0; ++i ) { const char *col_name; rc = KNamelistGet( names, i, &col_name ); DISP_RC( rc, "KNamelistGet() failed" ); if ( rc == 0 ) { p_col_def def = vdcd_append_col( defs, col_name ); rc = VCursorAddColumn( my_cursor, &(def->idx), def->name ); DISP_RC( rc, "VCursorAddColumn() failed" ); if ( rc == 0 ) { rc = VCursorDatatype( my_cursor, def->idx, &(def->type_decl), &(def->type_desc) ); DISP_RC( rc, "VCursorDatatype() failed" ); if ( rc == 0 ) { found++; } } } } col_defs_found = ( found > 0 ); } rc = VCursorRelease( my_cursor ); DISP_RC( rc, "VCursorRelease() failed" ); } rc = KNamelistRelease( names ); DISP_RC( rc, "KNamelistRelease() failed" ); } return col_defs_found; }
static rc_t CC _LoadKart ( struct XFSKartNode * Node ) { rc_t RCt; const struct XFSGapKart * Kart; struct KNamelist * List; uint32_t ListQ, ListI; const char * ListN; RCt = 0; Kart = NULL; List = NULL; ListQ = ListI = 0; ListN = NULL; XFS_CAN ( Node ) RCt = _AddSignatureFile ( Node ); if ( RCt == 0 ) { RCt = XFSGapKartDepotGet ( & Kart, XFSNodeName ( & ( Node -> node . node ) ) ); if ( RCt == 0 ) { RCt = XFSGapKartList ( Kart, & List, Node -> project_id ); if ( RCt == 0 ) { RCt = KNamelistCount ( List, & ListQ ); if ( RCt == 0 ) { for ( ListI = 0; ListI < ListQ; ListI ++ ) { RCt = KNamelistGet ( List, ListI, & ListN ); if ( RCt != 0 ) { break; } RCt = _AddKartItem ( Node, Kart, ListN ); if ( RCt != 0 ) { break; } } } KNamelistRelease ( List ); } XFSGapKartRelease ( Kart ); } } return RCt; } /* _LoadKart () */
/* * calls VTableListReadableColumns to get a list of all column-names of the table * creates a temporary read-cursor to test and get the column-type * walks the KNamelist with the available column-names * tries to add every one of them to the temp. cursor * if the column can be added to the cursor, it is appended * to the column-definition list */ rc_t col_defs_extract_from_table( col_defs* defs, const VTable *table ) { KNamelist *names; rc_t rc; if ( defs == NULL ) return RC( rcExe, rcNoTarg, rcResolving, rcSelf, rcNull ); if ( table == NULL ) return RC( rcExe, rcNoTarg, rcResolving, rcParam, rcNull ); rc = VTableListReadableColumns( table, &names ); DISP_RC( rc, "col_defs_extract_from_table:VTableListReadableColumns() failed" ); if ( rc == 0 ) { const VCursor *cursor; rc = VTableCreateCursorRead( table, &cursor ); DISP_RC( rc, "col_defs_extract_from_table:VTableCreateCursorRead() failed" ); if ( rc == 0 ) { uint32_t count; rc = KNamelistCount( names, &count ); DISP_RC( rc, "col_defs_extract_from_table:KNamelistCount() failed" ); if ( rc == 0 ) { uint32_t idx; for ( idx = 0; idx < count && rc == 0; ++idx ) { const char *name; rc = KNamelistGet( names, idx, &name ); DISP_RC( rc, "col_defs_extract_from_table:KNamelistGet() failed" ); if ( rc == 0 ) { uint32_t temp_idx; rc_t rc1 = VCursorAddColumn( cursor, &temp_idx, "%s", name ); DISP_RC( rc1, "col_defs_extract_from_table:VCursorAddColumn() failed" ); if ( rc1 == 0 ) { rc = col_defs_append_col( defs, name ); DISP_RC( rc, "col_defs_extract_from_table:col_defs_append_col() failed" ); } } } } rc = VCursorRelease( cursor ); DISP_RC( rc, "col_defs_extract_from_table:VCursorRelease() failed" ); } rc = KNamelistRelease( names ); DISP_RC( rc, "col_defs_extract_from_table:KNamelistRelease() failed" ); } return rc; }
/* sort by cid */ return VCtxIdCmp ( & a -> cid, & b -> cid ); } #if 0 /* more for later */ static rc_t create_cursor_all_readable_columns(const VTable *self, unsigned *ncol, uint32_t **idx, const VCursor **curs) { KNamelist *list; rc_t rc = VTableListReadableColumns(self, &list); if (rc == 0) { rc = VTableCreateCursorReadInternal(self, curs); if (rc == 0) { uint32_t n; rc = KNamelistCount(list, ncol); if (rc == 0) { n = *ncol; *idx = malloc(n * sizeof(**idx)); if (idx) { unsigned i; for (i = 0; i != (unsigned)n; ++i) { const char *name; rc = KNamelistGet(list, i, &name); if (rc) break; rc = VCursorAddColumn(*curs, &(*idx)[i], name); if (rc) break; } if (rc) free(*idx); } else rc = RC(rcVDB, rcTable, rcValidating, rcMemory, rcExhausted); } if (rc) VCursorRelease(*curs); } KNamelistRelease(list); } if (rc) { *idx = NULL; *curs = NULL; *ncol = 0; } return rc; }
static rc_t ReportBuild(const ReportFuncs *f, uint32_t indent, const VDBManager* mgr) { rc_t rc = 0; KNamelist* list = NULL; reportOpen(indent, "Build", 1, "static", 's', "false"); if (mgr) { rc_t rc2 = VDBManagerListExternalSchemaModules(mgr, &list); if (rc2 != 0) { reportError (indent + 1, rc2, "VDBManagerListExternalSchemaModules"); if (rc == 0 && rc2 != 0) { rc = rc2; } } else { uint32_t count = 0; rc2 = KNamelistCount(list, &count); if (rc2 != 0) { reportErrorStr(indent + 1, rc2, "KNamelistCount", "origin", "VDBManagerListExternalSchemaModules"); if (rc == 0 && rc2 != 0) { rc = rc2; } } else { uint32_t i = 0; for (i = 0; i < count && rc2 == 0; ++i) { const char* name = NULL; rc2 = KNamelistGet(list, i, &name); if (rc2 != 0) { reportErrorStr( indent + 1, rc2, "KNamelistGet", "origin", "VDBManagerListExternalSchemaModules"); if (rc == 0 && rc2 != 0) { rc = rc2; } } else { report(indent + 1, "Module", 1, "name", 's', name); } } } } RELEASE(KNamelist, list); reportClose(indent, "Build"); } return rc; }
static rc_t for_each_k_name( KNamelist *names, void *data, const name_fkt f ) { uint32_t count, idx; rc_t rc = KNamelistCount( names, &count ); display_rescode( rc, "KNamelistCount failed", NULL ); if ( rc == 0 ) { for ( idx=0; idx<count; ++idx ) { const char *my_path; rc = KNamelistGet( names, idx, &my_path ); display_rescode( rc, "KNamelistGet failed", NULL ); if ( rc == 0 ) rc = f( data, my_path ); } } return rc; }
static void dump_tbl ( const KTable *tbl, const char *tblname, int argc, char *argv [] ) { if ( argc >= 4 ) { int i; for ( i = 3; i < argc; ++ i ) { dump_col_name ( tbl, argv [ 1 ], tblname, argv [ i ] ); } } else { KNamelist *names; rc_t rc = KTableListCol ( tbl, & names ); if ( rc != 0 ) fprintf ( stderr, "failed to list columns for tbl '%s.%s'\n", argv [ 1 ], tblname ); else { uint32_t count; rc = KNamelistCount ( names, & count ); if ( rc != 0 ) fprintf ( stderr, "failed to count columns for tbl '%s.%s'\n", argv [ 1 ], tblname ); else { uint32_t i; for ( i = 0; i < count; ++ i ) { const char *name; rc = KNamelistGet ( names, i, & name ); if ( rc != 0 ) fprintf ( stderr, "failed to access column name [ %u ] for tbl '%s.%s'\n", i, argv [ 1 ], tblname ); else { dump_col_name ( tbl, argv [ 1 ], tblname, name ); } } } KNamelistRelease ( names ); } } }
static rc_t matcher_read_col_src_types( p_mcol col, const KNamelist *names, const uint32_t dflt_idx, const VSchema *schema ) { uint32_t count; rc_t rc = KNamelistCount( names, &count ); if ( rc == 0 ) { uint32_t idx; for ( idx = 0; idx < count && rc == 0; ++idx ) { const char *name; rc = KNamelistGet( names, idx, &name ); if ( rc == 0 ) rc = matcher_append_type( name, ( idx == dflt_idx ), idx, schema, &(col->src_types) ); } } return rc; }
static rc_t KRepositoryMgrCategoryRepositories ( const KConfigNode *cat, KRepCategory category, KRepositoryVector *repositories ) { KNamelist *sub_names; rc_t rc = KConfigNodeListChildren ( cat, & sub_names ); if ( rc == 0 ) { uint32_t i, count; rc = KNamelistCount ( sub_names, & count ); for ( i = 0; i < count && rc == 0; ++ i ) { const char *sub_name; rc = KNamelistGet ( sub_names, i, & sub_name ); if ( rc == 0 ) { KRepSubCategory subcategory = krepBadSubCategory; if ( strcmp ( "main", sub_name ) == 0 ) subcategory = krepMainSubCategory; else if ( strcmp ( "aux", sub_name ) == 0 ) subcategory = krepAuxSubCategory; else if ( strcmp ( "protected", sub_name ) == 0 ) subcategory = krepProtectedSubCategory; if ( subcategory != krepBadSubCategory ) { const KConfigNode *sub; rc = KConfigNodeOpenNodeRead ( cat, & sub, sub_name ); if ( rc == 0 ) { rc = KRepositoryMgrSubCategoryRepositories ( sub, category, subcategory, repositories ); KConfigNodeRelease ( sub ); } } } } KNamelistRelease ( sub_names ); } return rc; }
bool nlt_is_name_in_namelist( const KNamelist *list, const char *name_to_find ) { uint32_t count, idx; bool res = false; if ( list == NULL || name_to_find == NULL ) return res; if ( KNamelistCount( list, &count ) == 0 ) { for ( idx = 0; idx < count && res == false; ++idx ) { const char *item_name; if ( KNamelistGet( list, idx, &item_name ) == 0 ) { if ( nlt_strcmp( item_name, name_to_find ) == 0 ) res = true; } } } return res; }
bool nlt_namelist_is_sub_set_in_full_set( const KNamelist * sub_set, const KNamelist * full_set ) { bool res = false; uint32_t count; rc_t rc = KNamelistCount( sub_set, &count ); if ( rc == 0 ) { uint32_t idx; uint32_t found = 0; for ( idx = 0; idx < count && rc == 0; ++idx ) { const char *s; rc = KNamelistGet( sub_set, idx, &s ); if ( rc == 0 && s != NULL && nlt_is_name_in_namelist( full_set, s ) ) found++; } res = ( rc == 0 && count == found ); } return res; }
static rc_t matcher_read_dst_types( matcher* self, const VTable *table, const VSchema *schema ) { rc_t rc = 0; uint32_t idx, len; if ( self == NULL ) return RC( rcExe, rcNoTarg, rcResolving, rcSelf, rcNull ); if ( table == NULL || schema == NULL ) return RC( rcExe, rcNoTarg, rcResolving, rcParam, rcNull ); len = VectorLength( &(self->mcols) ); for ( idx = 0; idx < len && rc == 0; ++idx ) { p_mcol item = (p_mcol) VectorGet ( &(self->mcols), idx ); if ( item != NULL ) { KNamelist *names; rc = VTableListWritableDatatypes ( (VTable*)table, item->name, &names ); if ( rc == 0 ) { uint32_t type_count; rc = KNamelistCount( names, &type_count ); if ( rc == 0 && type_count > 0 ) { uint32_t type_idx; item->to_copy = true; /* !!! this column has to be copied */ for ( type_idx = 0; type_idx < type_count && rc == 0; ++type_idx ) { const char *name; rc = KNamelistGet( names, type_idx, &name ); if ( rc == 0 ) rc = matcher_append_type( name, false, idx, schema, &(item->dst_types) ); } } KNamelistRelease( names ); } } } return rc; }
static rc_t redactable_types_2_type_id_vector( const VSchema * s, const char * redactable_types, Vector * id_vector ) { const KNamelist *r_types; rc_t rc; if ( redactable_types == NULL || s == NULL || id_vector == NULL ) return RC( rcExe, rcNoTarg, rcResolving, rcParam, rcNull ); rc = nlt_make_namelist_from_string( &r_types, redactable_types ); if ( rc == 0 ) { uint32_t count, idx; rc = KNamelistCount( r_types, &count ); if ( rc == 0 && count > 0 ) for ( idx = 0; idx < count && rc == 0; ++idx ) { const char *name; rc = KNamelistGet( r_types, idx, &name ); if ( rc == 0 ) { VTypedecl td; rc = VSchemaResolveTypedecl ( s, &td, "%s", name ); if ( rc == 0 ) { uint32_t *id = malloc( sizeof *id ); if ( id != NULL ) { *id = td.type_id; rc = VectorAppend ( id_vector, NULL, id ); } else rc = RC( rcExe, rcNoTarg, rcResolving, rcMemory, rcExhausted ); } } } KNamelistRelease( r_types ); } return rc; }
static rc_t copy_metadata_root ( const KMDataNode *src_root, KMDataNode *dst_root, const char * excluded_nodes, const bool show_meta ) { KNamelist *names; const KNamelist *excluded_names = NULL; uint32_t i, count; rc_t rc = KMDataNodeListChild ( src_root, & names ); DISP_RC( rc, "copy_metadata_root:KMDataNodeListChild() failed" ); if ( rc != 0 ) return rc; if ( excluded_nodes != NULL ) { rc = nlt_make_namelist_from_string( &excluded_names, excluded_nodes ); DISP_RC( rc, "copy_metadata_root:nlt_make_namelist_from_string() failed" ); if ( rc != 0 ) return rc; } rc = KNamelistCount ( names, & count ); for ( i = 0; rc == 0 && i < count; ++ i ) { const char *node_path; rc = KNamelistGet ( names, i, & node_path ); DISP_RC( rc, "copy_metadata_root:KNamelistGet() failed" ); if ( rc == 0 ) { bool is_excluded = false; if ( excluded_names != NULL ) is_excluded = nlt_is_name_in_namelist( excluded_names, node_path ); if ( !is_excluded ) rc = copy_metadata_child ( src_root, dst_root, node_path, show_meta ); } } if ( excluded_names != NULL ) KNamelistRelease( excluded_names ); KNamelistRelease ( names ); return rc; }