1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
#![deny(bare_trait_objects)] #![doc(html_logo_url = "https://optimisticpeach.github.io/Logo.svg")] //! //! A dynamically allocated storage system. Check it out on [Github][gh], or its capabilities on the //! [tests][ts]. This is meant to serve as a storage solution for resources in a dynamic context. It //! supports runtime borrow checking using [`RefCell`][rc]s. It will support a concurrent context in //! the future. //! //! [gh]: https://github.com/OptimisticPeach/restor //! [ts]: https://github.com/OptimisticPeach/restor/tree/master/tests //! [rc]: https://doc.rust-lang.org/std/cell/struct.RefCell.html //! //! ## Example //! ``` //! # use restor::*; //! # fn main() { //! let mut storage = DynamicStorage::new(); //! storage.allocate_for::<usize>(); //! storage.allocate_for::<String>(); //! storage.insert::<String>("abc".into()); //! let mut my_string = storage.get::<&mut String>().unwrap(); //! storage.insert_many::<usize>(vec![2, 4, 8, 16, 32]); //! for i in storage.get::<&[usize]>().unwrap().iter() { //! *my_string = format!("{}, {:?}", &*my_string, i); //! } //! assert_eq!("abc, 2, 4, 8, 16, 32", &*my_string); //! # } //! ``` //! mod black_box; mod concurrent_black_box; mod macros; /// /// Shorthand for forming storage with preallocated types. /// It will also wrap it in an [`Arc`] (More below) /// /// # Usage /// The syntax for the macro is as follows: /// ```no_run /// # fn main() { /// # use restor::make_storage; /// # struct OtherTypes; /// # struct StorageType; /// # impl StorageType { /// # pub fn new() -> Self {StorageType} /// # pub fn allocate_for<T>(&mut self) {} /// # } /// make_storage!(StorageType); // -> StorageType /// make_storage!(Arc StorageType); // -> Arc<StorageType> /// make_storage!(StorageType: String, usize, isize, i32, OtherTypes); // -> StorageType with types preallocated /// make_storage!(Arc StorageType: String, usize, isize, i32, OtherTypes); // -> StorageType with types preallocated /// # } /// ``` /// /// # Example /// ``` /// use restor::{DynamicStorage, make_storage}; /// let x: DynamicStorage = make_storage!(DynamicStorage: usize, String, isize); /// x.insert(0usize).unwrap(); /// x.insert(String::new()).unwrap(); /// ``` /// # Arc Example /// ``` /// use restor::{RwLockStorage, make_storage}; /// let x = make_storage!(Arc RwLockStorage: usize, String); /// let nx = x.clone(); /// std::thread::spawn( move || { /// nx.insert(String::new()).unwrap(); /// }); /// x.insert(0usize); /// ``` /// /// [`Arc`]: https://doc.rust-lang.org/std/sync/struct.Arc.html /// #[macro_export] macro_rules! make_storage { ($storagetype:ty $(: $($contents:ty),*)? ) => { { let mut temp_storage__ = <$storagetype>::new(); $( $( temp_storage__.allocate_for::<$contents>(); )* )? temp_storage__ } }; (Arc $storage:ty $(: $($contents:ty),*)? ) => { { ::std::sync::Arc::new(make_storage!($storage $(: $($contents),*)?)) } } } pub use black_box::{BlackBox, DynamicStorage, ErrorDesc, Fetch, FetchMultiple, Unit, UnitError}; pub use concurrent_black_box::{MutexStorage, RwLockStorage};