uint16Slices.go

// Code generated by yasupGen; DO NOT EDIT.

package yasup

import (
	crypto "crypto/rand"
	"math/big"
	"math/rand"
)

var zeroValueUint16 uint16

//Uint16Insert will append elem at the position i. Might return ErrIndexOutOfBounds.
func Uint16Insert(sl *[]uint16, elem uint16, i int) error {
	if i < 0 || i > len(*sl) {
		return ErrIndexOutOfBounds
	}
	*sl = append(*sl, elem)
	copy((*sl)[i+1:], (*sl)[i:])
	(*sl)[i] = elem
	return nil
}

//Uint16Delete delete the element at the position i. Might return ErrIndexOutOfBounds.
func Uint16Delete(sl *[]uint16, i int) error {
	if i < 0 || i >= len(*sl) {
		return ErrIndexOutOfBounds
	}
	*sl = append((*sl)[:i], (*sl)[i+1:]...)
	return nil
}

//Uint16Contains will return true if elem is present in the slice and false otherwise.
func Uint16Contains(sl []uint16, elem uint16) bool {
	for i := range sl {
		if sl[i] == elem {
			return true
		}
	}
	return false
}

//Uint16Index returns the index of the first instance of elem, or -1 if elem is not present.
func Uint16Index(sl []uint16, elem uint16) int {
	for i := range sl {
		if sl[i] == elem {
			return i
		}
	}
	return -1
}

//Uint16LastIndex returns the index of the last instance of elem in the slice, or -1 if elem is not present.
func Uint16LastIndex(sl []uint16, elem uint16) int {
	for i := len(sl) - 1; i >= 0; i-- {
		if sl[i] == elem {
			return i
		}
	}
	return -1
}

//Uint16Count will return an int representing the amount of times that elem is present in the slice.
func Uint16Count(sl []uint16, elem uint16) int {
	var n int
	for i := range sl {
		if sl[i] == elem {
			n++
		}
	}
	return n
}

//Uint16Push is equivalent to Uint16Insert with index len(*sl).
func Uint16Push(sl *[]uint16, elem uint16) {
	Uint16Insert(sl, elem, len(*sl))
}

//Uint16FrontPush is equivalent to Uint16Insert with index 0.
func Uint16FrontPush(sl *[]uint16, elem uint16) {
	Uint16Insert(sl, elem, 0)
}

//Uint16Pop is equivalent to getting and removing the last element of the slice. Might return ErrEmptySlice.
func Uint16Pop(sl *[]uint16) (uint16, error) {
	if len(*sl) == 0 {
		return zeroValueUint16, ErrEmptySlice
	}
	last := len(*sl) - 1
	ret := (*sl)[last]
	Uint16Delete(sl, last)
	return ret, nil
}

//Uint16Pop is equivalent to getting and removing the first element of the slice. Might return ErrEmptySlice.
func Uint16FrontPop(sl *[]uint16) (uint16, error) {
	if len(*sl) == 0 {
		return zeroValueUint16, ErrEmptySlice
	}
	ret := (*sl)[0]
	Uint16Delete(sl, 0)
	return ret, nil
}

//Uint16Replace modifies the slice with the first n non-overlapping instances of old replaced by new. If n equals -1, there is no limit on the number of replacements.
func Uint16Replace(sl []uint16, old, new uint16, n int) (replacements int) {
	left := n
	for i := range sl {
		if left == 0 {
			break // no replacements left
		}
		if sl[i] == old {
			sl[i] = new
			left--
		}
	}
	return n - left
}

//Uint16ReplaceAll is equivalent to Uint16Replace with n = -1.
func Uint16ReplaceAll(sl []uint16, old, new uint16) (replacements int) {
	return Uint16Replace(sl, old, new, -1)
}

//Uint16Equals compares two uint16 slices. Returns true if their elements are equal.
func Uint16Equals(a, b []uint16) bool {
	if len(a) != len(b) {
		return false
	}
	for i := range a {
		if a[i] != b[i] {
			return false
		}
	}
	return true
}

//Uint16FastShuffle will randomly swap the uint16 elements of a slice using math/rand (fast but not cryptographycally secure).
func Uint16FastShuffle(sp []uint16) {
	rand.Shuffle(len(sp), func(i, j int) {
		sp[i], sp[j] = sp[j], sp[i]
	})
}

//Uint16SecureShuffle will randomly swap the uint16 elements of a slice using crypto/rand (resource intensive but cryptographically secure).
func Uint16SecureShuffle(sp []uint16) error {
	var i int64
	size := int64(len(sp)) - 1
	for i = 0; i < size+1; i++ {
		bigRandI, err := crypto.Int(crypto.Reader, big.NewInt(size))
		if err != nil {
			return err
		}
		randI := bigRandI.Int64()
		sp[size-i], sp[randI] = sp[randI], sp[size-i]
	}
	return nil
}