Struct wooting_analog_common::SDKResult

pub struct SDKResult<T>(pub Result<T, WootingAnalogResult>);

Methods from Deref<Target = Result<T, WootingAnalogResult>>

#[must_use = "if you intended to assert that this is ok, consider `.unwrap()` instead"]

pub const fn is_ok(&self) -> bool

Returns true if the result is Ok.

Examples

Basic usage:

let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_ok(), true);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_ok(), false);

#[must_use = "if you intended to assert that this is err, consider `.unwrap_err()` instead"]

pub const fn is_err(&self) -> bool

Returns true if the result is Err.

Examples

Basic usage:

let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_err(), false);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_err(), true);

#[must_use]

pub fn contains<U>(&self, x: &U) -> bool where
    U: PartialEq<T>, 

🔬 This is a nightly-only experimental API. (option_result_contains)

Returns true if the result is an Ok value containing the given value.

Examples

#![feature(option_result_contains)]

let x: Result<u32, &str> = Ok(2);
assert_eq!(x.contains(&2), true);

let x: Result<u32, &str> = Ok(3);
assert_eq!(x.contains(&2), false);

let x: Result<u32, &str> = Err("Some error message");
assert_eq!(x.contains(&2), false);

#[must_use]

pub fn contains_err<F>(&self, f: &F) -> bool where
    F: PartialEq<E>, 

🔬 This is a nightly-only experimental API. (result_contains_err)

Returns true if the result is an Err value containing the given value.

Examples

#![feature(result_contains_err)]

let x: Result<u32, &str> = Ok(2);
assert_eq!(x.contains_err(&"Some error message"), false);

let x: Result<u32, &str> = Err("Some error message");
assert_eq!(x.contains_err(&"Some error message"), true);

let x: Result<u32, &str> = Err("Some other error message");
assert_eq!(x.contains_err(&"Some error message"), false);

pub const fn as_ref(&self) -> Result<&T, &E>

Converts from &Result<T, E> to Result<&T, &E>.

Produces a new Result, containing a reference into the original, leaving the original in place.

Examples

Basic usage:

let x: Result<u32, &str> = Ok(2);
assert_eq!(x.as_ref(), Ok(&2));

let x: Result<u32, &str> = Err("Error");
assert_eq!(x.as_ref(), Err(&"Error"));

pub fn iter(&self) -> Iter<'_, T>

Returns an iterator over the possibly contained value.

The iterator yields one value if the result is Result::Ok, otherwise none.

Examples

Basic usage:

let x: Result<u32, &str> = Ok(7);
assert_eq!(x.iter().next(), Some(&7));

let x: Result<u32, &str> = Err("nothing!");
assert_eq!(x.iter().next(), None);

pub fn as_deref(&self) -> Result<&<T as Deref>::Target, &E>

Converts from Result<T, E> (or &Result<T, E>) to Result<&<T as Deref>::Target, &E>.

Coerces the Ok variant of the original Result via Deref and returns the new Result.

Examples

let x: Result<String, u32> = Ok("hello".to_string());
let y: Result<&str, &u32> = Ok("hello");
assert_eq!(x.as_deref(), y);

let x: Result<String, u32> = Err(42);
let y: Result<&str, &u32> = Err(&42);
assert_eq!(x.as_deref(), y);

Trait Implementations

impl<T: Debug> Debug for SDKResult<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Default for SDKResult<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> Deref for SDKResult<T>

type Target = Result<T, WootingAnalogResult>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a> From<FfiStr<'a>> for SDKResult<FfiStr<'a>>

fn from(res: FfiStr<'a>) -> Self

Performs the conversion.

impl<T> From<Result<T, WootingAnalogResult>> for SDKResult<T>

fn from(ptr: Result<T, WootingAnalogResult>) -> Self

Performs the conversion.

impl<T> From<WootingAnalogResult> for SDKResult<T>

fn from(res: WootingAnalogResult) -> Self

Performs the conversion.

impl From<f32> for SDKResult<f32>

fn from(res: f32) -> Self

Performs the conversion.

impl From<i32> for SDKResult<c_int>

fn from(res: c_int) -> Self

Performs the conversion.

impl From<i32> for SDKResult<u32>

fn from(res: c_int) -> Self

Performs the conversion.

impl From<u32> for SDKResult<u32>

fn from(res: u32) -> Self

Performs the conversion.

impl<T> Into<Result<T, WootingAnalogResult>> for SDKResult<T>

fn into(self) -> Result<T, WootingAnalogResult>

Performs the conversion.

impl Into<WootingAnalogResult> for SDKResult<()>

fn into(self) -> WootingAnalogResult

Performs the conversion.

impl Into<f32> for SDKResult<f32>

fn into(self) -> f32

Performs the conversion.

impl Into<i32> for SDKResult<u32>

fn into(self) -> i32

Performs the conversion.

impl Into<i32> for SDKResult<c_int>

fn into(self) -> c_int

Performs the conversion.