Struct Usage 

pub struct Usage<T, Scope = DefaultScope>(/* private fields */);

Implementations

impl<T, S> Usage<T, S>

pub fn new(x: <Usage<T, S> as Controlled>::Inner) -> Self

where Self: Controlled, S: Scope,

Trait Implementations

impl<T, Scope> Controlled for Usage<T, Scope>

where T: Controlled,

type Inner = <T as Controlled>::Inner

fn risky_unwrap(self) -> Self::Inner

Unwraps the inner value of the Controlled type. This is a risky operation because it consumes the Controlled type and returns the inner value negating the protections that the Controlled type provides.

fn init_from_inner(x: Self::Inner) -> Self

fn risky_ref(&self) -> &Self::Inner

Provides a reference to the inner value. This is a risky operation because it bypasses the protections that the Controlled type provides. Use with caution!

fn inner_mut(&mut self) -> &mut Self::Inner

fn new(inner: Self::Inner) -> Self

where Self: Sized,

Initialize a new instance of the Controlled type from the inner value.

fn generate<F>(f: F) -> Self

where Self: Sized, F: FnOnce() -> Self::Inner,

Generate a new instance of the Controlled type from a function that returns the inner value.

fn generate_ok<F, E>(f: F) -> Result<Self, E>

where Self: Sized, F: FnOnce() -> Result<Self::Inner, E>,

Generate a new Controlled type from a function that returns a Result with the inner value.

fn map<B, F>(self, f: F) -> <Self as ReplaceT<B>>::Output

where Self: Sized + ReplaceT<B>, F: FnOnce(<Self as Controlled>::Inner) -> B, <Self as ReplaceT<B>>::Output: Controlled<Inner = B>, B: Zeroize,

Map the inner value of this Controlled type. Conceptually similar to Option::map`.

fn map_ok<B, F, E>(self, f: F) -> Result<<Self as ReplaceT<B>>::Output, E>

where Self: Sized + ReplaceT<B>, F: FnOnce(<Self as Controlled>::Inner) -> Result<B, E>, <Self as ReplaceT<B>>::Output: Controlled<Inner = B>, B: Zeroize,

Similar to map but the closure returns a Result with the new inner value. The result is a Result with the new Controlled type.

fn zip<Other, Out, F>(self, b: Other, f: F) -> Protected<Out>

where Self: Sized, Other: Controlled, Out: Zeroize, F: FnOnce(Self::Inner, Other::Inner) -> Out,

Zip two Controlled values of the same type together with a function that combines them.

fn zip_ref<'a, A, Other, Out, F>( self, other: &'a Other, f: F, ) -> <Self as ReplaceT<Out>>::Output

where A: ?Sized + 'a, Self: Sized + ReplaceT<Out>, <Self as ReplaceT<Out>>::Output: Controlled<Inner = Out>, Other: AsProtectedRef<'a, A>, Out: Zeroize, F: FnOnce(Self::Inner, &A) -> Out,

Like zip but the second argument is a reference.

fn update<F>(&mut self, f: F)

where F: FnMut(&mut Self::Inner),

Similar to map but using references to that the inner value is updated in place.

fn update_with<Other, F>(&mut self, other: Other, f: F)

where F: FnMut(&mut Self::Inner, Other::Inner), Other: Controlled,

Update the inner value with another Controlled value. The inner value of the second argument is passed to the closure.

fn update_with_ref<'a, A, F>(&mut self, other: ProtectedRef<'a, A>, f: F)

where A: ?Sized + 'a, F: FnMut(&mut Self::Inner, &A),

Like update_with but the second argument is a reference.

fn iter<'a, I>(&'a self) -> impl Iterator<Item = Protected<I>>

where <Self as Controlled>::Inner: AsRef<[I]>, I: Copy + 'a,

Iterate over the inner value and wrap each element in a Protected. I must be Copy because Protected always takes ownership of the inner value.

fn replace(&mut self, new: Self) -> Self

where Self: Sized,

Replace the inner value with a new one. The new value must be Self.

fn risky_inner_mut(&mut self) -> &mut Self::Inner

Provides a mutable reference to the inner value. This is a risky operation because it bypasses the protections that the Controlled type provides. Use with caution!

impl<T, K, S> ReplaceT<K> for Usage<Protected<T>, S>

where Protected<K>: Controlled,

type Output = Protected<K>

impl<T, A> Serialize for Usage<T, A>

where T: Controlled, T::Inner: SafeSerialize,

Serialize implementation for Usage if it is controlled and the inner type is safe serializable.

For example, this allows us to serialize a Usage<Exportable<Protected<[u8; 32]>>> type.

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T, S> Zeroed for Usage<T, S>

where T: Zeroed,

fn zeroed() -> Self

impl<T, S> Acceptable<S> for Usage<T, S>

where S: Scope,