Finish custom Go Bindings for Folder.
Project: http://git-wip-us.apache.org/repos/asf/lucy/repo Commit: http://git-wip-us.apache.org/repos/asf/lucy/commit/5492483e Tree: http://git-wip-us.apache.org/repos/asf/lucy/tree/5492483e Diff: http://git-wip-us.apache.org/repos/asf/lucy/diff/5492483e Branch: refs/heads/LUCY-282-test-index-go-pt1 Commit: 5492483e447965ee64197df178f15e05bfa068ac Parents: e00c881 Author: Marvin Humphrey <[email protected]> Authored: Wed Oct 21 15:21:06 2015 -0700 Committer: Marvin Humphrey <[email protected]> Committed: Fri Oct 23 16:42:12 2015 -0700 ---------------------------------------------------------------------- go/build.go | 14 ++++ go/lucy/store.go | 185 +++++++++++++++++++++++++++++++++++++++++++++ go/lucy/store_test.go | 64 +++++++++------- 3 files changed, 235 insertions(+), 28 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/lucy/blob/5492483e/go/build.go ---------------------------------------------------------------------- diff --git a/go/build.go b/go/build.go index b1c155d..d15f5c8 100644 --- a/go/build.go +++ b/go/build.go @@ -254,8 +254,22 @@ func specClasses(parcel *cfc.Parcel) { outStreamBinding.Register() folderBinding := cfc.NewGoClass(parcel, "Lucy::Store::Folder") + folderBinding.SpecMethod("Initialize", "Initialize() error") folderBinding.SpecMethod("Open_Out", "OpenOut(string) (OutStream, error)") folderBinding.SpecMethod("Open_In", "OpenIn(string) (InStream, error)") + folderBinding.SpecMethod("Open_FileHandle", "OpenFileHandle(string, uint32) (FileHandle, error)") + folderBinding.SpecMethod("Open_Dir", "OpenDir(string) (DirHandle, error)") + folderBinding.SpecMethod("MkDir", "MkDir(string) error") + folderBinding.SpecMethod("List", "List(string) ([]string, error)") + folderBinding.SpecMethod("List_R", "ListR(string) ([]string, error)") + folderBinding.SpecMethod("Rename", "Rename(string, string) error") + folderBinding.SpecMethod("Hard_Link", "HardLink(string, string) error") + folderBinding.SpecMethod("Slurp_File", "SlurpFile(string) ([]byte, error)") + folderBinding.SpecMethod("Consolidate", "Consolidate(string) error") + folderBinding.SpecMethod("Local_Open_In", "LocalOpenIn(string) (InStream, error)") + folderBinding.SpecMethod("Local_Open_FileHandle", "LocalOpenFileHandle(string, uint32) (FileHandle, error)") + folderBinding.SpecMethod("Local_Open_Dir", "LocalOpenDir() (DirHandle, error)") + folderBinding.SpecMethod("Local_MkDir", "LocalMkDir(string) error") folderBinding.Register() } http://git-wip-us.apache.org/repos/asf/lucy/blob/5492483e/go/lucy/store.go ---------------------------------------------------------------------- diff --git a/go/lucy/store.go b/go/lucy/store.go index 111347c..da6e1c7 100644 --- a/go/lucy/store.go +++ b/go/lucy/store.go @@ -331,6 +331,13 @@ func (out *OutStreamIMP) Absorb(in InStream) error { }) } +func (f *FolderIMP) Initialize() error { + return clownfish.TrapErr(func() { + self := (*C.lucy_Folder)(clownfish.Unwrap(f, "f")) + C.LUCY_Folder_Initialize(self) + }) +} + func (f *FolderIMP) OpenOut(path string) (retval OutStream, err error) { err = clownfish.TrapErr(func() { self := (*C.lucy_Folder)(clownfish.Unwrap(f, "f")) @@ -360,3 +367,181 @@ func (f *FolderIMP) OpenIn(path string) (retval InStream, err error) { }) return retval, err } + +func (f *FolderIMP) OpenFileHandle(path string, flags uint32) (retval FileHandle, 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_FileHandle(self, pathC, 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 (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) MkDir(path string) error { + 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)) + success := C.LUCY_Folder_MkDir(self, pathC) + if !success { + cfErr := C.cfish_Err_get_error(); + return clownfish.WRAPAny(unsafe.Pointer(C.cfish_incref(unsafe.Pointer(cfErr)))).(error) + } + return nil +} + +func (f *FolderIMP) List(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(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 (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 (f *FolderIMP) Rename(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_Rename(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 (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 (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) 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 (f *FolderIMP) LocalOpenIn(name string) (retval InStream, 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_In(self, nameC) + if retvalC == nil { + cfErr := C.cfish_Err_get_error(); + panic(clownfish.WRAPAny(unsafe.Pointer(C.cfish_incref(unsafe.Pointer(cfErr)))).(error)) + } + retval = WRAPInStream(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 (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 (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 +} http://git-wip-us.apache.org/repos/asf/lucy/blob/5492483e/go/lucy/store_test.go ---------------------------------------------------------------------- diff --git a/go/lucy/store_test.go b/go/lucy/store_test.go index f972c96..c5aa6dd 100644 --- a/go/lucy/store_test.go +++ b/go/lucy/store_test.go @@ -297,12 +297,17 @@ func TestIOStreamMisc(t *testing.T) { func runFolderTests(t *testing.T, folder Folder) { var err error - folder.Initialize() + err = folder.Initialize() + if err != nil { + t.Errorf("Initialize: %v", err) + } if !folder.Check() { t.Errorf("Check") } - folder.MkDir("stuff") + if problem := folder.MkDir("stuff"); problem != nil { + t.Errorf("MkDir: %v", problem) + } outStream, err := folder.OpenOut("stuff/hello") if outStream == nil || err != nil { t.Errorf("OpenOut: %v", err) @@ -314,19 +319,22 @@ func runFolderTests(t *testing.T, folder Folder) { t.Errorf("OpenIn: %s", err) } inStream.Close() - fh := folder.OpenFileHandle("stuff/hello", 0x1) // 0x1 == FH_READ_ONLY - if fh == nil { - t.Errorf("OpenFileHandle") + fh, err := folder.OpenFileHandle("stuff/hello", 0x1) // 0x1 == FH_READ_ONLY + if fh == nil || err != nil { + t.Errorf("OpenFileHandle: %v", err) } fh.Close() - dh := folder.OpenDir("stuff") - if dh == nil { - t.Errorf("OpenDir") + dh, err := folder.OpenDir("stuff") + if dh == nil || err != nil { + t.Errorf("OpenDir: %v", err) } dh.Close() - if got := folder.SlurpFile("stuff/hello"); !reflect.DeepEqual(got, []byte("hi")) { - t.Errorf("SlurpFile: %s", got) + if got, err := folder.SlurpFile("stuff/hello"); !reflect.DeepEqual(got, []byte("hi")) || err != nil { + t.Errorf("SlurpFile: %v, %v", got, err) + } + if got, err := folder.SlurpFile("nope/nyet/nada"); got != nil || err == nil { + t.Errorf("SlurpFile [non-existent file]: %v, %v", got, err) } if !folder.Exists("stuff") { @@ -349,13 +357,13 @@ func runFolderTests(t *testing.T, folder Folder) { t.Errorf("IsDirectory [non-existent entry]") } - listExpected := []interface{}{"stuff"} - if got := folder.List(""); !reflect.DeepEqual(got, listExpected) { - t.Errorf("Unexpected result for List: %v", got) + listExpected := []string{"stuff"} + if got, err := folder.List(""); !reflect.DeepEqual(got, listExpected) || err != nil { + t.Errorf("Unexpected result for List: %v, %v", got, err) } - listRExpected := []interface{}{"stuff", "stuff/hello"} - if got := folder.ListR(""); !reflect.DeepEqual(got, listRExpected) { - t.Errorf("Unexpected result for ListR: %v", got) + listRExpected := []string{"stuff", "stuff/hello"} + if got, err := folder.ListR(""); !reflect.DeepEqual(got, listRExpected) || err != nil { + t.Errorf("Unexpected result for ListR: %v, %v", got, err) } if stuff := folder.FindFolder("stuff"); stuff == nil { t.Errorf("FindFolder") @@ -370,26 +378,26 @@ func runFolderTests(t *testing.T, folder Folder) { t.Errorf("EnclosingFolder [non-existent]") } - if success := folder.HardLink("stuff/hello", "aloha"); !success { - t.Errorf("HardLink") + if err := folder.HardLink("stuff/hello", "aloha"); err != nil { + t.Errorf("HardLink: %v", err) } - if success := folder.Rename("stuff/hello", "stuff/hola"); !success { - t.Errorf("Rename") + if err := folder.Rename("stuff/hello", "stuff/hola"); err != nil { + t.Errorf("Rename: %v", err) } if success := folder.Delete("stuff/hola"); !success { t.Errorf("Delete") } - if fh := folder.LocalOpenFileHandle("aloha", 0x1); fh == nil { - t.Errorf("LocalOpenFileHandle") + if fh, err := folder.LocalOpenFileHandle("aloha", 0x1); fh == nil || err != nil { + t.Errorf("LocalOpenFileHandle: %v", err) } - if in := folder.LocalOpenIn("aloha"); in == nil { - t.Errorf("LocalOpenIn") + if in, err := folder.LocalOpenIn("aloha"); in == nil || err != nil { + t.Errorf("LocalOpenIn: %v", err) } else { in.Close() } - if !folder.LocalMkDir("things") { - t.Errorf("LocalMkdir") + if err = folder.LocalMkDir("things"); err != nil { + t.Errorf("LocalMkdir: %v", err) } if !folder.LocalExists("things") { t.Errorf("LocalExists") @@ -400,8 +408,8 @@ func runFolderTests(t *testing.T, folder Folder) { if things := folder.LocalFindFolder("things"); things == nil { t.Errorf("LocalFindFolder") } - if dh := folder.LocalOpenDir(); dh == nil { - t.Errorf("LocalOpenDir") + if dh, err := folder.LocalOpenDir(); dh == nil || err != nil { + t.Errorf("LocalOpenDir: %v", err) } else { dh.Close() }
