gitee.com/sy_183/go-common@v1.0.5-0.20231205030221-958cfe129b47/stream/iter/iter.go

package iter

import (
	"gitee.com/sy_183/go-common/generic"
	"gitee.com/sy_183/go-common/maps"
	mapUnsafe "gitee.com/sy_183/go-common/maps/unsafe"
	"gitee.com/sy_183/go-common/slice"
	"gitee.com/sy_183/go-common/stream"
	"gitee.com/sy_183/go-common/strings"
	"unicode/utf8"
	_ "unsafe"
)

func Range[I generic.Integer](size I) stream.Iter[I] {
	var count I
	return func() (i I, ok bool) {
		if count < size {
			i = count
			count++
			return i, true
		}
		return
	}
}

func Repeat[V any, I generic.Integer](v V, size I) stream.Iter[V] {
	var count I
	return func() (value V, ok bool) {
		if count < size {
			count++
			return v, true
		}
		return
	}
}

func RepeatNew[V any, I generic.Integer](newFn func() V, size I) stream.Iter[V] {
	var count I
	return func() (value V, ok bool) {
		if count < size {
			count++
			return newFn(), true
		}
		return
	}
}

func RepeatClone[V any, I generic.Integer](v V, cloneFn func(V) V, size I) stream.Iter[V] {
	var count I
	return func() (value V, ok bool) {
		if count < size {
			count++
			return cloneFn(v), true
		}
		return
	}
}

func Elems[E any](elems ...E) stream.Iter[E] {
	return Slice(elems)
}

func Slice[E any](s []E) stream.Iter[E] {
	var i int
	return func() (e E, ok bool) {
		if i < len(s) {
			e = s[i]
			i++
			return e, true
		}
		return
	}
}

func ReverseSlice[E any](s []E) stream.Iter[E] {
	i := len(s) - 1
	return func() (e E, ok bool) {
		if i >= 0 {
			e = s[i]
			i--
			return e, true
		}
		return
	}
}

func SliceP[E any](s []E) stream.Iter[*E] {
	var i int
	return func() (e *E, ok bool) {
		if i < len(s) {
			e = &s[i]
			i++
			return e, true
		}
		return
	}
}

func ReverseSliceP[E any](s []E) stream.Iter[*E] {
	i := len(s) - 1
	return func() (e *E, ok bool) {
		if i >= 0 {
			e = &s[i]
			i--
			return e, true
		}
		return
	}
}

func SliceEntries[E any](s []E) stream.Iter[slice.Entry[E]] {
	var i int
	return func() (e slice.Entry[E], ok bool) {
		if i < len(s) {
			e.Index, e.Elem = i, s[i]
			i++
			return e, true
		}
		return
	}
}

func ReversSliceEntries[E any](s []E) stream.Iter[slice.Entry[E]] {
	i := len(s) - 1
	return func() (e slice.Entry[E], ok bool) {
		if i >= 0 {
			e.Index, e.Elem = i, s[i]
			i--
			return e, true
		}
		return
	}
}

func SlicePEntries[E any](s []E) stream.Iter[slice.Entry[*E]] {
	var i int
	return func() (e slice.Entry[*E], ok bool) {
		if i < len(s) {
			e.Index, e.Elem = i, &s[i]
			i++
			return e, true
		}
		return
	}
}

func ReverseSlicePEntries[E any](s []E) stream.Iter[slice.Entry[*E]] {
	i := len(s) - 1
	return func() (e slice.Entry[*E], ok bool) {
		if i >= 0 {
			e.Index, e.Elem = i, &s[i]
			i--
			return e, true
		}
		return
	}
}

func MapEntries[K comparable, V any](m map[K]V) stream.Iter[maps.Entry[K, V]] {
	iter := mapUnsafe.NewIter(m)
	return func() (e maps.Entry[K, V], ok bool) {
		if iter.Has() {
			e.Key = iter.Key()
			e.Value = iter.Value()
			iter.Next()
			return e, true
		}
		return
	}
}

func Keys[K comparable, V any](m map[K]V) stream.Iter[K] {
	iter := mapUnsafe.NewIter(m)
	return func() (k K, ok bool) {
		if iter.Has() {
			k = iter.Key()
			iter.Next()
			return k, true
		}
		return
	}
}

