Wraps a block index, allowing easy use of llrb.Get()

-----------------------------------------------------------------------------

a span of multiple blocks, from start to end, which match the blocks starting at an offset of ComparisonStartOffset

Wraps a blockspan so that it may easily be used in llrb. Corresponds to the start block of the blockspan.

satisfies filechecksum.ChecksumLookup

Wraps a blockspan so that it may easily be used in llrb. Corresponds to the end of the blockspan.

BasicSummary implements a version of the FileSummary interface

If the weak Hash object satisfies this interface, then StartFindMatchingBlocks will not allocate a circular buffer

* BlockSource is an interface used by the patchers to obtain blocks from the reference It does not stipulate where the reference data might be (it cou

BlockSourceBase provides an implementation of blocksource that takes care of everything except for the actual asyncronous request this makes blocksour

A BlockSourceOffsetResolver resolves a blockID to a start offset and and end offset in a file it also handles splitting up ranges of blocks into multi

BlockSourceRequester does synchronous requests on a remote source of blocks concurrency is handled by the BlockSourceBase. This provides a simple way

Checks blocks against their expected checksum

* C2 is a circular buffer intended to allow you to write a block of data of up to 'blocksize', and retrieve the data evicted by that operation, withou

For a given Block, the Weak & Strong hashes, and the offset This structure is only used to generate the index of reference files, since computing the

* Iterates though comparison looking for blocks that match ones from the index it emits each block to be read from the returned channel. Callers shoul

A function or object that can compress blocks the compression function must also write out the compressed blocks somewhere! Compressed blocks should b

* FileChecksumGenerator provides a description of what hashing functions to use to evaluate a file. Since the hashes store state, it is NOT safe to us

FileSummary combines many of the interfaces that are needed It is expected that you might implement it by embedding existing structs

This class provides the implementation of BlockSourceRequester for BlockSourceBase this simplifies creating new BlockSources that satisfy the requirem

The result merger takes many BlockMatchResult and combines adjoining results into spans of blocks

* RSync is an object designed to make the standard use-case for gosync as easy as possible. To this end, it hides away many low level choices by defa

ReadSeekerAt is the combinaton of ReadSeeker and ReaderAt interfaces

Rollsum32 is a rolling checksum implemenation inspired by rsync, but with 32bit internal values Create one using NewRollsum32

The specification of hash.Hash is such that it cannot be implemented without implementing storage but the most optimal storage scheme depends on usage

errorWatcher is a small helper object sendIfSet will only return a channel if there is an error set so w.sendIfSet() <- w.Err() is always safe in a se

-----------------------------------------------------------------------------

*should* produce a non-repeating sequence of bytes in a deterministic fashion use io.LimitReader to limit it to a specific length

Reads a continuous stream of bytes with the same value, up to length