func (d *DeletionsWriterIMP) DeleteByTerm(field string, term interface{}) error { return clownfish.TrapErr(func() { self := (*C.lucy_DeletionsWriter)(clownfish.Unwrap(d, "d")) fieldCF := (*C.cfish_String)(clownfish.GoToClownfish(field, unsafe.Pointer(C.CFISH_STRING), false)) defer C.cfish_decref(unsafe.Pointer(fieldCF)) termCF := (*C.cfish_Obj)(clownfish.GoToClownfish(term, unsafe.Pointer(C.CFISH_OBJ), false)) defer C.cfish_decref(unsafe.Pointer(termCF)) C.LUCY_DelWriter_Delete_By_Term(self, fieldCF, termCF) }) }
func (obj *IndexerIMP) DeleteByTerm(field string, term interface{}) error { return clownfish.TrapErr(func() { self := (*C.lucy_Indexer)(clownfish.Unwrap(obj, "obj")) fieldC := (*C.cfish_String)(clownfish.GoToClownfish(field, unsafe.Pointer(C.CFISH_STRING), false)) defer C.cfish_decref(unsafe.Pointer(fieldC)) termC := (*C.cfish_Obj)(clownfish.GoToClownfish(term, unsafe.Pointer(C.CFISH_OBJ), false)) defer C.cfish_decref(unsafe.Pointer(termC)) C.LUCY_Indexer_Delete_By_Term(self, fieldC, termC) }) }
func OpenSimple(index interface{}, language string) (s Simple, err error) { indexC := (*C.cfish_Obj)(clownfish.GoToClownfish(index, unsafe.Pointer(C.CFISH_OBJ), false)) defer C.cfish_decref(unsafe.Pointer(indexC)) languageC := (*C.cfish_String)(clownfish.GoToClownfish(language, unsafe.Pointer(C.CFISH_STRING), false)) defer C.cfish_decref(unsafe.Pointer(languageC)) err = clownfish.TrapErr(func() { cfObj := C.lucy_Simple_new(indexC, languageC) s = WRAPSimple(unsafe.Pointer(cfObj)) }) return s, err }
func (lr *LexiconReaderIMP) DocFreq(field string, term interface{}) (retval uint32, err error) { err = clownfish.TrapErr(func() { self := (*C.lucy_LexiconReader)(clownfish.Unwrap(lr, "lr")) fieldC := (*C.cfish_String)(clownfish.GoToClownfish(field, unsafe.Pointer(C.CFISH_STRING), false)) defer C.cfish_decref(unsafe.Pointer(fieldC)) termC := (*C.cfish_Obj)(clownfish.GoToClownfish(term, unsafe.Pointer(C.CFISH_OBJ), true)) defer C.cfish_decref(unsafe.Pointer(termC)) retval = uint32(C.LUCY_LexReader_Doc_Freq(self, fieldC, termC)) }) return retval, err }
func (f *FolderIMP) HardLink(from, to string) error { self := (*C.lucy_Folder)(clownfish.Unwrap(f, "f")) fromC := (*C.cfish_String)(clownfish.GoToClownfish(from, unsafe.Pointer(C.CFISH_STRING), false)) toC := (*C.cfish_String)(clownfish.GoToClownfish(to, unsafe.Pointer(C.CFISH_STRING), false)) defer C.cfish_decref(unsafe.Pointer(fromC)) defer C.cfish_decref(unsafe.Pointer(toC)) success := C.LUCY_Folder_Hard_Link(self, fromC, toC) if !success { cfErr := C.cfish_Err_get_error() return clownfish.WRAPAny(unsafe.Pointer(C.cfish_incref(unsafe.Pointer(cfErr)))).(error) } return nil }
func NewTermVector(field, text string, positions, startOffsets, endOffsets []int32) TermVector { fieldC := (*C.cfish_String)(clownfish.GoToClownfish(field, unsafe.Pointer(C.CFISH_STRING), false)) textC := (*C.cfish_String)(clownfish.GoToClownfish(text, unsafe.Pointer(C.CFISH_STRING), false)) defer C.cfish_decref(unsafe.Pointer(fieldC)) defer C.cfish_decref(unsafe.Pointer(textC)) posits := NewI32Array(positions) starts := NewI32Array(startOffsets) ends := NewI32Array(endOffsets) positsC := (*C.lucy_I32Array)(clownfish.Unwrap(posits, "posits")) startsC := (*C.lucy_I32Array)(clownfish.Unwrap(starts, "starts")) endsC := (*C.lucy_I32Array)(clownfish.Unwrap(ends, "ends")) retvalC := C.lucy_TV_new(fieldC, textC, positsC, startsC, endsC) return WRAPTermVector(unsafe.Pointer(retvalC)) }
func OpenRAMFileHandle(path string, flags uint32, ramFile RAMFile) (fh RAMFileHandle, err error) { err = clownfish.TrapErr(func() { pathC := (*C.cfish_String)(clownfish.GoToClownfish(path, unsafe.Pointer(C.CFISH_STRING), false)) ramFileC := (*C.lucy_RAMFile)(clownfish.GoToClownfish(ramFile, unsafe.Pointer(C.LUCY_RAMFILE), true)) defer C.cfish_decref(unsafe.Pointer(pathC)) cfObj := C.lucy_RAMFH_open(pathC, C.uint32_t(flags), ramFileC) if cfObj == nil { cfErr := C.cfish_Err_get_error() panic(clownfish.WRAPAny(unsafe.Pointer(C.cfish_incref(unsafe.Pointer(cfErr)))).(error)) } fh = WRAPRAMFileHandle(unsafe.Pointer(cfObj)) }) return fh, err }
func (lr *LexiconReaderIMP) fetchTermInfo(field string, term interface{}) (retval TermInfo, err error) { err = clownfish.TrapErr(func() { self := (*C.lucy_LexiconReader)(clownfish.Unwrap(lr, "lr")) fieldC := (*C.cfish_String)(clownfish.GoToClownfish(field, unsafe.Pointer(C.CFISH_STRING), false)) defer C.cfish_decref(unsafe.Pointer(fieldC)) termC := (*C.cfish_Obj)(clownfish.GoToClownfish(term, unsafe.Pointer(C.CFISH_OBJ), true)) defer C.cfish_decref(unsafe.Pointer(termC)) retvalCF := C.LUCY_LexReader_Fetch_Term_Info(self, fieldC, termC) if retvalCF != nil { retval = clownfish.ToGo(unsafe.Pointer(retvalCF)).(TermInfo) } }) return retval, err }
func (p *PostingListReaderIMP) PostingList(field string, term interface{}) (retval PostingList, err error) { err = clownfish.TrapErr(func() { self := (*C.lucy_PostingListReader)(clownfish.Unwrap(p, "p")) fieldC := (*C.cfish_String)(clownfish.GoToClownfish(field, unsafe.Pointer(C.CFISH_STRING), false)) defer C.cfish_decref(unsafe.Pointer(fieldC)) termC := (*C.cfish_Obj)(clownfish.GoToClownfish(term, unsafe.Pointer(C.CFISH_OBJ), true)) defer C.cfish_decref(unsafe.Pointer(termC)) retvalCF := C.LUCY_PListReader_Posting_List(self, fieldC, termC) if retvalCF != nil { retval = clownfish.ToGo(unsafe.Pointer(retvalCF)).(PostingList) } }) return retval, err }
func fetchEntry(ivars *C.lucy_InverterIVARS, fieldGo string) *C.lucy_InverterEntry { field := (*C.cfish_String)(clownfish.GoToClownfish(fieldGo, unsafe.Pointer(C.CFISH_STRING), false)) defer C.cfish_decref(unsafe.Pointer(field)) schema := ivars.schema fieldNum := C.LUCY_Seg_Field_Num(ivars.segment, field) if fieldNum == 0 { // This field seems not to be in the segment yet. Try to find it in // the Schema. if C.LUCY_Schema_Fetch_Type(schema, field) != nil { // The field is in the Schema. Get a field num from the Segment. fieldNum = C.LUCY_Seg_Add_Field(ivars.segment, field) } else { // We've truly failed to find the field. The user must // not have spec'd it. fieldGo := clownfish.CFStringToGo(unsafe.Pointer(field)) err := clownfish.NewErr("Unknown field name: '" + fieldGo + "'") panic(err) } } entry := C.CFISH_Vec_Fetch(ivars.entry_pool, C.size_t(fieldNum)) if entry == nil { newEntry := C.lucy_InvEntry_new(schema, field, fieldNum) C.CFISH_Vec_Store(ivars.entry_pool, C.size_t(fieldNum), (*C.cfish_Obj)(unsafe.Pointer(entry))) return newEntry } return (*C.lucy_InverterEntry)(unsafe.Pointer(entry)) }
func (a *AnalyzerIMP) Split(text string) []string { self := (*C.lucy_Analyzer)(clownfish.Unwrap(a, "a")) input := (*C.cfish_String)(clownfish.GoToClownfish(text, unsafe.Pointer(C.CFISH_STRING), false)) defer C.cfish_decref(unsafe.Pointer(input)) retvalCF := C.LUCY_Analyzer_Split(self, input) defer C.cfish_decref(unsafe.Pointer(retvalCF)) return vecToStringSlice(retvalCF) }
func (f *FolderIMP) Consolidate(path string) error { return clownfish.TrapErr(func() { self := (*C.lucy_Folder)(clownfish.Unwrap(f, "f")) pathC := (*C.cfish_String)(clownfish.GoToClownfish(path, unsafe.Pointer(C.CFISH_STRING), false)) defer C.cfish_decref(unsafe.Pointer(pathC)) C.LUCY_Folder_Consolidate(self, pathC) }) }
func (obj *IndexerIMP) AddIndex(index interface{}) error { return clownfish.TrapErr(func() { self := (*C.lucy_Indexer)(clownfish.Unwrap(obj, "obj")) indexC := (*C.cfish_Obj)(clownfish.GoToClownfish(index, unsafe.Pointer(C.CFISH_OBJ), false)) defer C.cfish_decref(unsafe.Pointer(indexC)) C.LUCY_Indexer_Add_Index(self, indexC) }) }
//export GOLUCY_Doc_Serialize func GOLUCY_Doc_Serialize(d *C.lucy_Doc, outstream *C.lucy_OutStream) { ivars := C.lucy_Doc_IVARS(d) fields := fetchDocFields(d) hash := clownfish.GoToClownfish(fields, unsafe.Pointer(C.CFISH_HASH), false) defer C.cfish_decref(hash) C.lucy_Freezer_serialize_hash((*C.cfish_Hash)(hash), outstream) C.LUCY_OutStream_Write_C32(outstream, C.uint32_t(ivars.doc_id)) }
func (s *StepperIMP) WriteDelta(outstream OutStream, value interface{}) error { return clownfish.TrapErr(func() { self := (*C.lucy_Stepper)(clownfish.Unwrap(s, "s")) outstreamCF := (*C.lucy_OutStream)(clownfish.Unwrap(outstream, "outstream")) valueCF := (*C.cfish_Obj)(clownfish.GoToClownfish(value, unsafe.Pointer(C.CFISH_OBJ), false)) defer C.cfish_decref(unsafe.Pointer(valueCF)) C.LUCY_Stepper_Write_Delta(self, outstreamCF, valueCF) }) }
func doNewQueryParser(schema Schema, defaultBoolop string, fields []string) QueryParser { schemaCF := (*C.lucy_Schema)(clownfish.Unwrap(schema, "schema")) defaultBoolopCF := (*C.cfish_String)(clownfish.GoToClownfish(defaultBoolop, unsafe.Pointer(C.CFISH_STRING), true)) defer C.cfish_decref(unsafe.Pointer(defaultBoolopCF)) fieldsCF := stringSliceToVec(fields) defer C.cfish_decref(unsafe.Pointer(fieldsCF)) retvalCF := C.lucy_QParser_new(schemaCF, nil, defaultBoolopCF, fieldsCF) return clownfish.WRAPAny(unsafe.Pointer(retvalCF)).(QueryParser) }
func OpenIndexSearcher(index interface{}) (obj IndexSearcher, err error) { indexC := (*C.cfish_Obj)(clownfish.GoToClownfish(index, unsafe.Pointer(C.CFISH_OBJ), false)) defer C.cfish_decref(unsafe.Pointer(indexC)) err = clownfish.TrapErr(func() { cfObj := C.lucy_IxSearcher_new(indexC) obj = WRAPIndexSearcher(unsafe.Pointer(cfObj)) }) return obj, err }
func (s *SnapshotIMP) WriteFile(folder Folder, path string) error { return clownfish.TrapErr(func() { self := (*C.lucy_Snapshot)(clownfish.Unwrap(s, "s")) folderC := (*C.lucy_Folder)(clownfish.Unwrap(folder, "folder")) pathC := (*C.cfish_String)(clownfish.GoToClownfish(path, unsafe.Pointer(C.CFISH_STRING), false)) defer C.cfish_decref(unsafe.Pointer(pathC)) C.LUCY_Snapshot_Write_File(self, folderC, pathC) }) }
func (s *SimpleIMP) Search(query string, offset, numWanted int) (totalHits int, err error) { err = clownfish.TrapErr(func() { self := (*C.lucy_Simple)(clownfish.Unwrap(s, "s")) qStringC := (*C.cfish_String)(clownfish.GoToClownfish(query, unsafe.Pointer(C.CFISH_STRING), false)) defer C.cfish_decref(unsafe.Pointer(qStringC)) totalHits = int(C.LUCY_Simple_Search(self, qStringC, C.uint32_t(offset), C.uint32_t(numWanted))) }) return totalHits, err }
func (s *SortCacheIMP) Find(term interface{}) (retval int32, err error) { err = clownfish.TrapErr(func() { self := (*C.lucy_SortCache)(clownfish.Unwrap(s, "s")) termCF := (*C.cfish_Obj)(clownfish.GoToClownfish(term, unsafe.Pointer(C.CFISH_OBJ), true)) defer C.cfish_decref(unsafe.Pointer(termCF)) retvalCF := C.LUCY_SortCache_Find(self, termCF) retval = int32(retvalCF) }) return retval, err }
func (r *IndexReaderIMP) Obtain(api string) (retval DataReader, err error) { err = clownfish.TrapErr(func() { self := (*C.lucy_IndexReader)(clownfish.Unwrap(r, "r")) apiC := (*C.cfish_String)(clownfish.GoToClownfish(api, unsafe.Pointer(C.CFISH_STRING), false)) defer C.cfish_decref(unsafe.Pointer(apiC)) retvalCF := C.LUCY_IxReader_Obtain(self, apiC) retval = clownfish.WRAPAny(unsafe.Pointer(C.cfish_incref(unsafe.Pointer(retvalCF)))).(DataReader) }) return retval, err }
func OpenBackgroundMerger(index interface{}, manager IndexManager) (bgm BackgroundMerger, err error) { err = clownfish.TrapErr(func() { indexC := (*C.cfish_Obj)(clownfish.GoToClownfish(index, unsafe.Pointer(C.CFISH_OBJ), false)) defer C.cfish_decref(unsafe.Pointer(indexC)) managerC := (*C.lucy_IndexManager)(clownfish.UnwrapNullable(manager)) cfObj := C.lucy_BGMerger_new(indexC, managerC) bgm = WRAPBackgroundMerger(unsafe.Pointer(cfObj)) }) return bgm, err }
func OpenIndexReader(index interface{}, snapshot Snapshot, manager IndexManager) (retval IndexReader, err error) { err = clownfish.TrapErr(func() { indexC := (*C.cfish_Obj)(clownfish.GoToClownfish(index, unsafe.Pointer(C.CFISH_OBJ), false)) defer C.cfish_decref(unsafe.Pointer(indexC)) snapshotC := (*C.lucy_Snapshot)(clownfish.UnwrapNullable(snapshot)) managerC := (*C.lucy_IndexManager)(clownfish.UnwrapNullable(manager)) cfObj := C.lucy_IxReader_open(indexC, snapshotC, managerC) retval = clownfish.WRAPAny(unsafe.Pointer(cfObj)).(IndexReader) }) return retval, err }
func (f *FolderIMP) SlurpFile(path string) (retval []byte, err error) { err = clownfish.TrapErr(func() { self := (*C.lucy_Folder)(clownfish.Unwrap(f, "f")) pathC := (*C.cfish_String)(clownfish.GoToClownfish(path, unsafe.Pointer(C.CFISH_STRING), false)) defer C.cfish_decref(unsafe.Pointer(pathC)) retvalC := C.LUCY_Folder_Slurp_File(self, pathC) defer C.cfish_decref(unsafe.Pointer(retvalC)) retval = clownfish.ToGo(unsafe.Pointer(retvalC)).([]byte) }) return retval, err }
func (f *FolderIMP) LocalMkDir(name string) error { self := (*C.lucy_Folder)(clownfish.Unwrap(f, "f")) nameC := (*C.cfish_String)(clownfish.GoToClownfish(name, unsafe.Pointer(C.CFISH_STRING), false)) defer C.cfish_decref(unsafe.Pointer(nameC)) success := C.LUCY_Folder_Local_MkDir(self, nameC) if !success { cfErr := C.cfish_Err_get_error() return clownfish.WRAPAny(unsafe.Pointer(C.cfish_incref(unsafe.Pointer(cfErr)))).(error) } return nil }
func (s *SortReaderIMP) fetchSortCache(field string) (retval SortCache, err error) { err = clownfish.TrapErr(func() { self := (*C.lucy_SortReader)(clownfish.Unwrap(s, "s")) fieldC := (*C.cfish_String)(clownfish.GoToClownfish(field, unsafe.Pointer(C.CFISH_STRING), false)) defer C.cfish_decref(unsafe.Pointer(fieldC)) retvalCF := C.LUCY_SortReader_Fetch_Sort_Cache(self, fieldC) if retvalCF != nil { retval = clownfish.ToGo(unsafe.Pointer(C.cfish_incref(unsafe.Pointer(retvalCF)))).(SortCache) } }) return retval, err }
func (in *InStreamIMP) Reopen(fileName string, offset int64, length int64) (InStream, error) { var retval InStream err := clownfish.TrapErr(func() { self := (*C.lucy_InStream)(clownfish.Unwrap(in, "in")) fileNameCF := (*C.cfish_String)(clownfish.GoToClownfish(fileName, unsafe.Pointer(C.CFISH_STRING), true)) defer C.cfish_decref(unsafe.Pointer(fileNameCF)) retvalCF := C.LUCY_InStream_Reopen(self, fileNameCF, C.int64_t(offset), C.int64_t(length)) retval = WRAPInStream(unsafe.Pointer(retvalCF)) }) return retval, err }
func OpenOutStream(file interface{}) (out OutStream, err error) { err = clownfish.TrapErr(func() { fileC := (*C.cfish_Obj)(clownfish.GoToClownfish(file, unsafe.Pointer(C.CFISH_OBJ), false)) defer C.cfish_decref(unsafe.Pointer(fileC)) cfObj := C.lucy_OutStream_open(fileC) if cfObj == nil { cfErr := C.cfish_Err_get_error() panic(clownfish.WRAPAny(unsafe.Pointer(C.cfish_incref(unsafe.Pointer(cfErr)))).(error)) } out = WRAPOutStream(unsafe.Pointer(cfObj)) }) return out, err }
func OpenFSDirHandle(path string) (dh FSDirHandle, err error) { err = clownfish.TrapErr(func() { pathC := (*C.cfish_String)(clownfish.GoToClownfish(path, unsafe.Pointer(C.CFISH_STRING), false)) defer C.cfish_decref(unsafe.Pointer(pathC)) cfObj := C.lucy_FSDH_open(pathC) if cfObj == nil { cfErr := C.cfish_Err_get_error() panic(clownfish.WRAPAny(unsafe.Pointer(C.cfish_incref(unsafe.Pointer(cfErr)))).(error)) } dh = WRAPFSDirHandle(unsafe.Pointer(cfObj)) }) return dh, err }
func (s *SearcherIMP) Hits(query interface{}, offset uint32, numWanted uint32, sortSpec SortSpec) (hits Hits, err error) { self := (*C.lucy_Searcher)(clownfish.Unwrap(s, "s")) sortSpecC := (*C.lucy_SortSpec)(clownfish.UnwrapNullable(sortSpec)) queryC := (*C.cfish_Obj)(clownfish.GoToClownfish(query, unsafe.Pointer(C.CFISH_OBJ), false)) defer C.cfish_decref(unsafe.Pointer(queryC)) err = clownfish.TrapErr(func() { hitsC := C.LUCY_Searcher_Hits(self, queryC, C.uint32_t(offset), C.uint32_t(numWanted), sortSpecC) hits = WRAPHits(unsafe.Pointer(hitsC)) }) return hits, err }