Trait gdnative::core_types::FromVariant

pub trait FromVariant {
    pub fn from_variant(variant: &Variant) -> Result<Self, FromVariantError>;
}

Types that can be converted from a Variant.

Option<T> and MaybeNot<T>

Option<T> requires the Variant to be T or Nil, in that order. For looser semantics, use MaybeNot<T>, which will catch all variant values that are not T as well.

Vec<T>

The FromVariant implementation for Vec<T> only allow homogeneous arrays. If you want to manually handle potentially heterogeneous values e.g. for error reporting, use VariantArray directly or compose with an appropriate wrapper: Vec<Option<T>> or Vec<MaybeNot<T>>.

Deriving FromVariant

The derive macro provides implementation consistent with derived ToVariant. See ToVariant for detailed documentation.

Required methods

pub fn from_variant(variant: &Variant) -> Result<Self, FromVariantError>

Loading content...

Implementations on Foreign Types

impl FromVariant for String

pub fn from_variant(variant: &Variant) -> Result<String, FromVariantError>

impl<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> FromVariant for (T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) where
    T2: FromVariant,
    T3: FromVariant,
    T4: FromVariant,
    T5: FromVariant,
    T6: FromVariant,
    T7: FromVariant,
    T8: FromVariant,
    T9: FromVariant,
    T10: FromVariant,
    T11: FromVariant,
    T12: FromVariant, 

pub fn from_variant(
    v: &Variant
) -> Result<(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), FromVariantError>

impl FromVariant for i64

pub fn from_variant(variant: &Variant) -> Result<i64, FromVariantError>

impl FromVariant for u8

pub fn from_variant(variant: &Variant) -> Result<u8, FromVariantError>

impl<T, E> FromVariant for Result<T, E> where
    E: FromVariant,
    T: FromVariant, 

pub fn from_variant(variant: &Variant) -> Result<Result<T, E>, FromVariantError>

impl<T> FromVariant for PhantomData<T>

pub fn from_variant(
    variant: &Variant
) -> Result<PhantomData<T>, FromVariantError>

impl<T10, T11, T12> FromVariant for (T10, T11, T12) where
    T10: FromVariant,
    T11: FromVariant,
    T12: FromVariant, 

pub fn from_variant(v: &Variant) -> Result<(T10, T11, T12), FromVariantError>

impl<T7, T8, T9, T10, T11, T12> FromVariant for (T7, T8, T9, T10, T11, T12) where
    T7: FromVariant,
    T8: FromVariant,
    T9: FromVariant,
    T10: FromVariant,
    T11: FromVariant,
    T12: FromVariant, 

pub fn from_variant(
    v: &Variant
) -> Result<(T7, T8, T9, T10, T11, T12), FromVariantError>

impl FromVariant for i16

pub fn from_variant(variant: &Variant) -> Result<i16, FromVariantError>

impl<T12> FromVariant for (T12,) where
    T12: FromVariant, 

pub fn from_variant(v: &Variant) -> Result<(T12,), FromVariantError>

impl FromVariant for u32

pub fn from_variant(variant: &Variant) -> Result<u32, FromVariantError>

impl FromVariant for Rotation3D<f32, UnknownUnit, UnknownUnit>

pub fn from_variant(
    variant: &Variant
) -> Result<Rotation3D<f32, UnknownUnit, UnknownUnit>, FromVariantError>

impl FromVariant for Vector2D<f32, UnknownUnit>

pub fn from_variant(
    variant: &Variant
) -> Result<Vector2D<f32, UnknownUnit>, FromVariantError>

impl<T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> FromVariant for (T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) where
    T3: FromVariant,
    T4: FromVariant,
    T5: FromVariant,
    T6: FromVariant,
    T7: FromVariant,
    T8: FromVariant,
    T9: FromVariant,
    T10: FromVariant,
    T11: FromVariant,
    T12: FromVariant, 

pub fn from_variant(
    v: &Variant
) -> Result<(T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), FromVariantError>

impl<T8, T9, T10, T11, T12> FromVariant for (T8, T9, T10, T11, T12) where
    T8: FromVariant,
    T9: FromVariant,
    T10: FromVariant,
    T11: FromVariant,
    T12: FromVariant, 

pub fn from_variant(
    v: &Variant
) -> Result<(T8, T9, T10, T11, T12), FromVariantError>

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> FromVariant for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) where
    T1: FromVariant,
    T2: FromVariant,
    T3: FromVariant,
    T4: FromVariant,
    T5: FromVariant,
    T6: FromVariant,
    T7: FromVariant,
    T8: FromVariant,
    T9: FromVariant,
    T10: FromVariant,
    T11: FromVariant,
    T12: FromVariant, 

pub fn from_variant(
    v: &Variant
) -> Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), FromVariantError>

impl<T6, T7, T8, T9, T10, T11, T12> FromVariant for (T6, T7, T8, T9, T10, T11, T12) where
    T6: FromVariant,
    T7: FromVariant,
    T8: FromVariant,
    T9: FromVariant,
    T10: FromVariant,
    T11: FromVariant,
    T12: FromVariant, 

pub fn from_variant(
    v: &Variant
) -> Result<(T6, T7, T8, T9, T10, T11, T12), FromVariantError>

impl FromVariant for f32

pub fn from_variant(variant: &Variant) -> Result<f32, FromVariantError>

impl<T> FromVariant for Option<T> where
    T: FromVariant, 

pub fn from_variant(variant: &Variant) -> Result<Option<T>, FromVariantError>

impl FromVariant for Transform2D<f32, UnknownUnit, UnknownUnit>

