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

package ranger

import (
	"errors"
	"gitee.com/sy_183/go-common/generic"
	"gitee.com/sy_183/go-common/maps"
	"gitee.com/sy_183/go-common/slice"
	"gitee.com/sy_183/go-common/stream"
	"gitee.com/sy_183/go-common/strings"
)

var EOF = errors.New("EOF")

func Range[I generic.Integer](size I) stream.Ranger[I] {
	return func(h stream.Handler[I]) error {
		for i := I(0); i < size; i++ {
			if err := h(i); err != nil {
				return err
			}
		}
		return nil
	}
}

func Repeat[V any, I generic.Integer](v V, size I) stream.Ranger[V] {
	return func(h stream.Handler[V]) error {
		for i := I(0); i < size; i++ {
			if err := h(v); err != nil {
				return err
			}
		}
		return nil
	}
}

func RepeatNew[V any, I generic.Integer](newFn func() V, size I) stream.Ranger[V] {
	return func(h stream.Handler[V]) error {
		for i := I(0); i < size; i++ {
			if err := h(newFn()); err != nil {
				return err
			}
		}
		return nil
	}
}

func RepeatClone[V any, I generic.Integer](v V, cloneFn func(V) V, size I) stream.Ranger[V] {
	return func(h stream.Handler[V]) error {
		for i := I(0); i < size; i++ {
			if err := h(cloneFn(v)); err != nil {
				return err
			}
		}
		return nil
	}
}

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

func Slice[E any](s []E) stream.Ranger[E] {
	return func(h stream.Handler[E]) error {
		for i := range s {
			if err := h(s[i]); err != nil {
				return err
			}
		}
		return nil
	}
}

func ReverseSlice[E any](s []E) stream.Ranger[E] {
	return func(h stream.Handler[E]) error {
		for i := len(s) - 1; i >= 0; i-- {
			if err := h(s[i]); err != nil {
				return err
			}
		}
		return nil
	}
}

func SliceP[E any](s []E) stream.Ranger[*E] {
	return func(h stream.Handler[*E]) error {
		for i := range s {
			if err := h(&s[i]); err != nil {
				return err
			}
		}
		return nil
	}
}

func ReverseSliceP[E any](s []E) stream.Ranger[*E] {
	return func(h stream.Handler[*E]) error {
		for i := len(s) - 1; i >= 0; i-- {
			if err := h(&s[i]); err != nil {
				return err
			}
		}
		return nil
	}
}

func SliceEntries[E any](s []E) stream.Ranger[slice.Entry[E]] {
	return func(h stream.Handler[slice.Entry[E]]) error {
		for i, e := range s {
			if err := h(slice.NewEntry(i, e)); err != nil {
				return err
			}
		}
		return nil
	}
}

func ReversSliceEntries[E any](s []E) stream.Ranger[slice.Entry[E]] {
	return func(h stream.Handler[slice.Entry[E]]) error {
		for i := len(s) - 1; i >= 0; i-- {
			if err := h(slice.NewEntry(i, s[i])); err != nil {
				return err
			}
		}
		return nil
	}
}

func SlicePEntries[E any](s []E) stream.Ranger[slice.Entry[*E]] {
	return func(h stream.Handler[slice.Entry[*E]]) error {
		for i := range s {
			if err := h(slice.NewEntry(i, &s[i])); err != nil {
				return err
			}
		}
		return nil
	}
}

func ReverseSlicePEntries[E any](s []E) stream.Ranger[slice.Entry[*E]] {
	return func(h stream.Handler[slice.Entry[*E]]) error {
		for i := len(s) - 1; i >= 0; i-- {
			if err := h(slice.NewEntry(i, &s[i])); err != nil {
				return err
			}
		}
		return nil
	}
}

func MapEntries[K comparable, V any](m map[K]V) stream.Ranger[maps.Entry[K, V]] {
	return func(h stream.Handler[maps.Entry[K, V]]) error {
		for k, v := range m {
			if err := h(maps.NewEntry(k, v)); err != nil {
				return err
			}
		}
		return nil
	}
}

func Keys[K comparable, V any](m map[K]V) stream.Ranger[K] {
	return func(h stream.Handler[K]) error {
		for k := range m {
			if err := h(k); err != nil {
				return err
			}
		}
		return nil
	}
}

func Values[K comparable, V any](m map[K]V) stream.Ranger[V] {
	return func(h stream.Handler[V]) error {
		for _, v := range m {
			if err := h(v); err != nil {
				return err
			}
		}
		return nil
	}
}

func Chan[O any](ch chan O) stream.Ranger[O] {
	return func(h stream.Handler[O]) error {
		for o := range ch {
			if err := h(o); err != nil {
				return err
			}
		}
		return nil
	}
}

