ptree

type Builder[T, Ref any] struct {
	// contains filtered or unexported fields
}

type BuilderParams[T, Ref any] struct {
	Store           Poster[Ref]
	MeanSize        int
	MaxSize         int
	Seed            *[16]byte
	Compare         CompareFunc[T]
	NewEncoder      func() Encoder[T]
	NewIndexEncoder func() IndexEncoder[T, Ref]
	Copy            func(dst *T, src T)
}

type CompareFunc[T any] func(a, b T) int

type Decoder[T, Ref any] interface {
	// ReadEntry parses an entry from src into ent.  It returns the number of bytes read or an error.
	Read(src []byte, ent *T) (int, error)
	// PeekEntry is like ReadEntry except it should not affect the state of the Decoder
	Peek(src []byte, ent *T) error
	// Reset returns the decoder to the original state for the star of a node.
	Reset(parent Index[T, Ref])
}

type Encoder[T any] interface {
	// Write encodes ent to dst and returns the number of bytes written or an error.
	// ErrOutOfRoom should be returned to indicate that the entry will not fit in the buffer.
	Write(dst []byte, ent T) (int, error)
	// EncodednLen returns the number of bytes that it would take to encode ent.
	// Calling EncodedLen should not affect the state of the Encoder.
	EncodedLen(ent T) int
	// Reset returns the encoder to it's orginally contructed state.
	Reset()
}

type Getter[Ref any] interface {
	// Get fills buf with data at ref, or returns an error.
	// Get will always return an n <= MaxSize()
	Get(ctx context.Context, ref Ref, buf []byte) (n int, err error)
	// MaxSize returns the maximum amount of bytes that could be stored at a ref.
	MaxSize() int
}

type Index[T, Ref any] struct {
	Ref Ref
	// IsNatural is true if this index is a natural boundary
	// A natural boundary.
	IsNatural bool

	Span  state.Span[T]
	Count uint
}

type IndexDecoder[T, Ref any] interface {
	Read(src []byte, ent *Index[T, Ref]) (int, error)
	// PeekEntry is like ReadEntry except it should not affect the state of the Decoder
	Peek(src []byte, ent *Index[T, Ref]) error
	// Reset returns the decoder to the original state for the star of a node.
	Reset(parent Index[T, Ref])
}

type IndexEncoder[T, Ref any] Encoder[Index[T, Ref]]

type IndexHandler[T, Ref any] func(Index[T, Ref]) error

type Iterator[T, Ref any] struct {
	// contains filtered or unexported fields
}

type IteratorParams[T, Ref any] struct {
	Store           Getter[Ref]
	NewDecoder      func() Decoder[T, Ref]
	NewIndexDecoder func() IndexDecoder[T, Ref]
	Compare         CompareFunc[T]
	Copy            func(dst *T, src T)

	Root Root[T, Ref]
	Span state.Span[T]
}

type Poster[Ref any] interface {
	// Posts stores the data and returns a Ref for retrieving it.
	Post(ctx context.Context, data []byte) (Ref, error)
	// MaxSize is the maximum amount of data that can be Posted in bytes
	MaxSize() int
}

type ReadParams[T, Ref any] struct {
	Store           Getter[Ref]
	NewDecoder      func() Decoder[T, Ref]
	NewIndexDecoder func() IndexDecoder[T, Ref]
	Compare         CompareFunc[T]
}

type Root[T, Ref any] struct {
	Index[T, Ref]
	Depth uint8
}

type Store[Ref any] interface {
	Getter[Ref]
	Poster[Ref]
}

type StreamReader[T, Ref any] struct {
	// contains filtered or unexported fields
}

type StreamReaderParams[T, Ref any] struct {
	Store     Getter[Ref]
	Decoder   Decoder[T, Ref]
	Compare   CompareFunc[T]
	NextIndex func(ctx context.Context, dst *Index[T, Ref]) error
}

type StreamWriter[T, Ref any] struct {
	// contains filtered or unexported fields
}

type StreamWriterParams[T, Ref any] struct {
	Store    Poster[Ref]
	Seed     *[16]byte
	MeanSize int
	MaxSize  int
	Compare  func(a, b T) int
	Encoder  Encoder[T]
	// OnIndex must not retain the index after the call has ended.
	OnIndex IndexHandler[T, Ref]
	Copy    func(dst *T, src T)
}