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 (h *HeatMapIMP) generateProximityBoosts(spans []Span) []Span {
self := (*C.lucy_HeatMap)(clownfish.Unwrap(h, "h"))
spansCF := spanSliceToVec(spans)
defer C.cfish_decref(unsafe.Pointer(spansCF))
retvalCF := C.LUCY_HeatMap_Generate_Proximity_Boosts(self, spansCF)
defer C.cfish_decref(unsafe.Pointer(retvalCF))
return vecToSpanSlice(retvalCF)
}
func (h *HeatMapIMP) flattenSpans(spans []Span) []Span {
self := (*C.lucy_HeatMap)(clownfish.Unwrap(h, "h"))
spansCF := spanSliceToVec(spans)
defer C.cfish_decref(unsafe.Pointer(spansCF))
retvalCF := C.LUCY_HeatMap_Flatten_Spans(self, spansCF)
defer C.cfish_decref(unsafe.Pointer(retvalCF))
return vecToSpanSlice(retvalCF)
}
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 (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 (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 (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 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 (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) 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 (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 (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
}
func NewMethod(name string, callbackFunc unsafe.Pointer, offset uint32) Method {
nameCF := (*C.cfish_String)(goToString(name, false))
defer C.cfish_decref(unsafe.Pointer(nameCF))
methCF := C.cfish_Method_new(nameCF, C.cfish_method_t(callbackFunc),
C.uint32_t(offset))
return WRAPMethod(unsafe.Pointer(methCF))
}
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))
}
//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 (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)
})
}
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 (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 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 *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
}
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 *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)
})
}
//export GOLUCY_Inverter_Invert_Doc
func GOLUCY_Inverter_Invert_Doc(inverter *C.lucy_Inverter, doc *C.lucy_Doc) {
ivars := C.lucy_Inverter_IVARS(inverter)
fields := (*C.cfish_Hash)(C.LUCY_Doc_Get_Fields(doc))
// Prepare for the new doc.
C.LUCY_Inverter_Set_Doc(inverter, doc)
// Extract and invert the doc's fields.
iter := C.cfish_HashIter_new(fields)
for C.CFISH_HashIter_Next(iter) {
field := C.CFISH_HashIter_Get_Key(iter)
obj := C.CFISH_HashIter_Get_Value(iter)
if obj == nil {
mess := "Invalid nil value for field" + clownfish.CFStringToGo(unsafe.Pointer(field))
panic(clownfish.NewErr(mess))
}
inventry := fetchEntry(ivars, field)
inventryIvars := C.lucy_InvEntry_IVARS(inventry)
fieldType := inventryIvars._type
// Get the field value.
var expectedType *C.cfish_Class
switch C.LUCY_FType_Primitive_ID(fieldType) & C.lucy_FType_PRIMITIVE_ID_MASK {
case C.lucy_FType_TEXT:
expectedType = C.CFISH_STRING
case C.lucy_FType_BLOB:
expectedType = C.CFISH_BLOB
case C.lucy_FType_INT32:
expectedType = C.CFISH_INTEGER
case C.lucy_FType_INT64:
expectedType = C.CFISH_INTEGER
case C.lucy_FType_FLOAT32:
expectedType = C.CFISH_FLOAT
case C.lucy_FType_FLOAT64:
expectedType = C.CFISH_FLOAT
default:
panic(clownfish.NewErr("Internal Lucy error: bad type id for field " +
clownfish.CFStringToGo(unsafe.Pointer(field))))
}
if !C.cfish_Obj_is_a(obj, expectedType) {
className := C.cfish_Obj_get_class_name((*C.cfish_Obj)(unsafe.Pointer(fieldType)))
mess := fmt.Sprintf("Invalid type for field '%s': '%s'",
clownfish.CFStringToGo(unsafe.Pointer(field)),
clownfish.CFStringToGo(unsafe.Pointer(className)))
panic(clownfish.NewErr(mess))
}
if inventryIvars.value != obj {
C.cfish_decref(unsafe.Pointer(inventryIvars.value))
inventryIvars.value = C.cfish_inc_refcount(unsafe.Pointer(obj))
}
C.LUCY_Inverter_Add_Field(inverter, inventry)
}
C.cfish_dec_refcount(unsafe.Pointer(iter))
}
func (d *DeletionsWriterIMP) generateDocMap(deletions Matcher, docMax int32, offset int32) (retval []int32, err error) {
err = clownfish.TrapErr(func() {
self := (*C.lucy_DeletionsWriter)(clownfish.Unwrap(d, "d"))
deletionsCF := (*C.lucy_Matcher)(clownfish.Unwrap(deletions, "deletions"))
retvalCF := C.LUCY_DelWriter_Generate_Doc_Map(self, deletionsCF, C.int32_t(docMax), C.int32_t(offset))
defer C.cfish_decref(unsafe.Pointer(retvalCF))
retval = i32ArrayToSlice(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 (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 (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 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
}