Struct SimpleArray

pub struct SimpleArray<T, A: Allocator = TESGlobalAlloc> { /* private fields */ }

Array whose first pointer is only a pointer to the length.

Memory layout:

┌────────────┬────────────┬────────────┬──────┬────────────┐
│ len: usize │ T[0]       │ T[1]       │ ...  │ T[N - 1]   │
└────────────┴────────────┴────────────┴──────┴────────────┘
                  ↑
  data: Unique<T> ┘

Example

use commonlibsse_ng::re::MemoryManager::SimpleArray::SimpleArray;
let array: SimpleArray<i32> = SimpleArray::new();
assert_eq!(array.len(), 0);

Implementations

impl<T> SimpleArray<T>

pub const fn new() -> Self

Creates a new empty SimpleArray.

Example

use commonlibsse_ng::re::MemoryManager::SimpleArray::SimpleArray;
let array: SimpleArray<i32> = SimpleArray::new();
assert_eq!(array.len(), 0);

pub fn with_capacity(count: usize) -> Self

Creates a new SimpleArray with the specified capacity.

Uninitialized memory leads to undefined operation, so 0 is entered.

Panics

This function may panic if the allocation fails.

Example

use commonlibsse_ng::re::MemoryManager::SimpleArray::SimpleArray;
let array: SimpleArray<i32> = SimpleArray::with_capacity(5);
assert_eq!(array.len(), 5);

impl<T, A> SimpleArray<T, A>

where A: Allocator,

pub const fn new_in(data: Option<Unique<T>>, alloc: A) -> Self

Creates a new empty SimpleArray with Allocator.

Example

use commonlibsse_ng::re::MemoryManager::SimpleArray::SimpleArray;
use stdx::alloc::Global; // Since TESAllocator is not available for CI, use Rust's.

let array: SimpleArray<i32, Global> = SimpleArray::new_in(None, Global);
assert_eq!(array.len(), 0);

pub const fn len(&self) -> usize

Returns the length of the array (the number of elements currently stored).

Equivalent C++ size()

Example

use commonlibsse_ng::re::MemoryManager::SimpleArray::SimpleArray;
let array: SimpleArray<i32> = SimpleArray::with_capacity(5);
assert_eq!(array.len(), 5);

pub const fn is_empty(&self) -> bool

Checks if the array is empty.

Example

use commonlibsse_ng::re::MemoryManager::SimpleArray::SimpleArray;
let array: SimpleArray<i32> = SimpleArray::new();
assert!(array.is_empty());

pub fn clear(&mut self)

Clears the array by deallocating its memory.

Safety

This function performs unsafe operations to deallocate the array memory.

Example

use commonlibsse_ng::re::MemoryManager::SimpleArray::SimpleArray;
let mut array: SimpleArray<i32> = SimpleArray::with_capacity(3);
array.clear();
assert!(array.is_empty());

pub fn resize(&mut self, count: usize)

Resizes the array to the specified count.

Panics

This function may panic if the allocation fails.

Example

use commonlibsse_ng::re::MemoryManager::SimpleArray::SimpleArray;
let mut array = SimpleArray::<u32>::with_capacity(3);
array.resize(5);
assert_eq!(array.len(), 5);

pub fn get(&self, index: usize) -> Option<&T>

Gets a reference to the element at the given index.

Return None if the index is out of bounds.

Example

use commonlibsse_ng::re::MemoryManager::SimpleArray::SimpleArray;
let mut array = SimpleArray::with_capacity(3);
array[0] = 1;
assert_eq!(array.get(0), Some(&1));
assert_eq!(array.get(5), None);

pub fn get_mut(&mut self, index: usize) -> Option<&mut T>

Gets a mutable reference to the element at the given index.

Return None if the index is out of bounds.

Example

use commonlibsse_ng::re::MemoryManager::SimpleArray::SimpleArray;
let mut array = SimpleArray::<i32>::with_capacity(3);
if let Some(value) = array.get_mut(1) {
    *value = 42;
};
assert_eq!(array[1], 42);
assert_eq!(array.get_mut(5), None);

pub const fn as_ptr(&self) -> *mut T

Returns a raw pointer to the data.

Equivalent C++ data()

Example

use commonlibsse_ng::re::MemoryManager::SimpleArray::SimpleArray;
let array: SimpleArray<i32> = SimpleArray::new();
let data = array.as_ptr();

pub const fn as_mut_slice(&mut self) -> &mut [T]

Returns a mutable slice of the array.

Safety

This function assumes that the array is properly initialized.

Example

use commonlibsse_ng::re::MemoryManager::SimpleArray::SimpleArray;
let mut array = SimpleArray::with_capacity(4);
let slice = array.as_mut_slice();
slice.copy_from_slice(&[1, 2, 3, 4]);

pub const fn as_slice(&self) -> &[T]

Returns a slice of the array.

Safety

This function assumes that the array is properly initialized.

Example

use commonlibsse_ng::re::MemoryManager::SimpleArray::SimpleArray;
let array = SimpleArray::<i32>::with_capacity(4);
let slice = array.as_slice();
assert_eq!(slice, &[0, 0, 0, 0]);

pub const fn iter(&self) -> SimpleArrayIterator<'_, T, A>

Creates an iterator that borrows the elements of the SimpleArray.

This method returns an iterator over references to the elements of the array. The iterator allows you to traverse the array without consuming it, meaning the array remains usable after the iteration.

Example

use commonlibsse_ng::re::MemoryManager::SimpleArray::SimpleArray;
let mut array = SimpleArray::with_capacity(3);
let slice = array.as_mut_slice();
slice[0] = 10;
slice[1] = 20;
slice[2] = 30;

let sum: i32 = array.iter().sum();
assert_eq!(sum, 60);

Trait Implementations

impl<T> Default for SimpleArray<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T, A: Allocator> Drop for SimpleArray<T, A>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: Hash, A: Allocator> Hash for SimpleArray<T, A>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T, A: Allocator> Index<usize> for SimpleArray<T, A>

type Output = T

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T, A: Allocator> IndexMut<usize> for SimpleArray<T, A>

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<'a, T, A: Allocator> IntoIterator for &'a SimpleArray<T, A>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = SimpleArrayIterator<'a, T, A>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T, A: Allocator> IntoIterator for SimpleArray<T, A>

type Item = T

The type of the elements being iterated over.

type IntoIter = SimpleArrayIntoIterator<T, A>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: Ord, A: Allocator> Ord for SimpleArray<T, A>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: PartialEq, A: Allocator> PartialEq for SimpleArray<T, A>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: PartialOrd, A: Allocator> PartialOrd for SimpleArray<T, A>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: Eq, A: Allocator> Eq for SimpleArray<T, A>