dm

type BlockMatch struct {
	// Index is same as LinePos.Index of starting line of match.
	// Length is number of lines that match.
	AIndex, BIndex, Length int
}

type BlockMatchByAIndex []BlockMatch

type BlockMatchByBIndex []BlockMatch

type BlockPair struct {
	AIndex, ALength int
	BIndex, BLength int
	MoveId          int // An attempt to tell one move from another.
	// If IsMatch and IsNormalizedMatch are both true, this means that the
	// lines match after normalization, and it is possible that some or even
	// all of them are exact mathes, but we've not recorded that.
	IsMatch           bool
	IsNormalizedMatch bool
	IsMove            bool // Does this represent a move?
}

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

type BlockPairByAIndex []*BlockPair

type BlockPairByBIndex []*BlockPair

type BlockPairs []*BlockPair

type Diff3Triple struct {
	TripleType Diff3TripleType

	// The lines in base that are the anchor for this block.
	BaseStart, BaseBeyond int

	// The BlockPairs that are the basis of this triple.
	B2YPair, B2TPair *BlockPair
}

type Diff3TripleType int

type Diff3Triples []*Diff3Triple

type DifferencerConfig struct {
	// Before computing the alignment between lines of two files, should
	// the common prefix and suffix be identified, reducing the number of
	// lines being aligned by the more general technique? (Improves the
	// alignment of inserted functions in C-like languages, as the trailing
	// curly braces get matched to the correct function more often.)
	MatchEnds bool

	// When matching the common prefix and suffix, after matching full lines,
	// should common normalized prefix and suffix lines be matched?
	MatchNormalizedEnds bool

	// When computing an alignment between files, should lines be normalized
	// before comparing (i.e. compare hashes of normalized lines, not of full
	// lines).
	AlignNormalizedLines bool

	// When computing an alignment between files, should unique/rare lines be
	// used for computing the alignment, or all lines?
	AlignRareLines bool

	// When deciding which lines are rare in a region being aligned, how many
	// times may a line appear (actually, how many times may its hash appear)
	// and still be considered rare?
	MaxRareLineOccurrencesInRange int

	// When selecting rare lines, discard those lines whose hash, after
	// normalization, appears more than this many times. If 0, not applied.
	MaxRareLineOccurrencesInFile int

	// When deciding which lines are rare in two regions being aligned,
	// must those lines appear the same number of times in each region?
	RequireSameRarity bool

	// When computing an alignment between files, should blocks of moved lines
	// be detected (i.e. detect re-ordering of paragraphs/functions).
	DetectBlockMoves bool

	// When computing the longest common subsequence of two file ranges,
	// how similar are two normalized lines to be considered, where 0 is
	// completely dissimilar, and 1 is equal.
	LcsNormalizedSimilarity float64

	// When computing an LCS alignment between files, should longer equal lines
	// be weighted more heavily that short lines?
	LengthWeightedSimilarity bool

	// When doing alignment (initial or move/copy detection), omit from
	// consideration the lines that are probably common (e.g. "/*" or "}").
	OmitProbablyCommonLines bool
}

type File struct {
	Name  string    // Command line arg
	Body  []byte    // Body of the file
	Lines []LinePos // Locations and hashes of the file lines.

	FullRange  FileRange
	FileRanges map[IndexPair]FileRange
}

type FilePair interface {
	AFile() *File
	BFile() *File

	FullFileRangePair() FileRangePair
	MakeSubRangePair(aIndex, aLength, bIndex, bLength int) FileRangePair

	MakeFileRangePair(aRange, bRange FileRange) FileRangePair

	ALength() int
	BLength() int

	BriefDebugString() string

	CompareFileLines(aIndex, bIndex int, maxRareOccurrences uint8) (equal, approx, rare bool)

	CanFillGapWithMatches(pair1, pair2 *BlockPair) (equal, approx bool)
}

type FileRange interface {
	File() *File

	// Is the FileRange empty (GetLineCount() == 0)?
	IsEmpty() bool

	// Returns the number of lines in the range.
	Length() int

	// Returns the index of the first line (zero for the whole file).
	FirstIndex() int

	// Returns index of line immediately after the range.
	BeyondIndex() int

	// Returns the LinePos for the line at offset within this range (where zero
	// is the first line in the range).
	LinePosAtOffset(offsetInRange int) LinePos

	// Returns the hash of the line (full or normalized) at the offset within this
	// range (where zero is the first line in the range).
	LineHashAtOffset(offsetInRange int, normalized bool) uint32

	// Returns those lines for which fn returns true.
	Select(fn func(lp LinePos) bool) []LinePos

	// Returns the positions (line numbers, zero-based) within
	// the underlying file at which the full line hashes appear.
	HashPositions() map[uint32][]int

	// Returns the positions (line numbers, zero-based) within
	// the underlying file at which the normalized line hashes appear.
	NormalizedHashPositions() map[uint32][]int

	// Returns a FileRange for the specified subset.
	MakeSubRange(startOffsetInRange, length int) FileRange

	ToFileIndex(offsetInRange int) (indexInFile int)
	ToRangeOffset(indexInFile int) (offsetInRange int)
}

