Struct fyrox::gui::core::variable::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) -> boolwhere 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 copy 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

This method tests for self and other values to be equal, and is used by ==.

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

This method 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 type_name(&self) -> &'static str

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

fn fields_info(&self, func: &mut dyn FnMut(Vec<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(Vec<&(dyn Reflect + 'static)>))

fn fields_mut( &mut self, func: &mut dyn FnMut(Vec<&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) ) -> 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,

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

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,