Struct objc2_foundation::NSArray

#[repr(C)]
pub struct NSArray<T, O: Ownership> { /* fields omitted */ }

TODO

You can have a Id<NSArray<T, Owned>, Owned>, which allows mutable access to the elements (without modifying the array itself), and Id<NSArray<T, Shared>, Shared> which allows sharing the array.

Id<NSArray<T, Owned>, Shared> is possible, but pretty useless. TODO: Can we make it impossible? Should we?

What about Id<NSArray<T, Shared>, Owned>?

Trait Implementations

impl<T, O: Ownership> Debug for NSArray<T, O>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Hash, O: Hash + Ownership> Hash for NSArray<T, O>

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, 

Feeds a slice of this type into the given Hasher.

impl<T: INSObject, O: Ownership> INSArray for NSArray<T, O>

type Ownership = O

The NSArray itself (length and number of items) is always immutable, but we would like to know when we’re the only owner of the array, to allow mutation of the array’s items.

We only implement INSCopying when O = Shared, so this is safe.

type Item = T

type ItemOwnership = O

fn new() -> Id<Self, Self::Ownership>

fn len(&self) -> usize

fn is_empty(&self) -> bool

fn get(&self, index: usize) -> Option<&Self::Item>

fn get_mut(&mut self, index: usize) -> Option<&mut Self::Item> where
    Self: INSArray<ItemOwnership = Owned>, 

fn get_retained(&self, index: usize) -> Id<Self::Item, Shared> where
    Self: INSArray<ItemOwnership = Shared>, 

fn first(&self) -> Option<&Self::Item>

fn first_mut(&mut self) -> Option<&mut Self::Item> where
    Self: INSArray<ItemOwnership = Owned>, 

fn last(&self) -> Option<&Self::Item>

fn last_mut(&mut self) -> Option<&mut Self::Item> where
    Self: INSArray<ItemOwnership = Owned>, 

fn iter(&self) -> NSEnumerator<'_, Self::Item>

fn from_vec(
    vec: Vec<Id<Self::Item, Self::ItemOwnership>>
) -> Id<Self, Self::Ownership>

fn objects_in_range(&self, range: Range<usize>) -> Vec<&Self::Item>

fn to_vec(&self) -> Vec<&Self::Item>

fn into_vec(array: Id<Self, Owned>) -> Vec<Id<Self::Item, Self::ItemOwnership>>

fn from_slice(slice: &[Id<Self::Item, Shared>]) -> Id<Self, Self::Ownership> where
    Self: INSArray<ItemOwnership = Shared>, 

fn to_shared_vec(&self) -> Vec<Id<Self::Item, Shared>> where
    Self: INSArray<ItemOwnership = Shared>, 

impl<T: INSObject> INSCopying for NSArray<T, Shared>

type Ownership = Shared

Indicates whether the type is mutable or immutable.

type Output = NSArray<T, Shared>

The output type.

fn copy(&self) -> Id<Self::Output, Self::Ownership>

impl<T: INSObject, O: Ownership> INSFastEnumeration for NSArray<T, O>

type Item = T

fn enumerator(&self) -> NSFastEnumerator<'_, Self>

impl<T: INSObject> INSMutableCopying for NSArray<T, Shared>

type Output = NSMutableArray<T, Shared>

TODO

fn mutable_copy(&self) -> Id<Self::Output, Owned>

impl<T, O: Ownership> INSObject for NSArray<T, O>

fn class() -> &'static Class

fn hash_code(&self) -> usize

fn is_equal<T: INSObject>(&self, other: &T) -> bool

fn description(&self) -> Id<NSString, Shared>

fn is_kind_of(&self, cls: &Class) -> bool

impl<T: INSObject, O: Ownership> Index<usize> for NSArray<T, O>

type Output = T

The returned type after indexing.

fn index(&self, index: usize) -> &T

Performs the indexing (container[index]) operation.

impl<T: PartialEq, O: PartialEq + Ownership> PartialEq<NSArray<T, O>> for NSArray<T, O>

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl<T, O: Ownership> RefEncode for NSArray<T, O>

const ENCODING_REF: Encoding<'static>

The Objective-C type-encoding for a reference of this type.

impl<T: Eq, O: Eq + Ownership> Eq for NSArray<T, O>

impl<T, O: Ownership> Message for NSArray<T, O>

impl<T: Sync + Send> Send for NSArray<T, Shared>

impl<T: Send> Send for NSArray<T, Owned>

impl<T: Sync + Send> Sync for NSArray<T, Shared>

impl<T: Sync> Sync for NSArray<T, Owned>