type FileRangePair interface {
	// The files.
	BaseFilePair() FilePair

	ARange() FileRange
	BRange() FileRange

	ALength() int
	BLength() int

	ToFileIndices(aOffset, bOffset int) (aIndex, bIndex int)
	ToRangeOffsets(aIndex, bIndex int) (aOffset, bOffset int)
	MakeSubRangePair(aOffset, aLength, bOffset, bLength int) FileRangePair

	BriefDebugString() string

	MeasureSharedEnds(onlyExactMatches bool, maxRareOccurrences uint8) SharedEndsData
	CompareLines(aOffset, bOffset int, maxRareOccurrences uint8) (equal, approx, rare bool)
	MakeSharedEndBlockPairs(rareEndsOnly, onlyExactMatches bool, maxRareOccurrences uint8) (prefixPairs, suffixPairs []*BlockPair)
	MakeMiddleRangePair(rareEndsOnly, onlyExactMatches bool, maxRareOccurrences uint8) FileRangePair
}

type Float32UnaryFunction interface {
	Compute(input float64) float64
}

type FourIndices [4]int

type GeneralizedLogisticFunction struct {
	A, K float64 // Lower and upper asymptotes which the output will approach.
	M    float64 // Origin of input.
	B    float64 // Exponential growth rate, used in: e ^ (-B(t-M))
	Q    float64 // Scalar growth rate, and Y(M) anchor, used in denominator: 1 + Q e ^ (-B(t-M))
	V    float64 // Asymmetry Factor (skews the curve left or right, so that one asymptote or another is "longer")
}

type GetIntervalFn func(pair *BlockPair) (begin, beyond int)

type HashPositions map[uint32][]int

type IndexPair struct {
	Index1, Index2 int
}

type IndexPairByIndex1 []IndexPair

type IndexPairByIndex2 []IndexPair

type IntervalSet interface {
	InsertInterval(begin, beyond int)
	ContainsSome(begin, beyond int) bool
	ContainsAll(begin, beyond int) bool
	Contains(position int) bool

	// If position is in an interval, returns that interval. If position is
	// between two intervals, returns those two; if beyond last interval, returns
	// the last interval; if before first interval, returns the first interval.
	IntervalsAround(position int) (result []IndexPair, isContained bool)
}

type LeadingWhitespaceStatistics struct {
	NumFilesAdded             uint64
	NumValidLines             uint64
	NumInvalidLines           uint64
	NumLeadingTabs            map[uint8]int
	NumLeadingSpaces          map[uint8]int
	NumLeadingSpacesAfterTab  map[uint8]int
	FracLeadingTabs           map[uint8]float32
	FracLeadingSpaces         map[uint8]float32
	FracLeadingSpacesAfterTab map[uint8]float32
}

type LineHasher interface {
	Compute(line []byte) (fullHash, normalizedHash uint32)
	Compute2(line, normalizedLine []byte) (fullHash, normalizedHash uint32)
}

type LinePos struct {
	Start, Length, Index int

	// Hash of the full line (including newline and/or carriage return at end).
	Hash uint32
	// Hash for a "normalized" version of the line, with the thought
	// that if there is a very large amount of difference between two files, it
	// maybe due to relatively minor formatting changes (e.g. indentation or
	// justification) rather than other kinds of changes.
	// Possible normalizations:
	// * leading and trailing whitespace removed
	// * all interior whitespace runs collapsed to a single space
	//   or maybe completely removed
	// * convert all letters characters to a single case (very aggressive)
	NormalizedHash uint32

	// Count of the normalized hash in the file.
	// Maximum is 255, but that is OK for rare-ness checking.
	CountInFile uint8

	// Length of line after normalization.
	// Maximum is 255, but that is OK for deciding whether a line is short or not.
	NormalizedLength uint8

	// Number of leading tabs and then leading spaces of a line. Capped at 255,
	// and set to 255 if the leading whitespace is not well-formed.
	LeadingTabs, LeadingSpaces uint8

	// Is this a well known common line (e.g. "/*" or "#", or an empty line).
	ProbablyCommon bool // Based solely on normalized content, not other lines.
}

type MatchCommonXFunc func(aRange, bRange FileRange, normalized bool) (
	aRest, bRest FileRange, bp *BlockPair)

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

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

type MoveCandidate2s []*MoveCandidate2

type MoveCandidates []*MoveCandidate

type SelectBlockPairFn func(pair *BlockPair) bool

type SharedEndsData struct {
	SharedEndsKey
	// If the lines in the range are equal, or equal after normalization
	// (approximately equal), then one or both of these booleans are true,
	// and the prefix and suffix lengths are 0.
	RangesAreEqual, RangesAreApproximatelyEqual bool

	// The FileRangePair which was measured to produce this.
	Source FileRangePair

	NonRarePrefixLength, NonRareSuffixLength int
	RarePrefixLength, RareSuffixLength       int
}

type SharedEndsKey struct {
	OnlyExactMatches   bool
	MaxRareOccurrences uint8
}

type SideBySideConfig struct {
	// How many columns (mono-spaced characters) does the output 'device' have?
	DisplayColumns int

	DisplayLineNumbers bool
	WrapLongLines      bool // Wrap (vs. truncate) long lines.

	SpacesPerTab int // Defaults to 8

	// Number of lines of context (exact match lines) to output adjacent to
	// changes. If 0, then all exact match lines are output.
	ContextLines int

	ZeroBasedLineNumbers bool
}

type SimilarityFactors struct {
	ExactRare          float32
	NormalizedRare     float32
	ExactNonRare       float32
	NormalizedNonRare  float32
	MaxRareOccurrences uint8
}