qfs

type AddedFile struct {
	Path  string
	Name  string
	Bytes int64
	Hash  string
	Size  string
}

type Adder interface {
	// AddFile adds a file or directory of files to the store
	// this function will return immediately, consumers should read
	// from the Added() channel to see the results of file addition.
	AddFile(context.Context, File) error
	// Added gives a channel to read added files from.
	Added() chan AddedFile
	// In IPFS land close calls adder.Finalize() and adder.PinRoot()
	// (files will only be pinned if the pin flag was set on NewAdder)
	Finalize() (string, error)
}

type AddingFS interface {
	// NewAdder allocates an Adder instance for adding files to the filestore
	// Adder gives a higher degree of control over the file adding process at the
	// cost of being harder to work with.
	// "pin" is a flag for recursively pinning this object
	// "wrap" sets weather the top level should be wrapped in a directory
	NewAdder(ctx context.Context, pin, wrap bool) (Adder, error)
}

type CAFS interface {
	IsContentAddressedFilesystem()
}

type Config struct {
	Type   string                 `json:"type"`
	Config map[string]interface{} `json:"config,omitempty"`
}

type Constructor func(ctx context.Context, cfg map[string]interface{}) (Filesystem, error)

type Destroyer interface {
	Destroy() error
}

type File interface {
	// Files implement ReadCloser, but can only be read from or closed if
	// they are not directories
	io.ReadCloser

	// FileName returns a filename associated with this file
	// TODO (b5): consider renaming this to Base
	FileName() string

	// FullPath returns the full path used when adding this file
	FullPath() string

	// IsDirectory returns true if the File is a directory (and therefore
	// supports calling `NextFile`) and false if the File is a normal file
	// (and therefor supports calling `Read` and `Close`)
	IsDirectory() bool

	// NextFile returns the next child file available (if the File is a
	// directory). It will return (nil, io.EOF) if no more files are
	// available. If the file is a regular file (not a directory), NextFile
	// will return a non-nil error.
	NextFile() (File, error)

	// ModTime returns file modification time
	ModTime() time.Time

	// MediaType returns a is a string that indicates the nature and format of a
	// document, file, or assortment of bytes. Media types are described in IETF
	// RFC 6838: https://tools.ietf.org/html/rfc6838
	// MediaTypes expand on Multipurpose Internet Mail Extensions or MIME types,
	// and can include "non-official" media type responses
	MediaType() string
}

type Filesystem interface {
	// Type returns a string identifier that distinguishes a filesystem from
	// all other implementations, example identifiers include: "local", "ipfs",
	// and "http"
	// types are used as path prefixes when multiplexing filesystems
	Type() string
	// Has returns whether the `path` is mapped to a value.
	// In some contexts, it may be much cheaper only to check for existence of
	// a value, rather than retrieving the value itself. (e.g. HTTP HEAD).
	// The default implementation is found in `GetBackedHas`.
	Has(ctx context.Context, path string) (exists bool, err error)
	// Get fetching files and directories from path strings.
	// in practice path strings can be things like:
	// * a local filesystem
	// * URLS (a "URL path resolver") or
	// * content-addressed file systems like IPFS or Git
	// Datasets & dataset components use a filesource to resolve string references
	Get(ctx context.Context, path string) (File, error)
	// Put places a file or directory on the filesystem, returning the root path.
	// The returned path may or may not honor the path of the given file
	Put(ctx context.Context, file File) (path string, err error)
	// Delete removes a file or directory from the filesystem
	Delete(ctx context.Context, path string) (err error)
}

type MemFS struct {
	Pinned  bool
	Network []*MemFS

	Files map[string]filer
	// contains filtered or unexported fields
}

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

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

type PathResolver interface {
	Get(ctx context.Context, path string) (File, error)
}

type PathSetter interface {
	SetPath(path string)
}

type PinningFS interface {
	Pin(ctx context.Context, key string, recursive bool) error
	Unpin(ctx context.Context, key string, recursive bool) error
}

type ReleasingFilesystem interface {
	Filesystem
	Done() <-chan struct{}
	DoneErr() error
}

type WriteHook func(ctx context.Context, f File, added map[string]string) (io.Reader, error)

type WriteHookFile interface {
	File
	RequiredPaths() []string
	HasRequiredPaths(paths map[string]string) bool
	CallAndAdd(ctx context.Context, adder Adder, added map[string]string) error
}