remapfs

Documentation

Index

• func MustSub(fsys fs.FS, sub string) fs.FS
• type FSMap
• type RemapFS
  • func MustNew(fsmap FSMap) *RemapFS
  • func New(fs_tbl FSMap) (*RemapFS, error)
  • func (rmfs *RemapFS) Open(name string) (fs.File, error)
  • func (rmfs *RemapFS) ReadDir(name string) ([]fs.DirEntry, error)
  • func (rmfs *RemapFS) ReadFile(name string) ([]byte, error)
  • func (rmfs *RemapFS) Stat(name string) (fs.FileInfo, error)

Examples

• MustNew
• New
• RemapFS.Open
• RemapFS.ReadDir
• RemapFS.ReadFile
• RemapFS.Stat

Functions

func MustSub

func MustSub(fsys fs.FS, sub string) fs.FS

Types

type FSMap

type FSMap map[string]fs.FS

type RemapFS

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

func MustNew

func MustNew(fsmap FSMap) *RemapFS

Example

package main

import (
	"embed"
	"fmt"
	"io/fs"

	"github.com/l4go/remapfs"
)

//go:embed test/root
var raw_rootFS embed.FS
var rootFS = remapfs.MustSub(raw_rootFS, "test/root")

//go:embed test/foo
var raw_fooFS embed.FS
var fooFS = remapfs.MustSub(raw_fooFS, "test/foo")

//go:embed test/foobar
var raw_foobarFS embed.FS
var foobarFS = remapfs.MustSub(raw_foobarFS, "test/foobar")

func main() {
	mfs := remapfs.MustNew(remapfs.FSMap{
		".":       rootFS,
		"foo":     fooFS,
		"foo/bar": foobarFS,
	})

	buf, err := fs.ReadFile(mfs, "foo.txt")
	if err != nil {
		return
	}

	fmt.Print(string(buf))
}

Output:

foo

func New

func New(fs_tbl FSMap) (*RemapFS, error)

Example

package main

import (
	"embed"
	"fmt"
	"io/fs"

	"github.com/l4go/remapfs"
)

//go:embed test/root
var raw_rootFS embed.FS
var rootFS = remapfs.MustSub(raw_rootFS, "test/root")

//go:embed test/foo
var raw_fooFS embed.FS
var fooFS = remapfs.MustSub(raw_fooFS, "test/foo")

//go:embed test/foobar
var raw_foobarFS embed.FS
var foobarFS = remapfs.MustSub(raw_foobarFS, "test/foobar")

func main() {
	mfs, err := remapfs.New(remapfs.FSMap{
		".":       rootFS,
		"foo":     fooFS,
		"foo/bar": foobarFS,
	})
	if err != nil {
		return
	}

	buf, err := fs.ReadFile(mfs, "foo/bar.txt")
	if err != nil {
		return
	}

	fmt.Print(string(buf))
}

Output:

bar

func (*RemapFS) Open

func (rmfs *RemapFS) Open(name string) (fs.File, error)

Example

package main

import (
	"embed"
	"fmt"
	"io/fs"

	"github.com/l4go/remapfs"
)

//go:embed test/root
var raw_rootFS embed.FS
var rootFS = remapfs.MustSub(raw_rootFS, "test/root")

//go:embed test/foo
var raw_fooFS embed.FS
var fooFS = remapfs.MustSub(raw_fooFS, "test/foo")

//go:embed test/foobar
var raw_foobarFS embed.FS
var foobarFS = remapfs.MustSub(raw_foobarFS, "test/foobar")

func main() {
	var mfs fs.FS
	var err error

	mfs, err = remapfs.New(remapfs.FSMap{
		".":       rootFS,
		"foo":     fooFS,
		"foo/bar": foobarFS,
	})

	_, err = mfs.Open("foo.txt")
	fmt.Println(err == nil)
	_, err = mfs.Open("bar.txt")
	fmt.Println(err == nil)
	_, err = mfs.Open("foo/bar.txt")
	fmt.Println(err == nil)
	_, err = mfs.Open("foo/baz.txt")
	fmt.Println(err == nil)
	_, err = mfs.Open("foo/bar/baz.txt")
	fmt.Println(err == nil)
}

Output:

true
false
true
false
true

func (*RemapFS) ReadDir

