storer

type DeltaObjectStorer interface {
	// DeltaObject is the same as EncodedObject but without resolving deltas.
	// Deltas will be returned as plumbing.DeltaObject instances.
	DeltaObject(plumbing.ObjectType, plumbing.Hash) (plumbing.EncodedObject, error)
}

type EncodedObjectIter interface {
	Next() (plumbing.EncodedObject, error)
	ForEach(func(plumbing.EncodedObject) error) error
	Close()
}

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

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

type EncodedObjectStorer interface {
	// NewEncodedObject returns a new plumbing.EncodedObject, the real type
	// of the object can be a custom implementation or the default one,
	// plumbing.MemoryObject.
	NewEncodedObject() plumbing.EncodedObject
	// SetEncodedObject saves an object into the storage, the object should
	// be create with the NewEncodedObject, method, and file if the type is
	// not supported.
	SetEncodedObject(plumbing.EncodedObject) (plumbing.Hash, error)
	// EncodedObject gets an object by hash with the given
	// plumbing.ObjectType. Implementors should return
	// (nil, plumbing.ErrObjectNotFound) if an object doesn't exist with
	// both the given hash and object type.
	//
	// Valid plumbing.ObjectType values are CommitObject, BlobObject, TagObject,
	// TreeObject and AnyObject. If plumbing.AnyObject is given, the object must
	// be looked up regardless of its type.
	EncodedObject(plumbing.ObjectType, plumbing.Hash) (plumbing.EncodedObject, error)
	// IterObjects returns a custom EncodedObjectStorer over all the object
	// on the storage.
	//
	// Valid plumbing.ObjectType values are CommitObject, BlobObject, TagObject,
	IterEncodedObjects(plumbing.ObjectType) (EncodedObjectIter, error)
	// HasEncodedObject returns ErrObjNotFound if the object doesn't
	// exist.  If the object does exist, it returns nil.
	HasEncodedObject(plumbing.Hash) error
	// EncodedObjectSize returns the plaintext size of the encoded object.
	EncodedObjectSize(plumbing.Hash) (int64, error)
}

type IndexStorer interface {
	SetIndex(*index.Index) error
	Index() (*index.Index, error)
}

type Initializer interface {
	// Init performs initialization of the storer and returns the error, if
	// any.
	Init() error
}

type LooseObjectStorer interface {
	// ForEachObjectHash iterates over all the (loose) object hashes
	// in the repository without necessarily having to read those objects.
	// Objects only inside pack files may be omitted.
	// If ErrStop is sent the iteration is stop but no error is returned.
	ForEachObjectHash(func(plumbing.Hash) error) error
	// LooseObjectTime looks up the (m)time associated with the
	// loose object (that is not in a pack file). Some
	// implementations (e.g. without loose objects)
	// always return an error.
	LooseObjectTime(plumbing.Hash) (time.Time, error)
	// DeleteLooseObject deletes a loose object if it exists.
	DeleteLooseObject(plumbing.Hash) error
}

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

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

type PackedObjectStorer interface {
	// ObjectPacks returns hashes of object packs if the underlying
	// implementation has pack files.
	ObjectPacks() ([]plumbing.Hash, error)
	// DeleteOldObjectPackAndIndex deletes an object pack and the corresponding index file if they exist.
	// Deletion is only performed if the pack is older than the supplied time (or the time is zero).
	DeleteOldObjectPackAndIndex(plumbing.Hash, time.Time) error
}

type PackfileWriter interface {
	// PackfileWriter returns a writer for writing a packfile to the storage
	//
	// If the Storer not implements PackfileWriter the objects should be written
	// using the Set method.
	PackfileWriter() (io.WriteCloser, error)
}

type ReferenceIter interface {
	Next() (*plumbing.Reference, error)
	ForEach(func(*plumbing.Reference) error) error
	Close()
}

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

type ReferenceStorer interface {
	SetReference(*plumbing.Reference) error
	// CheckAndSetReference sets the reference `new`, but if `old` is
	// not `nil`, it first checks that the current stored value for
	// `old.Name()` matches the given reference value in `old`.  If
	// not, it returns an error and doesn't update `new`.
	CheckAndSetReference(new, old *plumbing.Reference) error
	Reference(plumbing.ReferenceName) (*plumbing.Reference, error)
	IterReferences() (ReferenceIter, error)
	RemoveReference(plumbing.ReferenceName) error
	CountLooseRefs() (int, error)
	PackRefs() error
}

type ShallowStorer interface {
	SetShallow([]plumbing.Hash) error
	Shallow() ([]plumbing.Hash, error)
}

type Storer interface {
	EncodedObjectStorer
	ReferenceStorer
}

type Transaction interface {
	SetEncodedObject(plumbing.EncodedObject) (plumbing.Hash, error)
	EncodedObject(plumbing.ObjectType, plumbing.Hash) (plumbing.EncodedObject, error)
	Commit() error
	Rollback() error
}

type Transactioner interface {
	// Begin starts a transaction.
	Begin() Transaction
}