pub fn from_variant(
    variant: &Variant
) -> Result<Transform2D<f32, UnknownUnit, UnknownUnit>, FromVariantError>

impl FromVariant for i8

pub fn from_variant(variant: &Variant) -> Result<i8, FromVariantError>

impl<T> FromVariant for Vec<T, Global> where
    T: FromVariant, 

pub fn from_variant(
    variant: &Variant
) -> Result<Vec<T, Global>, FromVariantError>

impl FromVariant for u16

pub fn from_variant(variant: &Variant) -> Result<u16, FromVariantError>

impl FromVariant for u64

pub fn from_variant(variant: &Variant) -> Result<u64, FromVariantError>

impl<T11, T12> FromVariant for (T11, T12) where
    T11: FromVariant,
    T12: FromVariant, 

pub fn from_variant(v: &Variant) -> Result<(T11, T12), FromVariantError>

impl FromVariant for ()

pub fn from_variant(variant: &Variant) -> Result<(), FromVariantError>

impl FromVariant for usize

pub fn from_variant(variant: &Variant) -> Result<usize, FromVariantError>

impl<T4, T5, T6, T7, T8, T9, T10, T11, T12> FromVariant for (T4, T5, T6, T7, T8, T9, T10, T11, T12) where
    T4: FromVariant,
    T5: FromVariant,
    T6: FromVariant,
    T7: FromVariant,
    T8: FromVariant,
    T9: FromVariant,
    T10: FromVariant,
    T11: FromVariant,
    T12: FromVariant, 

pub fn from_variant(
    v: &Variant
) -> Result<(T4, T5, T6, T7, T8, T9, T10, T11, T12), FromVariantError>

impl<T9, T10, T11, T12> FromVariant for (T9, T10, T11, T12) where
    T9: FromVariant,
    T10: FromVariant,
    T11: FromVariant,
    T12: FromVariant, 

pub fn from_variant(
    v: &Variant
) -> Result<(T9, T10, T11, T12), FromVariantError>

impl FromVariant for f64

pub fn from_variant(variant: &Variant) -> Result<f64, FromVariantError>

impl FromVariant for Rect<f32, UnknownUnit>

pub fn from_variant(
    variant: &Variant
) -> Result<Rect<f32, UnknownUnit>, FromVariantError>

impl FromVariant for Vector3D<f32, UnknownUnit>

pub fn from_variant(
    variant: &Variant
) -> Result<Vector3D<f32, UnknownUnit>, FromVariantError>

impl FromVariant for isize

pub fn from_variant(variant: &Variant) -> Result<isize, FromVariantError>

impl FromVariant for i32

pub fn from_variant(variant: &Variant) -> Result<i32, FromVariantError>

impl<T5, T6, T7, T8, T9, T10, T11, T12> FromVariant for (T5, T6, T7, T8, T9, T10, T11, T12) where
    T5: FromVariant,
    T6: FromVariant,
    T7: FromVariant,
    T8: FromVariant,
    T9: FromVariant,
    T10: FromVariant,
    T11: FromVariant,
    T12: FromVariant, 

pub fn from_variant(
    v: &Variant
) -> Result<(T5, T6, T7, T8, T9, T10, T11, T12), FromVariantError>

impl FromVariant for bool

pub fn from_variant(variant: &Variant) -> Result<bool, FromVariantError>

Loading content...

Implementors

impl FromVariant for Aabb

pub fn from_variant(variant: &Variant) -> Result<Aabb, FromVariantError>

impl FromVariant for Basis

pub fn from_variant(variant: &Variant) -> Result<Basis, FromVariantError>

impl FromVariant for Color

pub fn from_variant(variant: &Variant) -> Result<Color, FromVariantError>

impl FromVariant for Dictionary<Shared>

pub fn from_variant(
    variant: &Variant
) -> Result<Dictionary<Shared>, FromVariantError>

impl FromVariant for GodotString

pub fn from_variant(variant: &Variant) -> Result<GodotString, FromVariantError>

impl FromVariant for NodePath

pub fn from_variant(variant: &Variant) -> Result<NodePath, FromVariantError>

impl FromVariant for Plane

pub fn from_variant(variant: &Variant) -> Result<Plane, FromVariantError>

impl FromVariant for Rid

pub fn from_variant(variant: &Variant) -> Result<Rid, FromVariantError>

impl FromVariant for Transform

pub fn from_variant(variant: &Variant) -> Result<Transform, FromVariantError>

impl FromVariant for Variant

pub fn from_variant(variant: &Variant) -> Result<Variant, FromVariantError>

impl FromVariant for VariantArray<Shared>

pub fn from_variant(
    variant: &Variant
) -> Result<VariantArray<Shared>, FromVariantError>

impl<T> FromVariant for MaybeNot<T> where
    T: FromVariant, 

pub fn from_variant(variant: &Variant) -> Result<MaybeNot<T>, FromVariantError>

impl<T> FromVariant for TypedArray<T> where
    T: Element, 

pub fn from_variant(
    variant: &Variant
) -> Result<TypedArray<T>, FromVariantError>

impl<T> FromVariant for Instance<T, Shared> where
    T: NativeClass,
    <T as NativeClass>::Base: GodotObject,
    <<T as NativeClass>::Base as GodotObject>::RefKind == RefCounted, 

pub fn from_variant(
    variant: &Variant
) -> Result<Instance<T, Shared>, FromVariantError>

impl<T> FromVariant for Ref<T, Shared> where
    T: GodotObject, 

pub fn from_variant(
    variant: &Variant
) -> Result<Ref<T, Shared>, FromVariantError>

Loading content...