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)
}
