goconsume

func NewApplier ¶ added in v1.1.0

func NewApplier(funcs ...interface{}) Applier

NewApplier creates an Applier from multiple functions like the ones passed to MapFilter chained together. The returned Applier can be passed as a parameter to MapFilter or to NewApplier.

func Page ¶

func Page(
	zeroBasedPageNo int,
	itemsPerPage int,
	aValueSlicePointer interface{},
	morePages *bool) ConsumeFinalizer

Page returns a consumer that does pagination. The items in page fetched get stored in the slice pointed to by aValueSlicePointer. If there are more pages after page fetched, Page sets morePages to true; otherwise, it sets morePages to false. Note that the values stored at aValueSlicePointer and morePages are undefined until caller calls Finalize() on returned ConsumeFinalizer.

func AppendPtrsTo ¶

func AppendPtrsTo(aPointerSlicePointer interface{}) Consumer

AppendPtrsTo returns a Consumer that appends consumed values to the slice pointed to by aPointerSlicePointer. Each time the returned Consumer consumes a value, it allocates a new value on the heap, copies the consumed value to that allocated value, and finally appends the pointer to the newly allocated value to the slice pointed to by aPointerSlicePointer. aPointerSlicePointer is a pointer to a slice of pointers to values supporting assignment. The CanConsume method of returned consumer always returns true.

func AppendTo ¶

func AppendTo(aValueSlicePointer interface{}) Consumer

AppendTo returns a Consumer that appends consumed values to the slice pointed to by aValueSlicePointer. aValueSlicePointer is a pointer to a slice of values supporting assignment. The CanConsume method of returned consumer always returns true.

func Compose ¶

func Compose(consumers ...Consumer) Consumer

Compose returns the consumers passed to it as a single Consumer. When returned consumer consumes a value, each consumer passed in that is able to consume a value consumes that value. CanConsume() of returned consumer returns false when the CanConsume() method of each consumer passed in returns false.

func MapFilter ¶ added in v1.1.0

func MapFilter(consumer Consumer, funcs ...interface{}) Consumer

MapFilter returns a Consumer that passes only filtered and mapped values onto the consumer parameter. The returned Consumer applies each function in funcs to the value passed to its Consume method. The resulting value is then passed to the Consume method of the consumer parameter. Each function in func returns a bool and takes one or two pointer arguments to values. If a function returns false, it means that the value passed to it should not be consumed. The one argument functions never change the value passed to it as they are simple filters. The 2 argument functions are mappers. They leave their first argument unchanged, but use it to set their second argument. This second argument is what gets passed to the next function in funcs or to consumer if it is the last function in funcs.

The NewApplier function can return an Applier which represents zero or more of these functions chained together. Applier instances can be passed as parameters to MapFilter just like the functions mentioned above.

package main

import (
	"fmt"
	"strconv"

	"github.com/keep94/goconsume"
)

func main() {
	var evens []string
	consumer := goconsume.MapFilter(
		goconsume.AppendTo(&evens),
		func(ptr *int) bool {
			return (*ptr)%2 == 0
		},
		func(src *int, dest *string) bool {
			*dest = strconv.Itoa(*src)
			return true
		},
	)
	ints := []int{1, 2, 4}
	for _, i := range ints {
		if consumer.CanConsume() {
			consumer.Consume(&i)
		}
	}
	fmt.Println(evens)
}

Output:

[2 4]

func Nil ¶

func Nil() Consumer

Nil returns a consumer that consumes nothing. Calling CanConsume() on returned consumer returns false, and calling Consume() on returned consumer panics.

func Slice ¶

func Slice(consumer Consumer, start, end int) Consumer

Slice returns a Consumer that passes the start th value consumed inclusive to the end th value consumed exclusive onto consumer where start and end are zero based. The returned consumer ignores the first start values it consumes. After that it passes the values it consumes onto consumer until it has consumed end values. The CanConsume() method of returned consumer returns false if the CanConsume() method of the underlying consumer returns false or if the returned consumer has consumed end values. Note that if end <= start, the underlying consumer will never get any values.