Trait PartialReflect

Source

pub trait PartialReflect:
    DynamicTypePath
    + Send
    + Sync
    + 'static {
Show 20 methods    // Required methods
    fn get_represented_type_info(&self) -> Option<&'static TypeInfo>;
    fn into_partial_reflect(self: Box<Self>) -> Box<dyn PartialReflect>;
    fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static);
    fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static);
    fn try_into_reflect(
        self: Box<Self>,
    ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>;
    fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>;
    fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>;
    fn try_apply(
        &mut self,
        value: &(dyn PartialReflect + 'static),
    ) -> Result<(), ApplyError>;
    fn reflect_ref(&self) -> ReflectRef<'_>;
    fn reflect_mut(&mut self) -> ReflectMut<'_>;
    fn reflect_owned(self: Box<Self>) -> ReflectOwned;

    // Provided methods
    fn apply(&mut self, value: &(dyn PartialReflect + 'static)) { ... }
    fn reflect_kind(&self) -> ReflectKind { ... }
    fn to_dynamic(&self) -> Box<dyn PartialReflect> { ... }
    fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError> { ... }
    fn reflect_clone_and_take<T>(&self) -> Result<T, ReflectCloneError>
       where T: 'static,
             Self: Sized + TypePath { ... }
    fn reflect_hash(&self) -> Option<u64> { ... }
    fn reflect_partial_eq(
        &self,
        _value: &(dyn PartialReflect + 'static),
    ) -> Option<bool> { ... }
    fn debug(&self, f: &mut Formatter<'_>) -> Result<(), Error> { ... }
    fn is_dynamic(&self) -> bool { ... }
}

Expand description

The foundational trait of bevy_reflect, used for accessing and modifying data dynamically.

This is a supertrait of Reflect, meaning any type which implements Reflect implements PartialReflect by definition.

It’s recommended to use the derive macro for Reflect rather than manually implementing this trait. Doing so will automatically implement this trait as well as many other useful traits for reflection, including one of the appropriate subtraits: Struct, TupleStruct or Enum.

See the crate-level documentation to see how this trait and its subtraits can be used.

Required Methods§

Source

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

Returns the TypeInfo of the type represented by this value.

For most types, this will simply return their own TypeInfo. However, for dynamic types, such as DynamicStruct or DynamicList, this will return the type they represent (or None if they don’t represent any particular type).

This method is great if you have an instance of a type or a dyn Reflect, and want to access its TypeInfo. However, if this method is to be called frequently, consider using TypeRegistry::get_type_info as it can be more performant for such use cases.

Source

fn into_partial_reflect(self: Box<Self>) -> Box<dyn PartialReflect>

Casts this type to a boxed, reflected value.

This is useful for coercing trait objects.

Source

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

Casts this type to a reflected value.

This is useful for coercing trait objects.

Source

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

Casts this type to a mutable, reflected value.

This is useful for coercing trait objects.

Source

fn try_into_reflect( self: Box<Self>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

Attempts to cast this type to a boxed, fully-reflected value.

Source

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

Attempts to cast this type to a fully-reflected value.

Source

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

Attempts to cast this type to a mutable, fully-reflected value.

Source

fn try_apply( &mut self, value: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>

Tries to apply a reflected value to this value.

Functions the same as the apply function but returns an error instead of panicking.

§Handling Errors

This function may leave self in a partially mutated state if a error was encountered on the way. consider maintaining a cloned instance of this data you can switch to if a error is encountered.

Source

fn reflect_ref(&self) -> ReflectRef<'_>

Returns an immutable enumeration of “kinds” of type.

See ReflectRef.

Source

fn reflect_mut(&mut self) -> ReflectMut<'_>

Returns a mutable enumeration of “kinds” of type.

See ReflectMut.

Source

fn reflect_owned(self: Box<Self>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

See ReflectOwned.

Provided Methods§

Source

fn apply(&mut self, value: &(dyn PartialReflect + 'static))

Applies a reflected value to this value.

If Self implements a reflection subtrait, then the semantics of this method are as follows:

If Self is a Struct, then the value of each named field of value is applied to the corresponding named field of self. Fields which are not present in both structs are ignored.
If Self is a TupleStruct or Tuple, then the value of each numbered field is applied to the corresponding numbered field of self. Fields which are not present in both values are ignored.
If Self is an Enum, then the variant of self is updated to match the variant of value. The corresponding fields of that variant are applied from value onto self. Fields which are not present in both values are ignored.
If Self is a List or Array, then each element of value is applied to the corresponding element of self. Up to self.len() items are applied, and excess elements in value are appended to self.
If Self is a Map, then for each key in value, the associated value is applied to the value associated with the same key in self. Keys which are not present in self are inserted, and keys from self which are not present in value are removed.
If Self is a Set, then each element of value is applied to the corresponding element of Self. If an element of value does not exist in Self then it is cloned and inserted. If an element from self is not present in value then it is removed.
If Self is none of these, then value is downcast to Self, cloned, and assigned to self.

Note that Reflect must be implemented manually for Lists, Maps, and Sets in order to achieve the correct semantics, as derived implementations will have the semantics for Struct, TupleStruct, Enum or none of the above depending on the kind of type. For lists, maps, and sets, use the list_apply, map_apply, and set_apply helper functions when implementing this method.

§Panics

Derived implementations of this method will panic:

If the type of value is not of the same kind as Self (e.g. if Self is a List, while value is a Struct).
If Self is any complex type and the corresponding fields or elements of self and value are not of the same type.
If Self is an opaque type and value cannot be downcast to Self

Source

fn reflect_kind(&self) -> ReflectKind

Returns a zero-sized enumeration of “kinds” of type.

See ReflectKind.

Source

fn to_dynamic(&self) -> Box<dyn PartialReflect>

Converts this reflected value into its dynamic representation based on its kind.

For example, a List type will internally invoke List::to_dynamic_list, returning DynamicList. A Struct type will invoke Struct::to_dynamic_struct, returning DynamicStruct. And so on.

If the kind is opaque, then the value will attempt to be cloned directly via reflect_clone, since opaque types do not have any standard dynamic representation.

To attempt to clone the value directly such that it returns a concrete instance of this type, use reflect_clone.

§Panics

This method will panic if the kind is opaque and the call to reflect_clone fails.

§Example

let value = (1, true, 3.14);
let dynamic_value = value.to_dynamic();
assert!(dynamic_value.is_dynamic())

Source

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

Attempts to clone Self using reflection.

Unlike to_dynamic, which generally returns a dynamic representation of Self, this method attempts create a clone of Self directly, if possible.

If the clone cannot be performed, an appropriate ReflectCloneError is returned.

§Example

let value = (1, true, 3.14);
let cloned = value.reflect_clone().unwrap();
assert!(cloned.is::<(i32, bool, f64)>())

Source

fn reflect_clone_and_take<T>(&self) -> Result<T, ReflectCloneError>
where T: 'static, Self: Sized + TypePath,

For a type implementing PartialReflect, combines reflect_clone and take in a useful fashion, automatically constructing an appropriate ReflectCloneError if the downcast fails.

This is an associated function, rather than a method, because methods with generic types prevent dyn-compatibility.

Source

fn reflect_hash(&self) -> Option<u64>

Returns a hash of the value (which includes the type).

If the underlying type does not support hashing, returns None.

Source

fn reflect_partial_eq( &self, _value: &(dyn PartialReflect + 'static), ) -> Option<bool>

Returns a “partial equality” comparison result.

If the underlying type does not support equality testing, returns None.

Source

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

Debug formatter for the value.

Any value that is not an implementor of other Reflect subtraits (e.g. List, Map), will default to the format: "Reflect(type_path)", where type_path is the type path of the underlying type.

Source

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

Dynamic types include the ones built-in to this crate, such as DynamicStruct, DynamicList, and DynamicTuple. However, they may be custom types used as proxies for other types or to facilitate scripting capabilities.

By default, this method will return false.

Trait PartialReflect Copy item path

Required Methods§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

fn into_partial_reflect(self: Box<Self>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn try_into_reflect( self: Box<Self>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn try_apply( &mut self, value: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>

§Handling Errors

fn reflect_ref(&self) -> ReflectRef<'_>

fn reflect_mut(&mut self) -> ReflectMut<'_>

fn reflect_owned(self: Box<Self>) -> ReflectOwned

Provided Methods§

fn apply(&mut self, value: &(dyn PartialReflect + 'static))

§Panics

fn reflect_kind(&self) -> ReflectKind

fn to_dynamic(&self) -> Box<dyn PartialReflect>

§Panics

§Example

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

§Example

fn reflect_clone_and_take<T>(&self) -> Result<T, ReflectCloneError>where T: 'static, Self: Sized + TypePath,

fn reflect_hash(&self) -> Option<u64>

fn reflect_partial_eq( &self, _value: &(dyn PartialReflect + 'static), ) -> Option<bool>

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

fn is_dynamic(&self) -> bool

Implementations§

impl dyn PartialReflect

pub fn represents<T>(&self) -> boolwhere T: Reflect + TypePath,

pub fn try_downcast<T>( self: Box<dyn PartialReflect>, ) -> Result<Box<T>, Box<dyn PartialReflect>>where T: Any,

pub fn try_take<T>( self: Box<dyn PartialReflect>, ) -> Result<T, Box<dyn PartialReflect>>where T: Any,

pub fn try_downcast_ref<T>(&self) -> Option<&T>where T: Any,

pub fn try_downcast_mut<T>(&mut self) -> Option<&mut T>where T: Any,

Trait Implementations§

impl Debug for dyn PartialReflect

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

impl TypePath for dyn PartialReflect

fn type_path() -> &'static str

fn short_type_path() -> &'static str

fn type_ident() -> Option<&'static str>

fn crate_name() -> Option<&'static str>

fn module_path() -> Option<&'static str>

Implementations on Foreign Types§

impl PartialReflect for &'static str

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

fn into_partial_reflect(self: Box<&'static str>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn try_into_reflect( self: Box<&'static str>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn reflect_ref(&self) -> ReflectRef<'_>

fn reflect_mut(&mut self) -> ReflectMut<'_>

fn reflect_owned(self: Box<&'static str>) -> ReflectOwned

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

fn reflect_hash(&self) -> Option<u64>

fn reflect_partial_eq( &self, value: &(dyn PartialReflect + 'static), ) -> Option<bool>

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

fn try_apply( &mut self, value: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>

impl PartialReflect for &'static Location<'static>

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

fn into_partial_reflect( self: Box<&'static Location<'static>>, ) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn try_into_reflect( self: Box<&'static Location<'static>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn reflect_kind(&self) -> ReflectKind

fn reflect_ref(&self) -> ReflectRef<'_>

fn reflect_mut(&mut self) -> ReflectMut<'_>

fn reflect_owned(self: Box<&'static Location<'static>>) -> ReflectOwned

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

fn reflect_hash(&self) -> Option<u64>

fn reflect_partial_eq( &self, value: &(dyn PartialReflect + 'static), ) -> Option<bool>

fn try_apply( &mut self, value: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>

impl PartialReflect for &'static Path

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

fn into_partial_reflect(self: Box<&'static Path>) -> Box<dyn PartialReflect>

Trait PartialReflect

fn reflect_clone_and_take<T>(&self) -> Result<T, ReflectCloneError>
where T: 'static, Self: Sized + TypePath,

pub fn represents<T>(&self) -> bool
where T: Reflect + TypePath,

pub fn try_downcast<T>( self: Box<dyn PartialReflect>, ) -> Result<Box<T>, Box<dyn PartialReflect>>
where T: Any,

pub fn try_take<T>( self: Box<dyn PartialReflect>, ) -> Result<T, Box<dyn PartialReflect>>
where T: Any,

pub fn try_downcast_ref<T>(&self) -> Option<&T>
where T: Any,

pub fn try_downcast_mut<T>(&mut self) -> Option<&mut T>
where T: Any,