Struct ExtState

pub struct ExtState<'a, T: Serialize + DeserializeOwned + Clone + Debug, O: HasExtState> { /* private fields */ }

Serializes extension data.

This struct should be used instead of simple set_ext_state and get_ext_state calls.

The features, that make it better are:

• It serializes not strings, but anything, can be serialized by serde crate.
• It provides the similar interface as for global ext state values, as well as to project or other objects ext data. Currently supported: Project, Track, TrackSend, Envelope, Item, Take
• it erases data, if in process of development you decided to turn the persistence off.
• it can be initialized with value, but only once, if persistence is needed.

Also, it is very idiomatic and type-safe, so it ideally suits as gui state etc.

Note

Be careful with ext section and key. If two different states of different types are saved for one key — it will panic at get().

Usage

use rea_rs::{ExtState, HasExtState, Reaper, Project};
let rpr = Reaper::get();
let mut state =
    ExtState::new("test section", "first", Some(10), true, rpr);
assert_eq!(state.get().expect("can not get value"), 10);
state.set(56);
assert_eq!(state.get().expect("can not get value"), 56);
state.delete();
assert!(state.get().is_none());

let mut pr = rpr.current_project();
let mut state: ExtState<u32, Project> =
    ExtState::new("test section", "first", None, true, &pr);
assert_eq!(state.get().expect("can not get value"), 10);
state.set(56);
assert_eq!(state.get().expect("can not get value"), 56);
state.delete();
assert!(state.get().is_none());

let tr = pr.get_track_mut(0).unwrap();
let mut state = ExtState::new("testsection", "first", 45, false, &tr);
assert_eq!(state.get().expect("can not get value"), 45);
state.set(15);
assert_eq!(state.get().expect("can not get value"), 15);
state.delete();
assert_eq!(state.get(), None);

Implementations

impl<'a, T: Serialize + DeserializeOwned + Clone + Debug, O: HasExtState> ExtState<'a, T, O>

pub fn new( section: impl Into<String>, key: impl Into<String>, value: impl Into<Option<T>>, persist: bool, object: &'a O, ) -> Self

Create ext state object.

If Some(value) provided, but persist is true, only first call to the ExtState::new will initialize it. Later will keep previous value.

pub fn get(&self) -> Option<T>

Get value from ext state.

Returns None if no value saved in REAPER.

Panics

If value of the wrong type stored in the same section/key.

pub fn set(&mut self, value: T)

Set the value to ext state.

pub fn delete(&mut self)

Erase ext value, but keep the object.

Trait Implementations

impl<'a, T: Debug + Serialize + DeserializeOwned + Clone + Debug, O: Debug + HasExtState> Debug for ExtState<'a, T, O>

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

Formats the value using the given formatter.

impl<'a, T: PartialEq + Serialize + DeserializeOwned + Clone + Debug, O: PartialEq + HasExtState> PartialEq for ExtState<'a, T, O>

fn eq(&self, other: &ExtState<'a, T, O>) -> 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<'a, T: Serialize + DeserializeOwned + Clone + Debug, O: HasExtState> StructuralPartialEq for ExtState<'a, T, O>