Struct bevy::reflect::DynamicEnum
source · pub struct DynamicEnum { /* private fields */ }
Expand description
A dynamic representation of an enum.
This allows for enums to be configured at runtime.
§Example
// The original enum value
let mut value: Option<usize> = Some(123);
// Create a DynamicEnum to represent the new value
let mut dyn_enum = DynamicEnum::new(
"None",
DynamicVariant::Unit
);
// Apply the DynamicEnum as a patch to the original value
value.apply(&dyn_enum);
// Tada!
assert_eq!(None, value);
Implementations§
source§impl DynamicEnum
impl DynamicEnum
sourcepub fn new<I, V>(variant_name: I, variant: V) -> DynamicEnum
pub fn new<I, V>(variant_name: I, variant: V) -> DynamicEnum
Create a new DynamicEnum
to represent an enum at runtime.
§Arguments
variant_name
: The name of the variant to setvariant
: The variant data
Examples found in repository?
examples/reflection/dynamic_types.rs (line 252)
11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258
fn main() {
#[derive(Reflect, Default)]
#[reflect(Identifiable, Default)]
struct Player {
id: u32,
}
#[reflect_trait]
trait Identifiable {
fn id(&self) -> u32;
}
impl Identifiable for Player {
fn id(&self) -> u32 {
self.id
}
}
// Normally, when instantiating a type, you get back exactly that type.
// This is because the type is known at compile time.
// We call this the "concrete" or "canonical" type.
let player: Player = Player { id: 123 };
// When working with reflected types, however, we often "erase" this type information
// using the `Reflect` trait object.
// The underlying type is still the same (in this case, `Player`),
// but now we've hidden that information from the compiler.
let reflected: Box<dyn Reflect> = Box::new(player);
// Because it's the same type under the hood, we can still downcast it back to the original type.
assert!(reflected.downcast_ref::<Player>().is_some());
// But now let's "clone" our type using `Reflect::clone_value`.
let cloned: Box<dyn Reflect> = reflected.clone_value();
// If we try to downcast back to `Player`, we'll get an error.
assert!(cloned.downcast_ref::<Player>().is_none());
// Why is this?
// Well the reason is that `Reflect::clone_value` actually creates a dynamic type.
// Since `Player` is a struct, we actually get a `DynamicStruct` back.
assert!(cloned.is::<DynamicStruct>());
// This dynamic type is used to represent (or "proxy") the original type,
// so that we can continue to access its fields and overall structure.
let ReflectRef::Struct(cloned_ref) = cloned.reflect_ref() else {
panic!("expected struct")
};
let id = cloned_ref.field("id").unwrap().downcast_ref::<u32>();
assert_eq!(id, Some(&123));
// It also enables us to create a representation of a type without having compile-time
// access to the actual type. This is how the reflection deserializers work.
// They generally can't know how to construct a type ahead of time,
// so they instead build and return these dynamic representations.
let input = "(id: 123)";
let mut registry = TypeRegistry::default();
registry.register::<Player>();
let registration = registry.get(std::any::TypeId::of::<Player>()).unwrap();
let deserialized = TypedReflectDeserializer::new(registration, ®istry)
.deserialize(&mut ron::Deserializer::from_str(input).unwrap())
.unwrap();
// Our deserialized output is a `DynamicStruct` that proxies/represents a `Player`.
assert!(deserialized.downcast_ref::<DynamicStruct>().is_some());
assert!(deserialized.represents::<Player>());
// And while this does allow us to access the fields and structure of the type,
// there may be instances where we need the actual type.
// For example, if we want to convert our `dyn Reflect` into a `dyn Identifiable`,
// we can't use the `DynamicStruct` proxy.
let reflect_identifiable = registration
.data::<ReflectIdentifiable>()
.expect("`ReflectIdentifiable` should be registered");
// This fails since the underlying type of `deserialized` is `DynamicStruct` and not `Player`.
assert!(reflect_identifiable
.get(deserialized.as_reflect())
.is_none());
// So how can we go from a dynamic type to a concrete type?
// There are two ways:
// 1. Using `Reflect::apply`.
{
// If you know the type at compile time, you can construct a new value and apply the dynamic
// value to it.
let mut value = Player::default();
value.apply(deserialized.as_reflect());
assert_eq!(value.id, 123);
// If you don't know the type at compile time, you need a dynamic way of constructing
// an instance of the type. One such way is to use the `ReflectDefault` type data.
let reflect_default = registration
.data::<ReflectDefault>()
.expect("`ReflectDefault` should be registered");
let mut value: Box<dyn Reflect> = reflect_default.default();
value.apply(deserialized.as_reflect());
let identifiable: &dyn Identifiable = reflect_identifiable.get(value.as_reflect()).unwrap();
assert_eq!(identifiable.id(), 123);
}
// 2. Using `FromReflect`
{
// If you know the type at compile time, you can use the `FromReflect` trait to convert the
// dynamic value into the concrete type directly.
let value: Player = Player::from_reflect(deserialized.as_reflect()).unwrap();
assert_eq!(value.id, 123);
// If you don't know the type at compile time, you can use the `ReflectFromReflect` type data
// to perform the conversion dynamically.
let reflect_from_reflect = registration
.data::<ReflectFromReflect>()
.expect("`ReflectFromReflect` should be registered");
let value: Box<dyn Reflect> = reflect_from_reflect
.from_reflect(deserialized.as_reflect())
.unwrap();
let identifiable: &dyn Identifiable = reflect_identifiable.get(value.as_reflect()).unwrap();
assert_eq!(identifiable.id(), 123);
}
// Lastly, while dynamic types are commonly generated via reflection methods like
// `Reflect::clone_value` or via the reflection deserializers,
// you can also construct them manually.
let mut my_dynamic_list = DynamicList::default();
my_dynamic_list.push(1u32);
my_dynamic_list.push(2u32);
my_dynamic_list.push(3u32);
// This is useful when you just need to apply some subset of changes to a type.
let mut my_list: Vec<u32> = Vec::new();
my_list.apply(&my_dynamic_list);
assert_eq!(my_list, vec![1, 2, 3]);
// And if you want it to actually proxy a type, you can configure it to do that as well:
assert!(!my_dynamic_list.as_reflect().represents::<Vec<u32>>());
my_dynamic_list.set_represented_type(Some(<Vec<u32>>::type_info()));
assert!(my_dynamic_list.as_reflect().represents::<Vec<u32>>());
// ============================= REFERENCE ============================= //
// For reference, here are all the available dynamic types:
// 1. `DynamicTuple`
{
let mut dynamic_tuple = DynamicTuple::default();
dynamic_tuple.insert(1u32);
dynamic_tuple.insert(2u32);
dynamic_tuple.insert(3u32);
let mut my_tuple: (u32, u32, u32) = (0, 0, 0);
my_tuple.apply(&dynamic_tuple);
assert_eq!(my_tuple, (1, 2, 3));
}
// 2. `DynamicArray`
{
let dynamic_array = DynamicArray::from_vec(vec![1u32, 2u32, 3u32]);
let mut my_array = [0u32; 3];
my_array.apply(&dynamic_array);
assert_eq!(my_array, [1, 2, 3]);
}
// 3. `DynamicList`
{
let mut dynamic_list = DynamicList::default();
dynamic_list.push(1u32);
dynamic_list.push(2u32);
dynamic_list.push(3u32);
let mut my_list: Vec<u32> = Vec::new();
my_list.apply(&dynamic_list);
assert_eq!(my_list, vec![1, 2, 3]);
}
// 4. `DynamicMap`
{
let mut dynamic_map = DynamicMap::default();
dynamic_map.insert("x", 1u32);
dynamic_map.insert("y", 2u32);
dynamic_map.insert("z", 3u32);
let mut my_map: HashMap<&str, u32> = HashMap::new();
my_map.apply(&dynamic_map);
assert_eq!(my_map.get("x"), Some(&1));
assert_eq!(my_map.get("y"), Some(&2));
assert_eq!(my_map.get("z"), Some(&3));
}
// 5. `DynamicStruct`
{
#[derive(Reflect, Default, Debug, PartialEq)]
struct MyStruct {
x: u32,
y: u32,
z: u32,
}
let mut dynamic_struct = DynamicStruct::default();
dynamic_struct.insert("x", 1u32);
dynamic_struct.insert("y", 2u32);
dynamic_struct.insert("z", 3u32);
let mut my_struct = MyStruct::default();
my_struct.apply(&dynamic_struct);
assert_eq!(my_struct, MyStruct { x: 1, y: 2, z: 3 });
}
// 6. `DynamicTupleStruct`
{
#[derive(Reflect, Default, Debug, PartialEq)]
struct MyTupleStruct(u32, u32, u32);
let mut dynamic_tuple_struct = DynamicTupleStruct::default();
dynamic_tuple_struct.insert(1u32);
dynamic_tuple_struct.insert(2u32);
dynamic_tuple_struct.insert(3u32);
let mut my_tuple_struct = MyTupleStruct::default();
my_tuple_struct.apply(&dynamic_tuple_struct);
assert_eq!(my_tuple_struct, MyTupleStruct(1, 2, 3));
}
// 7. `DynamicEnum`
{
#[derive(Reflect, Default, Debug, PartialEq)]
enum MyEnum {
#[default]
Empty,
Xyz(u32, u32, u32),
}
let mut values = DynamicTuple::default();
values.insert(1u32);
values.insert(2u32);
values.insert(3u32);
let dynamic_variant = DynamicVariant::Tuple(values);
let dynamic_enum = DynamicEnum::new("Xyz", dynamic_variant);
let mut my_enum = MyEnum::default();
my_enum.apply(&dynamic_enum);
assert_eq!(my_enum, MyEnum::Xyz(1, 2, 3));
}
}
sourcepub fn new_with_index<I, V>(
variant_index: usize,
variant_name: I,
variant: V,
) -> DynamicEnum
pub fn new_with_index<I, V>( variant_index: usize, variant_name: I, variant: V, ) -> DynamicEnum
Create a new DynamicEnum
with a variant index to represent an enum at runtime.
§Arguments
variant_index
: The index of the variant to setvariant_name
: The name of the variant to setvariant
: The variant data
sourcepub fn set_represented_type(
&mut self,
represented_type: Option<&'static TypeInfo>,
)
pub fn set_represented_type( &mut self, represented_type: Option<&'static TypeInfo>, )
Sets the type to be represented by this DynamicEnum
.
§Panics
Panics if the given type is not a TypeInfo::Enum
.
sourcepub fn set_variant<I, V>(&mut self, name: I, variant: V)
pub fn set_variant<I, V>(&mut self, name: I, variant: V)
Set the current enum variant represented by this struct.
sourcepub fn set_variant_with_index<I, V>(
&mut self,
variant_index: usize,
variant_name: I,
variant: V,
)
pub fn set_variant_with_index<I, V>( &mut self, variant_index: usize, variant_name: I, variant: V, )
Set the current enum variant represented by this struct along with its variant index.
sourcepub fn from<TEnum>(value: TEnum) -> DynamicEnumwhere
TEnum: Enum,
pub fn from<TEnum>(value: TEnum) -> DynamicEnumwhere
TEnum: Enum,
Create a DynamicEnum
from an existing one.
This is functionally the same as DynamicEnum::from_ref
except it takes an owned value.
sourcepub fn from_ref<TEnum>(value: &TEnum) -> DynamicEnumwhere
TEnum: Enum,
pub fn from_ref<TEnum>(value: &TEnum) -> DynamicEnumwhere
TEnum: Enum,
Create a DynamicEnum
from an existing one.
This is functionally the same as DynamicEnum::from
except it takes a reference.
Trait Implementations§
source§impl Debug for DynamicEnum
impl Debug for DynamicEnum
source§impl Default for DynamicEnum
impl Default for DynamicEnum
source§fn default() -> DynamicEnum
fn default() -> DynamicEnum
Returns the “default value” for a type. Read more
source§impl Enum for DynamicEnum
impl Enum for DynamicEnum
source§fn field(&self, name: &str) -> Option<&(dyn Reflect + 'static)>
fn field(&self, name: &str) -> Option<&(dyn Reflect + 'static)>
Returns a reference to the value of the field (in the current variant) with the given name. Read more
source§fn field_at(&self, index: usize) -> Option<&(dyn Reflect + 'static)>
fn field_at(&self, index: usize) -> Option<&(dyn Reflect + 'static)>
Returns a reference to the value of the field (in the current variant) at the given index.
source§fn field_mut(&mut self, name: &str) -> Option<&mut (dyn Reflect + 'static)>
fn field_mut(&mut self, name: &str) -> Option<&mut (dyn Reflect + 'static)>
Returns a mutable reference to the value of the field (in the current variant) with the given name. Read more
source§fn field_at_mut(&mut self, index: usize) -> Option<&mut (dyn Reflect + 'static)>
fn field_at_mut(&mut self, index: usize) -> Option<&mut (dyn Reflect + 'static)>
Returns a mutable reference to the value of the field (in the current variant) at the given index.
source§fn index_of(&self, name: &str) -> Option<usize>
fn index_of(&self, name: &str) -> Option<usize>
Returns the index of the field (in the current variant) with the given name. Read more
source§fn name_at(&self, index: usize) -> Option<&str>
fn name_at(&self, index: usize) -> Option<&str>
Returns the name of the field (in the current variant) with the given index. Read more
source§fn iter_fields(&self) -> VariantFieldIter<'_> ⓘ
fn iter_fields(&self) -> VariantFieldIter<'_> ⓘ
Returns an iterator over the values of the current variant’s fields.
source§fn variant_name(&self) -> &str
fn variant_name(&self) -> &str
The name of the current variant.
source§fn variant_index(&self) -> usize
fn variant_index(&self) -> usize
The index of the current variant.
source§fn variant_type(&self) -> VariantType
fn variant_type(&self) -> VariantType
The type of the current variant.
fn clone_dynamic(&self) -> DynamicEnum
source§fn is_variant(&self, variant_type: VariantType) -> bool
fn is_variant(&self, variant_type: VariantType) -> bool
Returns true if the current variant’s type matches the given one.
source§fn variant_path(&self) -> String
fn variant_path(&self) -> String
Returns the full path to the current variant.
source§impl Reflect for DynamicEnum
impl Reflect for DynamicEnum
source§fn get_represented_type_info(&self) -> Option<&'static TypeInfo>
fn get_represented_type_info(&self) -> Option<&'static TypeInfo>
source§fn into_any(self: Box<DynamicEnum>) -> Box<dyn Any>
fn into_any(self: Box<DynamicEnum>) -> Box<dyn Any>
Returns the value as a
Box<dyn Any>
.source§fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
Returns the value as a
&mut dyn Any
.source§fn into_reflect(self: Box<DynamicEnum>) -> Box<dyn Reflect>
fn into_reflect(self: Box<DynamicEnum>) -> Box<dyn Reflect>
Casts this type to a boxed reflected value.
source§fn as_reflect(&self) -> &(dyn Reflect + 'static)
fn as_reflect(&self) -> &(dyn Reflect + 'static)
Casts this type to a reflected value.
source§fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)
fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)
Casts this type to a mutable reflected value.
source§fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>
fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>
Performs a type-checked assignment of a reflected value to this value. Read more
source§fn reflect_kind(&self) -> ReflectKind
fn reflect_kind(&self) -> ReflectKind
Returns a zero-sized enumeration of “kinds” of type. Read more
source§fn reflect_ref(&self) -> ReflectRef<'_>
fn reflect_ref(&self) -> ReflectRef<'_>
Returns an immutable enumeration of “kinds” of type. Read more
source§fn reflect_mut(&mut self) -> ReflectMut<'_>
fn reflect_mut(&mut self) -> ReflectMut<'_>
Returns a mutable enumeration of “kinds” of type. Read more
source§fn reflect_owned(self: Box<DynamicEnum>) -> ReflectOwned
fn reflect_owned(self: Box<DynamicEnum>) -> ReflectOwned
Returns an owned enumeration of “kinds” of type. Read more
source§fn clone_value(&self) -> Box<dyn Reflect>
fn clone_value(&self) -> Box<dyn Reflect>
Clones the value as a
Reflect
trait object. Read moresource§fn reflect_hash(&self) -> Option<u64>
fn reflect_hash(&self) -> Option<u64>
Returns a hash of the value (which includes the type). Read more
source§fn reflect_partial_eq(&self, value: &(dyn Reflect + 'static)) -> Option<bool>
fn reflect_partial_eq(&self, value: &(dyn Reflect + 'static)) -> Option<bool>
Returns a “partial equality” comparison result. Read more
source§fn debug(&self, f: &mut Formatter<'_>) -> Result<(), Error>
fn debug(&self, f: &mut Formatter<'_>) -> Result<(), Error>
Debug formatter for the value. Read more
source§fn is_dynamic(&self) -> bool
fn is_dynamic(&self) -> bool
Indicates whether or not this type is a dynamic type. Read more
source§fn apply(&mut self, value: &(dyn Reflect + 'static))
fn apply(&mut self, value: &(dyn Reflect + 'static))
Applies a reflected value to this value. Read more
source§fn serializable(&self) -> Option<Serializable<'_>>
fn serializable(&self) -> Option<Serializable<'_>>
Returns a serializable version of the value. Read more
source§impl TypePath for DynamicEnum
impl TypePath for DynamicEnum
source§fn type_path() -> &'static str
fn type_path() -> &'static str
Returns the fully qualified path of the underlying type. Read more
source§fn short_type_path() -> &'static str
fn short_type_path() -> &'static str
Returns a short, pretty-print enabled path to the type. Read more
source§fn type_ident() -> Option<&'static str>
fn type_ident() -> Option<&'static str>
source§fn crate_name() -> Option<&'static str>
fn crate_name() -> Option<&'static str>
Auto Trait Implementations§
impl Freeze for DynamicEnum
impl !RefUnwindSafe for DynamicEnum
impl Send for DynamicEnum
impl Sync for DynamicEnum
impl Unpin for DynamicEnum
impl !UnwindSafe for DynamicEnum
Blanket Implementations§
source§impl<T, U> AsBindGroupShaderType<U> for T
impl<T, U> AsBindGroupShaderType<U> for T
source§fn as_bind_group_shader_type(&self, _images: &RenderAssets<GpuImage>) -> U
fn as_bind_group_shader_type(&self, _images: &RenderAssets<GpuImage>) -> U
Return the
T
ShaderType
for self
. When used in AsBindGroup
derives, it is safe to assume that all images in self
exist.source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
source§impl<T> Downcast for Twhere
T: Any,
impl<T> Downcast for Twhere
T: Any,
source§fn into_any(self: Box<T>) -> Box<dyn Any>
fn into_any(self: Box<T>) -> Box<dyn Any>
Convert
Box<dyn Trait>
(where Trait: Downcast
) to Box<dyn Any>
. Box<dyn Any>
can
then be further downcast
into Box<ConcreteType>
where ConcreteType
implements Trait
.source§fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Convert
Rc<Trait>
(where Trait: Downcast
) to Rc<Any>
. Rc<Any>
can then be
further downcast
into Rc<ConcreteType>
where ConcreteType
implements Trait
.source§fn as_any(&self) -> &(dyn Any + 'static)
fn as_any(&self) -> &(dyn Any + 'static)
Convert
&Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &Any
’s vtable from &Trait
’s.source§fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
Convert
&mut Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &mut Any
’s vtable from &mut Trait
’s.source§impl<T> DowncastSync for T
impl<T> DowncastSync for T
source§impl<T> DynamicTypePath for Twhere
T: TypePath,
impl<T> DynamicTypePath for Twhere
T: TypePath,
source§fn reflect_type_path(&self) -> &str
fn reflect_type_path(&self) -> &str
See
TypePath::type_path
.source§fn reflect_short_type_path(&self) -> &str
fn reflect_short_type_path(&self) -> &str
source§fn reflect_type_ident(&self) -> Option<&str>
fn reflect_type_ident(&self) -> Option<&str>
See
TypePath::type_ident
.source§fn reflect_crate_name(&self) -> Option<&str>
fn reflect_crate_name(&self) -> Option<&str>
See
TypePath::crate_name
.source§fn reflect_module_path(&self) -> Option<&str>
fn reflect_module_path(&self) -> Option<&str>
source§impl<S> FromSample<S> for S
impl<S> FromSample<S> for S
fn from_sample_(s: S) -> S
source§impl<T> FromWorld for Twhere
T: Default,
impl<T> FromWorld for Twhere
T: Default,
source§fn from_world(_world: &mut World) -> T
fn from_world(_world: &mut World) -> T
Creates
Self
using data from the given World
.source§impl<T> GetPath for T
impl<T> GetPath for T
source§fn reflect_path<'p>(
&self,
path: impl ReflectPath<'p>,
) -> Result<&(dyn Reflect + 'static), ReflectPathError<'p>>
fn reflect_path<'p>( &self, path: impl ReflectPath<'p>, ) -> Result<&(dyn Reflect + 'static), ReflectPathError<'p>>
Returns a reference to the value specified by
path
. Read moresource§fn reflect_path_mut<'p>(
&mut self,
path: impl ReflectPath<'p>,
) -> Result<&mut (dyn Reflect + 'static), ReflectPathError<'p>>
fn reflect_path_mut<'p>( &mut self, path: impl ReflectPath<'p>, ) -> Result<&mut (dyn Reflect + 'static), ReflectPathError<'p>>
Returns a mutable reference to the value specified by
path
. Read moresource§fn path<'p, T>(
&self,
path: impl ReflectPath<'p>,
) -> Result<&T, ReflectPathError<'p>>where
T: Reflect,
fn path<'p, T>(
&self,
path: impl ReflectPath<'p>,
) -> Result<&T, ReflectPathError<'p>>where
T: Reflect,
Returns a statically typed reference to the value specified by
path
. Read moresource§fn path_mut<'p, T>(
&mut self,
path: impl ReflectPath<'p>,
) -> Result<&mut T, ReflectPathError<'p>>where
T: Reflect,
fn path_mut<'p, T>(
&mut self,
path: impl ReflectPath<'p>,
) -> Result<&mut T, ReflectPathError<'p>>where
T: Reflect,
Returns a statically typed mutable reference to the value specified by
path
. Read moresource§impl<T> Instrument for T
impl<T> Instrument for T
source§fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
source§fn in_current_span(self) -> Instrumented<Self> ⓘ
fn in_current_span(self) -> Instrumented<Self> ⓘ
source§impl<T> IntoEither for T
impl<T> IntoEither for T
source§fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
Converts
self
into a Left
variant of Either<Self, Self>
if into_left
is true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moresource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
Converts
self
into a Left
variant of Either<Self, Self>
if into_left(&self)
returns true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moresource§impl<F, T> IntoSample<T> for Fwhere
T: FromSample<F>,
impl<F, T> IntoSample<T> for Fwhere
T: FromSample<F>,
fn into_sample(self) -> T
source§impl<T> Pointable for T
impl<T> Pointable for T
source§impl<R, P> ReadPrimitive<R> for P
impl<R, P> ReadPrimitive<R> for P
source§fn read_from_little_endian(read: &mut R) -> Result<Self, Error>
fn read_from_little_endian(read: &mut R) -> Result<Self, Error>
Read this value from the supplied reader. Same as
ReadEndian::read_from_little_endian()
.