func (h *HitsIMP) Next(hit interface{}) bool { self := (*C.lucy_Hits)(clownfish.Unwrap(h, "h")) ivars := C.lucy_Hits_IVARS(self) matchDoc := (*C.lucy_MatchDoc)(unsafe.Pointer( C.CFISH_Vec_Fetch(ivars.match_docs, C.size_t(ivars.offset)))) ivars.offset += 1 if matchDoc == nil { // Bail if there aren't any more *captured* hits. (There may be // more total hits.) return false } else { // Lazily fetch HitDoc, set score. searcher := clownfish.WRAPAny(unsafe.Pointer(C.cfish_incref( unsafe.Pointer(ivars.searcher)))).(Searcher) docID := int32(C.LUCY_MatchDoc_Get_Doc_ID(matchDoc)) err := searcher.ReadDoc(docID, hit) if err != nil { h.err = err return false } if ss, ok := hit.(setScorer); ok { ss.SetScore(float32(C.LUCY_MatchDoc_Get_Score(matchDoc))) } return true } }
func (lock *LockIMP) Obtain() error { self := (*C.lucy_Lock)(clownfish.Unwrap(lock, "lock")) success := C.LUCY_Lock_Obtain(self) if !success { cfErr := C.cfish_Err_get_error() return clownfish.WRAPAny(unsafe.Pointer(C.cfish_incref(unsafe.Pointer(cfErr)))).(error) } return nil }
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 (fh *FileHandleIMP) ReleaseWindow(window FileWindow) error { self := (*C.lucy_FileHandle)(clownfish.Unwrap(fh, "fh")) windowC := (*C.lucy_FileWindow)(clownfish.Unwrap(window, "window")) success := C.LUCY_FH_Release_Window(self, windowC) if !success { cfErr := C.cfish_Err_get_error() return clownfish.WRAPAny(unsafe.Pointer(C.cfish_incref(unsafe.Pointer(cfErr)))).(error) } return nil }
func (fh *FileHandleIMP) Window(window FileWindow, offset, length int64) error { self := (*C.lucy_FileHandle)(clownfish.Unwrap(fh, "fh")) windowC := (*C.lucy_FileWindow)(clownfish.Unwrap(window, "window")) success := C.LUCY_FH_Window(self, windowC, C.int64_t(offset), C.int64_t(length)) if !success { cfErr := C.cfish_Err_get_error() return clownfish.WRAPAny(unsafe.Pointer(C.cfish_incref(unsafe.Pointer(cfErr)))).(error) } return nil }
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 (p *PolyAnalyzerIMP) GetAnalyzers() []Analyzer { self := (*C.lucy_PolyAnalyzer)(clownfish.Unwrap(p, "p")) retvalCF := C.LUCY_PolyAnalyzer_Get_Analyzers(self) size := C.CFISH_Vec_Get_Size(retvalCF) retval := make([]Analyzer, int(size)) for i := 0; i < int(size); i++ { child := unsafe.Pointer(C.CFISH_Vec_Fetch(retvalCF, C.size_t(i))) retval[i] = clownfish.WRAPAny(unsafe.Pointer(C.cfish_incref(child))).(Analyzer) } return retval }
func (d *DeletionsWriterIMP) segDeletions(segReader SegReader) (retval Matcher, err error) { err = clownfish.TrapErr(func() { self := (*C.lucy_DeletionsWriter)(clownfish.Unwrap(d, "d")) segReaderCF := (*C.lucy_SegReader)(clownfish.Unwrap(segReader, "segReader")) retvalCF := C.LUCY_DelWriter_Seg_Deletions(self, segReaderCF) if retvalCF != nil { retval = clownfish.WRAPAny(unsafe.Pointer(retvalCF)).(Matcher) } }) return retval, 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) 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 (f *FolderIMP) LocalOpenDir() (retval DirHandle, err error) { err = clownfish.TrapErr(func() { self := (*C.lucy_Folder)(clownfish.Unwrap(f, "f")) retvalC := C.LUCY_Folder_Local_Open_Dir(self) if retvalC == nil { cfErr := C.cfish_Err_get_error() panic(clownfish.WRAPAny(unsafe.Pointer(C.cfish_incref(unsafe.Pointer(cfErr)))).(error)) } retval = WRAPDirHandle(unsafe.Pointer(retvalC)) }) return retval, err }
func (q *QueryIMP) MakeCompiler(searcher Searcher, boost float32, subordinate bool) (retval Compiler, err error) { err = clownfish.TrapErr(func() { self := (*C.lucy_Query)(clownfish.Unwrap(q, "q")) searcherCF := (*C.lucy_Searcher)(clownfish.Unwrap(searcher, "searcher")) retvalCF := C.LUCY_Query_Make_Compiler(self, searcherCF, C.float(boost), C.bool(subordinate)) if retvalCF != nil { retval = clownfish.WRAPAny(unsafe.Pointer(retvalCF)).(Compiler) } }) return retval, err }
func OpenCompoundFileReader(folder Folder) (reader CompoundFileReader, err error) { err = clownfish.TrapErr(func() { folderC := (*C.lucy_Folder)(clownfish.Unwrap(folder, "Folder")) cfObj := C.lucy_CFReader_open(folderC) if cfObj == nil { cfErr := C.cfish_Err_get_error() panic(clownfish.WRAPAny(unsafe.Pointer(C.cfish_incref(unsafe.Pointer(cfErr)))).(error)) } reader = WRAPCompoundFileReader(unsafe.Pointer(cfObj)) }) return reader, 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 (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 (f *FolderIMP) OpenDir(path string) (retval DirHandle, 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_Open_Dir(self, pathC) if retvalC == nil { cfErr := C.cfish_Err_get_error() panic(clownfish.WRAPAny(unsafe.Pointer(C.cfish_incref(unsafe.Pointer(cfErr)))).(error)) } retval = WRAPDirHandle(unsafe.Pointer(retvalC)) }) return retval, err }
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 (f *FolderIMP) LocalOpenFileHandle(name string, flags uint32) (retval FileHandle, err error) { err = clownfish.TrapErr(func() { 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)) retvalC := C.LUCY_Folder_Local_Open_FileHandle(self, nameC, C.uint32_t(flags)) if retvalC == nil { cfErr := C.cfish_Err_get_error() panic(clownfish.WRAPAny(unsafe.Pointer(C.cfish_incref(unsafe.Pointer(cfErr)))).(error)) } retval = WRAPFileHandle(unsafe.Pointer(retvalC)) }) return retval, err }
func (c *CompilerIMP) MakeMatcher(reader SegReader, needScore bool) (retval Matcher, err error) { err = clownfish.TrapErr(func() { self := (*C.lucy_Compiler)(clownfish.Unwrap(c, "c")) readerCF := (*C.lucy_SegReader)(clownfish.Unwrap(reader, "reader")) retvalCF := C.LUCY_Compiler_Make_Matcher(self, readerCF, C.bool(needScore)) if retvalCF != nil { retval = clownfish.WRAPAny(unsafe.Pointer(retvalCF)).(Matcher) } }) if err != nil || retval == nil { return nil, err } return retval, err }
func (f *FolderIMP) ListR(path string) (retval []string, 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_List_R(self, pathC) if retvalC == nil { cfErr := C.cfish_Err_get_error() panic(clownfish.WRAPAny(unsafe.Pointer(C.cfish_incref(unsafe.Pointer(cfErr)))).(error)) } defer C.cfish_decref(unsafe.Pointer(retvalC)) retval = vecToStringSlice(retvalC) }) return retval, err }
// Read data into the supplied doc. func (s *SearcherIMP) ReadDoc(docID int32, doc interface{}) error { self := (*C.lucy_Searcher)(clownfish.Unwrap(s, "s")) class := C.cfish_Obj_get_class((*C.cfish_Obj)(unsafe.Pointer(self))) if class == C.LUCY_INDEXSEARCHER { ixReader := C.LUCY_IxSearcher_Get_Reader((*C.lucy_IndexSearcher)(unsafe.Pointer(self))) cfStr := (*C.cfish_String)(clownfish.GoToClownfish("Lucy::Index::DocReader", unsafe.Pointer(C.CFISH_STRING), false)) defer C.cfish_decref(unsafe.Pointer(cfStr)) docReader := C.LUCY_IxReader_Fetch(ixReader, cfStr) if docReader == nil { return clownfish.NewErr("No DocReader available") } docReaderGo := clownfish.WRAPAny(unsafe.Pointer(C.cfish_incref(unsafe.Pointer(docReader)))).(DocReader) return docReaderGo.ReadDoc(docID, doc) } else { return clownfish.NewErr("Support for ReadDoc not implemented") } }
func NewHeatMap(spans []Span, window uint32) HeatMap { spansCF := spanSliceToVec(spans) defer C.cfish_decref(unsafe.Pointer(spansCF)) retvalCF := C.lucy_HeatMap_new(spansCF, C.uint32_t(window)) return clownfish.WRAPAny(unsafe.Pointer(retvalCF)).(HeatMap) }
func createTestSuite() clownfish.TestSuite { ts := C.testlucy_Test_create_test_suite() return clownfish.WRAPAny(unsafe.Pointer(ts)).(clownfish.TestSuite) }