iter

type ArrStream ¶

type ArrStream[V any] struct {
	// contains filtered or unexported fields
}

func Array[V any](arr []V) *ArrStream[V]

func ReverseArray[V any](arr []V) *ArrStream[V]

func (it *ArrStream[V]) Close()

func (it *ArrStream[V]) HasNext() bool

func (it *ArrStream[V]) Next() (V, error)

func (it *ArrStream[V]) NextBatch() ([]V, error)

type Closer ¶

type Closer interface {
	Close()
}

type Dual ¶

type Dual[K, V any] interface {
	Next() (K, V, error)
	HasNext() bool
}

Dual - return 2 items - usually called Key and Value (or `k` and `v`) Example:

for s.HasNext() {
	k, v, err := s.Next()
	if err != nil {
		return err
	}
}

type EmptyDual ¶

type EmptyDual[K, V any] struct{}

func (EmptyDual[K, V]) HasNext() bool

func (EmptyDual[K, V]) Next() (k K, v V, err error)

type EmptyUnary ¶

type EmptyUnary[T any] struct{}

func (EmptyUnary[T]) HasNext() bool

func (EmptyUnary[T]) Next() (v T, err error)

type FilterDualIter ¶

type FilterDualIter[K, V any] struct {
	// contains filtered or unexported fields
}

FilterDualIter - analog `map` (in terms of map-filter-reduce pattern) please avoid reading from Disk/DB more elements and then filter them. Better push-down filter conditions to lower-level iterator to reduce disk reads amount.

func FilterDual[K, V any](it Dual[K, V], filter func(K, V) bool) *FilterDualIter[K, V]

func FilterKV(it KV, filter func(k, v []byte) bool) *FilterDualIter[[]byte, []byte]

func (m *FilterDualIter[K, v]) Close()

func (m *FilterDualIter[K, V]) HasNext() bool

func (m *FilterDualIter[K, V]) Next() (k K, v V, err error)

type FilterUnaryIter ¶

type FilterUnaryIter[T any] struct {
	// contains filtered or unexported fields
}

FilterUnaryIter - analog `map` (in terms of map-filter-reduce pattern) please avoid reading from Disk/DB more elements and then filter them. Better push-down filter conditions to lower-level iterator to reduce disk reads amount.

func FilterU64(it U64, filter func(k uint64) bool) *FilterUnaryIter[uint64]

func FilterUnary[T any](it Unary[T], filter func(T) bool) *FilterUnaryIter[T]

func (m *FilterUnaryIter[T]) Close()

func (m *FilterUnaryIter[T]) HasNext() bool

func (m *FilterUnaryIter[T]) Next() (k T, err error)

type IntersectIter ¶

type IntersectIter[T constraints.Ordered] struct {
	// contains filtered or unexported fields
}

IntersectIter

func (m *IntersectIter[T]) Close()

func (m *IntersectIter[T]) HasNext() bool

func (m *IntersectIter[T]) Next() (T, error)

type KV ¶

type KV Dual[[]byte, []byte]

often used shortcuts

func UnionKV(x, y KV, limit int) KV

type NextPageDual ¶

type NextPageDual[K, V any] func(pageToken string) (keys []K, values []V, nextPageToken string, err error)

internal types

type NextPageUnary ¶

type NextPageUnary[T any] func(pageToken string) (arr []T, nextPageToken string, err error)

internal types

type Paginated ¶

type Paginated[T any] struct {
	// contains filtered or unexported fields
}

PaginatedIter - for remote-list pagination

Rationale: If an API does not support pagination from the start, supporting it later is troublesome because adding pagination breaks the API's behavior. Clients that are unaware that the API now uses pagination could incorrectly assume that they received a complete result, when in fact they only received the first page.

To support pagination (returning list results in pages) in a List method, the API shall:

• The client uses this field to request a specific page of the list results.
• define an int32 field page_size in the List method's request message. Clients use this field to specify the maximum number of results to be returned by the server. The server may further constrain the maximum number of results returned in a single page. If the page_size is 0, the server will decide the number of results to be returned.
• define a string field next_page_token in the List method's response message. This field represents the pagination token to retrieve the next page of results. If the value is "", it means no further results for the request.

