wpk

Dec 25, 2023

Changes in this version

+ const PathSeparator

+ var VarChar [256]bool = func() (a [256]bool) { ... }()

+ var VarCharFirst [256]bool = func() (a [256]bool) { ... }()

+ func DirExists(fpath string) (bool, error)

+ func FileExists(fpath string) (bool, error)

+ func JoinFilePath(dir, base string) string

+ func JoinPath(dir, base string) string

+ func PathName(fpath string) string

Nov 29, 2023

Changes in this version

+ type PkgReader interface

+ type RFile interface

Oct 10, 2023

Changes in this version

+ func JoinFast(dir, base string) string

type TagRaw

+ func (t TagRaw) TagUnixms() (int64, bool)

type TagsetIterator

+ func (tsi *TagsetIterator) Add(tid TID, tag TagRaw) TagsetRaw

+ func (tsi *TagsetIterator) AddOk(tid TID, tag TagRaw) (TagsetRaw, bool)

+ func (tsi *TagsetIterator) DelOk(tid TID) (TagsetRaw, bool)

+ func (tsi *TagsetIterator) SetOk(tid TID, tag TagRaw) (TagsetRaw, bool)

type TagsetRaw

+ func CopyTagset(ts TagsetRaw) TagsetRaw

+ func (ts TagsetRaw) Add(tid TID, tag TagRaw) TagsetRaw

+ func (ts TagsetRaw) AddOk(tid TID, tag TagRaw) (TagsetRaw, bool)

+ func (ts TagsetRaw) DelOk(tid TID) (TagsetRaw, bool)

+ func (ts TagsetRaw) SetOk(tid TID, tag TagRaw) (TagsetRaw, bool)

+ func (ts TagsetRaw) TagUnixms(tid TID) (int64, bool)

Oct 3, 2023

Changes in this version

+ func ToLower(s string) string

+ func ToUpper(s string) string

+ type SeqMap struct

+ func (m *SeqMap[K, T]) Delete(key K) (ret T, ok bool)

+ func (m *SeqMap[K, T]) Has(key K) (ok bool)

+ func (m *SeqMap[K, T]) Init(c int)

+ func (m *SeqMap[K, T]) Len() int

+ func (m *SeqMap[K, T]) Peek(key K) (ret T, ok bool)

+ func (m *SeqMap[K, T]) Poke(key K, val T)

+ func (m *SeqMap[K, T]) Pop() (key K, val T, ok bool)

+ func (m *SeqMap[K, T]) Push(key K, val T) (ok bool)

+ func (m *SeqMap[K, T]) Range(f func(K, T) bool)

type TagRaw

+ func UnixmsTag(val time.Time) TagRaw

Sep 20, 2023

Changes in this version

+ var ErrBadIntLen = errors.New("unacceptable integer length")

+ var ErrTsiConst = errors.New("content changes are disabled for iterator")

+ func GetF32(b []byte) float32

+ func GetF64(b []byte) float64

+ func GetU16(b []byte) uint16

+ func GetU32(b []byte) uint32

+ func GetU64(b []byte) uint64

+ func ReadF32(r io.Reader) (f float32, err error)

+ func ReadF64(r io.Reader) (f float64, err error)

+ func ReadU16(r io.Reader) (u uint16, err error)

+ func ReadU32(r io.Reader) (u uint32, err error)

+ func ReadU64(r io.Reader) (u uint64, err error)

+ func SetF32(b []byte, f float32)

+ func SetF64(b []byte, f float64)

+ func SetU16(b []byte, u uint16)

+ func SetU32(b []byte, u uint32)

+ func SetU64(b []byte, u uint64)

+ func WriteF32(w io.Writer, f float32) (err error)

+ func WriteF64(w io.Writer, f float64) (err error)

+ func WriteU16(w io.Writer, u uint16) (err error)

+ func WriteU32(w io.Writer, u uint32) (err error)

+ func WriteU64(w io.Writer, u uint64) (err error)

type FTT

+ func (ftt *FTT) OpenFile(fpath string) (err error)

