Enum CubeOption 

pub enum CubeOption<T: CubeType> {
    Some(T),
    None,
}

Variants

Some(T)

None

Implementations

impl<T: CubeType> CubeOption<T>

pub fn new_Some(_0: T) -> Self

pub fn __expand_new_Some( _: &mut Scope, _0: <T as CubeType>::ExpandType, ) -> CubeOptionExpand<T>

pub fn new_None() -> Self

pub fn __expand_new_None(_: &mut Scope) -> CubeOptionExpand<T>

impl<T: CubeType> CubeOption<T>

pub fn is_some(&self) -> bool

pub fn unwrap(self) -> T

pub fn is_none(&self) -> bool

pub fn unwrap_or(self, fallback: T) -> T

pub fn __expand_is_some( scope: &mut Scope, this: <Self as CubeType>::ExpandType, ) -> <bool as CubeType>::ExpandType

pub fn __expand_unwrap( scope: &mut Scope, this: <Self as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

pub fn __expand_is_none( scope: &mut Scope, this: <Self as CubeType>::ExpandType, ) -> <bool as CubeType>::ExpandType

pub fn __expand_unwrap_or( scope: &mut Scope, this: <Self as CubeType>::ExpandType, fallback: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

Trait Implementations

impl<T: Clone + CubeType> Clone for CubeOption<T>

fn clone(&self) -> CubeOption<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: CubeType> CubeDebug for CubeOption<T>

fn set_debug_name(&self, scope: &mut Scope, name: &'static str)

Set the debug name of this type’s expansion. Should do nothing for types that don’t appear at runtime

impl<T: CubeType> CubeType for CubeOption<T>

type ExpandType = CubeOptionExpand<T>

fn into_mut(scope: &mut Scope, expand: Self::ExpandType) -> Self::ExpandType

Wrapper around the init method, necessary to type inference.

impl<T: Debug + CubeType> Debug for CubeOption<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for CubeOption<T>

where T: Deserialize<'de> + CubeType,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: CubeType + Into<T::ExpandType>> From<CubeOption<T>> for CubeOptionExpand<T>

fn from(value: CubeOption<T>) -> Self

Converts to this type from the input type.

impl<T: Hash + CubeType> Hash for CubeOption<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: LaunchArg> LaunchArg for CubeOption<T>

type RuntimeArg<'a, R: Runtime> = CubeOptionArgs<'a, T, R>

The runtime argument for the kernel.

type CompilationArg = CubeOptionCompilationArg<T>

Compilation argument.

fn compilation_arg<R: Runtime>( runtime_arg: &Self::RuntimeArg<'_, R>, ) -> Self::CompilationArg

fn expand( arg: &Self::CompilationArg, builder: &mut KernelBuilder, ) -> <Self as CubeType>::ExpandType

Register an input variable during compilation that fill the KernelBuilder.

fn expand_output( arg: &Self::CompilationArg, builder: &mut KernelBuilder, ) -> <Self as CubeType>::ExpandType

Register an output variable during compilation that fill the KernelBuilder.

impl<T: PartialEq + CubeType> PartialEq for CubeOption<T>

fn eq(&self, other: &CubeOption<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Serialize for CubeOption<T>

where T: Serialize + CubeType,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Copy + CubeType> Copy for CubeOption<T>

impl<T: Eq + CubeType> Eq for CubeOption<T>

impl<T: CubeType> StructuralPartialEq for CubeOption<T>