unifs

package module
v1.20240116.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 16, 2024 License: MIT Imports: 5 Imported by: 0

Documentation

Index

Examples

Constants

This section is empty.

Variables

View Source 
var ErrInvalid = errors.New("invalid argument")
View Source 
var ErrUncPathSupported = errors.New("UNC path is not supported.")
View Source 
var Zero = UniPath{/* contains filtered or unexported fields */}

Functions

func Clean 

func Clean(uni_name string) (string, error)
Example 
package main

import (
	"fmt"

	"github.com/l4go/unifs"
)

func main() {
	fmt.Println(unifs.MustClean("/C:/foo/../bar/"))
	fmt.Println(unifs.MustClean("/foo/../bar/"))
	fmt.Println(unifs.MustClean("/foo/../../bar/"))

}

Output:

/C:/bar
/bar
/bar

func FromFSPath 

func FromFSPath(fs_name string) (string, error)
Example 
package main

import (
	"fmt"

	"github.com/l4go/unifs"
)

func main() {
	var name string
	var err error
	name, err = unifs.FromFSPath(".")
	fmt.Println(name, err == nil)
	name, err = unifs.FromFSPath("hoge")
	fmt.Println(name, err == nil)
	name, err = unifs.FromFSPath("hoge/fuga")
	fmt.Println(name, err == nil)
	name, err = unifs.FromFSPath("C:")
	fmt.Println(name, err == nil)
	name, err = unifs.FromFSPath("C:/hoge")
	fmt.Println(name, err == nil)

}

Output:

/ true
/hoge true
/hoge/fuga true
/C: true
/C:/hoge true

func FromOSPath 

func FromOSPath(os_name string) (string, error)

func Glob 

func Glob(fsys fs.FS, pattern string) ([]string, error)
Example 
ups, err := unifs.Glob(testfs, "/test/*.txt")
if err != nil {
	return
}
for _, up := range ups {
	fmt.Println(up)
}

Output:

/test/sample.txt
/test/dummy.txt

func Join 

func Join(names ...string) (string, error)
Example 
package main

import (
	"fmt"

	"github.com/l4go/unifs"
)

func main() {
	fmt.Println(unifs.MustJoin("/C:/foo/", "../bar"))
	fmt.Println(unifs.MustJoin("/foo/", "../bar/"))
	fmt.Println(unifs.MustJoin("/foo/", "../../bar"))

}

Output:

/C:/bar
/bar
/bar

func MustClean 

func MustClean(uni_name string) string

func MustJoin 

func MustJoin(names ...string) string

func Open 

func Open(fsys fs.FS, name string) (fs.File, error)
Example 
var err error
_, err = unifs.Open(testfs, "/test/sample.txt")
fmt.Println(err == nil)

Output:

true

func ReadDir 

func ReadDir(fsys fs.FS, name string) ([]fs.DirEntry, error)
Example 
var err error
_, err = unifs.ReadDir(testfs, "/")
fmt.Println(err == nil)
_, err = unifs.ReadDir(testfs, "/test")
fmt.Println(err == nil)

Output:

true
true

func ReadFile 

func ReadFile(fsys fs.FS, name string) ([]byte, error)
Example 
var err error
_, err = unifs.ReadFile(testfs, "/test/sample.txt")
fmt.Println(err == nil)

Output:

true

func Stat 

func Stat(fsys fs.FS, name string) (fs.FileInfo, error)
Example 
var err error
_, err = unifs.Stat(testfs, "/test/sample.txt")
fmt.Println(err == nil)

Output:

true

func Sub 

func Sub(fsys fs.FS, name string) (fs.FS, error)
Example 
var err error
var subfs fs.FS

subfs, err = unifs.Sub(testfs, "/test")
fmt.Println(err == nil)
_, err = unifs.Open(subfs, "/sample.txt")
fmt.Println(err == nil)

Output:

true
true

func ToFSPath 

func ToFSPath(uni_name string) (string, error)
Example 
package main

import (
	"fmt"

	"github.com/l4go/unifs"
)

func main() {
	fmt.Println(unifs.ToFSPath("/C:"))
	fmt.Println(unifs.ToFSPath("/C:/"))
	fmt.Println(unifs.ToFSPath("/C:/hoge"))
	fmt.Println(unifs.ToFSPath("/C:/hoge/"))

}