+ func (ftt *FTT) OpenStream(r io.ReadSeeker) (err error)

+ func (ftt *FTT) TagsetNum() int

type Header

+ func (hdr *Header) Count() int

+ func (hdr *Header) FttSize() Uint

+ func (hdr *Header) Parse(buf []byte) (n int64, err error)

Aug 28, 2023

Changes in this version

+ const TIDtmbjpeg

+ const TIDtmbwebp

type FTT

+ func (ftt *FTT) GetInfo() (TagsetRaw, bool)

+ func (ftt *FTT) Parse(buf []byte) (n int64, err error)

type Package

+ func (pkg *Package) GetTagset(fkey string) (TagsetRaw, bool)

+ func (pkg *Package) SetupTagset(ts TagsetRaw)

+ type PkgFile interface

+ type RWMap struct

+ func (rwm *RWMap[K, T]) Delete(key K)

+ func (rwm *RWMap[K, T]) Get(key K) (ret T, ok bool)

+ func (rwm *RWMap[K, T]) GetAndDelete(key K) (ret T, ok bool)

+ func (rwm *RWMap[K, T]) Has(key K) (ok bool)

+ func (rwm *RWMap[K, T]) Init(c int)

+ func (rwm *RWMap[K, T]) Len() int

+ func (rwm *RWMap[K, T]) Range(f func(K, T) bool)

+ func (rwm *RWMap[K, T]) Set(key K, val T)

Aug 25, 2023

Changes in this version

+ func B2S(b []byte) string

+ func S2B(s string) (b []byte)

type Package

+ func (pkg *Package) RenameDir(olddir, newdir string, skipexist bool) (count int, err error)

+ func (pkg *Package) TrimPath(fpath string) string

Nov 3, 2022

Changes in this version

type FTT

+ func (ftt *FTT) CheckTagset(ts *TagsetRaw) (fpath string, err error)

+ func (ftt *FTT) DataSize() Uint

Sep 20, 2022

Changes in this version

+ const InfoName

+ const PackName

+ const SignBuild

+ const SignReady

+ var ErrOtherSubdir = errors.New("directory refers to other workspace")

+ func TempPath(fname string) string

+ type CompleteFS interface

+ type FTT struct

+ func (ftt *FTT) Append(wpt, wpf io.WriteSeeker) (err error)

+ func (ftt *FTT) Begin(wpt io.WriteSeeker) (err error)

+ func (ftt *FTT) Info() (ts *TagsetRaw, ok bool)

+ func (ftt *FTT) Init(pts TypeSize)

+ func (ftt *FTT) IsSplitted() bool

+ func (ftt *FTT) NewTagset() *TagsetRaw

+ func (ftt *FTT) OpenDir(fulldir string) (fs.ReadDirFile, error)

+ func (ftt *FTT) ReadDirN(fulldir string, n int) (list []fs.DirEntry, err error)

+ func (ftt *FTT) ReadFTT(r io.ReadSeeker) (err error)

+ func (ftt *FTT) ReadFrom(r io.Reader) (n int64, err error)

+ func (ftt *FTT) SetInfo() *TagsetRaw

+ func (ftt *FTT) Sync(wpt, wpf io.WriteSeeker) (err error)

+ func (ftt *FTT) WriteTo(w io.Writer) (n int64, err error)

+ type PackDirFile struct

+ func (f *PackDirFile) Close() error

+ func (f *PackDirFile) Read(b []byte) (n int, err error)

+ func (f *PackDirFile) ReadDir(n int) (matches []fs.DirEntry, err error)

+ func (f *PackDirFile) Stat() (fs.FileInfo, error)

type Package

+ Workspace string

+ func OpenPackage(fpath string) (pkg *Package, err error)

+ func (pkg *Package) DelTagset(fkey string)

+ func (pkg *Package) FullPath(fpath string) string

+ func (pkg *Package) GetDelTagset(fkey string) (ts *TagsetRaw, ok bool)

+ func (pkg *Package) HasTagset(fkey string) (ok bool)

+ func (pkg *Package) Open(dir string) (fs.File, error)

