Struct objc_foundation::NSDictionary

pub struct NSDictionary<K, V> { /* fields omitted */ }

Trait Implementations

impl<K, V> INSDictionary for NSDictionary<K, V> where
    K: INSObject,
    V: INSObject, 

type Key = K

type Value = V

type Own = Owned

fn count(&self) -> usize

fn object_for(&self, key: &Self::Key) -> Option<&Self::Value>

fn keys(&self) -> Vec<&Self::Key>

fn values(&self) -> Vec<&Self::Value>

fn keys_and_objects(&self) -> (Vec<&Self::Key>, Vec<&Self::Value>)

Important traits for NSEnumerator<'a, T>

impl<'a, T> Iterator for NSEnumerator<'a, T> where
    T: INSObject,  type Item = &'a T;

fn key_enumerator(&self) -> NSEnumerator<Self::Key>

Important traits for NSEnumerator<'a, T>

impl<'a, T> Iterator for NSEnumerator<'a, T> where
    T: INSObject,  type Item = &'a T;

fn object_enumerator(&self) -> NSEnumerator<Self::Value>

fn keys_array(&self) -> Id<NSSharedArray<Self::Key>>

fn from_keys_and_objects<T>(
    keys: &[&T],
    vals: Vec<Id<Self::Value, Self::Own>>
) -> Id<Self> where
    T: INSCopying<Output = Self::Key>, 

fn into_values_array(dict: Id<Self>) -> Id<NSArray<Self::Value, Self::Own>>

impl<K, V> INSFastEnumeration for NSDictionary<K, V> where
    K: INSObject,
    V: INSObject, 

type Item = K

Important traits for NSFastEnumerator<'a, C>

impl<'a, C: INSFastEnumeration> Iterator for NSFastEnumerator<'a, C> type Item = &'a C::Item;

fn enumerator(&self) -> NSFastEnumerator<Self>

impl<K, V> INSObject for NSDictionary<K, V> where
    K: INSObject,
    V: INSObject, 

fn class() -> &'static Class

fn hash_code(&self) -> usize

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

fn description(&self) -> ShareId<NSString>

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

fn new() -> Id<Self>

impl<'a, K, V> Index<&'a K> for NSDictionary<K, V> where
    K: INSObject,
    V: INSObject, 

type Output = V

The returned type after indexing.

fn index(&self, index: &K) -> &V

Performs the indexing (container[index]) operation.

impl<K, V> Message for NSDictionary<K, V>

unsafe fn send_message<A, R>(
    &self,
    sel: Sel,
    args: A
) -> Result<R, MessageError> where
    A: MessageArguments,
    R: Any, 

Sends a message to self with the given selector and arguments.

fn verify_message<A, R>(&self, sel: Sel) -> Result<(), MessageError> where
    A: EncodeArguments,
    R: Encode, 

Verifies that the argument and return types match the encoding of the method for the given selector.