Output:

C: <nil>
C: <nil>
C:/hoge <nil>
C:/hoge <nil>

func ToFSPaths 

func ToFSPaths(uni_names []string) ([]string, error)

func ToOSPath 

func ToOSPath(uni_name string) (string, error)
Example (Unix) 
package main

import (
	"fmt"

	"github.com/l4go/unifs"
)

func main() {
	var name string
	var err error
	name, err = unifs.ToOSPath("/C:")
	fmt.Println(err == nil, name)
	name, err = unifs.ToOSPath("/C:/")
	fmt.Println(err == nil, name)
	name, err = unifs.ToOSPath("/C:/hoge")
	fmt.Println(err == nil, name)
	name, err = unifs.ToOSPath("/C:/hoge/")
	fmt.Println(err == nil, name)
}

Output:

true /C:
true /C:/
true /C:/hoge
true /C:/hoge/

func ToOSPaths 

func ToOSPaths(uni_names []string) ([]string, error)

func ValidPath 

func ValidPath(uni_name string) bool
Example 
package main

import (
	"fmt"

	"github.com/l4go/unifs"
)

func main() {
	fmt.Println(unifs.ValidPath("/C:/"))
	fmt.Println(unifs.ValidPath("/C:/hoge"))
	fmt.Println(unifs.ValidPath("/"))
	fmt.Println(unifs.ValidPath(""))
	fmt.Println(unifs.ValidPath("hoge/fuga"))
	fmt.Println(unifs.ValidPath("../hoge"))

}

Output:

true
true
true
false
false
false

func ValidSubPath 

func ValidSubPath(uni_name string) bool
Example 
package main

import (
	"fmt"

	"github.com/l4go/unifs"
)

func main() {
	fmt.Println(unifs.ValidSubPath("hoge"))
	fmt.Println(unifs.ValidSubPath("hoge/fuga"))
	fmt.Println(unifs.ValidSubPath("../hoge"))
	fmt.Println(unifs.ValidSubPath(`hoge\fuga`))
	fmt.Println(unifs.ValidSubPath("hoge\x00"))

}

Output:

true
true
true
false
false

Types

type UniPath 

type UniPath struct {
	// contains filtered or unexported fields
}

func MustNew 

func MustNew(uni_name string) UniPath

func MustNewFromFSPath 

func MustNewFromFSPath(fs_name string) UniPath

func MustNewFromOSPath 

func MustNewFromOSPath(os_path string) UniPath

func New 

func New(uni_name string) (UniPath, error)
Example 
package main

import (
	"fmt"

	"github.com/l4go/unifs"
)

func main() {
	var up unifs.UniPath
	var err error

	up, err = unifs.New("hoge")
	fmt.Println(up, err == nil)
	up, err = unifs.New("/")
	fmt.Println(up, err == nil)
	up, err = unifs.New("/hoge")
	fmt.Println(up, err == nil)
	up, err = unifs.New("/hoge/fuga/")
	fmt.Println(up, err == nil)
	up, err = unifs.New("/C:")
	fmt.Println(up, err == nil)
	up, err = unifs.New("/C:/hoge")
	fmt.Println(up, err == nil)

}

Output:

 false
/ true
/hoge true
/hoge/fuga true
/C: true
/C:/hoge true

func NewFromFSPath 

func NewFromFSPath(fs_name string) (UniPath, error)
Example 
package main

import (
	"fmt"

	"github.com/l4go/unifs"
)

func main() {
	var up unifs.UniPath
	var err error

	up, err = unifs.NewFromFSPath(".")
	fmt.Println(up, err == nil)
	up, err = unifs.NewFromFSPath("hoge")
	fmt.Println(up, err == nil)
	up, err = unifs.NewFromFSPath("hoge/fuga")
	fmt.Println(up, err == nil)
	up, err = unifs.NewFromFSPath("/")
	fmt.Println(up, err == nil)
	up, err = unifs.NewFromFSPath("/hoge")
	fmt.Println(up, err == nil)
	up, err = unifs.NewFromFSPath("hoge/")
	fmt.Println(up, err == nil)

}

Output:

/ true
/hoge true
/hoge/fuga true
 false
 false
 false

func NewFromOSPath 

func NewFromOSPath(os_name string) (UniPath, error)
Example (Unix) 
package main

