octodiff

type Adler32RollingChecksum struct{}

type Adler32RollingChecksumV2 struct{}

type BinaryDeltaReader struct {
	ProgressReporter ProgressReporter
	// contains filtered or unexported fields
}

type BinaryDeltaWriter struct {
	Output io.Writer
	// contains filtered or unexported fields
}

type ChunkSignature struct {
	// StartOffset is not written to disk, it's just calculated in-memory
	StartOffset int64
	// These fields are included in the binary file
	Length          uint16
	Hash            []byte
	RollingChecksum uint32
}

type DeltaBuilder struct {
	ProgressReporter ProgressReporter
}

type DeltaReader interface {
	ExpectedHash() ([]byte, error)
	HashAlgorithm() (HashAlgorithm, error)

	// Apply reads the delta file.
	// This method will invoke the second func to copy the data from the original file multiple times if needed.
	// This method will also invoke first func to write data from the delta file to the destination file multiple times if needed.
	Apply(
		func([]byte) error,
		func(int64, int64) error,
	) error
}

type DeltaWriter interface {
	WriteMetadata(hashAlgorithm HashAlgorithm, expectedNewFileHash []byte) error
	WriteCopyCommand(offset int64, length int64) error
	WriteDataCommand(source io.ReadSeeker, offset int64, length int64) error

	// A DeltaWriter may "hold" the last CopyCommand, to allow merging sequential copy commands
	// Because of this, we need to tell the writer when it's done to flush any unwritten CopyCommand
	Flush() error
}

type HashAlgorithm interface {
	Name() string
	HashLength() int
	HashOverData(data []byte) []byte
	HashOverReader(reader io.Reader) ([]byte, error)
}

type ProgressReporter interface {
	ReportProgress(operation string, currentPosition int64, total int64)
}

type ReaderIterator struct {

	// Output; zero-init is good
	Current []byte
	// contains filtered or unexported fields
}

type RollingChecksum interface {
	Name() string
	Calculate(block []byte) uint32
	Rotate(checksum uint32, remove byte, add byte, chunkSize int) uint32
}

type Sha1HashAlgorithm struct {
}

type Signature struct {
	HashAlgorithm            HashAlgorithm
	RollingChecksumAlgorithm RollingChecksum
	Chunks                   []*ChunkSignature
}

type SignatureBuilder struct {
	ChunkSize                int
	HashAlgorithm            HashAlgorithm    // must be non-null
	RollingChecksumAlgorithm RollingChecksum  // must be non-null
	ProgressReporter         ProgressReporter // must be non-null
}

type SignatureReader struct {
	ProgressReporter ProgressReporter // must be non-null
}