+ func (pkg *Package) ReadDir(dir string) ([]fs.DirEntry, error)

+ func (pkg *Package) ReadFile(fpath string) ([]byte, error)

+ func (pkg *Package) SetTagset(fkey string, ts *TagsetRaw)

+ func (pkg *Package) Stat(fpath string) (fs.FileInfo, error)

+ func (pkg *Package) Sub(dir string) (sub fs.FS, err error)

+ func (pkg *Package) Tagset(fkey string) (ts *TagsetRaw, ok bool)

+ type TagRaw []byte

+ func BoolTag(val bool) TagRaw

+ func ByteTag(val byte) TagRaw

+ func NumberTag(val float64) TagRaw

+ func StrTag(val string) TagRaw

+ func TimeTag(val time.Time) TagRaw

+ func Uint16Tag(val uint16) TagRaw

+ func Uint32Tag(val uint32) TagRaw

+ func Uint64Tag(val uint64) TagRaw

+ func UintLenTag(val Uint, l byte) TagRaw

+ func UintTag(val Uint) TagRaw

+ func UnixTag(val time.Time) TagRaw

+ func (t TagRaw) TagBool() (bool, bool)

+ func (t TagRaw) TagByte() (byte, bool)

+ func (t TagRaw) TagNumber() (float64, bool)

+ func (t TagRaw) TagStr() (string, bool)

+ func (t TagRaw) TagTime() (time.Time, bool)

+ func (t TagRaw) TagUint() (ret Uint, ok bool)

+ func (t TagRaw) TagUint16() (uint16, bool)

+ func (t TagRaw) TagUint32() (uint32, bool)

+ func (t TagRaw) TagUint64() (uint64, bool)

+ type TagsetRaw struct

+ func (ts *TagsetRaw) AccessTime() time.Time

+ func (ts *TagsetRaw) BirthTime() time.Time

+ func (ts *TagsetRaw) ChangeTime() time.Time

+ func (ts *TagsetRaw) Data() []byte

+ func (ts *TagsetRaw) Del(tid Uint) bool

+ func (ts *TagsetRaw) Get(tid Uint) (TagRaw, bool)

+ func (ts *TagsetRaw) Has(tid Uint) bool

+ func (ts *TagsetRaw) HasBirthTime() bool

+ func (ts *TagsetRaw) HasChangeTime() bool

+ func (ts *TagsetRaw) Info() (fs.FileInfo, error)

+ func (ts *TagsetRaw) IsDir() bool

+ func (ts *TagsetRaw) Iterator() *TagsetIterator

+ func (ts *TagsetRaw) ModTime() time.Time

+ func (ts *TagsetRaw) Mode() fs.FileMode

+ func (ts *TagsetRaw) Name() string

+ func (ts *TagsetRaw) Num() (n int)

+ func (ts *TagsetRaw) Path() string

+ func (ts *TagsetRaw) Pos() (offset, size Uint)

+ func (ts *TagsetRaw) Put(tid Uint, tag TagRaw) *TagsetRaw

+ func (ts *TagsetRaw) Set(tid Uint, tag TagRaw) bool

+ func (ts *TagsetRaw) Size() int64

+ func (ts *TagsetRaw) Sys() interface{}

+ func (ts *TagsetRaw) TagBool(tid Uint) (bool, bool)

+ func (ts *TagsetRaw) TagByte(tid Uint) (byte, bool)

+ func (ts *TagsetRaw) TagNumber(tid Uint) (float64, bool)

+ func (ts *TagsetRaw) TagStr(tid Uint) (string, bool)

+ func (ts *TagsetRaw) TagTime(tid Uint) (time.Time, bool)

+ func (ts *TagsetRaw) TagUint(tid Uint) (Uint, bool)

+ func (ts *TagsetRaw) TagUint16(tid Uint) (uint16, bool)

+ func (ts *TagsetRaw) TagUint32(tid Uint) (uint32, bool)

+ func (ts *TagsetRaw) TagUint64(tid Uint) (uint64, bool)

+ func (ts *TagsetRaw) Type() fs.FileMode

+ type Uint uint64

