float32.go

// +build !ignore_autogenerated

// Code generated by collections-gen. DO NOT EDIT.

package collections

import (
	"sort"
)

// Float32 is a collection of float32 values.
type Float32 struct {
	items []float32
}

// NewFloat32 creates a new collection from a slice of float32.
func NewFloat32(items []float32) *Float32 {
	return &Float32{items}
}

// Interface returns the underlying slice used by the collection as interface{}
// value.
func (c *Float32) Interface() interface{} {
	return c.items
}

// Items returns the underlying slice of float32 values used by the
// collection.
func (c *Float32) Items() []float32 {
	return c.items
}

// EachIndex calls fn for every item in the collection. The slice index of the
// item is passed to fn as the second argument.
func (c *Float32) EachIndex(fn func(float32, int)) {
	for i, item := range c.items {
		fn(item, i)
	}
}

// Each calls fn for every item in the collection.
func (c *Float32) Each(fn func(float32)) {
	c.EachIndex(func(item float32, _ int) {
		fn(item)
	})
}

// IndexOf searches for el in the collection and returns the first index where
// el is found. If el is not present in the collection IndexOf will return -1.
func (c *Float32) IndexOf(el float32) int {
	for i, item := range c.items {
		if item == el {
			return i
		}
	}

	return -1
}

// First returns the first item from the collection. Will panic if the
// underlying slice is empty.
func (c *Float32) First() float32 {
	return c.Nth(0)
}

// FirstN returns the first n float32 items of the collection. Will
// return less than n items if the underlying slice's length is < n.
func (c *Float32) FirstN(n int) []float32 {
	if n > c.Len() {
		return c.Items()
	}

	return c.Slice(0, n)
}

// Last returns the last item from the collection. Will panic if the underlying
// slice is empty.
func (c *Float32) Last() float32 {
	return c.Nth(c.Len() - 1)
}

// LastN returns the last n float32 items of the collection. Will return
// less than n items if the underlying slice's length is < n.
func (c *Float32) LastN(n int) []float32 {
	if c.Len()-n < 0 {
		return c.Items()
	}

	return c.Slice(c.Len()-n, c.Len())
}

// Get returns the item at pos from the collection. Will panic if the
// underlying slice is shorter than pos+1.
func (c *Float32) Get(pos int) float32 {
	return c.Nth(pos)
}

// Nth returns the nth item from the collection. Will panic if the underlying
// slice is shorter than pos+1.
func (c *Float32) Nth(pos int) float32 {
	return c.items[pos]
}

// Len returns the length of the underlying float32 slice.
func (c *Float32) Len() int {
	return len(c.items)
}

// Cap returns the capacity of the underlying float32 slice.
func (c *Float32) Cap() int {
	return cap(c.items)
}

// Append appends items and returns the collection.
func (c *Float32) Append(items ...float32) *Float32 {
	c.items = append(c.items, items...)
	return c
}

// Prepend prepends items and returns the collection.
func (c *Float32) Prepend(items ...float32) *Float32 {
	c.items = append(items, c.items...)
	return c
}

// Copy creates a copy of the collection and the underlying float32 slice.
func (c *Float32) Copy() *Float32 {
	s := make([]float32, c.Len(), c.Len())
	copy(s, c.items)

	return NewFloat32(s)
}

// Filter removes all items from the collection for which fn evaluates to
// false and returns c.
func (c *Float32) Filter(fn func(float32) bool) *Float32 {
	s := c.items[:0]

	for _, item := range c.items {
		if fn(item) {
			s = append(s, item)
		}
	}

	var zeroValue float32

	for i := len(s); i < len(c.items); i++ {
		c.items[i] = zeroValue
	}

	c.items = s

	return c
}

// Collect removes all items from the collection for which fn evaluates to
// false and returns c.
func (c *Float32) Collect(fn func(float32) bool) *Float32 {
	return c.Filter(fn)
}

// Reject removes all items from the collection for which fn evaluates to
// true and returns c.
func (c *Float32) Reject(fn func(float32) bool) *Float32 {
	return c.Filter(func(v float32) bool {
		return !fn(v)
	})
}

// Partition partitions the collection into two new collections. The first
// collection contains all items where fn evaluates to true, the second one all
// items where fn evaluates to false.
func (c *Float32) Partition(fn func(float32) bool) (*Float32, *Float32) {
	lhs := make([]float32, 0, c.Len())
	rhs := make([]float32, 0, c.Len())

	for _, item := range c.items {
		if fn(item) {
			lhs = append(lhs, item)
		} else {
			rhs = append(rhs, item)
		}
	}

	return NewFloat32(lhs), NewFloat32(rhs)
}

