func (s *SortCacheIMP) Value(ord int32) (retval interface{}, err error) { err = clownfish.TrapErr(func() { self := (*C.lucy_SortCache)(clownfish.Unwrap(s, "s")) retvalCF := C.LUCY_SortCache_Value(self, C.int32_t(ord)) defer C.cfish_decref(unsafe.Pointer(retvalCF)) retval = clownfish.ToGo(unsafe.Pointer(retvalCF)) }) return retval, err }
//export GOLUCY_Doc_Deserialize func GOLUCY_Doc_Deserialize(d *C.lucy_Doc, instream *C.lucy_InStream) *C.lucy_Doc { ivars := C.lucy_Doc_IVARS(d) hash := unsafe.Pointer(C.lucy_Freezer_read_hash(instream)) defer C.cfish_decref(hash) fields := clownfish.ToGo(hash) fieldsID := registry.store(fields) ivars.fields = unsafe.Pointer(fieldsID) ivars.doc_id = C.int32_t(C.LUCY_InStream_Read_C32(instream)) return d }
func (im *IndexManagerIMP) MakeSnapshotFilename() (retval string, err error) { err = clownfish.TrapErr(func() { self := (*C.lucy_IndexManager)(clownfish.Unwrap(im, "im")) retvalC := C.LUCY_IxManager_Make_Snapshot_Filename(self) if retvalC != nil { defer C.cfish_decref(unsafe.Pointer(retvalC)) retval = clownfish.ToGo(unsafe.Pointer(retvalC)).(string) } }) return retval, err }
func (im *IndexManagerIMP) ReadMergeData() (retval map[string]interface{}, err error) { err = clownfish.TrapErr(func() { self := (*C.lucy_IndexManager)(clownfish.Unwrap(im, "im")) retvalC := C.LUCY_IxManager_Read_Merge_Data(self) if retvalC != nil { defer C.cfish_decref(unsafe.Pointer(retvalC)) retval = clownfish.ToGo(unsafe.Pointer(retvalC)).(map[string]interface{}) } }) 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 (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 vecToSpanSlice(v *C.cfish_Vector) []Span { if v == nil { return nil } length := int(C.CFISH_Vec_Get_Size(v)) slice := make([]Span, length) for i := 0; i < length; i++ { elem := C.CFISH_Vec_Fetch(v, C.size_t(i)) slice[i] = clownfish.ToGo(unsafe.Pointer(elem)).(Span) } return slice }
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 (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 (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 (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 }
func (d *DataReaderIMP) Aggregator(readers []DataReader, offsets []int32) (retval DataReader, err error) { err = clownfish.TrapErr(func() { self := (*C.lucy_DataReader)(clownfish.Unwrap(d, "d")) size := len(readers) readersC := C.cfish_Vec_new(C.size_t(size)) defer C.cfish_decref(unsafe.Pointer(readersC)) for i := 0; i < size; i++ { elemC := clownfish.Unwrap(readers[i], "readers[i]") C.CFISH_Vec_Push(readersC, C.cfish_incref(elemC)) } offs := NewI32Array(offsets) offsetsC := (*C.lucy_I32Array)(clownfish.Unwrap(offs, "offs")) retvalCF := C.LUCY_DataReader_Aggregator(self, readersC, offsetsC) defer C.cfish_decref(unsafe.Pointer(retvalCF)) if retvalCF != nil { retval = clownfish.ToGo(unsafe.Pointer(retvalCF)).(DataReader) } }) return retval, err }
//export GOLUCY_Doc_Store func GOLUCY_Doc_Store(d *C.lucy_Doc, field *C.cfish_String, value *C.cfish_Obj) { fields := fetchDocFields(d) fieldGo := clownfish.CFStringToGo(unsafe.Pointer(field)) valGo := clownfish.ToGo(unsafe.Pointer(value)) fields[fieldGo] = valGo }