Struct SharedValue 

pub struct SharedValue { /* private fields */ }

A pointer to a value so it can be modified in many places

Rust’s ownership rules preclude multiple mutable borrows from taking place. The basis interface is designed around the assumption that this is possible. This provides an abstraction around handling a value that is accessible in multiple locations.

This abstracts away the implementation details, allowing for a range of different methods to be tested and implemented. The current implementation, based on using unsafe pointers, has the best performance by a significant factor.

use crystal_packing::SharedValue;
let x = SharedValue::new(1.);
let shared_x = &x;

assert!(shared_x.get_value() == 1.);
assert!(shared_x.get_value() == x.get_value());

// Updating the SharedValue will update the linked variable
shared_x.set_value(2.);
assert!(shared_x.get_value() == x.get_value());
assert!(shared_x.get_value() == 2.);
assert!(x.get_value() == 2.);

Implementations

impl SharedValue

pub fn new(val: f64) -> SharedValue

Create a SharedValue allowing modification of the given value

Arguments

• val - A reference to a f64 value which can be updated in multiple locations

Remarks

This provides a highly performant access to modifying the value of a variable in multiple locations.

modifying the value will result in a runtime memory fault. An alternative implementation which takes &mut f64 would not suffer from the same issues, however this then has issues with mutability of lifetimes.

pub fn get_value(&self) -> f64

Get the value of the variable being shared

pub fn set_value(&self, value: f64)

This updates the value which is being shared

Arguments

• value - The new value to assign to the shared value

Remarks

This breaks the single mutability rules of rust, and is consequently unsafe to use in threaded code.

Example

use crystal_packing::SharedValue;
let x = SharedValue::new(1.);
let shared_x = &x;

// Update the value of x through shared_x
shared_x.set_value(2.);

// The values of both x and shared_x will be updated
assert_eq!(x.get_value(), 2.);
assert_eq!(shared_x.get_value(), 2.);

Trait Implementations

impl Debug for SharedValue

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SharedValue

fn deserialize<D>(deserializer: D) -> Result<SharedValue, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for SharedValue

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Send for SharedValue

impl Sync for SharedValue