Struct InheritableVariable

pub struct InheritableVariable<T> { /* private fields */ }

A wrapper for a variable that hold additional flag that tells that initial value was changed in runtime.

InheritableVariables are used for resource inheritance system. Resource inheritance may just sound weird, but the idea behind it is very simple - take property values from parent resource if the value in current hasn’t changed in runtime.

To get better understanding, let’s look at very simple example. Imagine you have a scene with a 3d model instance. Now you realizes that the 3d model has a misplaced object and you need to fix it, you open a 3D modelling software (Blender, 3Ds max, etc) and move the object to a correct spot and re-save the 3D model. The question is: what should happen with the instance of the object in the scene? Logical answer would be: if it hasn’t been modified, then just take the new position from the 3D model. This is where inheritable variable comes into play. If you’ve change the value of such variable, it will remember changes and the object will stay on its new position instead of changed.

Deref and DerefMut

Access via Deref provides access to inner variable. DerefMut marks variable as modified and returns a mutable reference to inner variable.

Implementations

impl<T> InheritableVariable<T>

where T: Clone,

pub fn clone_inner(&self) -> T

Clones wrapped value.

pub fn try_sync_model<S>(&self, setter: S) -> bool

where S: FnOnce(T),

Tries to sync a value in a data model with a value in the inheritable variable. The value will be synced only if it was marked as needs sync.

impl<T> InheritableVariable<T>

pub fn new_modified(value: T) -> InheritableVariable<T>

Creates new modified variable from given value. This method should always be used to create inheritable variables in the engine.

pub fn new_non_modified(value: T) -> InheritableVariable<T>

Creates new variable without any flags set.

pub fn new_with_flags(value: T, flags: VariableFlags) -> InheritableVariable<T>

Creates new variable from a given value with custom flags.

pub fn set_value_and_mark_modified(&mut self, value: T) -> T

Replaces value and also raises the VariableFlags::MODIFIED flag.

pub fn set_value_with_flags(&mut self, value: T, flags: VariableFlags) -> T

Replaces value and flags.

pub fn set_value_silent(&mut self, value: T) -> T

Replaces current value without marking the variable modified.

pub fn need_sync(&self) -> bool

Returns true if the respective data model’s variable must be synced.

pub fn get_value_ref(&self) -> &T

Returns a reference to the wrapped value.

pub fn get_value_mut_and_mark_modified(&mut self) -> &mut T

Returns a mutable reference to the wrapped value.

Important notes.

The method raises modified flag, no matter if actual modification was made!

pub fn get_value_mut_silent(&mut self) -> &mut T

Returns a mutable reference to the wrapped value.

Important notes.

This method does not mark the value as modified!

pub fn is_modified(&self) -> bool

Returns true if variable was modified and should not be overwritten during property inheritance.

pub fn mark_modified(&mut self)

Marks value as modified, so its value won’t be overwritten during property inheritance.

pub fn take(self) -> T

Deconstructs the variable and returns the wrapped value.

Trait Implementations

impl<T> Clone for InheritableVariable<T>

where T: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for InheritableVariable<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Default for InheritableVariable<T>

where T: Default,

fn default() -> InheritableVariable<T>

Returns the “default value” for a type.

impl<T> DerefMut for InheritableVariable<T>

fn deref_mut(&mut self) -> &mut <InheritableVariable<T> as Deref>::Target

Mutably dereferences the value.

impl<T> From<T> for InheritableVariable<T>

fn from(v: T) -> InheritableVariable<T>

Converts to this type from the input type.

impl<T> PartialEq for InheritableVariable<T>

where T: PartialEq,