+ type Union struct

+ List []*Package

+ func (u *Union) AllKeys() (res []string)

+ func (u *Union) Close() (err error)

+ func (u *Union) Glob(pattern string) (res []string, err error)

+ func (u *Union) Open(dir string) (fs.File, error)

+ func (u *Union) ReadDir(dir string) ([]fs.DirEntry, error)

+ func (u *Union) ReadDirN(dir string, n int) (list []fs.DirEntry, err error)

+ func (u *Union) ReadFile(fpath string) ([]byte, error)

+ func (u *Union) Stat(fpath string) (fs.FileInfo, error)

+ func (u *Union) Sub(dir string) (fs.FS, error)

+ type UnionDir struct

+ func (f *UnionDir) Close() error

+ func (f *UnionDir) Read([]byte) (int, error)

+ func (f *UnionDir) ReadDir(n int) ([]fs.DirEntry, error)

+ func (f *UnionDir) Stat() (fs.FileInfo, error)

+ type Void = struct

Aug 23, 2022

Changes in this version

+ const PTStagsz

+ const PTStidsz

+ var ErrRangeTSSize = errors.New("tagset size value is exceeds out of the type dimension")

type FTT_t

+ func (ftt *FTT_t) NewTagset() *Tagset_t

+ func (ftt *FTT_t) Open(dir string) (df fs.ReadDirFile, err error)

+ func (ftt *FTT_t) ReadDir(dir string, n int) (matches []fs.DirEntry, err error)

type Package

+ func (pack *Package) BaseTagset(offset, size uint, fpath string) *Tagset_t

type ReadDirFile

+ FTT *FTT_t

type Tagset_t

+ func (ts *Tagset_t) Info() (fs.FileInfo, error)

+ func (ts *Tagset_t) Pos() (offset, size uint)

+ func (ts *Tagset_t) Type() fs.FileMode

Aug 17, 2022

Changes in this version

+ var ErrCondFSize = errors.New("size of file size type should be not more than file offset size")

+ var ErrCondTID = errors.New("size of tag ID type should be not more than tagset size")

+ var ErrCondTSize = errors.New("size of tag size type should be not more than tagset size")

+ var ErrSizeFID = errors.New("size of file ID type is differs from expected")

+ var ErrSizeFOffset = errors.New("size of file offset type is differs from expected")

+ var ErrSizeFSize = errors.New("size of file size type is differs from expected")

+ var ErrSizeTID = errors.New("size of tag ID type is differs from expected")

+ var ErrSizeTSSize = errors.New("size of tagset size type is differs from expected")

+ var ErrSizeTSize = errors.New("size of tag size type is differs from expected")

+ func ReadUint(r io.Reader, l byte) (data uint, err error)

+ func ReadUintBuf(b []byte) uint

+ func UintTagset(ts *Tagset_t[TID_t, TSize_t], tid TID_t) (ret T, ok bool)

+ func Uint_l() byte

+ func Uint_r(b []byte) (ret T)

+ func Uint_w(b []byte, v T)

+ func WriteUint(w io.Writer, data uint, l byte) (err error)

+ func WriteUintBuf(b []byte, v uint)

type Header

+ func (hdr *Header) PTS(idx int) byte

type Package

+ func NewPackage(foffset, fsize, fidsz, tssize byte) (pack *Package[TID_t, TSize_t])

+ func (pack *Package[TID_t, TSize_t]) Init(foffset, fsize, fidsz, tssize byte)

+ type TID_i interface

+ type TSize_i interface

type Tag_t

+ func TagUint(val T) Tag_t

+ func TagUintLen(val uint, l byte) Tag_t

+ type TypeSize [8]byte

+ func (pts TypeSize) Checkup(TID_l, TSize_l byte) error

Jul 24, 2022

Changes in this version

type TID_t

+ const TIDatime

+ const TIDbtime

+ const TIDctime

+ const TIDmtime

type Tag_t

+ func TagTime(val time.Time) Tag_t

+ func TagUnix(val time.Time) Tag_t

+ func (t Tag_t) Time() (time.Time, bool)