// Map calls fn for each item in the collection an replaces its value with the
// result of fn.
func (c *Float32) Map(fn func(float32) float32) *Float32 {
	return c.MapIndex(func(item float32, _ int) float32 {
		return fn(item)
	})
}

// MapIndex calls fn for each item in the collection an replaces its value with the
// result of fn.
func (c *Float32) MapIndex(fn func(float32, int) float32) *Float32 {
	for i, item := range c.items {
		c.items[i] = fn(item, i)

	}

	return c
}

// Reduce calls fn for each item in c and reduces the result into reducer. The
// reducer contains the value returned by the call to fn for the previous item.
// Reducer will be the zero float32 value on the first invocation.
func (c *Float32) Reduce(fn func(reducer float32, item float32) float32) float32 {
	var reducer float32

	for _, item := range c.items {
		reducer = fn(reducer, item)
	}

	return reducer
}

// Find returns the first item for which fn evaluates to true. If the
// collection does not contain a matching item, Find will return the zero
// float32 value. If you need to distinguish zero values from a condition
// that did not match any item consider using FindOk instead.
func (c *Float32) Find(fn func(float32) bool) float32 {
	item, _ := c.FindOk(fn)

	return item
}

// FindOk returns the first item for which fn evaluates to true. If the
// collection does not contain a matching item, FindOk will return the zero
// float32 value. The second return value denotes whether the condition
// matched any item or not.
func (c *Float32) FindOk(fn func(float32) bool) (float32, bool) {
	for _, item := range c.items {
		if fn(item) {
			return item, true
		}
	}

	var zeroValue float32
	return zeroValue, false
}

// Any returns true as soon as fn evaluates to true for one item in c.
func (c *Float32) Any(fn func(float32) bool) bool {
	for _, item := range c.items {
		if fn(item) {
			return true
		}
	}

	return false
}

// All returns true if fn evaluates to true for all items in c.
func (c *Float32) All(fn func(float32) bool) bool {
	for _, item := range c.items {
		if !fn(item) {
			return false
		}
	}

	return true
}

// Contains returns true if the collection contains el.
func (c *Float32) Contains(el float32) bool {
	for _, item := range c.items {
		if item == el {
			return true
		}
	}

	return false
}

// Sort sorts the collection using the passed in comparator func.
func (c *Float32) Sort(fn func(float32, float32) bool) *Float32 {
	sort.Slice(c.items, c.lessFunc(fn))
	return c
}

// IsSorted returns true if the collection is sorted in the order defined by
// the passed in comparator func.
func (c *Float32) IsSorted(fn func(float32, float32) bool) bool {
	return sort.SliceIsSorted(c.items, c.lessFunc(fn))
}

func (c *Float32) lessFunc(fn func(float32, float32) bool) func(int, int) bool {
	return func(i, j int) bool {
		return fn(c.items[i], c.items[j])
	}
}

// Reverse reverses the order of the collection items in place and returns c.
func (c *Float32) Reverse() *Float32 {
	for l, r := 0, len(c.items)-1; l < r; l, r = l+1, r-1 {
		c.items[l], c.items[r] = c.items[r], c.items[l]
	}

	return c
}

// Remove removes the collection item at position pos. Will panic if pos is out
// of bounds.
func (c *Float32) Remove(pos int) *Float32 {
	c.items = append(c.items[:pos], c.items[pos+1:]...)
	return c
}

// RemoveItem removes all instances of item from the collection and returns it.
func (c *Float32) RemoveItem(item float32) *Float32 {
	for i, el := range c.items {
		if el == item {
			c.items = append(c.items[:i], c.items[i+1:]...)
		}
	}

	return c
}

// InsertItem inserts item into the collection at position pos. Will panic if
// pos is out of bounds.
func (c *Float32) InsertItem(item float32, pos int) *Float32 {
	var zeroValue float32
	c.items = append(c.items, zeroValue)
	copy(c.items[pos+1:], c.items[pos:])
	c.items[pos] = item
	return c
}

// Cut returns a copy of the underlying float32 slice with the items
// between index i and j removed. Will panic if i or j is out of bounds of the
// underlying slice.
func (c *Float32) Cut(i, j int) []float32 {
	s := make([]float32, 0, c.Len())
	s = append(s, c.items[:i]...)
	return append(s, c.items[j:]...)
}

// Slice returns the float32 items between slice index i and j. Will
// panic if i or j is out of bounds.
func (c *Float32) Slice(i, j int) []float32 {
	return c.items[i:j]
}