slice_uint32.go

// Code generated by go generate; DO NOT EDIT.
// This file was generated by robots at 2020-04-08 01:37:45.19604 +0000 UTC.

package golist

import (
	"fmt"
	"math/rand"
	"sort"
	"time"
)

// SliceUint32 is a slice of type uint32.
type SliceUint32 struct {
	data []uint32
}

// NewSliceUint32 returns a pointer to a new SliceUint32 initialized with the specified elements.
func NewSliceUint32(elems ...uint32) *SliceUint32 {
	s := new(SliceUint32)
	s.data = make([]uint32, len(elems))
	for i := 0; i < len(elems); i++ {
		s.data[i] = elems[i]
	}
	return s
}

// Append adds the elements to the end of SliceUint32.
func (s *SliceUint32) Append(elems ...uint32) *SliceUint32 {
	if s == nil {
		return nil
	}
	s.data = append(s.data, elems...)
	return s
}

// Prepend adds the elements to the beginning of SliceUint32.
func (s *SliceUint32) Prepend(elems ...uint32) *SliceUint32 {
	if s == nil {
		return nil
	}
	s.data = append(elems, s.data...)
	return s
}

// At returns the element in SliceUint32 at the specified index.
func (s *SliceUint32) At(index int) uint32 {
	if s.data == nil || len(s.data) == 0 {
		panic("SliceUint32 does not contain any elements")
	}

	if index >= len(s.data) || index < 0 {
		panic(fmt.Sprintf("index %d outside the range of SliceUint32", index))
	}

	return s.data[index]
}

// Set sets the element of SliceUint32 at the specified index.
func (s *SliceUint32) Set(index int, elem uint32) *SliceUint32 {
	if s == nil {
		return nil
	}
	s.data[index] = elem
	return s
}

// Insert inserts the elements into SliceUint32 at the specified index.
func (s *SliceUint32) Insert(index int, elems ...uint32) *SliceUint32 {
	if s == nil {
		return nil
	}

	// Grow the slice by the number of elements (using the zero value)
	var zero uint32
	for i := 0; i < len(elems); i++ {
		s.data = append(s.data, zero)
	}

	// Use copy to move the upper part of the slice out of the way and open a hole.
	copy(s.data[index+len(elems):], s.data[index:])

	// Store the new values
	for i := 0; i < len(elems); i++ {
		s.data[index+i] = elems[i]
	}

	// Return the result.
	return s
}

// Remove removes the element from SliceUint32 at the specified index.
func (s *SliceUint32) Remove(index int) *SliceUint32 {
	if s == nil {
		return nil
	}
	s.data = append(s.data[:index], s.data[index+1:]...)
	return s
}

// Filter removes elements from SliceUint32 that do not satisfy the filter function.
func (s *SliceUint32) Filter(fn func(elem uint32) bool) *SliceUint32 {
	if s == nil {
		return nil
	}
	data := s.data[:0]
	for _, elem := range s.data {
		if fn(elem) {
			data = append(data, elem)
		}
	}
	s.data = data
	return s
}

// Transform modifies each element of SliceUint32 according to the specified function.
func (s *SliceUint32) Transform(fn func(elem uint32) uint32) *SliceUint32 {
	if s == nil {
		return nil
	}
	for i, elem := range s.data {
		s.data[i] = fn(elem)
	}
	return s
}

// Unique modifies SliceUint32 to keep only the first occurrence of each element (removing any duplicates).
func (s *SliceUint32) Unique() *SliceUint32 {
	if s == nil {
		return nil
	}
	seen := make(map[uint32]struct{})
	data := s.data[:0]
	for _, elem := range s.data {
		if _, ok := seen[elem]; !ok {
			data = append(data, elem)
			seen[elem] = struct{}{}
		}
	}
	s.data = data
	return s
}

// Reverse reverses the order of the elements of SliceUint32.
func (s *SliceUint32) Reverse() *SliceUint32 {
	if s == nil {
		return nil
	}

	for i := len(s.data)/2 - 1; i >= 0; i-- {
		opp := len(s.data) - 1 - i
		s.Swap(i, opp)
	}

	return s
}

// Shuffle randomly shuffles the order of the elements in SliceUint32.
func (s *SliceUint32) Shuffle(seed int64) *SliceUint32 {
	if s == nil {
		return nil
	}

	if seed == 0 {
		seed = time.Now().UnixNano()
	}

	r := rand.New(rand.NewSource(seed))
	r.Shuffle(s.Count(), s.Swap)

	return s
}

// Data returns the raw elements of SliceUint32.
func (s *SliceUint32) Data() []uint32 {
	if s == nil {
		return nil
	}
	return s.data
}

// Count returns the number of elements in SliceUint32.
func (s *SliceUint32) Count() int {
	return len(s.data)
}

// Len returns the number of elements in SliceUint32 (alias for Count).
func (s *SliceUint32) Len() int {
	return s.Count()
}

// Swap swaps the elements in SliceUint32 specified by the indices i and j.
func (s *SliceUint32) Swap(i, j int) {
	s.data[i], s.data[j] = s.data[j], s.data[i]
}

// Less returns true if the SliceUint32 element at index i is less than the element at index j.
func (s *SliceUint32) Less(i, j int) bool {
	return s.data[i] < s.data[j]
}

// Sort sorts the elements of SliceUint32 in increasing order.
func (s *SliceUint32) Sort() *SliceUint32 {
	if s == nil {
		return nil
	}
	sort.Sort(s)
	return s
}

// Min returns the smallest (least ordered) element in SliceUint32.
func (s *SliceUint32) Min() uint32 {
	if s.data == nil || len(s.data) == 0 {
		panic("SliceUint32 does not contain any elements")
	}
	// start with the first value
	min := s.data[0]
	for _, elem := range s.data[1:] {
		if elem < min {
			min = elem
		}
	}
	return min
}

// Max returns the largest (greatest ordered) element in SliceUint32.
func (s *SliceUint32) Max() uint32 {
	if s.data == nil || len(s.data) == 0 {
		panic("SliceUint32 does not contain any elements")
	}
	// start with the first value
	max := s.data[0]
	for _, elem := range s.data[1:] {
		if elem > max {
			max = elem
		}
	}
	return max
}

// Clone performs a deep copy of SliceUint32 and returns it
func (s *SliceUint32) Clone() *SliceUint32 {
	if s == nil {
		return nil
	}
	s2 := new(SliceUint32)
	s2.data = make([]uint32, len(s.data))
	copy(s2.data, s.data)
	return s2
}

// Equal returns true if the SliceUint32 is logically equivalent to the specified SliceUint32.
func (s *SliceUint32) Equal(s2 *SliceUint32) bool {
	if s == s2 {
		return true
	}

	if s == nil || s2 == nil {
		return false // has to be false because s == s2 tested earlier
	}

	if len(s.data) != len(s2.data) {
		return false
	}

	for i, elem := range s.data {
		if elem != s2.data[i] {
			return false
		}
	}

	return true
}