void trie(FILE *pool,FILE *check,FILE *result) { TRIE *head = trie_create(); char line[BUFFERSIZE]; int exitflag=0; int i; while(fgets(line,BUFFERSIZE,pool)) { /*delete the useless character '\r'*/ exitflag = trimString(line); if(!exitflag) { reverseString(line); trie_add(&head,line); } else { /*printf("Error email %s",line);*/ continue; } } while(fgets(line,BUFFERSIZE,check)) { i = 0; while(line[i]!='\r' && line[i]!='\n') i++; line[i] = '\0'; exitflag = trimString(line); if(!exitflag) { reverseString(line); if(trie_check(&head,line)) { fprintf(result,"yes\n"); } else { fprintf(result,"no\n"); } } } trie_destroy(&head); }
int Trie_init(Trie *self, PyObject *args, PyObject *kwds) { unsigned int order = 5; static char *kwlist[] = {"order", NULL}; self->__safe_for_unpickling__ = 1; if (! PyArg_ParseTupleAndKeywords(args, kwds, "|I", kwlist, &order)) { PyErr_Print(); return -1; } if (self == NULL) { return -1; } else { self->trie = trie_create(order); return 0; } }
void trie(FILE *pool,FILE *check,FILE *result) { clock_t start,end,start1; start = clock(); TRIE *head = trie_create(); char line[BUFFERSIZE]; int count=0; int i=0; int exitflag=0; while(fgets(line,BUFFERSIZE,pool)) { /*delete the useless character '\r'*/ exitflag = trimString(line); if(!exitflag){ reverseString(line); trie_add(&head,line); // if(!(++count%100000)){ // end = clock(); // printf("%d,%f \n",count++,(double)(end -start)/CLOCKS_PER_SEC); // } }else{ /*printf("Error email %s",line);*/ continue; } } //end = clock(); //printf("Creating tree using %f\n",(double)(end -start)/CLOCKS_PER_SEC); start1 = clock(); while(fgets(line,BUFFERSIZE,check)) { i = 0; while(line[i]!='\r' && line[i]!='\n') i++; line[i] = '\0'; exitflag = trimString(line); if(!exitflag){ reverseString(line); if(trie_check(&head,line)) { fprintf(result,"yes\n"); }else { fprintf(result,"no\n"); } } } trie_destroy(&head); end = clock(); printf("%f\n",(double)(end -start)/CLOCKS_PER_SEC); }
void trie_add(TRIE *head, char *str, void *object) { TRIE *trie = head; char *p = str; if(*str == '\0' || str == 0) return; while(1) { if(trie->nodes[(int)*p] == 0) { trie->nodes[(int)*p] = trie_create(); } trie = trie->nodes[(int)*p]; if(*(p+1) == '\0') break; p++; } trie->object = object; }
int main(int argc, char* argv[]) { int *a, *b, *c, *d; a = malloc(sizeof(int)); *a = 1; b = malloc(sizeof(int)); *b = 2; c = malloc(sizeof(int)); *c = 3; d = malloc(sizeof(int)); *d = 4; struct trie* test_trie = trie_create(); printf("created new trie at %p\n", test_trie); void* inserted = trie_insert(test_trie, "aa", a); printf("inserted %d at %p\n", *a, inserted); int *trie_value = trie_lookup(test_trie, "aa"); printf("lookup got %d\n", *trie_value); inserted = trie_insert(test_trie, "ab", b); printf("inserted %d at %p\n", *a, inserted); trie_value = trie_lookup(test_trie, "ab"); printf("lookup got %d\n", *trie_value); inserted = trie_insert(test_trie, "ccz", c); printf("inserted %d at %p\n", *a, inserted); trie_value = trie_lookup(test_trie, "ccz"); printf("lookup got %d\n", *trie_value); trie_value = trie_lookup_prefix(test_trie, "c", NULL); printf("prefix lookup got %d\n", *trie_value); trie_value = trie_lookup_prefix(test_trie, "a", d); printf("ambiguous prefix lookup got %d\n", *trie_value); trie_destroy(test_trie); printf("freed trie\n"); return 0; }
/* Gets node which might involve its creation. Sets *return to negative value * on error, to zero on successful insertion and to positive number if element * was already in the trie. */ static void get_or_create(trie_t trie, const char str[], void *data, int *result) { trie_t *link = ≜ while(1) { /* Create inexistent node. */ if(trie == NULL_TRIE) { trie = trie_create(); if(trie == NULL_TRIE) { *result = -1; break; } trie->value = *str; *link = trie; } if(trie->value == *str) { if(*str == '\0') { /* Found full match. */ *result = (trie->exists != 0); trie->exists = 1; trie->data = data; break; } link = &trie->children; ++str; } else { link = (*str < trie->value) ? &trie->left : &trie->right; } trie = *link; } }
int main() { trie_t t; trie_create(&t, sizeof(int)); char* nome = "yudi"; int i = 50; trie_add_element(&t, nome, strlen(nome), &i); nome = ""; i = -1; trie_add_element(&t, nome, strlen(nome), &i); nome = "barbara"; i = 100; trie_add_element(&t, nome, strlen(nome), &i); nome = "raul"; i = 10; trie_add_element(&t, nome, strlen(nome), &i); nome = "tutu"; i = 1; trie_add_element(&t, nome, strlen(nome), &i); nome = "boris"; i = 100000; trie_add_element(&t, nome, strlen(nome), &i); print_lexicography(&t); printf("remove: %s\n", nome); trie_remove_element(&t, nome, strlen(nome)); print_lexicography(&t); trie_destroy(&t); return 0; }
int intern_init(struct intern *pool) { pool->trie = trie_create(); return pool->trie == NULL ? -1 : 0; }
* documentation are those of the authors and should not be interpreted * as representing official policies, either expressed. */ #include "trie.h" #include "unit_test.h" void dealloc(void *val) { free(val); } TEST_START("trie.c") TEST(create_destroy) struct trie *root = trie_create(); trie_destroy(root, dealloc); TSET() TEST(simple_insert) char *key = "cat"; struct trie *trie = trie_create(); struct trie_iter *iter = trie_insert(trie, key, key); ASSERT_STR_EQUAL(trie_key(iter), key); ASSERT_STR_EQUAL(trie_value(iter), key); iter = trie_lookup(trie, key); ASSERT_STR_EQUAL(trie_key(iter), key); ASSERT_STR_EQUAL(trie_value(iter), key);
int compare_two_panes(CompareType ct, ListType lt, int group_paths, int skip_empty) { int next_id = 1; entries_t curr, other; trie_t *const trie = trie_create(); ui_cancellation_reset(); ui_cancellation_enable(); curr = make_diff_list(trie, curr_view, &next_id, ct, skip_empty, 0); other = make_diff_list(trie, other_view, &next_id, ct, skip_empty, lt == LT_DUPS); ui_cancellation_disable(); trie_free_with_data(trie, &free_compare_records); /* Clear progress message displayed by make_diff_list(). */ ui_sb_quick_msg_clear(); if(ui_cancellation_requested()) { free_dir_entries(curr_view, &curr.entries, &curr.nentries); free_dir_entries(other_view, &other.entries, &other.nentries); status_bar_message("Comparison has been cancelled"); return 1; } if(!group_paths || lt != LT_ALL) { /* Sort both lists according to unique file numbers to group identical files * (sorting is stable, tags are set in make_diff_list()). */ qsort(curr.entries, curr.nentries, sizeof(*curr.entries), &id_sorter); qsort(other.entries, other.nentries, sizeof(*other.entries), &id_sorter); } if(lt == LT_UNIQUE) { make_unique_lists(curr, other); return 0; } if(lt == LT_DUPS) { leave_only_dups(&curr, &other); } flist_custom_start(curr_view, lt == LT_ALL ? "diff" : "dups diff"); flist_custom_start(other_view, lt == LT_ALL ? "diff" : "dups diff"); fill_side_by_side(curr, other, group_paths); if(flist_custom_finish(curr_view, CV_DIFF, 0) != 0) { show_error_msg("Comparison", "No results to display"); return 0; } if(flist_custom_finish(other_view, CV_DIFF, 0) != 0) { assert(0 && "The error shouldn't be happening here."); } curr_view->list_pos = 0; other_view->list_pos = 0; curr_view->custom.diff_cmp_type = ct; other_view->custom.diff_cmp_type = ct; curr_view->custom.diff_path_group = group_paths; other_view->custom.diff_path_group = group_paths; assert(curr_view->list_rows == other_view->list_rows && "Diff views must be in sync!"); ui_view_schedule_redraw(curr_view); ui_view_schedule_redraw(other_view); return 0; }
int compare_one_pane(FileView *view, CompareType ct, ListType lt, int skip_empty) { int i, dup_id; FileView *other = (view == curr_view) ? other_view : curr_view; const char *const title = (lt == LT_ALL) ? "compare" : (lt == LT_DUPS) ? "dups" : "nondups"; int next_id = 1; entries_t curr; trie_t *trie = trie_create(); ui_cancellation_reset(); ui_cancellation_enable(); curr = make_diff_list(trie, view, &next_id, ct, skip_empty, 0); ui_cancellation_disable(); trie_free_with_data(trie, &free_compare_records); /* Clear progress message displayed by make_diff_list(). */ ui_sb_quick_msg_clear(); if(ui_cancellation_requested()) { free_dir_entries(view, &curr.entries, &curr.nentries); status_bar_message("Comparison has been cancelled"); return 1; } qsort(curr.entries, curr.nentries, sizeof(*curr.entries), &id_sorter); flist_custom_start(view, title); dup_id = -1; next_id = 0; for(i = 0; i < curr.nentries; ++i) { dir_entry_t *entry = &curr.entries[i]; if(lt == LT_ALL) { flist_custom_put(view, entry); continue; } if(entry->id == dup_id) { put_or_free(view, entry, next_id, lt == LT_DUPS); continue; } dup_id = (i < curr.nentries - 1 && entry[0].id == entry[1].id) ? entry->id : -1; if(entry->id == dup_id) { put_or_free(view, entry, ++next_id, lt == LT_DUPS); continue; } put_or_free(view, entry, next_id, lt == LT_UNIQUE); } /* Entries' data has been moved out of them or freed, so need to free only the * list. */ dynarray_free(curr.entries); if(flist_custom_finish(view, lt == LT_UNIQUE ? CV_REGULAR : CV_COMPARE, 0) != 0) { show_error_msg("Comparison", "No results to display"); return 0; } /* Leave the other pane, if it's in the CV_DIFF mode, two panes are needed for * this. */ if(other->custom.type == CV_DIFF) { cd_updir(other, 1); } view->list_pos = 0; ui_view_schedule_redraw(view); return 0; }
void addEventGroupFields(mxArray* mxTrial, mxArray* mxGroupMeta, const GroupInfo* pg, unsigned trialIdx, timestamp_t timeTrialStart, bool useGroupPrefix, unsigned groupMetaIndex) { // field names will be groupName_<eventName> // but the signal always comes in as .eventName and the contents are the name // of the event // // so: build up a trie where the eventName is the key and a TimestampBuffer is the value Trie* eventTrie = trie_create(); Trie* trieNode; // get timestamp buffer from group buffer const TimestampBuffer* groupTimestamps = pg->tsBuffers + trialIdx; const char* groupName = pg->name; // for now check that the event group has only 1 signal and it's type is EventName bool printError = false; if(pg->nSignals != 1) printError = true; else if(pg->signals[0]->type != SIGNAL_TYPE_EVENTNAME) printError = true; if(printError) { logError("Event groups must have 1 signal of type event name"); return; } const SignalDataBuffer*psdb = pg->signals[0]; const SampleBuffer* ptb = psdb->buffers + trialIdx; char eventName[MAX_SIGNAL_NAME]; char* dataPtr = (char*)ptb->data; for(unsigned iSample = 0; iSample < ptb->nSamples; iSample++) { // first copy string into buffer, then zero terminate it unsigned bytesThisSample = ptb->bytesEachSample[iSample]; // TODO add overflow detection memcpy(eventName, dataPtr, bytesThisSample); dataPtr += bytesThisSample; eventName[bytesThisSample] = '\0'; //logError("Event %s\n", eventName); // search for this eventName in the trie EventTrieInfo* info = (EventTrieInfo*)trie_lookup(eventTrie, eventName); if(info == NULL) { // doesn't exist, give it a TimestampBuffer info = (EventTrieInfo*)CALLOC(sizeof(EventTrieInfo), 1); strncpy(info->eventName, eventName, MAX_SIGNAL_NAME); trie_add(eventTrie, eventName, info); } // push this timestamp to the buffer bool success = pushTimestampToTimestampBuffer(&info->tsBuffer, groupTimestamps->timestamps[iSample]); if(!success) { logError("Issue building event fields\n"); return; } } // now iterate over the eventName trie and add each field unsigned nEventNames = trie_count(eventTrie); mxArray* mxSignalNames = mxCreateCellMatrix(nEventNames, 1); unsigned iEvent = 0; unsigned fieldNum = 0; trieNode = trie_get_first(eventTrie); char fieldName[MAX_SIGNAL_NAME]; while(trieNode != NULL) { EventTrieInfo* info = (EventTrieInfo*)trieNode->value; // build the groupName_eventName field name if(useGroupPrefix) snprintf(fieldName, MAX_SIGNAL_NAME, "%s_%s", groupName, info->eventName); else strncpy(fieldName, info->eventName, MAX_SIGNAL_NAME); // store the name of the field in the cell array mxSetCell(mxSignalNames, iEvent, mxCreateString(fieldName)); // copy timestamps from buffer to double vector mxArray* mxTimestamps = mxCreateNumericMatrix(info->tsBuffer.nSamples, 1, mxDOUBLE_CLASS, mxREAL); // subtract off trial start time and convert to ms, rounding at ms double_t* buffer = (double_t*)mxGetData(mxTimestamps); for(unsigned i = 0; i < info->tsBuffer.nSamples; i++) buffer[i] = round((info->tsBuffer.timestamps[i] - timeTrialStart)); // add event time list field to trial struct fieldNum = mxAddField(mxTrial, fieldName); mxSetFieldByNumber(mxTrial, 0, fieldNum, mxTimestamps); // get the next event in the trie trieNode = trie_get_next(trieNode); iEvent++; } // free the event Trie resources trie_flush(eventTrie, FREE); // add signal names to the meta array fieldNum = mxGetFieldNumber(mxGroupMeta, "signalNames"); if(fieldNum == -1) fieldNum = mxAddField(mxGroupMeta, "signalNames"); mxSetFieldByNumber(mxGroupMeta, groupMetaIndex, fieldNum, mxSignalNames); }