func Values[K comparable, V any](m map[K]V) stream.Iter[V] {
	iter := mapUnsafe.NewIter(m)
	return func() (v V, ok bool) {
		if iter.Has() {
			v = iter.Value()
			iter.Next()
			return v, true
		}
		return
	}
}

func Chan[O any](ch chan O) stream.Iter[O] {
	return func() (o O, ok bool) {
		o, ok = <-ch
		return
	}
}

func ChanCaches[O any](ch chan O) stream.Iter[O] {
	return func() (o O, ok bool) {
		select {
		case o, ok = <-ch:
		default:
		}
		return
	}
}

//go:linkname decoderune runtime.decoderune
func decoderune(s string, k int) (r rune, pos int)

func Runes(s string) stream.Iter[rune] {
	var i int
	return func() (r rune, ok bool) {
		if i < len(s) {
			r = rune(s[i])
			if r < utf8.RuneSelf {
				i++
			} else {
				r, i = decoderune(s, i)
			}
			return r, true
		}
		return
	}
}

func RuneEntries(s string) stream.Iter[strings.RuneEntry] {
	var i int
	return func() (e strings.RuneEntry, ok bool) {
		if i < len(s) {
			e.Rune = rune(s[i])
			e.Index = i
			if e.Rune < utf8.RuneSelf {
				i++
			} else {
				e.Rune, i = decoderune(s, i)
			}
			return e, true
		}
		return
	}
}

func Chars(s string) stream.Iter[byte] {
	var i int
	return func() (ch byte, ok bool) {
		if i < len(s) {
			ch = s[i]
			i++
			return ch, true
		}
		return
	}
}

func CharEntries(s string) stream.Iter[strings.CharEntry] {
	var i int
	return func() (e strings.CharEntry, ok bool) {
		if i < len(s) {
			e.Index, e.Char = i, s[i]
			i++
			return e, true
		}
		return
	}
}

func Map[I, O any](mapper stream.Mapper[I, O], iter stream.Iter[I]) stream.Iter[O] {
	return func() (o O, ok bool) {
		var i I
		if i, ok = iter(); ok {
			return mapper(i), true
		}
		return
	}
}

func FlatMap[I, O any](mapper stream.Mapper[I, stream.Iter[O]], iter stream.Iter[I]) stream.Iter[O] {
	var cur stream.Iter[O]
	return func() (o O, ok bool) {
		var i I
		for {
			if cur == nil {
				if i, ok = iter(); ok {
					cur = mapper(i)
				} else {
					return
				}
			}

			if o, ok = cur(); ok {
				return
			}
			cur = nil
		}
	}
}

func Filter[V any](filter stream.Filter[V], iter stream.Iter[V]) stream.Iter[V] {
	return func() (v V, ok bool) {
		for {
			if v, ok = iter(); ok {
				if !filter(v) {
					continue
				}
			}
			return
		}
	}
}

func Reject[V any](reject stream.Filter[V], iter stream.Iter[V]) stream.Iter[V] {
	return func() (v V, ok bool) {
		for {
			if v, ok = iter(); ok {
				if reject(v) {
					continue
				}
			}
			return
		}
	}
}

func Limit[V any](limit int, iter stream.Iter[V]) stream.Iter[V] {
	var count int
	return func() (v V, ok bool) {
		if v, ok = iter(); ok {
			if count < limit {
				count++
				return v, true
			}
			var zero V
			return zero, false
		}
		return
	}
}

func Skip[V any](skip int, iter stream.Iter[V]) stream.Iter[V] {
	var count int
	return func() (v V, ok bool) {
		if v, ok = iter(); ok {
			if count < skip {
				count++
				var zero V
				return zero, false
			}
			return v, true
		}
		return
	}
}

func Unique[V comparable](iter stream.Iter[V]) stream.Iter[V] {
	set := make(map[V]struct{})
	return func() (v V, ok bool) {
		for {
			if v, ok = iter(); ok {
				if _, has := set[v]; has {
					continue
				}
				set[v] = struct{}{}
			}
			return
		}
	}
}

func Concat[V any](is ...stream.Iter[V]) stream.Iter[V] {
	var i int
	return func() (v V, ok bool) {
		for i < len(is) {
			if v, ok = is[i](); !ok {
				i++
			} else {
				return
			}
		}
		return
	}
}