see: https://cloud.google.com/apis/design/design_patterns

func Paginate[T any](f NextPageUnary[T]) *Paginated[T]

func PaginateU64(f NextPageUnary[uint64]) *Paginated[uint64]

func (it *Paginated[T]) Close()

func (it *Paginated[T]) HasNext() bool

func (it *Paginated[T]) Next() (v T, err error)

type PaginatedDual ¶

type PaginatedDual[K, V any] struct {
	// contains filtered or unexported fields
}

func PaginateDual[K, V any](f NextPageDual[K, V]) *PaginatedDual[K, V]

func PaginateKV(f NextPageDual[[]byte, []byte]) *PaginatedDual[[]byte, []byte]

func (it *PaginatedDual[K, V]) Close()

func (it *PaginatedDual[K, V]) HasNext() bool

func (it *PaginatedDual[K, V]) Next() (k K, v V, err error)

type PairsWithErrorIter ¶

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

PairsWithErrorIter - return N, keys and then error

func PairsWithError(errorAt int) *PairsWithErrorIter

func (m *PairsWithErrorIter) HasNext() bool

func (m *PairsWithErrorIter) Next() ([]byte, []byte, error)

type RangeIter ¶

type RangeIter[T constraints.Integer] struct {
	// contains filtered or unexported fields
}

func Range[T constraints.Integer](from, to T) *RangeIter[T]

func (it *RangeIter[T]) Close()

func (it *RangeIter[T]) HasNext() bool

func (it *RangeIter[T]) Next() (T, error)

type TransformDualIter ¶

type TransformDualIter[K, V any] struct {
	// contains filtered or unexported fields
}

TransformDualIter - analog `map` (in terms of map-filter-reduce pattern)

func TransformDual[K, V any](it Dual[K, V], transform func(K, V) (K, V, error)) *TransformDualIter[K, V]

func TransformKV(it KV, transform func(k, v []byte) ([]byte, []byte, error)) *TransformDualIter[[]byte, []byte]

func (m *TransformDualIter[K, v]) Close()

func (m *TransformDualIter[K, V]) HasNext() bool

func (m *TransformDualIter[K, V]) Next() (K, V, error)

type TransformKV2U64Iter ¶

type TransformKV2U64Iter[K, V []byte] struct {
	// contains filtered or unexported fields
}

func TransformKV2U64[K, V []byte](it KV, transform func(K, V) (uint64, error)) *TransformKV2U64Iter[K, V]

func (m *TransformKV2U64Iter[K, v]) Close()

func (m *TransformKV2U64Iter[K, V]) HasNext() bool

func (m *TransformKV2U64Iter[K, V]) Next() (uint64, error)

type U64 ¶

type U64 Unary[uint64]

often used shortcuts

type Unary ¶

type Unary[V any] interface {
	Next() (V, error)
	//NextBatch() ([]V, error)
	HasNext() bool
}

Unary - return 1 item. Example:

for s.HasNext() {
	v, err := s.Next()
	if err != nil {
		return err
	}
}

func Intersect[T constraints.Ordered](x, y Unary[T], limit int) Unary[T]

func Union[T constraints.Ordered](x, y Unary[T], asc order.By, limit int) Unary[T]

type UnionKVIter ¶

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

UnionKVIter - merge 2 kv.Pairs streams to 1 in lexicographically order 1-st stream has higher priority - when 2 streams return same key

func (m *UnionKVIter) Close()

func (m *UnionKVIter) HasNext() bool

func (m *UnionKVIter) Next() ([]byte, []byte, error)

type UnionUnary ¶

type UnionUnary[T constraints.Ordered] struct {
	// contains filtered or unexported fields
}

UnionUnary

func (m *UnionUnary[T]) Close()

func (m *UnionUnary[T]) HasNext() bool

func (m *UnionUnary[T]) Next() (res T, err error)