accessio

type AnnotatedBlobAccess[T blobaccess.DataAccess] interface {
	blobaccess.BlobAccess
	Source() T
}

type BlobAccess = blobaccess.BlobAccess

type BlobCache interface {
	BlobSource
	BlobSink
	AddData(data blobaccess.DataAccess) (int64, digest.Digest, error)
}

type BlobSink interface {
	refmgmt.Allocatable
	AddBlob(blob blobaccess.BlobAccess) (int64, digest.Digest, error)
}

type BlobSource interface {
	refmgmt.Allocatable
	GetBlobData(digest digest.Digest) (int64, blobaccess.DataAccess, error)
}

type Buffer interface {
	Write(out []byte) (int, error)
	Reader() (io.ReadCloser, error)
	Len() int
	Close() error
	Release() error
}

type CleanupCache interface {
	// Cleanup can be implemented to offer a cache reorg.
	// It returns the number and size of
	//	- handled entries (cnt, size)
	//	- not handled entries (ncnt, nsize)
	//	- failing entries (fcnt, fsize)
	Cleanup(p common.Printer, before *time.Time, dryrun bool) (cnt int, ncnt int, fcnt int, size int64, nsize int64, fsize int64, err error)
}

type Closer func() error

type CloserCallback func()

type DataAccess = blobaccess.DataAccess

type DataSource = blobaccess.DataSource

type DataWriter interface {
	WriteTo(Writer) (int64, digest.Digest, error)
}

type FileFormat string

type LimitedBuffer struct {
	*LimitedWriter
	// contains filtered or unexported fields
}

type LimitedWriter struct {
	W io.Writer // underlying reader
	N int64     // max bytes remaining
}

type NopCloser = iotools.NopCloser

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

type Option interface {
	ApplyOption(options Options) error
}

type Options interface {
	Option

	SetFileFormat(FileFormat)
	GetFileFormat() *FileFormat

	SetPathFileSystem(vfs.FileSystem)
	GetPathFileSystem() vfs.FileSystem

	SetRepresentation(vfs.FileSystem)
	GetRepresentation() vfs.FileSystem

	SetFile(vfs.File)
	GetFile() vfs.File

	SetReader(closer io.Reader)
	GetReader() io.Reader

	ValidForPath(path string) error
	WriterFor(path string, mode vfs.FileMode) (io.WriteCloser, error)

	DefaultFormat(fmt FileFormat)
	Default()

	DefaultForPath(path string) error
}

type ReaderProvider interface {
	Reader() (io.ReadCloser, error)
}

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

type RootedCache interface {
	Root() (string, vfs.FileSystem)
}

type StandardOptions struct {
	// FilePath is the path of the repository base in the filesystem
	FileFormat *FileFormat `json:"fileFormat,omitempty"`
	// FileSystem is the virtual filesystem to evaluate the file path. Default is the OS filesytem
	// or the filesystem defined as base filesystem for the context
	// This configuration option is not available for the textual representation of
	// the repository specification
	PathFileSystem vfs.FileSystem `json:"-"`
	// Representation is the virtual filesystem to represent the active repository cache.
	// This configuration option is not available for the textual representation of
	// the repository specification
	Representation vfs.FileSystem `json:"-"`
	// File is an opened file object to use instead of the path and path filesystem
	// It should never be closed if given to support temporary files
	File vfs.File `json:"-"`
	// Reader provides a one time access to the content (archive content only)
	// The resulting access is therefore temporary and cannot be written back
	// to its origin, but to other destinations.
	// The reader must be closed by the provider.
	Reader io.Reader `json:"-"`
}

type StaticAllocatable struct{}

type Writer interface {
	io.Writer
	io.WriterAt
}