func goToBoolean(value interface{}, nullable bool) unsafe.Pointer { switch v := value.(type) { case bool: if v { return unsafe.Pointer(C.cfish_incref(unsafe.Pointer(C.CFISH_TRUE))) } else { return unsafe.Pointer(C.cfish_incref(unsafe.Pointer(C.CFISH_FALSE))) } case Obj: certifyCF(v, C.CFISH_BOOLEAN, nullable) return unsafe.Pointer(C.cfish_incref(unsafe.Pointer(v.TOPTR()))) } mess := fmt.Sprintf("Can't convert %T to clownfish.Boolean", value) panic(NewErr(mess)) }
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 goToHash(value interface{}, nullable bool) unsafe.Pointer { switch v := value.(type) { case map[string]interface{}: if v == nil { if nullable { return nil } } else { size := len(v) hash := C.cfish_Hash_new(C.size_t(size)) for key, val := range v { newVal := GoToClownfish(val, nil, true) keySize := len(key) keyStr := C.CString(key) cfKey := C.cfish_Str_new_steal_utf8(keyStr, C.size_t(keySize)) defer C.cfish_dec_refcount(unsafe.Pointer(cfKey)) C.CFISH_Hash_Store(hash, cfKey, (*C.cfish_Obj)(newVal)) } return unsafe.Pointer(hash) } case Obj: certifyCF(v, C.CFISH_HASH, nullable) return unsafe.Pointer(C.cfish_incref(unsafe.Pointer(v.TOPTR()))) } mess := fmt.Sprintf("Can't convert %T to clownfish.Hash", value) panic(NewErr(mess)) }
func ToGo(ptr unsafe.Pointer) interface{} { if ptr == nil { return nil } class := C.cfish_Obj_get_class((*C.cfish_Obj)(ptr)) if class == C.CFISH_STRING { return CFStringToGo(ptr) } else if class == C.CFISH_BLOB { return BlobToGo(ptr) } else if class == C.CFISH_VECTOR { return VectorToGo(ptr) } else if class == C.CFISH_HASH { return HashToGo(ptr) } else if class == C.CFISH_BOOLEAN { if ptr == unsafe.Pointer(C.CFISH_TRUE) { return true } else { return false } } else if class == C.CFISH_INTEGER { val := C.CFISH_Int_Get_Value((*C.cfish_Integer)(ptr)) return int64(val) } else if class == C.CFISH_FLOAT { val := C.CFISH_Float_Get_Value((*C.cfish_Float)(ptr)) return float64(val) } else { // Don't convert to a native Go type, but wrap in a Go struct. return WRAPAny(unsafe.Pointer(C.cfish_incref(unsafe.Pointer(ptr)))) } }
//export GOLUCY_Doc_Field_Names func GOLUCY_Doc_Field_Names(d *C.lucy_Doc) *C.cfish_Vector { fields := fetchDocFields(d) vec := clownfish.NewVector(len(fields)) for key, _ := range fields { vec.Push(key) } return (*C.cfish_Vector)(C.cfish_incref(clownfish.Unwrap(vec, "vec"))) }
//export GoCfish_TrapErr_internal func GoCfish_TrapErr_internal(routine C.CFISH_Err_Attempt_t, context unsafe.Pointer) *C.cfish_Err { err := TrapErr(func() { C.GoCfish_RunRoutine(routine, context) }) if err != nil { ptr := (err.(Err)).TOPTR() return ((*C.cfish_Err)(unsafe.Pointer(C.cfish_incref(unsafe.Pointer(ptr))))) } return nil }
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 (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 (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 (spec *SortSpecIMP) GetRules() []SortRule { self := (*C.lucy_SortSpec)(clownfish.Unwrap(spec, "spec")) vec := C.LUCY_SortSpec_Get_Rules(self) length := int(C.CFISH_Vec_Get_Size(vec)) slice := make([]SortRule, length) for i := 0; i < length; i++ { elem := C.cfish_incref(unsafe.Pointer(C.CFISH_Vec_Fetch(vec, C.size_t(i)))) slice[i] = WRAPSortRule(unsafe.Pointer(elem)) } return slice }
func (td *TopDocsIMP) GetMatchDocs() []MatchDoc { self := (*C.lucy_TopDocs)(clownfish.Unwrap(td, "td")) vec := C.LUCY_TopDocs_Get_Match_Docs(self) length := int(C.CFISH_Vec_Get_Size(vec)) slice := make([]MatchDoc, length) for i := 0; i < length; i++ { elem := C.cfish_incref(unsafe.Pointer(C.CFISH_Vec_Fetch(vec, C.size_t(i)))) slice[i] = WRAPMatchDoc(unsafe.Pointer(elem)) } return slice }
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 spanSliceToVec(slice []Span) *C.cfish_Vector { if slice == nil { return nil } length := len(slice) vec := C.cfish_Vec_new(C.size_t(length)) for i := 0; i < length; i++ { elem := clownfish.Unwrap(slice[i], "slice[i]") C.CFISH_Vec_Push(vec, C.cfish_incref(elem)) } return vec }
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 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 (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 (sc *SortCollectorIMP) PopMatchDocs() []MatchDoc { self := (*C.lucy_SortCollector)(clownfish.Unwrap(sc, "sc")) matchDocsC := C.LUCY_SortColl_Pop_Match_Docs(self) defer C.cfish_decref(unsafe.Pointer(matchDocsC)) length := int(C.CFISH_Vec_Get_Size(matchDocsC)) slice := make([]MatchDoc, length) for i := 0; i < length; i++ { elem := C.cfish_incref(unsafe.Pointer(C.CFISH_Vec_Fetch(matchDocsC, C.size_t(i)))) slice[i] = WRAPMatchDoc(unsafe.Pointer(elem)) } return slice }
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 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 (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 goToFloat(value interface{}, nullable bool) unsafe.Pointer { switch v := value.(type) { case float32: return unsafe.Pointer(C.cfish_Float_new(C.double(v))) case float64: return unsafe.Pointer(C.cfish_Float_new(C.double(v))) case Obj: certifyCF(v, C.CFISH_FLOAT, nullable) return unsafe.Pointer(C.cfish_incref(unsafe.Pointer(v.TOPTR()))) } mess := fmt.Sprintf("Can't convert %T to clownfish.Float", value) panic(NewErr(mess)) }
func goToString(value interface{}, nullable bool) unsafe.Pointer { switch v := value.(type) { case string: size := len(v) str := C.CString(v) return unsafe.Pointer(C.cfish_Str_new_steal_utf8(str, C.size_t(size))) case Obj: certifyCF(v, C.CFISH_STRING, nullable) return unsafe.Pointer(C.cfish_incref(unsafe.Pointer(v.TOPTR()))) } mess := fmt.Sprintf("Can't convert %T to clownfish.String", value) panic(NewErr(mess)) }
// Convert a Go type into an incremented Clownfish object. If the supplied // object is a Clownfish object wrapped in a Go struct, extract the Clownfish // object and incref it before returning its address. func GoToClownfish(value interface{}, class unsafe.Pointer, nullable bool) unsafe.Pointer { klass := (*C.cfish_Class)(class) // Default to accepting any type. if klass == nil { klass = C.CFISH_OBJ } // Convert the value according to its type if possible. switch v := value.(type) { case string: if klass == C.CFISH_STRING || klass == C.CFISH_OBJ { return goToString(value, nullable) } case []byte: if klass == C.CFISH_BLOB || klass == C.CFISH_OBJ { return goToBlob(value, nullable) } case int, uint, uintptr, int64, int32, int16, int8, uint64, uint32, uint16, uint8: if klass == C.CFISH_INTEGER || klass == C.CFISH_OBJ { return goToInteger(value, nullable) } case float32, float64: if klass == C.CFISH_FLOAT || klass == C.CFISH_OBJ { return goToFloat(value, nullable) } case bool: if klass == C.CFISH_BOOLEAN || klass == C.CFISH_OBJ { return goToBoolean(value, nullable) } case []interface{}: if klass == C.CFISH_VECTOR || klass == C.CFISH_OBJ { return goToVector(value, nullable) } case map[string]interface{}: if klass == C.CFISH_HASH || klass == C.CFISH_OBJ { return goToHash(value, nullable) } case Obj: certifyCF(value, klass, nullable) return unsafe.Pointer(C.cfish_incref(unsafe.Pointer(v.TOPTR()))) case nil: if nullable { return nil } } // Report a conversion error. className := StringToGo(unsafe.Pointer(C.CFISH_Class_Get_Name(klass))) panic(NewErr(fmt.Sprintf("Can't convert a %T to %s", value, className))) }
func (d *DataReaderIMP) GetSegments() []Segment { self := (*C.lucy_DataReader)(clownfish.Unwrap(d, "d")) retvalCF := C.LUCY_DataReader_Get_Segments(self) if retvalCF == nil { return nil } size := C.CFISH_Vec_Get_Size(retvalCF) retval := make([]Segment, int(size)) for i := 0; i < int(size); i++ { elem := unsafe.Pointer(C.CFISH_Vec_Fetch(retvalCF, C.size_t(i))) retval[i] = clownfish.ToGo(unsafe.Pointer(C.cfish_incref(elem))).(Segment) } return retval }
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 (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 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 (r *IndexReaderIMP) SegReaders() []SegReader { self := (*C.lucy_IndexReader)(clownfish.Unwrap(r, "r")) retvalCF := C.LUCY_IxReader_Seg_Readers(self) defer C.cfish_decref(unsafe.Pointer(retvalCF)) if retvalCF == nil { return nil } size := C.CFISH_Vec_Get_Size(retvalCF) retval := make([]SegReader, int(size)) for i := 0; i < int(size); i++ { elem := unsafe.Pointer(C.CFISH_Vec_Fetch(retvalCF, C.size_t(i))) retval[i] = clownfish.ToGo(unsafe.Pointer(C.cfish_incref(elem))).(SegReader) } return retval }