int16.go

package slices

import "sort"

/* generated by github.com/schigh/slices/base/base.go.  do not edit. */

// Int16Slice is the alias of []int16
type Int16Slice []int16

// Value returns the aliased []int16
func (slice Int16Slice) Value() []int16 {
	return []int16(slice)
}

// IndexOf returns the first index of needle, or -1 if not found
func (slice Int16Slice) IndexOf(needle int16) int {
	for i := 0; i < len(slice); i++ {
		if needle == slice[i] {
			return i
		}
	}

	return NotInSlice
}

// Contains returns true if the slice contains needle
func (slice Int16Slice) Contains(needle int16) bool {
	return slice.IndexOf(needle) != NotInSlice
}

// SortAsc will sort the slice in ascending order
func (slice Int16Slice) SortAsc() Int16Slice {
	sort.SliceStable(slice, func(i, j int) bool {
		return slice[i] < slice[j]
	})
	return slice
}

// SortDesc will sort the slice in descending order
func (slice Int16Slice) SortDesc() Int16Slice {
	sort.SliceStable(slice, func(i, j int) bool {
		return slice[j] < slice[i]
	})
	return slice
}

// Reverse will reverse the order of the slice
func (slice Int16Slice) Reverse() Int16Slice {
	l := len(slice)
	for i, j := 0, l-1; i < l/2; i++ {
		slice[i], slice[j] = slice[j], slice[i]
		j--
	}

	return slice
}

// Unique filters out duplicate int16 values
func (slice Int16Slice) Unique() Int16Slice {
	u := make([]int16, 0, len(slice))
	m := make(map[int16]bool)

	for i := 0; i < len(slice); i++ {
		if _, ok := m[slice[i]]; !ok {
			m[slice[i]] = true
			u = append(u, slice[i])
		}
	}

	return Int16Slice(u)
}

// Filter will return all int16 values that evaluate true in the user-supplied function
func (slice Int16Slice) Filter(f func(int16) bool) Int16Slice {
	out := make([]int16, 0, len(slice))
	for i := 0; i < len(slice); i++ {
		if f(slice[i]) {
			out = append(out, slice[i])
		}
	}

	return Int16Slice(out)
}

// Each will apply a function to each int16 in the slice.
// This function will iterate over the slice completely.  No
// items in the slice should be mutated by this operation.
func (slice Int16Slice) Each(f func(int16)) {
	for i := 0; i < len(slice); i++ {
		f(slice[i])
	}
}

// TryEach will apply a function to each int16 in the slice.
// If the function returns an error, the iteration will stop and return
// the index of the element that caused the function to return the error.
// The second returned value will be first error returned from the
// supplied function, and nil otherwise.
// No items in the slice should be mutated by this operation.
func (slice Int16Slice) TryEach(f func(int16) error) (int, error) {
	for i := 0; i < len(slice); i++ {
		if err := f(slice[i]); err != nil {
			return i, err
		}
	}

	return NotInSlice, nil
}

// IfEach will apply a function to each int16 in the slice.
// If the function returns false, the iteration will stop and return
// the index of the element that caused the function to return false.
// The second returned value will be true if all members of the slice
// cause the provided function to return true, and false otherwise.
// No items in the slice should be mutated by this operation.
func (slice Int16Slice) IfEach(f func(int16) bool) (int, bool) {
	for i := 0; i < len(slice); i++ {
		if !f(slice[i]) {
			return i, false
		}
	}

	return NotInSlice, true
}

// Map will apply a function to each int16 in the slice and replace the previous value
func (slice Int16Slice) Map(f func(int16) int16) {
	for i := 0; i < len(slice); i++ {
		slice[i] = f(slice[i])
	}
}

// Chunk will divide the slice of int16 into smaller slices defined by chunk length
func (slice Int16Slice) Chunk(size int) [][]int16 {
	l := len(slice)
	if l == 0 || size <= 0 {
		return make([][]int16, 0)
	}

	floor := l / size
	out := make([][]int16, 0, floor+1)
	var k int

	for i := 0; i < floor; i++ {
		k = i*size + size
		out = append(out, slice[i*size:k])
	}
	if l > k {
		out = append(out, slice[k:])
	}

	return out
}