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
Null value
Present(T)
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: Debug> Debug for Nullable<T>
[src]
fn fmt(&self, __arg_0: &mut Formatter) -> Result
[src]
Formats the value using the given formatter. Read more
impl<T: Clone> Clone for Nullable<T>
[src]
fn clone(&self) -> Nullable<T>
[src]
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
1.0.0[src]
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
[src]
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
[src]
This method tests for !=
.
impl<T: PartialOrd> PartialOrd for Nullable<T>
[src]
fn partial_cmp(&self, __arg_0: &Nullable<T>) -> Option<Ordering>
[src]
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, __arg_0: &Nullable<T>) -> bool
[src]
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
[src]
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
[src]
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
[src]
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,
[src]
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>,
[src]
D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more