LUCY-282 Test Go bindings for Index compoments pt1

core/Lucy/Index/Snapshot.c

@@ -109,7 +109,9 @@ Snapshot_Read_File_IMP(Snapshot *self, Folder *folder, String *path) {
 
     // Eliminate all prior data. Pick a snapshot file.
     S_zero_out(self);
-    ivars->path = path ? Str_Clone(path) : IxFileNames_latest_snapshot(folder);
+    ivars->path = (path != NULL && Str_Get_Size(path) > 0)
+                  ? Str_Clone(path)
+                  : IxFileNames_latest_snapshot(folder);
 
     if (ivars->path) {
         Hash *snap_data
@@ -178,7 +180,7 @@ Snapshot_Write_File_IMP(Snapshot *self, Folder *folder, String *path) {
 
     // Update path.
     DECREF(ivars->path);
-    if (path) {
+    if (path != NULL && Str_Get_Size(path) != 0) {
         ivars->path = Str_Clone(path);
     }
     else {

core/Lucy/Index/Snapshot.cfh

@@ -71,7 +71,7 @@ public class Lucy::Index::Snapshot inherits Clownfish::Obj {
      * @param folder A Folder.
      * @param path The location of the snapshot file.  If not supplied, the
      * most recent snapshot file in the base directory will be chosen.
-     * @return the object, allowing an assignment idiom.
+     * @return the Snapshot object itself
      */
     public Snapshot*
     Read_File(Snapshot *self, Folder *folder, String *path = NULL);

go/build.go

@@ -148,10 +148,46 @@ func specClasses(parcel *cfc.Parcel) {
 	indexerBinding := cfc.NewGoClass(parcel, "Lucy::Index::Indexer")
 	indexerBinding.SpecMethod("", "Close() error")
 	indexerBinding.SpecMethod("Add_Doc", "AddDoc(doc interface{}) error")
+	indexerBinding.SpecMethod("Add_Index", "AddIndex(interface{}) error")
+	indexerBinding.SpecMethod("Delete_By_Term", "DeleteByTerm(string, interface{}) error")
+	indexerBinding.SpecMethod("Delete_By_Query", "DeleteByQuery(Query) error")
+	indexerBinding.SpecMethod("Delete_By_Doc_ID", "DeleteByDocID(int32) error")
+	indexerBinding.SpecMethod("Prepare_Commit", "PrepareCommit() error")
 	indexerBinding.SpecMethod("Commit", "Commit() error")
 	indexerBinding.SetSuppressStruct(true)
 	indexerBinding.Register()
 
+	bgMergerBinding := cfc.NewGoClass(parcel, "Lucy::Index::BackgroundMerger")
+	bgMergerBinding.SpecMethod("Prepare_Commit", "PrepareCommit() error")
+	bgMergerBinding.SpecMethod("Commit", "Commit() error")
+	bgMergerBinding.Register()
+
+	managerBinding := cfc.NewGoClass(parcel, "Lucy::Index::IndexManager")
+	managerBinding.SpecMethod("Write_Merge_Data", "WriteMergeData(int64) error")
+	managerBinding.SpecMethod("Read_Merge_Data", "ReadMergeData() (map[string]interface{}, error)")
+	managerBinding.SpecMethod("Remove_Merge_Data", "RemoveMergeData() error")
+	managerBinding.SpecMethod("Make_Snapshot_Filename", "MakeSnapshotFilename() (string, error)")
+	managerBinding.SpecMethod("Recycle", "Recycle(PolyReader, DeletionsWriter, int64, bool) ([]SegReader, error)")
+	managerBinding.Register()
+
+	tvBinding := cfc.NewGoClass(parcel, "Lucy::Index::TermVector")
+	tvBinding.SpecMethod("Get_Positions", "GetPositions() []int32")
+	tvBinding.SpecMethod("Get_Start_Offsets", "GetStartOffsets() []int32")
+	tvBinding.SpecMethod("Get_End_Offsets", "GetEndOffsets() []int32")
+	tvBinding.SetSuppressCtor(true)
+	tvBinding.Register()
+
+	snapshotBinding := cfc.NewGoClass(parcel, "Lucy::Index::Snapshot")
+	snapshotBinding.SpecMethod("List", "List() []string")
+	snapshotBinding.SpecMethod("Read_File", "ReadFile(Folder, string) (Snapshot, error)")
+	snapshotBinding.SpecMethod("Write_File", "WriteFile(Folder, string) error")
+	snapshotBinding.Register()
+
+	segBinding := cfc.NewGoClass(parcel, "Lucy::Index::Segment")
+	segBinding.SpecMethod("Read_File", "ReadFile(Folder) error")
+	segBinding.SpecMethod("Write_File", "WriteFile(Folder) error")
+	segBinding.Register()
+
 	schemaBinding := cfc.NewGoClass(parcel, "Lucy::Plan::Schema")
 	schemaBinding.SpecMethod("All_Fields", "AllFields() []string")
 	schemaBinding.Register()

go/lucy/index.go

@@ -19,6 +19,10 @@ package lucy
 /*
 #include "Lucy/Index/Indexer.h"
 #include "Lucy/Index/IndexManager.h"
+#include "Lucy/Index/BackgroundMerger.h"
+#include "Lucy/Index/TermVector.h"
+#include "Lucy/Index/Segment.h"
+#include "Lucy/Index/Snapshot.h"
 #include "Lucy/Document/Doc.h"
 #include "Lucy/Plan/Schema.h"
 #include "Clownfish/Hash.h"
@@ -174,9 +178,209 @@ func (obj *IndexerIMP) findRealField(name string) (string, error) {
 	return "", clownfish.NewErr(fmt.Sprintf("Unknown field: '%v'", name))
 }
 
+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 (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 (obj *IndexerIMP) DeleteByQuery(query Query) error {
+	return clownfish.TrapErr(func() {
+		self := (*C.lucy_Indexer)(clownfish.Unwrap(obj, "obj"))
+		queryC := (*C.lucy_Query)(clownfish.Unwrap(query, "query"))
+		C.LUCY_Indexer_Delete_By_Query(self, queryC)
+	})
+}
+
+func (obj *IndexerIMP) DeleteByDocID(docID int32) error {
+	return clownfish.TrapErr(func() {
+		self := (*C.lucy_Indexer)(clownfish.Unwrap(obj, "obj"))
+		C.LUCY_Indexer_Delete_By_Doc_ID(self, C.int32_t(docID))
+	})
+}
+
+func (obj *IndexerIMP) PrepareCommit() error {
+	self := ((*C.lucy_Indexer)(unsafe.Pointer(obj.TOPTR())))
+	return clownfish.TrapErr(func() {
+		C.LUCY_Indexer_Prepare_Commit(self)
+	})
+}
+
 func (obj *IndexerIMP) Commit() error {
 	self := ((*C.lucy_Indexer)(unsafe.Pointer(obj.TOPTR())))
 	return clownfish.TrapErr(func() {
 		C.LUCY_Indexer_Commit(self)
 	})
 }
+
+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
+}
+
+func (bgm *BackgroundMergerIMP) PrepareCommit() error {
+	return clownfish.TrapErr(func() {
+		self := (*C.lucy_BackgroundMerger)(clownfish.Unwrap(bgm, "bgm"))
+		C.LUCY_BGMerger_Prepare_Commit(self)
+	})
+}
+
+func (bgm *BackgroundMergerIMP) Commit() error {
+	return clownfish.TrapErr(func() {
+		self := (*C.lucy_BackgroundMerger)(clownfish.Unwrap(bgm, "bgm"))
+		C.LUCY_BGMerger_Commit(self)
+	})
+}
+
+func (im *IndexManagerIMP) WriteMergeData(cutoff int64) error {
+	return clownfish.TrapErr(func() {
+		self := (*C.lucy_IndexManager)(clownfish.Unwrap(im, "im"))
+		C.LUCY_IxManager_Write_Merge_Data(self, C.int64_t(cutoff))
+	})
+}
+
+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 (im *IndexManagerIMP) RemoveMergeData() error {
+	return clownfish.TrapErr(func() {
+		self := (*C.lucy_IndexManager)(clownfish.Unwrap(im, "im"))
+		C.LUCY_IxManager_Remove_Merge_Data(self)
+	})
+}
+
+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) 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 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 (tv *TermVectorIMP) GetPositions() []int32 {
+	self := (*C.lucy_TermVector)(clownfish.Unwrap(tv, "tv"))
+	return i32ArrayToSlice(C.LUCY_TV_Get_Positions(self))
+}
+
+func (tv *TermVectorIMP) GetStartOffsets() []int32 {
+	self := (*C.lucy_TermVector)(clownfish.Unwrap(tv, "tv"))
+	return i32ArrayToSlice(C.LUCY_TV_Get_Start_Offsets(self))
+}
+
+func (tv *TermVectorIMP) GetEndOffsets() []int32 {
+	self := (*C.lucy_TermVector)(clownfish.Unwrap(tv, "tv"))
+	return i32ArrayToSlice(C.LUCY_TV_Get_End_Offsets(self))
+}
+
+func (s *SnapshotIMP) List() []string {
+	self := (*C.lucy_Snapshot)(clownfish.Unwrap(s, "s"))
+	retvalC := C.LUCY_Snapshot_List(self)
+	defer C.cfish_decref(unsafe.Pointer(retvalC))
+	return vecToStringSlice(retvalC)
+}
+
+func (s *SnapshotIMP) ReadFile(folder Folder, path string) (Snapshot, error) {
+	err := 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_Read_File(self, folderC, pathC)
+	})
+	return s, 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 *SegmentIMP) WriteFile(folder Folder) error {
+	return clownfish.TrapErr(func() {
+		self := (*C.lucy_Segment)(clownfish.Unwrap(s, "s"))
+		folderC := (*C.lucy_Folder)(clownfish.Unwrap(folder, "folder"))
+		C.LUCY_Seg_Write_File(self, folderC)
+	})
+}
+
+func (s *SegmentIMP) ReadFile(folder Folder) error {
+	return clownfish.TrapErr(func() {
+		self := (*C.lucy_Segment)(clownfish.Unwrap(s, "s"))
+		folderC := (*C.lucy_Folder)(clownfish.Unwrap(folder, "folder"))
+		C.LUCY_Seg_Read_File(self, folderC)
+	})
+}