type Tagset_t

+ func (ts *Tagset_t) AccessTime() time.Time

+ func (ts *Tagset_t) BirthTime() time.Time

+ func (ts *Tagset_t) ChangeTime() time.Time

+ func (ts *Tagset_t) HasBirthTime() bool

+ func (ts *Tagset_t) HasChangeTime() bool

+ func (ts *Tagset_t) Time(tid TID_t) (time.Time, bool)

May 20, 2022

Changes in this version

+ const FID_l

+ const FOffset_l

+ const FSize_l

+ const PTSfid

+ const PTSfoffset

+ const PTSfsize

+ const PTStid

+ const PTStsize

+ const PTStssize

+ const TID_l

+ const TSSize_l

+ const TSize_l

+ var ErrSignFTT = errors.New("header contains incorrect data")

+ var FID_r = func(b []byte) FID_t

+ var FID_w = func(b []byte, v FID_t)

+ var FOffset_r = func(b []byte) FOffset_t

+ var FOffset_w = func(b []byte, v FOffset_t)

+ var FSize_r = func(b []byte) FSize_t

+ var FSize_w = func(b []byte, v FSize_t)

+ var PackageTypeSizes = [8]byte

+ var TID_r = func(b []byte) TID_t

+ var TID_w = func(b []byte, v TID_t)

+ var TSSize_r = func(b []byte) TSSize_t

+ var TSSize_w = func(b []byte, v TSSize_t)

+ var TSize_r = func(b []byte) TSize_t

+ var TSize_w = func(b []byte, v TSize_t)

+ func MakeDataPath(fpath string) string

+ func MakeTagsPath(fpath string) string

+ type FID_t uint32

+ type FOffset_t uint64

+ type FSize_t uint64

+ type FTT_t struct

+ func (ftt *FTT_t) DelTagset(fkey string)

+ func (ftt *FTT_t) Enum(f func(string, *Tagset_t) bool)

+ func (ftt *FTT_t) GetDelTagset(fkey string) (ts *Tagset_t, ok bool)

+ func (ftt *FTT_t) HasTagset(fkey string) (ok bool)

+ func (ftt *FTT_t) Info() *Tagset_t

+ func (ftt *FTT_t) ReadFrom(r io.Reader) (n int64, err error)

+ func (ftt *FTT_t) SetTagset(fkey string, ts *Tagset_t)

+ func (ftt *FTT_t) Tagset(fkey string) (ts *Tagset_t, ok bool)

+ func (ftt *FTT_t) WriteTo(w io.Writer) (n int64, err error)

type Header

+ func (pack *Header) DataPos() (uint64, uint64)

+ func (pack *Header) IsReady() (err error)

+ func (pack *Header) IsSplitted() bool

+ type PackDirLogger = func(r io.ReadSeeker, ts *Tagset_t) error

type Package

+ func (pack *Package) Append(wpt, wpf io.WriteSeeker) (err error)

+ func (pack *Package) Begin(wpt io.WriteSeeker) (err error)

+ func (pack *Package) OpenFTT(r io.ReadSeeker) (err error)

+ func (pack *Package) PackData(w io.WriteSeeker, r io.Reader, fpath string) (ts *Tagset_t, err error)

+ func (pack *Package) PackDir(w io.WriteSeeker, dirname, prefix string, logger PackDirLogger) (err error)

+ func (pack *Package) PackFile(w io.WriteSeeker, file *os.File, kpath string) (ts *Tagset_t, err error)

+ func (pack *Package) PutAlias(oldname, newname string) error

+ func (pack *Package) Rename(oldname, newname string) error

+ func (pack *Package) Sync(wpt, wpf io.WriteSeeker) (err error)

+ type TID_t uint16

+ const TIDattr

+ const TIDconst

+ const TIDlabel

+ const TIDnone

+ const TIDtmbimg

+ const TIDtmbmime

+ type TSSize_t uint16

+ type TSize_t uint16

+ type Tag_t []byte

+ func TagFID(val FID_t) Tag_t

+ func TagFOffset(val FOffset_t) Tag_t