fn eq(&self, other: &InheritableVariable<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> Reflect for InheritableVariable<T>

where T: Reflect + Clone + PartialEq + Debug,

fn source_path() -> &'static str

fn type_name(&self) -> &'static str

fn doc(&self) -> &'static str

fn assembly_name(&self) -> &'static str

Returns a parent assembly name of the type that implements this trait. WARNING: You should use proc-macro (#[derive(Reflect)]) to ensure that this method will return correct assembly name. In other words - there’s no guarantee, that any implementation other than proc-macro will return a correct name of the assembly. Alternatively, you can use env!("CARGO_PKG_NAME") as an implementation.

fn type_assembly_name() -> &'static str

Returns a parent assembly name of the type that implements this trait. WARNING: You should use proc-macro (#[derive(Reflect)]) to ensure that this method will return correct assembly name. In other words - there’s no guarantee, that any implementation other than proc-macro will return a correct name of the assembly. Alternatively, you can use env!("CARGO_PKG_NAME") as an implementation.

fn fields_info(&self, func: &mut dyn FnMut(&[FieldInfo<'_, '_>]))

fn into_any(self: Box<InheritableVariable<T>>) -> Box<dyn Any>

fn as_any(&self, func: &mut dyn FnMut(&(dyn Any + 'static)))

fn as_any_mut(&mut self, func: &mut dyn FnMut(&mut (dyn Any + 'static)))

fn as_reflect(&self, func: &mut dyn FnMut(&(dyn Reflect + 'static)))

fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut (dyn Reflect + 'static)))

fn set( &mut self, value: Box<dyn Reflect>, ) -> Result<Box<dyn Reflect>, Box<dyn Reflect>>

fn set_field( &mut self, field: &str, value: Box<dyn Reflect>, func: &mut dyn FnMut(Result<Box<dyn Reflect>, Box<dyn Reflect>>), )

Calls user method specified with #[reflect(setter = ..)] or falls back to Reflect::field_mut

fn fields(&self, func: &mut dyn FnMut(&[&(dyn Reflect + 'static)]))

fn fields_mut( &mut self, func: &mut dyn FnMut(&mut [&mut (dyn Reflect + 'static)]), )

fn field( &self, name: &str, func: &mut dyn FnMut(Option<&(dyn Reflect + 'static)>), )

fn field_mut( &mut self, name: &str, func: &mut dyn FnMut(Option<&mut (dyn Reflect + 'static)>), )

fn as_array(&self, func: &mut dyn FnMut(Option<&(dyn ReflectArray + 'static)>))

fn as_array_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectArray + 'static)>), )

fn as_list(&self, func: &mut dyn FnMut(Option<&(dyn ReflectList + 'static)>))

fn as_list_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectList + 'static)>), )

fn as_inheritable_variable( &self, func: &mut dyn FnMut(Option<&(dyn ReflectInheritableVariable + 'static)>), )

fn as_inheritable_variable_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectInheritableVariable + 'static)>), )

fn as_hash_map( &self, func: &mut dyn FnMut(Option<&(dyn ReflectHashMap + 'static)>), )

fn as_hash_map_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectHashMap + 'static)>), )

impl<T> ReflectInheritableVariable for InheritableVariable<T>

where T: Reflect + Clone + PartialEq + Debug,

fn try_inherit( &mut self, parent: &(dyn ReflectInheritableVariable + 'static), ignored_types: &[TypeId], ) -> Result<Option<Box<dyn Reflect>>, InheritError>

Tries to inherit a value from parent. It will succeed only if the current variable is not marked as modified.

fn reset_modified_flag(&mut self)

Resets modified flag from the variable.

fn flags(&self) -> VariableFlags

Returns current variable flags.

fn set_flags(&mut self, flags: VariableFlags)

fn is_modified(&self) -> bool

Returns true if value was modified.

fn value_equals( &self, other: &(dyn ReflectInheritableVariable + 'static), ) -> bool

Returns true if value equals to other’s value.

fn clone_value_box(&self) -> Box<dyn Reflect>

Clones self value.

fn mark_modified(&mut self)

Marks value as modified, so its value won’t be overwritten during property inheritance.

fn inner_value_mut(&mut self) -> &mut (dyn Reflect + 'static)

Returns a mutable reference to wrapped value without marking the variable itself as modified.

fn inner_value_ref(&self) -> &(dyn Reflect + 'static)

Returns a shared reference to wrapped value without marking the variable itself as modified.

impl<T> Visit for InheritableVariable<T>

where T: Visit,

Special non-derived implementation of Visit to account for the special needs of InheritableVariable from Visitors.

fn visit(&mut self, name: &str, visitor: &mut Visitor) -> Result<(), VisitError>

Read or write this value, depending on whether Visitor::is_reading() is true or false. InheritableVariable uses the visit method in a very special way. Rather than just directly visiting the inner value and flags of the InheritableVariable, it allows for several distinct possibilities.

Cases when the visitor is reading:

1. If the visitor is reading, InheritableVariable allows for the possibilities that the data being read is not an InheritableVariable but is data of type T. It uses this data to set the inner value and adds VariableFlags::MODIFIED to InheritableVariable::flags.

2. The data for this InheritableVariable may be missing entirely from the given visitor. If so, then leave inner value unmodified and remove the MODIFIED flag from flags.

Cases when the visitor is writing:

1. If the visitor is writing and the MODIFIED flag is not set, then InheritableVariable writes nothing at all. It does not even write an empty region.

2. If the visitor is writing and the MODIFIED flag is set, then the InheritableVariable writes itself to the Visitor as if InheritableVariable were a normal struct, writing a Field for “Flags” and causing value to write itself.

If the VisitorFlags::SERIALIZE_EVERYTHING flag is set in the Visitor::flags, this causes the InheritableVariable to act as if its MODIFIED flag were set.

impl<T> Deref for InheritableVariable<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &<InheritableVariable<T> as Deref>::Target

Dereferences the value.

impl<T> Eq for InheritableVariable<T>

where T: Eq,