import (
	"fmt"
	"os"

	"github.com/l4go/unifs"
)

func main() {
	var up unifs.UniPath
	var err error

	os.Chdir("/usr")
	up, err = unifs.NewFromOSPath(".")
	fmt.Println(up, err == nil)
	up, err = unifs.NewFromOSPath("hoge")
	fmt.Println(up, err == nil)
	up, err = unifs.NewFromOSPath("hoge/fuga")
	fmt.Println(up, err == nil)
	up, err = unifs.NewFromOSPath("/")
	fmt.Println(up, err == nil)
	up, err = unifs.NewFromOSPath("/hoge")
	fmt.Println(up, err == nil)

}

Output:

/usr true
/usr/hoge true
/usr/hoge/fuga true
/ true
/hoge true

func (UniPath) FSPath 

func (up UniPath) FSPath() string

func (UniPath) Glob 

func (up UniPath) Glob(fsys fs.FS) ([]UniPath, error)

func (UniPath) IsZero 

func (up UniPath) IsZero() bool

func (UniPath) Join 

func (up UniPath) Join(names ...string) (UniPath, error)
Example 
package main

import (
	"fmt"

	"github.com/l4go/unifs"
)

func main() {
	var err error
	var up, tp unifs.UniPath

	up, err = unifs.New("/test")
	fmt.Println(err == nil)
	tp, err = up.Join("sample.txt")
	fmt.Println(tp, err == nil)
	tp, err = up.Join("hoge/sample.txt")
	fmt.Println(tp, err == nil)
	tp, err = up.Join(`hoge\sample.txt`)
	fmt.Println(tp, err == nil)
	tp, err = up.Join("../sample.txt")
	fmt.Println(tp, err == nil)
	tp, err = up.Join("../../sample.txt")
	fmt.Println(tp, err == nil)
}

Output:

true
/test/sample.txt true
/test/hoge/sample.txt true
 false
/sample.txt true
/sample.txt true

func (UniPath) MustJoin 

func (up UniPath) MustJoin(names ...string) UniPath

func (UniPath) OSPath 

func (up UniPath) OSPath() string

func (UniPath) Open 

func (up UniPath) Open(fsys fs.FS) (fs.File, error)
Example 
var err error
var up unifs.UniPath

up, err = unifs.New("/test/sample.txt")
fmt.Println(err == nil)
_, err = up.Open(testfs)
fmt.Println(err == nil)

Output:

true
true

func (UniPath) ReadDir 

func (up UniPath) ReadDir(fsys fs.FS) ([]fs.DirEntry, error)
Example 
var err error
var up unifs.UniPath

up, err = unifs.New("/")
fmt.Println(err == nil)
_, err = up.ReadDir(testfs)
fmt.Println(err == nil)
up, err = unifs.New("/test")
fmt.Println(err == nil)
_, err = up.ReadDir(testfs)
fmt.Println(err == nil)
up, err = unifs.New("/hoge")
fmt.Println(err == nil)
_, err = up.ReadDir(testfs)
fmt.Println(err == nil)

Output:

true
true
true
true
true
false

func (UniPath) ReadFile 

func (up UniPath) ReadFile(fsys fs.FS) ([]byte, error)
Example 
var err error
var up unifs.UniPath

up, err = unifs.New("/test/sample.txt")
fmt.Println(err == nil)
_, err = up.ReadFile(testfs)
fmt.Println(err == nil)

Output:

true
true

func (UniPath) Stat 

func (up UniPath) Stat(fsys fs.FS) (fs.FileInfo, error)
Example 
var err error
var up unifs.UniPath

up, err = unifs.New("/test/sample.txt")
fmt.Println(err == nil)
_, err = up.Stat(testfs)
fmt.Println(err == nil)

Output:

true
true

func (UniPath) String 

func (up UniPath) String() string

func (UniPath) Sub 

func (up UniPath) Sub(fsys fs.FS) (fs.FS, error)
Example 
var err error
var subfs fs.FS
var up unifs.UniPath

up, err = unifs.New("/test")
fmt.Println(err == nil)
subfs, err = up.Sub(testfs)
fmt.Println(err == nil)
_, err = unifs.Open(subfs, "/sample.txt")
fmt.Println(err == nil)

Output:

true
true
true

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.