func (c *ClassIMP) GetMethods() []Method {
self := (*C.cfish_Class)(Unwrap(c, "c"))
methsVec := C.CFISH_Class_Get_Methods(self)
size := C.CFISH_Vec_Get_Size(methsVec)
meths := make([]Method, 0, int(size))
for i := C.size_t(0); i < size; i++ {
meths = append(meths, WRAPMethod(unsafe.Pointer(C.CFISH_Vec_Fetch(methsVec, i))))
}
C.cfish_decref(unsafe.Pointer(methsVec))
return meths
}
// Turn a Vector of Clownfish Strings into a slice of Go string. NULL
// elements in the Vector are not allowed.
func vecToStringSlice(v *C.cfish_Vector) []string {
if v == nil {
return nil
}
length := int(C.CFISH_Vec_Get_Size(v))
slice := make([]string, length)
for i := 0; i < length; i++ {
slice[i] = clownfish.CFStringToGo(unsafe.Pointer(C.CFISH_Vec_Fetch(v, C.size_t(i))))
}
return slice
}
func (h *HashIMP) Keys() []string {
self := (*C.cfish_Hash)(Unwrap(h, "h"))
keysCF := C.CFISH_Hash_Keys(self)
numKeys := C.CFISH_Vec_Get_Size(keysCF)
keys := make([]string, 0, int(numKeys))
for i := C.size_t(0); i < numKeys; i++ {
keys = append(keys, CFStringToGo(unsafe.Pointer(C.CFISH_Vec_Fetch(keysCF, i))))
}
C.cfish_decref(unsafe.Pointer(keysCF))
return keys
}
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 (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 (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 (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 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 (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 (im *IndexManagerIMP) Recycle(reader PolyReader, delWriter DeletionsWriter,
cutoff int64, optimize bool) (retval []SegReader, err error) {
err = clownfish.TrapErr(func() {
self := (*C.lucy_IndexManager)(clownfish.Unwrap(im, "im"))
readerC := (*C.lucy_PolyReader)(clownfish.Unwrap(reader, "reader"))
delWriterC := (*C.lucy_DeletionsWriter)(clownfish.Unwrap(delWriter, "delWriter"))
vec := C.LUCY_IxManager_Recycle(self, readerC, delWriterC,
C.int64_t(cutoff), C.bool(optimize))
if vec != nil {
defer C.cfish_decref(unsafe.Pointer(vec))
size := int(C.CFISH_Vec_Get_Size(vec))
retval = make([]SegReader, size)
for i := 0; i < size; i++ {
elem := C.CFISH_Vec_Fetch(vec, C.size_t(i))
retval[i] = WRAPSegReader(unsafe.Pointer(C.cfish_incref(unsafe.Pointer(elem))))
}
}
})
return retval, err
}
func VectorToGo(ptr unsafe.Pointer) []interface{} {
vec := (*C.cfish_Vector)(ptr)
if vec == nil {
return nil
}
class := C.cfish_Obj_get_class((*C.cfish_Obj)(ptr))
if class != C.CFISH_VECTOR {
mess := "Not a Vector: " + StringToGo(unsafe.Pointer(C.CFISH_Class_Get_Name(class)))
panic(NewErr(mess))
}
size := C.CFISH_Vec_Get_Size(vec)
if size > C.size_t(maxInt) {
panic(fmt.Sprintf("Overflow: %d > %d", size, maxInt))
}
slice := make([]interface{}, int(size))
for i := 0; i < int(size); i++ {
slice[i] = ToGo(unsafe.Pointer(C.CFISH_Vec_Fetch(vec, C.size_t(i))))
}
return slice
}
func (obj *IndexerIMP) findFieldC(name string) *C.cfish_String {
self := ((*C.lucy_Indexer)(unsafe.Pointer(obj.TOPTR())))
if obj.fieldNames == nil {
obj.fieldNames = make(map[string]clownfish.String)
}
f, ok := obj.fieldNames[name]
if !ok {
schema := C.LUCY_Indexer_Get_Schema(self)
fieldList := C.LUCY_Schema_All_Fields(schema)
defer C.cfish_dec_refcount(unsafe.Pointer(fieldList))
for i := 0; i < int(C.CFISH_Vec_Get_Size(fieldList)); i++ {
cfString := unsafe.Pointer(C.CFISH_Vec_Fetch(fieldList, C.size_t(i)))
field := clownfish.CFStringToGo(cfString)
if strings.EqualFold(name, field) {
C.cfish_inc_refcount(cfString)
f = clownfish.WRAPString(cfString)
obj.fieldNames[name] = f
}
}
}
return (*C.cfish_String)(unsafe.Pointer(f.TOPTR()))
}
func (obj *IndexerIMP) findRealField(name string) (string, error) {
self := ((*C.lucy_Indexer)(unsafe.Pointer(obj.TOPTR())))
if obj.fieldNames == nil {
obj.fieldNames = make(map[string]string)
}
if field, ok := obj.fieldNames[name]; ok {
return field, nil
} else {
schema := C.LUCY_Indexer_Get_Schema(self)
fieldList := C.LUCY_Schema_All_Fields(schema)
defer C.cfish_dec_refcount(unsafe.Pointer(fieldList))
for i := 0; i < int(C.CFISH_Vec_Get_Size(fieldList)); i++ {
cfString := unsafe.Pointer(C.CFISH_Vec_Fetch(fieldList, C.size_t(i)))
field := clownfish.CFStringToGo(cfString)
if strings.EqualFold(name, field) {
obj.fieldNames[name] = field
return field, nil
}
}
}
return "", clownfish.NewErr(fmt.Sprintf("Unknown field: '%v'", name))
}