+ func TagFSize(val FSize_t) Tag_t

+ func TagUint8(val uint8) Tag_t

+ func (t Tag_t) Bool() (bool, bool)

+ func (t Tag_t) Byte() (byte, bool)

+ func (t Tag_t) FID() (FID_t, bool)

+ func (t Tag_t) FOffset() (FOffset_t, bool)

+ func (t Tag_t) FSize() (FSize_t, bool)

+ func (t Tag_t) Number() (float64, bool)

+ func (t Tag_t) String() (string, bool)

+ func (t Tag_t) Uint() (uint, bool)

+ func (t Tag_t) Uint16() (uint16, bool)

+ func (t Tag_t) Uint32() (uint32, bool)

+ func (t Tag_t) Uint64() (uint64, bool)

+ func (t Tag_t) Uint8() (uint8, bool)

type Tagger

+ OpenTagset func(*Tagset_t) (NestedFile, error)

+ Tagset func(string) (*Tagset_t, bool)

+ type TagsetIterator struct

+ func (tsi *TagsetIterator) Del(tid TID_t) bool

+ func (tsi *TagsetIterator) Failed() bool

+ func (tsi *TagsetIterator) Next() (ok bool)

+ func (tsi *TagsetIterator) Passed() bool

+ func (tsi *TagsetIterator) Put(tid TID_t, tag Tag_t) *Tagset_t

+ func (tsi *TagsetIterator) Reset()

+ func (tsi *TagsetIterator) Set(tid TID_t, tag Tag_t) bool

+ func (tsi *TagsetIterator) TID() TID_t

+ func (tsi *TagsetIterator) Tag() Tag_t

+ func (tsi *TagsetIterator) TagLen() TSSize_t

+ type Tagset_t struct

+ func GetPackageInfo(r io.ReadSeeker) (ts *Tagset_t, err error)

+ func MakeTagset(data []byte) *Tagset_t

+ func (ts *Tagset_t) Bool(tid TID_t) (bool, bool)

+ func (ts *Tagset_t) Byte(tid TID_t) (byte, bool)

+ func (ts *Tagset_t) Data() []byte

+ func (ts *Tagset_t) Del(tid TID_t) bool

+ func (ts *Tagset_t) FID() (FID_t, bool)

+ func (ts *Tagset_t) FOffset() (FOffset_t, bool)

+ func (ts *Tagset_t) FSize() (FSize_t, bool)

+ func (ts *Tagset_t) Get(tid TID_t) (Tag_t, bool)

+ func (ts *Tagset_t) Has(tid TID_t) bool

+ func (ts *Tagset_t) IsDir() bool

+ func (ts *Tagset_t) Iterator() *TagsetIterator

+ func (ts *Tagset_t) ModTime() time.Time

+ func (ts *Tagset_t) Mode() fs.FileMode

+ func (ts *Tagset_t) Name() string

+ func (ts *Tagset_t) Num() (n int)

+ func (ts *Tagset_t) Number(tid TID_t) (float64, bool)

+ func (ts *Tagset_t) Path() string

+ func (ts *Tagset_t) Put(tid TID_t, tag Tag_t) *Tagset_t

+ func (ts *Tagset_t) Set(tid TID_t, tag Tag_t) bool

+ func (ts *Tagset_t) Size() int64

+ func (ts *Tagset_t) String(tid TID_t) (string, bool)

+ func (ts *Tagset_t) Sys() interface{}

+ func (ts *Tagset_t) Uint(tid TID_t) (uint, bool)

+ func (ts *Tagset_t) Uint16(tid TID_t) (uint16, bool)

+ func (ts *Tagset_t) Uint32(tid TID_t) (uint32, bool)

+ func (ts *Tagset_t) Uint64(tid TID_t) (uint64, bool)

+ type WriteSeekCloser interface

Jun 17, 2021

Changes in this version

+ type FileReader interface

+ Size func() int64

type Header

+ func (pack *Header) FTTSize() int64

+ type NestedFile interface

type Packager

+ OpenTags func(TagSlice) (NestedFile, error)

type Writer

+ LastFID FID