func (rmfs *RemapFS) ReadDir(name string) ([]fs.DirEntry, error)

Example

package main

import (
	"embed"
	"fmt"
	"io/fs"

	"github.com/l4go/remapfs"
)

//go:embed test/root
var raw_rootFS embed.FS
var rootFS = remapfs.MustSub(raw_rootFS, "test/root")

//go:embed test/foo
var raw_fooFS embed.FS
var fooFS = remapfs.MustSub(raw_fooFS, "test/foo")

//go:embed test/foobar
var raw_foobarFS embed.FS
var foobarFS = remapfs.MustSub(raw_foobarFS, "test/foobar")

func main() {
	var mfs fs.FS
	var err error

	mfs, err = remapfs.New(remapfs.FSMap{
		".":       rootFS,
		"foo":     fooFS,
		"foo/bar": foobarFS,
	})
	if err != nil {
		return
	}

	if ents, er := fs.ReadDir(mfs, "."); er == nil {
		for _, el := range ents {
			fmt.Println(el.Name())
		}
	}
	if ents, er := fs.ReadDir(mfs, "foo/bar"); er == nil {
		for _, el := range ents {
			fmt.Println(el.Name())
		}
	}

}

Output:

foo.txt
hoge.txt
baz.txt

func (*RemapFS) ReadFile

func (rmfs *RemapFS) ReadFile(name string) ([]byte, error)

Example

package main

import (
	"embed"
	"fmt"
	"io/fs"

	"github.com/l4go/remapfs"
)

//go:embed test/root
var raw_rootFS embed.FS
var rootFS = remapfs.MustSub(raw_rootFS, "test/root")

//go:embed test/foo
var raw_fooFS embed.FS
var fooFS = remapfs.MustSub(raw_fooFS, "test/foo")

//go:embed test/foobar
var raw_foobarFS embed.FS
var foobarFS = remapfs.MustSub(raw_foobarFS, "test/foobar")

func main() {
	var mfs fs.FS
	var err error

	mfs, err = remapfs.New(remapfs.FSMap{
		".":       rootFS,
		"foo":     fooFS,
		"foo/bar": foobarFS,
	})
	if err != nil {
		return
	}

	var buf []byte
	buf, err = fs.ReadFile(mfs, "foo.txt")
	if err != nil {
		fmt.Println("error")
	} else {
		fmt.Print(string(buf))
	}

	buf, err = fs.ReadFile(mfs, "bar.txt")
	if err != nil {
		fmt.Println("error")
	} else {
		fmt.Print(string(buf))
	}

	buf, err = fs.ReadFile(mfs, "foo/bar.txt")
	if err != nil {
		fmt.Println("error")
	} else {
		fmt.Print(string(buf))
	}

}

Output:

foo
error
bar

func (*RemapFS) Stat

func (rmfs *RemapFS) Stat(name string) (fs.FileInfo, error)

Example

package main

import (
	"embed"
	"fmt"
	"io/fs"

	"github.com/l4go/remapfs"
)

//go:embed test/root
var raw_rootFS embed.FS
var rootFS = remapfs.MustSub(raw_rootFS, "test/root")

//go:embed test/foo
var raw_fooFS embed.FS
var fooFS = remapfs.MustSub(raw_fooFS, "test/foo")

//go:embed test/foobar
var raw_foobarFS embed.FS
var foobarFS = remapfs.MustSub(raw_foobarFS, "test/foobar")

func main() {
	var mfs fs.FS
	var err error

	mfs, err = remapfs.New(remapfs.FSMap{
		".":       rootFS,
		"foo":     fooFS,
		"foo/bar": foobarFS,
	})

	_, err = fs.Stat(mfs, "foo.txt")
	fmt.Println(err == nil)
	_, err = fs.Stat(mfs, "bar.txt")
	fmt.Println(err == nil)
	_, err = fs.Stat(mfs, "baz.txt")
	fmt.Println(err == nil)
	_, err = fs.Stat(mfs, "foo/bar.txt")
	fmt.Println(err == nil)
	_, err = fs.Stat(mfs, "foo/baz.txt")
	fmt.Println(err == nil)
	_, err = fs.Stat(mfs, "foo/bar/baz.txt")
	fmt.Println(err == nil)

}

Output:

true
false
false
true
false
true