Struct Reference 

pub struct Reference<T: ?Sized>(/* private fields */);

A container privately holding an enum with variants containing different kinds of references, the availability of some of which depends on crate features. Reference is borrowed like a RefCell. It is also reexported at the crate level.

Implementations

impl<T: ?Sized> Reference<T>

pub const unsafe fn from_ptr(ptr: *mut T) -> Self

Create a Reference from a raw mutable pointer. This is useful if you are not multithreading and you want to avoid dynamic allocation. Making the target static is recommended. The static_reference! macro is a convenient way of making an object static and getting a Reference of the raw pointer variant to it. Because the object is guaranteed to be static, it can be called without an unsafe block.

pub const fn from_rc_ref_cell(rc_ref_cell: Rc<RefCell<T>>) -> Self

Create a Reference from an Rc<RefCell<T>>. The rc_ref_cell_reference function is a convenient way of putting an object in an Rc<RefCell<T>> and getting a Reference of this variant to it.

pub const unsafe fn from_ptr_rw_lock(ptr_rw_lock: *const RwLock<T>) -> Self

Create a Reference from a *const RwLock<T>. Making the RwLock itself static is recommended. The static_rw_lock_reference! macro is a convenient way of putting an object in a static RwLock and getting a Reference of this variant to it.

pub const unsafe fn from_ptr_mutex(ptr_mutex: *const Mutex<T>) -> Self

Create a Reference from a *const Mutex<T>. Making the Mutex itself static is recommended. The static_mutex_reference! macro is a convenient way of putting an object in a static Mutex and getting a Reference of this variant to it.

pub const fn from_arc_rw_lock(arc_rw_lock: Arc<RwLock<T>>) -> Self

Create a Reference from an Arc<RwLock<T>>. The arc_rw_lock_reference function is a convenient way of putting an object in an Arc<RwLock> and getting a Reference of this variant to it.

pub const fn from_arc_mutex(arc_mutex: Arc<Mutex<T>>) -> Self

Create a Reference from an Arc<Mutex<T>>. The arc_mutex_reference function is a convenient way of putting an object in an Arc<Mutex> and getting a Reference of this variant to it.

pub fn into_inner(self) -> ReferenceUnsafe<T>

Get the inner ReferenceUnsafe.

pub fn borrow(&self) -> Borrow<'_, T>

Immutably borrow the Reference like a RefCell.

Examples found in repository

examples/pid.rs (line 161)

fn main() {
    const SETPOINT: Quantity = Quantity::new(5.0, MILLIMETER);
    const KP: Quantity = Quantity::dimensionless(1.0);
    const KI: Quantity = Quantity::dimensionless(0.01);
    const KD: Quantity = Quantity::dimensionless(0.1);
    println!("PID Controller using RRTK Streams");
    println!(
        "kp = {:?}; ki = {:?}; kd = {:?}",
        KP.value, KI.value, KD.value
    );
    let input = to_dyn!(Getter<Quantity, ()>, rc_ref_cell_reference(MyStream::new()));
    let mut stream = StreamPID::new(input.clone(), SETPOINT, KP, KI, KD);
    stream.update().unwrap();
    println!(
        "time: {:?}; setpoint: {:?}; process: {:?}; command: {:?}",
        stream.get().unwrap().unwrap().time.0,
        SETPOINT.value,
        input.borrow().get().unwrap().unwrap().value.value,
        stream.get().unwrap().unwrap().value
    );
    for _ in 0..6 {
        input.borrow_mut().update().unwrap();
        stream.update().unwrap();
        println!(
            "time: {:?}; setpoint: {:?}; process: {:?}; command: {:?}",
            stream.get().unwrap().unwrap().time,
            SETPOINT,
            input.borrow().get().unwrap().unwrap().value,
            stream.get().unwrap().unwrap().value
        );
    }
}

pub fn borrow_mut(&self) -> BorrowMut<'_, T>

Mutably borrow the Reference like a RefCell.

Examples found in repository

examples/pid.rs (line 105)

    fn update(&mut self) -> NothingOrError<()> {
        //The other streams used that are not updated here do not need to be updated. Streams like
        //SumStream just calculate their output in the get method since they do not need to store
        //any data beyond the `Reference`s to their inputs. The non-math streams used here work in
        //a similar way.
        self.int.borrow_mut().update()?;
        self.drv.borrow_mut().update()?;
        self.pro_float_maker.borrow_mut().update()?;
        self.int_float_maker.borrow_mut().update()?;
        self.drv_float_maker.borrow_mut().update()?;
        Ok(())
    }
}
#[cfg(feature = "alloc")]
struct MyStream {
    time: Time,
}
#[cfg(feature = "alloc")]
impl MyStream {
    pub fn new() -> Self {
        Self { time: Time(0) }
    }
}
//In a real system, obviously, the process variable must be dependent on the command. This is a
//very rudimentary placeholder and a poor model of an actual system. All this example is
//intended to do is to show the PID controller's command values and not model a real system by
//assuming a constant velocity.
#[cfg(feature = "alloc")]
impl Getter<Quantity, ()> for MyStream {
    fn get(&self) -> Output<Quantity, ()> {
        Ok(Some(Datum::new(
            self.time,
            Quantity::from(self.time) * Quantity::new(0.5, MILLIMETER_PER_SECOND),
        )))
    }
}
#[cfg(feature = "alloc")]
impl Updatable<()> for MyStream {
    fn update(&mut self) -> NothingOrError<()> {
        self.time += Time(2_000_000_000);
        Ok(())
    }
}
#[cfg(feature = "alloc")]
fn main() {
    const SETPOINT: Quantity = Quantity::new(5.0, MILLIMETER);
    const KP: Quantity = Quantity::dimensionless(1.0);
    const KI: Quantity = Quantity::dimensionless(0.01);
    const KD: Quantity = Quantity::dimensionless(0.1);
    println!("PID Controller using RRTK Streams");
    println!(
        "kp = {:?}; ki = {:?}; kd = {:?}",
        KP.value, KI.value, KD.value
    );
    let input = to_dyn!(Getter<Quantity, ()>, rc_ref_cell_reference(MyStream::new()));
    let mut stream = StreamPID::new(input.clone(), SETPOINT, KP, KI, KD);
    stream.update().unwrap();
    println!(
        "time: {:?}; setpoint: {:?}; process: {:?}; command: {:?}",
        stream.get().unwrap().unwrap().time.0,
        SETPOINT.value,
        input.borrow().get().unwrap().unwrap().value.value,
        stream.get().unwrap().unwrap().value
    );
    for _ in 0..6 {
        input.borrow_mut().update().unwrap();
        stream.update().unwrap();
        println!(
            "time: {:?}; setpoint: {:?}; process: {:?}; command: {:?}",
            stream.get().unwrap().unwrap().time,
            SETPOINT,
            input.borrow().get().unwrap().unwrap().value,
            stream.get().unwrap().unwrap().value
        );
    }
}

Trait Implementations

impl<T: ?Sized> Clone for Reference<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: ?Sized> From<Reference<T>> for ReferenceUnsafe<T>

fn from(was: Reference<T>) -> Self

Converts to this type from the input type.