Mar 25, 2021

Changes in this version

+ const HeaderSize

+ const LabelSize

+ const SignSize

+ func Envfmt(p string) string

+ func Normalize(kpath string) string

+ func PathExists(path string) (bool, error)

+ func ReadDir(pack Tagger, dir string, n int) (matches []fs.DirEntry, err error)

+ type DirEntry struct

+ func (f *DirEntry) Info() (fs.FileInfo, error)

+ func (f *DirEntry) Type() fs.FileMode

type ErrTag

+ Key string

+ What error

+ type Header struct

+ func (pack *Header) DataSize() int64

+ func (pack *Header) FTTOffset() int64

+ func (pack *Header) Label() string

+ func (pack *Header) ReadFrom(r io.Reader) (n int64, err error)

+ func (pack *Header) RecNumber() int

+ func (pack *Header) SetLabel(label string)

+ func (pack *Header) WriteTo(w io.Writer) (n int64, err error)

+ type NFTOMap map[string]OFFSET

type Package

+ Tags NFTOMap

+ func (pack *Package) NFTO() NFTOMap

type Packager

+ DataSize func() int64

+ RecNumber func() int

+ type ReadDirFile struct

+ Pack Tagger

+ func (f *ReadDirFile) Close() error

+ func (f *ReadDirFile) Read(b []byte) (n int, err error)

+ func (f *ReadDirFile) ReadDir(n int) (matches []fs.DirEntry, err error)

+ func (f *ReadDirFile) Stat() (fs.FileInfo, error)

type Tagger

+ NFTO func() NFTOMap

type Writer

+ func (pack *Writer) Finalize(w io.WriteSeeker) (err error)

+ func (pack *Writer) Reset()

Feb 21, 2021

Changes in this version

+ const PackHdrSize

+ const Prebuild

+ const Signature

+ var ErrAlready = errors.New("file already present in package")

+ var ErrNoFID = errors.New("file ID is absent")

+ var ErrNoOffset = errors.New("file offset is absent")

+ var ErrNoPath = errors.New("file name is absent")

+ var ErrNoSize = errors.New("file size is absent")

+ var ErrNoTag = errors.New("tag with given ID not found")

+ var ErrNotFound = errors.New("file is not found in package")

+ var ErrOutFID = errors.New("file ID is out of range")

+ var ErrOutOff = errors.New("file offset is out of bounds")

+ var ErrOutSize = errors.New("file size is out of bounds")

+ var ErrSignBad = errors.New("signature does not pass")

+ var ErrSignPre = errors.New("package is not ready yet")

+ var ToSlash = filepath.ToSlash

+ func OpenDir(pack Tagger, dir string) (http.File, error)

+ func ToKey(kpath string) string

+ type ErrKey struct

+ Key string

+ What error

+ func (e *ErrKey) Error() string

+ func (e *ErrKey) Unwrap() error

+ type ErrTag struct

+ TID TID

+ func (e *ErrTag) Error() string

+ func (e *ErrTag) Unwrap() error

+ type FID uint32

+ type File struct

+ Pack Tagger

+ func (f *File) Close() error

+ func (f *File) Readdir(count int) (matches []os.FileInfo, err error)

+ func (f *File) Stat() (os.FileInfo, error)

+ type OFFSET uint64

+ type PackDirHook = func(fi os.FileInfo, kpath, fpath string) bool

+ type PackHdr struct

+ RecNumber FID

+ Signature [0x18]byte

+ TagNumber FID

+ TagOffset OFFSET

+ type Package struct

+ TAT TATMap

+ func (pack *Package) Enum() TATMap

+ func (pack *Package) Glob(pattern string, found func(key string) error) (err error)

+ func (pack *Package) Read(r io.ReadSeeker) (err error)

+ type Packager interface

+ Extract func(string) ([]byte, error)

+ OpenWPK func(string) error

+ SubDir func(string) Packager

+ type SIZE uint64

+ type TATMap map[string]OFFSET

+ type TID uint16

+ const TIDauthor

+ const TIDcategory

+ const TIDchange

+ const TIDcomment

