deprecated

type ItemIndexFunc func(itemOffset, itemLength uint64, v interface{}, p []byte) error

type LegacyPackedScanner interface {
	LegacyScanner
}

type LegacyPackedScannerOpts struct {
	LegacyScannerOpts

	// Transform is called on the data read from a record to reverse any
	// transformations performed when creating the record. It is intended
	// for decompression, decryption etc.
	Transform func(scratch, in []byte) (out []byte, err error)
}

type LegacyPackedWriter interface {
	// Write writes a []byte record to the supplied writer. Each call to write
	// results in a new record being written.
	// Calls to Write and Record may be interspersed.
	io.Writer

	// Marshal marshals an object priort to writing it to the underlying
	// recordio stream.
	Marshal(v interface{}) (n int, err error)

	// Flush is called to write any currently buffered data to the current
	// record. A subsequent write will result in a new record being
	// written. Flush must be called to ensure that the last record is
	// completely written.
	Flush() error
}

type LegacyPackedWriterOpts struct {
	// Marshal is called to marshal an object to a byte slice.
	Marshal MarshalFunc

	// Index is called whenever a new record is written.
	Index RecordIndex

	// Flushed is called whenever a record is written.
	Flushed func() error

	// Transform is called when buffered data is about to be written to a record.
	// It is intended for implementing data transformations such as compression
	// and/or encryption. The Transform function specified here must be
	// reversible by the Transform function in the Scanner.
	Transform func(in [][]byte) (buf []byte, err error)

	// MaxItems is the maximum number of items to pack into a single record.
	// It defaults to DefaultPackedItems if set to 0.
	// If MaxItems exceeds MaxPackedItems it will silently set to MaxPackedItems.
	MaxItems uint32

	// MaxBytes is the maximum number of bytes to pack into a single record.
	// It defaults to DefaultPackedBytes if set to 0.
	MaxBytes uint32
}

type LegacyScanner interface {
	// Reset is equivalent to creating a new scanner, but it retains underlying
	// storage. So it is more efficient than NewScanner. Err is reset to nil. Scan
	// and Bytes will read from rd.
	Reset(rd io.Reader)

	// Scan returns true if a new record was read, false otherwise. It will return
	// false on encoutering an error; the error may be retrieved using the Err
	// method. Note, that Scan will reuse storage from one invocation to the next.
	Scan() bool

	// Bytes returns the current record as read by a prior call to Scan. It may
	// always be called.
	Bytes() []byte

	// Err returns the first error encountered.
	Err() error

	// Unmarshal unmarshals the raw bytes using a preconfigured UnmarshalFunc.
	// It will return an error if there is no preconfigured UnmarshalFunc.
	// Calls to Bytes and Unmarshal may be interspersed.
	Unmarshal(data interface{}) error
}

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

type LegacyScannerOpts struct {
	// Unmarshal is called to unmarshal an object from the supplied byte slice.
	Unmarshal UnmarshalFunc
}

type LegacyWriter interface {
	// Write writes a []byte record to the supplied writer. Each call to write
	// results in a new record being written.
	// Calls to Write and Record may be interspersed.
	io.Writer

	// WriteSlices writes out the supplied slices as a single record, it
	// is intended to avoid having to copy slices into a single slice purely
	// to write them out as a single record.
	WriteSlices(hdr []byte, bufs ...[]byte) (n int, err error)

	// Marshal writes a record using a preconfigured MarshalFunc to the supplied
	// writer. Each call to Record results in a new record being written.
	// Calls to Write and Record may be interspersed.
	Marshal(v interface{}) (n int, err error)
}

type LegacyWriterOpts struct {
	// Marshal is called to marshal an object to a byte slice.
	Marshal MarshalFunc

	// Index is called to enable generating an index for a recordio file; it is
	// called whenever a new record or item is written as per the package
	// level comments.
	Index func(offset, length uint64, v interface{}, p []byte) error
}

type MarshalFunc func(scratch []byte, v interface{}) ([]byte, error)

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

type ObjectPackerOpts struct {
	PackerOpts
}

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

type PackerOpts struct {
	// Buffers will be used to accumulate the buffers written to the packer
	// rather than the Packer allocating its own storage. However, this
	// supplied slice will be grown when its capacity is exceeded, in which case
	// the underlying array used by the caller will no longer store the
	// buffers being packed. It is left to the caller to allocate a buffer
	// large enough to contain the number of buffers that it writes.
	Buffers [][]byte

	// Transform is called when buffered data is about to be written to a record.
	// It is intended for implementing data transformations such as compression
	// and/or encryption. The Transform function specified here must be
	// reversible by the Transform function in the Scanner.
	Transform func(in [][]byte) (buf []byte, err error)
}

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

type RecordIndex func(recordOffset, recordLength, nitems uint64) (ItemIndexFunc, error)

type UnmarshalFunc func(data []byte, v interface{}) error

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

type UnpackerOpts struct {
	// Buffers is used in the same way as by the Packer and PackerOpts.
	Buffers [][]byte

	// Transform is called on the data read from a record to reverse any
	// transformations performed when creating the record. It is intended
	// for decompression, decryption etc.
	Transform func(scratch, in []byte) (out []byte, err error)
}