Enum swagger::nullable_format::Nullable
[−]
[src]
pub enum Nullable<T> { Null, Present(T), }
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
Present(T)
Methods
impl<T> Nullable<T>
[src]
fn is_present(&self) -> bool
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);
fn is_null(&self) -> bool
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);
fn as_ref(&self) -> Nullable<&T>
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);
fn as_mut(&mut self) -> Nullable<&mut T>
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));
fn expect(self, msg: &str) -> T
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`
fn unwrap(self) -> T
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
fn unwrap_or(self, def: T) -> T
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");
fn unwrap_or_else<F: FnOnce() -> T>(self, f: F) -> T
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);
fn map<U, F: FnOnce(T) -> U>(self, f: F) -> Nullable<U>
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));
fn map_or<U, F: FnOnce(T) -> U>(self, default: U, f: F) -> U
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);
fn map_or_else<U, D: FnOnce() -> U, F: FnOnce(T) -> U>(
self,
default: D,
f: F
) -> U
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);
fn ok_or<E>(self, err: E) -> Result<T, E>
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));
fn ok_or_else<E, F: FnOnce() -> E>(self, err: F) -> Result<T, E>
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));
fn and<U>(self, optb: Nullable<U>) -> Nullable<U>
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);
fn and_then<U, F: FnOnce(T) -> Nullable<U>>(self, f: F) -> Nullable<U>
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);
fn or(self, optb: Nullable<T>) -> Nullable<T>
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);
fn or_else<F: FnOnce() -> Nullable<T>>(self, f: F) -> Nullable<T>
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);
fn take(&mut self) -> Nullable<T>
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]
fn cloned(self) -> Nullable<T>
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]
fn unwrap_or_default(self) -> T
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: Debug> Debug for Nullable<T>
[src]
impl<T: Clone> Clone for Nullable<T>
[src]
fn clone(&self) -> Nullable<T>
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
1.0.0
Performs copy-assignment from source
. Read more
impl<T: Copy> Copy for Nullable<T>
[src]
impl<T: PartialEq> PartialEq for Nullable<T>
[src]
fn eq(&self, __arg_0: &Nullable<T>) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, __arg_0: &Nullable<T>) -> bool
This method tests for !=
.
impl<T: PartialOrd> PartialOrd for Nullable<T>
[src]
fn partial_cmp(&self, __arg_0: &Nullable<T>) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, __arg_0: &Nullable<T>) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, __arg_0: &Nullable<T>) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, __arg_0: &Nullable<T>) -> bool
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, __arg_0: &Nullable<T>) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl<T> Default for Nullable<T>
[src]
impl<T> From<T> for Nullable<T>
[src]
impl<T> Serialize for Nullable<T> where
T: Serialize,
[src]
T: Serialize,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
S: Serializer,
Serialize this value into the given Serde serializer. Read more
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>,
D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more