+ const TIDcrc32c

+ const TIDcrc32ieee

+ const TIDcrc32k

+ const TIDcrc64iso

+ const TIDcreated

+ const TIDfid

+ const TIDfileattr

+ const TIDkeywords

+ const TIDlastaccess

+ const TIDlastwrite

+ const TIDlink

+ const TIDmd5

+ const TIDmime

+ const TIDoffset

+ const TIDpath

+ const TIDsha1

+ const TIDsha224

+ const TIDsha256

+ const TIDsha384

+ const TIDsha512

+ const TIDsize

+ const TIDsys

+ const TIDversion

+ type Tag []byte

+ func TagBool(val bool) Tag

+ func TagByte(val byte) Tag

+ func TagNumber(val float64) Tag

+ func TagString(val string) Tag

+ func TagUint16(val TID) Tag

+ func TagUint32(val uint32) Tag

+ func TagUint64(val uint64) Tag

+ func (t Tag) Bool() (bool, bool)

+ func (t Tag) Byte() (byte, bool)

+ func (t Tag) Number() (float64, bool)

+ func (t Tag) String() (string, bool)

+ func (t Tag) Uint() (uint, bool)

+ func (t Tag) Uint16() (TID, bool)

+ func (t Tag) Uint32() (uint32, bool)

+ func (t Tag) Uint64() (uint64, bool)

+ type TagSlice []byte

+ func NewDirTagset(dir string) TagSlice

+ func (ts TagSlice) Bool(tid TID) (bool, bool)

+ func (ts TagSlice) Byte(tid TID) (byte, bool)

+ func (ts TagSlice) FID() FID

+ func (ts TagSlice) GetTag(tid TID) (Tag, error)

+ func (ts TagSlice) IsDir() bool

+ func (ts TagSlice) ModTime() time.Time

+ func (ts TagSlice) Mode() os.FileMode

+ func (ts TagSlice) Name() string

+ func (ts TagSlice) Num() int

+ func (ts TagSlice) Number(tid TID) (float64, bool)

+ func (ts TagSlice) Offset() int64

+ func (ts TagSlice) Path() string

+ func (ts TagSlice) Size() int64

+ func (ts TagSlice) String(tid TID) (string, bool)

+ func (ts TagSlice) Sys() interface{}

+ func (ts TagSlice) Uint(tid TID) (uint, bool)

+ func (ts TagSlice) Uint16(tid TID) (TID, bool)

+ func (ts TagSlice) Uint32(tid TID) (uint32, bool)

+ func (ts TagSlice) Uint64(tid TID) (uint64, bool)

+ type Tagger interface

+ Enum func() TATMap

+ NamedTags func(string) (TagSlice, bool)

+ type TagsMap map[string]Tagset

+ type Tagset map[TID]Tag

+ func (ts Tagset) FID() FID

+ func (ts Tagset) Name() string

+ func (ts Tagset) Offset() int64

+ func (ts Tagset) Path() string

+ func (ts Tagset) ReadFrom(r io.Reader) (n int64, err error)

+ func (ts Tagset) Size() int64

+ func (ts Tagset) WriteTo(w io.Writer) (n int64, err error)

+ type Writer struct

+ Tags TagsMap

+ func (pack *Writer) Append(w io.WriteSeeker) (err error)

+ func (pack *Writer) Begin(w io.WriteSeeker) (err error)

+ func (pack *Writer) Complete(w io.WriteSeeker) (err error)

+ func (pack *Writer) DelAlias(name string) bool

+ func (pack *Writer) PackData(w io.WriteSeeker, r io.Reader, kpath string) (tags Tagset, err error)

+ func (pack *Writer) PackDir(w io.WriteSeeker, dirname, prefix string, hook PackDirHook) (err error)

+ func (pack *Writer) PackFile(w io.WriteSeeker, file *os.File, kpath string) (tags Tagset, err error)

+ func (pack *Writer) PutAlias(oldname, newname string) error

+ func (pack *Writer) Read(r io.ReadSeeker) (err error)

+ func (pack *Writer) Rename(oldname, newname string) error