Enum Target 

pub enum Target<'a> {
    RefMut(&'a mut Dynamic),
    SharedValue {
        guard: DynamicWriteLock<'a, Dynamic>,
        shared_value: Dynamic,
    },
    TempValue(Dynamic),
    Bit {
        source: &'a mut Dynamic,
        value: Dynamic,
        bit: u8,
    },
    BitField {
        source: &'a mut Dynamic,
        value: Dynamic,
        mask: INT,
        shift: u8,
    },
    BlobByte {
        source: &'a mut Dynamic,
        value: Dynamic,
        index: usize,
    },
    StringChar {
        source: &'a mut Dynamic,
        value: Dynamic,
        index: usize,
    },
    StringSlice {
        source: &'a mut Dynamic,
        value: Dynamic,
        start: usize,
        end: usize,
        exclusive: bool,
    },
}

(internals) A type that encapsulates a mutation target for an expression with side effects. Exported under the internals feature only.

This type is typically used to hold a mutable reference to the target of an indexing or property access operation.

Example

// Normal `Dynamic` value
let mut value = Dynamic::from(42_i64);
let target: Target = value.into();

// Mutable reference to a `Dynamic` value
let mut value = Dynamic::from(42_i64);
let value_ref = &mut value;
let target: Target = value.into();

Variants

RefMut(&'a mut Dynamic)

The target is a mutable reference to a Dynamic.

SharedValue

The target is a mutable reference to a shared Dynamic.

Fields

guard: DynamicWriteLock<'a, Dynamic>

Lock guard to the shared Dynamic.

shared_value: Dynamic

Copy of the shared value.

TempValue(Dynamic)

The target is a temporary Dynamic value (i.e. its mutation can cause no side effects).

Bit

The target is a bit inside an INT. This is necessary because directly pointing to a bit inside an INT is impossible.

Fields

source: &'a mut Dynamic

Mutable reference to the source Dynamic.

value: Dynamic

Copy of the boolean bit, as a Dynamic.

bit: u8

Bit offset.

BitField

The target is a range of bits inside an INT. This is necessary because directly pointing to a range of bits inside an INT is impossible.

Fields

source: &'a mut Dynamic

Mutable reference to the source Dynamic.

value: Dynamic

Copy of the integer value of the bits, as a Dynamic.

mask: INT

Bitmask to apply to the source value (i.e. shifted)

shift: u8

Number of bits to right-shift the source value.

BlobByte

The target is a byte inside a Blob. This is necessary because directly pointing to a byte inside a BLOB is impossible.

Fields

source: &'a mut Dynamic

Mutable reference to the source Dynamic.

value: Dynamic

Copy of the byte at the index, as a Dynamic.

index: usize

Offset index.

StringChar

The target is a character inside a string. This is necessary because directly pointing to a char inside a String is impossible.

Fields

source: &'a mut Dynamic

Mutable reference to the source Dynamic.

value: Dynamic

Copy of the character at the offset, as a Dynamic.

index: usize

Offset index.

StringSlice

The target is a slice of a string. This is necessary because directly pointing to a char inside a String is impossible.

Fields

source: &'a mut Dynamic

Mutable reference to the source Dynamic.

value: Dynamic

Copy of the character at the offset, as a Dynamic.

start: usize

Offset index.

end: usize

End index.

exclusive: bool

Is exclusive?

Implementations

impl<'a> Target<'a>

pub const fn is_ref(&self) -> bool

Is the Target a reference pointing to other data?

pub const fn is_temp_value(&self) -> bool

Is the Target a temp value?

pub fn is_shared(&self) -> bool

Is the Target a shared value?

pub fn take_or_clone(self) -> Dynamic

Get the value of the Target as a Dynamic, cloning a referenced value if necessary.

pub fn take_ref(self) -> Option<&'a mut Dynamic>

Take a &mut Dynamic reference from the Target.

pub fn into_owned(self) -> Self

Convert a shared or reference Target into a target with an owned value.

pub fn source(&self) -> &Dynamic

Get the source Dynamic of the Target.

pub fn propagate_changed_value( &mut self, _pos: Position, ) -> Result<(), Box<EvalAltResult>>

Propagate a changed value back to the original source. This has no effect for direct references.

Trait Implementations

impl AsMut<Dynamic> for Target<'_>

fn as_mut(&mut self) -> &mut Dynamic

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsRef<Dynamic> for Target<'_>

fn as_ref(&self) -> &Dynamic

Converts this type into a shared reference of the (usually inferred) input type.

impl Borrow<Dynamic> for Target<'_>

fn borrow(&self) -> &Dynamic

Immutably borrows from an owned value.

impl BorrowMut<Dynamic> for Target<'_>

fn borrow_mut(&mut self) -> &mut Dynamic

Mutably borrows from an owned value.

impl<'a> Debug for Target<'a>

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

Formats the value using the given formatter.

impl<T: Into<Dynamic>> From<T> for Target<'_>

fn from(value: T) -> Self

Converts to this type from the input type.

impl<'a> TryFrom<&'a mut Dynamic> for Target<'a>

type Error = Box<EvalAltResult>

The type returned in the event of a conversion error.

fn try_from(value: &'a mut Dynamic) -> Result<Self, Self::Error>

Performs the conversion.