[−][src]Enum openapi_context::nullable_format::Nullable
The Nullable type. Represents a value which may be specified as null on an API. Note that this is distinct from a value that is optional and not present!
Nullable implements many of the same methods as the Option type (map, unwrap, etc).
Variants
Null value
Value is present
Methods
impl<T> Nullable<T>
[src]
pub fn is_present(&self) -> bool
[src]
Returns true
if the Nullable is a Present
value.
Examples
let x: Nullable<u32> = Nullable::Present(2); assert_eq!(x.is_present(), true); let x: Nullable<u32> = Nullable::Null; assert_eq!(x.is_present(), false);
pub fn is_null(&self) -> bool
[src]
Returns true
if the Nullable is a Null
value.
Examples
let x: Nullable<u32> = Nullable::Present(2); assert_eq!(x.is_null(), false); let x: Nullable<u32> = Nullable::Null; assert_eq!(x.is_null(), true);
pub fn as_ref(&self) -> Nullable<&T>
[src]
Converts from Nullable<T>
to Nullable<&T>
.
Examples
Convert an Nullable<
String
>
into a Nullable<
usize
>
, preserving the original.
The map
method takes the self
argument by value, consuming the original,
so this technique uses as_ref
to first take a Nullable
to a reference
to the value inside the original.
let num_as_str: Nullable<String> = Nullable::Present("10".to_string()); // First, cast `Nullable<String>` to `Nullable<&String>` with `as_ref`, // then consume *that* with `map`, leaving `num_as_str` on the stack. let num_as_int: Nullable<usize> = num_as_str.as_ref().map(|n| n.len()); println!("still can print num_as_str: {:?}", num_as_str);
pub fn as_mut(&mut self) -> Nullable<&mut T>
[src]
Converts from Nullable<T>
to Nullable<&mut T>
.
Examples
let mut x = Nullable::Present(2); match x.as_mut() { Nullable::Present(v) => *v = 42, Nullable::Null => {}, } assert_eq!(x, Nullable::Present(42));
pub fn expect(self, msg: &str) -> T
[src]
Unwraps a Nullable, yielding the content of a Nullable::Present
.
Panics
Panics if the value is a Nullable::Null
with a custom panic message provided by
msg
.
Examples
let x = Nullable::Present("value"); assert_eq!(x.expect("the world is ending"), "value");
let x: Nullable<&str> = Nullable::Null; x.expect("the world is ending"); // panics with `the world is ending`
pub fn unwrap(self) -> T
[src]
Moves the value v
out of the Nullable<T>
if it is Nullable::Present(v)
.
In general, because this function may panic, its use is discouraged.
Instead, prefer to use pattern matching and handle the Nullable::Null
case explicitly.
Panics
Panics if the self value equals Nullable::Null
.
Examples
let x = Nullable::Present("air"); assert_eq!(x.unwrap(), "air");
let x: Nullable<&str> = Nullable::Null; assert_eq!(x.unwrap(), "air"); // fails
pub fn unwrap_or(self, def: T) -> T
[src]
Returns the contained value or a default.
Examples
assert_eq!(Nullable::Present("car").unwrap_or("bike"), "car"); assert_eq!(Nullable::Null.unwrap_or("bike"), "bike");
pub fn unwrap_or_else<F: FnOnce() -> T>(self, f: F) -> T
[src]
Returns the contained value or computes it from a closure.
Examples
let k = 10; assert_eq!(Nullable::Present(4).unwrap_or_else(|| 2 * k), 4); assert_eq!(Nullable::Null.unwrap_or_else(|| 2 * k), 20);
pub fn map<U, F: FnOnce(T) -> U>(self, f: F) -> Nullable<U>
[src]
Maps a Nullable<T>
to Nullable<U>
by applying a function to a contained value.
Examples
Convert a Nullable<
String
>
into a Nullable<
usize
>
, consuming the original:
let maybe_some_string = Nullable::Present(String::from("Hello, World!")); // `Nullable::map` takes self *by value*, consuming `maybe_some_string` let maybe_some_len = maybe_some_string.map(|s| s.len()); assert_eq!(maybe_some_len, Nullable::Present(13));
pub fn map_or<U, F: FnOnce(T) -> U>(self, default: U, f: F) -> U
[src]
Applies a function to the contained value (if any),
or returns a default
(if not).
Examples
let x = Nullable::Present("foo"); assert_eq!(x.map_or(42, |v| v.len()), 3); let x: Nullable<&str> = Nullable::Null; assert_eq!(x.map_or(42, |v| v.len()), 42);
pub fn map_or_else<U, D: FnOnce() -> U, F: FnOnce(T) -> U>(
self,
default: D,
f: F
) -> U
[src]
self,
default: D,
f: F
) -> U
Applies a function to the contained value (if any),
or computes a default
(if not).
Examples
let k = 21; let x = Nullable::Present("foo"); assert_eq!(x.map_or_else(|| 2 * k, |v| v.len()), 3); let x: Nullable<&str> = Nullable::Null; assert_eq!(x.map_or_else(|| 2 * k, |v| v.len()), 42);
pub fn ok_or<E>(self, err: E) -> Result<T, E>
[src]
Transforms the Nullable<T>
into a Result<T, E>
, mapping Nullable::Present(v)
to
Ok(v)
and Nullable::Null
to Err(err)
.
Examples
let x = Nullable::Present("foo"); assert_eq!(x.ok_or(0), Ok("foo")); let x: Nullable<&str> = Nullable::Null; assert_eq!(x.ok_or(0), Err(0));
pub fn ok_or_else<E, F: FnOnce() -> E>(self, err: F) -> Result<T, E>
[src]
Transforms the Nullable<T>
into a Result<T, E>
, mapping Nullable::Present(v)
to
Ok(v)
and Nullable::Null
to Err(err())
.
Examples
let x = Nullable::Present("foo"); assert_eq!(x.ok_or_else(|| 0), Ok("foo")); let x: Nullable<&str> = Nullable::Null; assert_eq!(x.ok_or_else(|| 0), Err(0));
pub fn and<U>(self, optb: Nullable<U>) -> Nullable<U>
[src]
Returns Nullable::Null
if the Nullable is Nullable::Null
, otherwise returns optb
.
Examples
let x = Nullable::Present(2); let y: Nullable<&str> = Nullable::Null; assert_eq!(x.and(y), Nullable::Null); let x: Nullable<u32> = Nullable::Null; let y = Nullable::Present("foo"); assert_eq!(x.and(y), Nullable::Null); let x = Nullable::Present(2); let y = Nullable::Present("foo"); assert_eq!(x.and(y), Nullable::Present("foo")); let x: Nullable<u32> = Nullable::Null; let y: Nullable<&str> = Nullable::Null; assert_eq!(x.and(y), Nullable::Null);
pub fn and_then<U, F: FnOnce(T) -> Nullable<U>>(self, f: F) -> Nullable<U>
[src]
Returns Nullable::Null
if the Nullable is Nullable::Null
, otherwise calls f
with the
wrapped value and returns the result.
Some languages call this operation flatmap.
Examples
fn sq(x: u32) -> Nullable<u32> { Nullable::Present(x * x) } fn nope(_: u32) -> Nullable<u32> { Nullable::Null } assert_eq!(Nullable::Present(2).and_then(sq).and_then(sq), Nullable::Present(16)); assert_eq!(Nullable::Present(2).and_then(sq).and_then(nope), Nullable::Null); assert_eq!(Nullable::Present(2).and_then(nope).and_then(sq), Nullable::Null); assert_eq!(Nullable::Null.and_then(sq).and_then(sq), Nullable::Null);
pub fn or(self, optb: Nullable<T>) -> Nullable<T>
[src]
Returns the Nullable if it contains a value, otherwise returns optb
.
Examples
let x = Nullable::Present(2); let y = Nullable::Null; assert_eq!(x.or(y), Nullable::Present(2)); let x = Nullable::Null; let y = Nullable::Present(100); assert_eq!(x.or(y), Nullable::Present(100)); let x = Nullable::Present(2); let y = Nullable::Present(100); assert_eq!(x.or(y), Nullable::Present(2)); let x: Nullable<u32> = Nullable::Null; let y = Nullable::Null; assert_eq!(x.or(y), Nullable::Null);
pub fn or_else<F: FnOnce() -> Nullable<T>>(self, f: F) -> Nullable<T>
[src]
Returns the Nullable if it contains a value, otherwise calls f
and
returns the result.
Examples
fn nobody() -> Nullable<&'static str> { Nullable::Null } fn vikings() -> Nullable<&'static str> { Nullable::Present("vikings") } assert_eq!(Nullable::Present("barbarians").or_else(vikings), Nullable::Present("barbarians")); assert_eq!(Nullable::Null.or_else(vikings), Nullable::Present("vikings")); assert_eq!(Nullable::Null.or_else(nobody), Nullable::Null);
pub fn take(&mut self) -> Nullable<T>
[src]
Takes the value out of the Nullable, leaving a Nullable::Null
in its place.
Examples
let mut x = Nullable::Present(2); x.take(); assert_eq!(x, Nullable::Null); let mut x: Nullable<u32> = Nullable::Null; x.take(); assert_eq!(x, Nullable::Null);
impl<'a, T: Clone> Nullable<&'a T>
[src]
pub fn cloned(self) -> Nullable<T>
[src]
Maps an Nullable<&T>
to an Nullable<T>
by cloning the contents of the
Nullable.
Examples
let x = 12; let opt_x = Nullable::Present(&x); assert_eq!(opt_x, Nullable::Present(&12)); let cloned = opt_x.cloned(); assert_eq!(cloned, Nullable::Present(12));
impl<T: Default> Nullable<T>
[src]
pub fn unwrap_or_default(self) -> T
[src]
Returns the contained value or a default
Consumes the self
argument then, if Nullable::Present
, returns the contained
value, otherwise if Nullable::Null
, returns the default value for that
type.
Examples
let x = Nullable::Present(42); assert_eq!(42, x.unwrap_or_default()); let y: Nullable<i32> = Nullable::Null; assert_eq!(0, y.unwrap_or_default());
Trait Implementations
impl<T: Clone> Clone for Nullable<T>
[src]
impl<T: Copy> Copy for Nullable<T>
[src]
impl<T: Debug> Debug for Nullable<T>
[src]
impl<T> Default for Nullable<T>
[src]
impl<'de, T> Deserialize<'de> for Nullable<T> where
T: DeserializeOwned,
[src]
T: DeserializeOwned,
fn deserialize<D>(deserializer: D) -> Result<Nullable<T>, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T> From<T> for Nullable<T>
[src]
impl<T: PartialEq> PartialEq<Nullable<T>> for Nullable<T>
[src]
impl<T: PartialOrd> PartialOrd<Nullable<T>> for Nullable<T>
[src]
fn partial_cmp(&self, other: &Nullable<T>) -> Option<Ordering>
[src]
fn lt(&self, other: &Nullable<T>) -> bool
[src]
fn le(&self, other: &Nullable<T>) -> bool
[src]
fn gt(&self, other: &Nullable<T>) -> bool
[src]
fn ge(&self, other: &Nullable<T>) -> bool
[src]
impl<T> Serialize for Nullable<T> where
T: Serialize,
[src]
T: Serialize,
impl<T> StructuralPartialEq for Nullable<T>
[src]
Auto Trait Implementations
impl<T> RefUnwindSafe for Nullable<T> where
T: RefUnwindSafe,
T: RefUnwindSafe,
impl<T> Send for Nullable<T> where
T: Send,
T: Send,
impl<T> Sync for Nullable<T> where
T: Sync,
T: Sync,
impl<T> Unpin for Nullable<T> where
T: Unpin,
T: Unpin,
impl<T> UnwindSafe for Nullable<T> where
T: UnwindSafe,
T: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> DeserializeOwned for T where
T: for<'de> Deserialize<'de>,
[src]
T: for<'de> Deserialize<'de>,
impl<T> From<!> for T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> Same<T> for T
type Output = T
Should always be Self
impl<T> SendSyncUnwindSafe for T where
T: Send + Sync + UnwindSafe + ?Sized,
[src]
T: Send + Sync + UnwindSafe + ?Sized,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,