func ChanCaches[O any](ch chan O) stream.Ranger[O] {
	return func(h stream.Handler[O]) error {
		for {
			select {
			case o, ok := <-ch:
				if !ok {
					return nil
				} else if err := h(o); err != nil {
					return err
				}
			default:
				return nil
			}
		}
	}
}

func Runes(s string) stream.Ranger[rune] {
	return func(h stream.Handler[rune]) error {
		for _, r := range s {
			if err := h(r); err != nil {
				return err
			}
		}
		return nil
	}
}

func RuneEntries(s string) stream.Ranger[strings.RuneEntry] {
	return func(h stream.Handler[strings.RuneEntry]) error {
		for i, r := range s {
			if err := h(strings.NewRuneEntry(i, r)); err != nil {
				return err
			}
		}
		return nil
	}
}

func Chars(s string) stream.Ranger[byte] {
	return func(h stream.Handler[byte]) error {
		for i := 0; i < len(s); i++ {
			if err := h(s[i]); err != nil {
				return err
			}
		}
		return nil
	}
}

func CharEntries(s string) stream.Ranger[strings.CharEntry] {
	return func(h stream.Handler[strings.CharEntry]) error {
		for i := 0; i < len(s); i++ {
			if err := h(strings.NewCharEntry(i, s[i])); err != nil {
				return err
			}
		}
		return nil
	}
}

func Iter[V any](iter stream.Iter[V]) stream.Ranger[V] {
	return func(h stream.Handler[V]) error {
		for {
			if v, ok := iter(); ok {
				if err := h(v); err != nil {
					return err
				}
			} else {
				return nil
			}
		}
	}
}

func Handle[V any](ranger stream.Ranger[V], h stream.Handler[V], eh stream.ErrorHandler[V]) stream.Ranger[V] {
	return func(handler stream.Handler[V]) error {
		return ranger(func(v V) error {
			if err := h(v); err != nil {
				if eh != nil {
					return eh(v, err)
				}
				return err
			}
			return handler(v)
		})
	}
}

func HandleMap[I any, O any](ranger stream.Ranger[I], hm stream.HandlerMapper[I, O], eh stream.ErrorHandler[I]) stream.Ranger[O] {
	return func(handler stream.Handler[O]) error {
		return ranger(func(i I) error {
			o, err := hm(i)
			if err != nil {
				if eh != nil {
					return eh(i, err)
				}
				return err
			}
			return handler(o)
		})
	}
}

func Map[I, O any](ranger stream.Ranger[I], mapper stream.Mapper[I, O]) stream.Ranger[O] {
	return func(h stream.Handler[O]) error {
		return ranger(func(i I) error {
			return h(mapper(i))
		})
	}
}

func FlatMap[I, O any](ranger stream.Ranger[I], mapper stream.Mapper[I, stream.Ranger[O]]) stream.Ranger[O] {
	return func(h stream.Handler[O]) error {
		return ranger(func(i I) error {
			return mapper(i)(func(o O) error {
				return h(o)
			})
		})
	}
}

func Filter[V any](ranger stream.Ranger[V], filter stream.Filter[V]) stream.Ranger[V] {
	return func(h stream.Handler[V]) error {
		return ranger(func(v V) error {
			if filter(v) {
				return h(v)
			}
			return nil
		})
	}
}

func Reject[V any](ranger stream.Ranger[V], reject stream.Filter[V]) stream.Ranger[V] {
	return func(h stream.Handler[V]) error {
		return ranger(func(v V) error {
			if !reject(v) {
				return h(v)
			}
			return nil
		})
	}
}

func Limit[V any, I generic.Integer](limit I, ranger stream.Ranger[V]) stream.Ranger[V] {
	var count I
	return func(h stream.Handler[V]) error {
		if err := ranger(func(v V) error {
			if count < limit {
				count++
				return h(v)
			}
			return EOF
		}); err != nil {
			if err == EOF {
				return nil
			}
			return err
		}
		return nil
	}
}

func Skip[V any, I generic.Integer](skip I, ranger stream.Ranger[V]) stream.Ranger[V] {
	var count I
	return func(h stream.Handler[V]) error {
		return ranger(func(v V) error {
			if count < skip {
				count++
				return nil
			}
			return h(v)
		})
	}
}

func Unique[V comparable](ranger stream.Ranger[V]) stream.Ranger[V] {
	set := make(map[V]struct{})
	return func(h stream.Handler[V]) error {
		return ranger(func(v V) error {
			if _, has := set[v]; !has {
				set[v] = struct{}{}
				return h(v)
			}
			return nil
		})
	}
}

func Concat[V any](rangers ...stream.Ranger[V]) stream.Ranger[V] {
	return func(h stream.Handler[V]) error {
		for _, ranger := range rangers {
			if err := ranger(func(v V) error {
				return h(v)
			}); err != nil {
				return err
			}
		}
		return nil
	}
}