├── .gitignore
├── CHANGELOG.md
├── Cargo.toml
├── Readme.md
├── crates
    └── yewtil-macro
    │   ├── Cargo.toml
    │   └── src
    │       ├── function_component.rs
    │       └── lib.rs
├── examples
    ├── dsl
    │   ├── Cargo.toml
    │   └── src
    │   │   └── main.rs
    ├── effect
    │   ├── Cargo.toml
    │   └── src
    │   │   └── main.rs
    ├── fetch
    │   ├── .cargo
    │   │   └── config
    │   ├── Cargo.toml
    │   ├── Readme.md
    │   ├── index.html
    │   ├── main.js
    │   └── src
    │   │   └── lib.rs
    ├── function_component
    │   ├── Cargo.toml
    │   └── src
    │   │   ├── button.rs
    │   │   └── main.rs
    ├── futures
    │   ├── Cargo.toml
    │   ├── README.md
    │   ├── index.html
    │   ├── main.js
    │   └── src
    │   │   └── lib.rs
    ├── history
    │   ├── Cargo.toml
    │   └── src
    │   │   └── main.rs
    ├── lrc
    │   ├── Cargo.toml
    │   └── src
    │   │   ├── child.rs
    │   │   └── main.rs
    ├── mrc_irc
    │   ├── Cargo.toml
    │   └── src
    │   │   ├── child.rs
    │   │   └── main.rs
    └── pure_component
    │   ├── Cargo.toml
    │   └── src
    │       ├── button.rs
    │       └── main.rs
└── src
    ├── dsl.rs
    ├── dsl
        ├── vcomp.rs
        ├── vlist.rs
        ├── vtag.rs
        └── vtext.rs
    ├── effect.rs
    ├── fetch.rs
    ├── fetch
        ├── action.rs
        ├── error.rs
        ├── request.rs
        └── state.rs
    ├── future.rs
    ├── history.rs
    ├── lib.rs
    ├── not_equal_assign.rs
    ├── ptr
        ├── irc.rs
        ├── lrc.rs
        ├── mod.rs
        ├── mrc.rs
        ├── rc_box.rs
        └── takeable.rs
    └── pure.rs


/.gitignore:
--------------------------------------------------------------------------------
1 | /target
2 | **/*.rs.bk
3 | Cargo.lock
4 | .idea
5 | 


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
 1 | # Changelog
 2 | 
 3 | <!-- START TEMPLATE
 4 | 
 5 | ## ✨ **VERSION** *(DATE)*
 6 | 
 7 | - #### ⚡️ Features
 8 |   - Sample
 9 | - #### 🛠 Fixes
10 |   - Sample
11 | - #### 🚨 Breaking changes
12 |   - Sample
13 | 
14 | END TEMPLATE-->
15 | 
16 | ## ✨ **v0.2.0** *11/18/19*
17 | - #### ⚡️ Features
18 |   - Add new `FetchRequest` trait, `fetch_resource()` function, and `FetchState` enum 
19 |   to simplify making fetch requests using futures.
20 |   - Add `Default` implementations to `Irc` and `Mrc`.
21 | 


--------------------------------------------------------------------------------
/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "yewtil"
 3 | version = "0.2.0"
 4 | authors = ["Henry Zimmerman <zimhen7@gmail.com>"]
 5 | edition = "2018"
 6 | description = "Utility crate for Yew"
 7 | license = "MIT/Apache-2.0"
 8 | repository = "https://github.com/yewstack/yewtil"
 9 | readme = "Readme.md"
10 | 
11 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
12 | 
13 | [features]
14 | # Only stable is included by default.
15 | default = ["stable"]
16 | # Broad features
17 | all = ["stable", "experimental"]
18 | ## All features MUST be stable or experimental
19 | stable = ["neq", "pure", "history", "mrc_irc", "effect", "future"]
20 | experimental = ["dsl", "lrc", "with_callback", "fetch" ]
21 | 
22 | 
23 | # Some pointers are stable, some experimental.
24 | # This makes sure you get all the pointers
25 | ptr = ["lrc", "mrc_irc"]
26 | 
27 | # Misc features
28 | neq = []
29 | pure = ["neq", "yewtil-macro"]
30 | with_callback = []
31 | history = []
32 | dsl = []
33 | effect = []
34 | fetch = ["serde", "serde_json", "neq", "future"]
35 | future = ["wasm-bindgen-futures", "wasm-bindgen", "stdweb", "futures", "web-sys"]
36 | 
37 | # Ptr features
38 | lrc = []
39 | mrc_irc = []
40 | 
41 | [dependencies]
42 | yew = { git = "https://github.com/yewstack/yew", branch="master" }
43 | #yew = "0.10.0"
44 | yewtil-macro = {path = "crates/yewtil-macro", version="0.1.0", optional=true}
45 | log = "0.4.8"
46 | 
47 | 
48 | wasm-bindgen-futures = {version = "0.4.3", optional = true}
49 | wasm-bindgen = {version = "0.2.51", features=["serde-serialize"], optional = true}
50 | futures = {version = "0.3.1", optional = true}
51 | serde = {version= "1.0.102", optional = true}
52 | serde_json = { version = "1.0.41", optional = true }
53 | stdweb = { version = "0.4.20", features = ["futures-support", "experimental_features_which_may_break_on_minor_version_bumps"], optional = true }
54 | 
55 | [dependencies.web-sys]
56 | version = "0.3.31"
57 | optional = true
58 | features = [
59 |   'Headers',
60 |   'Request',
61 |   'RequestInit',
62 |   'RequestMode',
63 |   'Response',
64 |   'Window',
65 |   'Location',
66 |   'Storage',
67 | ]
68 | 
69 | 
70 | [workspace]
71 | members = [
72 |     "crates/yewtil-macro",
73 |     "examples/pure_component",
74 |     "examples/dsl",
75 |     "examples/lrc",
76 |     "examples/history",
77 |     "examples/mrc_irc",
78 |     "examples/effect",
79 |     "examples/fetch",
80 |     "examples/futures",
81 |     "examples/function_component"
82 | ]
83 | 


--------------------------------------------------------------------------------
/Readme.md:
--------------------------------------------------------------------------------
  1 | # This project has been moved 
  2 | This project has been incorporated into the [Yew](https://github.com/yewstack/yew) repository, and can specifically be found [here](https://github.com/yewstack/yew/tree/master/yewtil).
  3 | You should address all questions or improvements there instead of here.
  4 | This repository will be archived in the near future.
  5 | 
  6 | # Yewtil
  7 | Utility crate for the [Yew](https://github.com/yewstack/yew) frontend web framework.
  8 | 
  9 | ## Purpose
 10 | Provide a place for commonly used utilities for Yew to reside without them having to be included in the Yew crate itself.
 11 | As a consequence of this, the Yew crate is free to make changes that may cause breakages in this crate.
 12 | 
 13 | ## Features
 14 | Currently, this crate supports these features in a stable capacity:
 15 | * `NeqAssign` - makes assigning props and returning a relevant ShouldRender value easier.
 16 | * Pure Components - implement pure components using the `PureComponent` trait and the `Pure` Component adaptor. 
 17 | This should make it much easier to define simple components that don't hold state.
 18 |   * Function components - a macro that takes a function that returns `Html` and converts it to a pure component.
 19 | * `Mrc`/`Irc` smart pointers - Rc-like pointers that are more ergonomic to use within Yew.
 20 | * `History` - A wrapper that holds the history of values that have been assigned to it.
 21 | * `Effect` - A way to update component state by defining what to change inside of `html!` callbacks
 22 |  instead of handling messages in `Component::update()`.
 23 | 
 24 | This crate also has an experimental feature flag that enables the following features:
 25 | * `Lrc` smart pointer - Rc-like pointer implemented on top of a linked list. Allows for novel state update mechanics 
 26 | and traversal over linked shared pointers. <sup><sub>(This needs to be fuzz tested to make sure it doesn't leak.)</sub></sup>
 27 | * DSL for `Html<Self>` - A function-based domain-specific-language for Yew that can be used in a limited capacity instead of the `html!` macro. <sup><sub>(Broken by recent changes in yew. Will be rewritten from scratch eventually.)</sub></sup>
 28 | 
 29 | These experimental features are either not sufficiently vetted, may change significantly, or may be removed.
 30 | 
 31 | ## Example Projects 
 32 | Examples for every stable feature exist [here](https://github.com/hgzimmerman/yewtil/tree/master/examples). 
 33 | 
 34 | Check out the [Pure Components example](https://github.com/hgzimmerman/yewtil/tree/master/examples/demo) to see how Pure Components work.
 35 | 
 36 | ## Example
 37 | #### neq_assign:
 38 | ```rust
 39 | fn change(&mut self, props: Self::Properties) -> ShouldRender {
 40 |     self.props.neq_assign(props)
 41 | }
 42 | ```
 43 | 
 44 | -------------
 45 | 
 46 | #### Pure Component:
 47 | ```rust
 48 | pub type Button = Pure<PureButton>;
 49 | 
 50 | #[derive(PartialEq, Properties)]
 51 | pub struct PureButton {
 52 |     #[props(required)]
 53 |     pub callback: Callback<Msg>,
 54 |     pub text: String,
 55 | }
 56 | 
 57 | impl PureComponent for PureButton {
 58 |     fn render(&self) -> VNode {
 59 |         html! {
 60 |             <button onclick=&self.callback>{ &self.text }</button>
 61 |         }
 62 |     }
 63 | }
 64 | ```
 65 | 
 66 | --------------
 67 | 
 68 | #### History
 69 | ```rust
 70 | pub struct Model {
 71 |     text: History<String>,
 72 | }
 73 | 
 74 | // ...
 75 | fn update(&mut self, msg: Self::Message) -> ShouldRender {
 76 |     match msg {
 77 |         Msg::SetText(text) => self.text.neq_set(text),
 78 |         Msg::Reset => self.text.reset(),
 79 |         Msg::Forget => {
 80 |             self.text.forget();
 81 |             false
 82 |         }
 83 |     }
 84 | }
 85 | ```
 86 | 
 87 | ## Update Schedule
 88 | This crate will target stable Yew.
 89 | 
 90 | As new idioms are introduced to Yew, this crate may see updates, but given the rarity of those, this crate may sit unaltered for some time.
 91 | 
 92 | ## Scoping
 93 | This crate aims to be more permissive in what is allowed in than Yew, so if you have a function, type, or trait you would like to share, please open a PR or Issue.
 94 | 
 95 | Components are welcome as well, but they must not have external dependencies, should solve some problem encountered my many users of Yew, and should allow for theming if possible, like an auto-scrolling wrapper, a RecyclerView/Infinite-scrolling component, or possibly a comprehensive Input component.
 96 | 
 97 | Common UI elements like modals or dropdowns should probably best be left to CSS-framework component libraries, as they should often be coupled to the external CSS used to display them.
 98 | 
 99 | ### Stability
100 | Since this crate aims to present a variety of helper types, traits, and functions, where the utility of each may be unknown at the time the feature is added, newer additions may be not be included in the default feature-set, and may be locked behind an `experimental` flag. 
101 | While in early development, features marked as `experimental` may be changed more frequently or even entirely removed, while those marked as `stable` will not be removed and can be depended on to not change significantly.
102 | 


--------------------------------------------------------------------------------
/crates/yewtil-macro/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "yewtil-macro"
 3 | version = "0.1.0"
 4 | authors = ["Henry Zimmerman <zimhen7@gmail.com>"]
 5 | edition = "2018"
 6 | license = "MIT/Apache-2.0"
 7 | description = "Macros to be re-exported from the yewtil crate"
 8 | 
 9 | [lib]
10 | proc-macro = true
11 | 
12 | [dependencies]
13 | syn = "1.0.11"
14 | quote = "1.0.2"
15 | proc-macro2 = "1.0.6"
16 | 


--------------------------------------------------------------------------------
/crates/yewtil-macro/src/function_component.rs:
--------------------------------------------------------------------------------
  1 | use proc_macro2::{TokenStream, Ident, Span};
  2 | use proc_macro::TokenStream as TokenStream1;
  3 | use syn::{Visibility, Error, Field, Stmt, Block, VisPublic, Type};
  4 | use syn::Token;
  5 | use syn::token;
  6 | use syn::punctuated::Punctuated;
  7 | use syn::parse::{Parse, ParseBuffer};
  8 | use syn::{parenthesized, braced};
  9 | use syn::parse_macro_input;
 10 | use syn::export::ToTokens;
 11 | use quote::quote;
 12 | 
 13 | pub fn function_component_handler(attr: TokenStream, item: TokenStream1) -> TokenStream1 {
 14 |     let component_name = attr.to_string();
 15 |     assert!(!component_name.is_empty(), "you must provide a component name. eg: function_component(MyComponent)");
 16 |     let component_name = Ident::new(&component_name, Span::call_site());
 17 | 
 18 |     let item_copy = item.clone();
 19 | 
 20 |     let function = parse_macro_input!(item_copy as Function);
 21 | 
 22 |     TokenStream1::from(FunctionComponentInfo {
 23 |         component_name,
 24 |         function
 25 |     }.to_token_stream())
 26 | }
 27 | 
 28 | pub struct FunctionComponentInfo {
 29 |     component_name: Ident,
 30 |     function: Function
 31 | }
 32 | 
 33 | 
 34 | // TODO, support type parameters
 35 | 
 36 | pub struct Function {
 37 |     pub vis: Visibility,
 38 |     pub fn_token: Token![fn],
 39 |     pub name: Ident,
 40 |     pub paren_token: token::Paren,
 41 |     pub fields: Punctuated<Field, Token![,]>,
 42 |     pub returns_token: Token![->],
 43 |     pub return_ty: Ident,
 44 |     pub brace_token: token::Brace,
 45 |     pub body: Vec<Stmt>
 46 | }
 47 | 
 48 | impl Parse for Function {
 49 |     fn parse(input: &ParseBuffer) -> Result<Self, Error> {
 50 |         let content;
 51 |         let content2;
 52 |         Ok(Function {
 53 |             vis: input.parse()?,
 54 |             fn_token: input.parse()?,
 55 |             name: input.parse()?,
 56 |             paren_token: parenthesized!(content in input),
 57 |             fields: content.parse_terminated(Field::parse_named)?,
 58 |             returns_token: input.parse()?,
 59 |             return_ty: input.parse()?,
 60 |             brace_token: braced!(content2 in input),
 61 |             body: content2.call(Block::parse_within)?
 62 |         })
 63 |     }
 64 | }
 65 | 
 66 | impl ToTokens for Function {
 67 |     fn to_tokens(&self, tokens: &mut TokenStream) {
 68 |         let Function {
 69 |             vis, fn_token, name, fields, returns_token, return_ty,  body, ..
 70 |         } = self;
 71 |         let fields = fields.iter()
 72 |             .map(|field: &Field| {
 73 |                 let mut new_field: Field = field.clone();
 74 |                 new_field.attrs = vec![];
 75 |                 new_field
 76 |             })
 77 |             .collect::<Punctuated<_, Token![,]>>();
 78 | 
 79 |         tokens.extend(quote! {
 80 |             #vis #fn_token #name(#fields) #returns_token #return_ty {
 81 |                 #(#body)*
 82 |             }
 83 |         })
 84 |     }
 85 | }
 86 | 
 87 | impl ToTokens for FunctionComponentInfo {
 88 |     fn to_tokens(&self, tokens: &mut TokenStream) {
 89 |         let FunctionComponentInfo {
 90 |             component_name, function
 91 |         } = self;
 92 |         // The function tokens must be re-generated in order to strip the attributes that are not allowed.
 93 |         let function_token_stream = function.to_token_stream();
 94 |         let Function {
 95 |             vis, name, fields, ..
 96 |         } = function;
 97 | 
 98 |         let impl_name = format!("FuncComp{}", component_name.to_string());
 99 |         let impl_name = Ident::new(&impl_name, Span::call_site());
100 | 
101 |         let alias = quote! {
102 |             #vis type #component_name = ::yewtil::Pure<#impl_name>;
103 |         };
104 | 
105 |         // Set the fields to be public and strips references as necessary.
106 |         // This will preserve attributes like #[props(required)], which will appear in the generated struct below.
107 |         let new_fields = fields.iter()
108 |             .map(|field: &Field| {
109 |                 let mut new_field: Field = field.clone();
110 |                 let visibility = Visibility::Public(VisPublic{ pub_token: syn::token::Pub {span: Span::call_site()} });
111 |                 // Strip references so the component can have a static lifetime.
112 |                 // TODO Handle 'static lifetimes gracefully here - allowing &'static strings instead of erroneously converting them to plain strs.
113 |                 let ty = match &field.ty {
114 |                     Type::Reference(x) => {
115 |                         let elem = x.elem.clone();
116 |                         Type::Verbatim(quote!{
117 |                             #elem
118 |                         })
119 |                     }
120 |                     x => x.clone()
121 |                 };
122 |                 new_field.vis = visibility;
123 |                 new_field.ty = ty;
124 |                 new_field
125 |             })
126 |             .collect::<Punctuated<_, Token![,]>>();
127 | 
128 | 
129 |         let component_struct = quote!{
130 |             #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::yew::Properties)]
131 |             #vis struct #impl_name {
132 |                 #new_fields
133 |             }
134 |         };
135 | 
136 |         let arguments = fields.iter().zip(new_fields.iter())
137 |             .map(|(field, new_field): (&Field, &Field)| {
138 |                 let field_name = field.ident.as_ref().expect("Field must have name");
139 | 
140 |                 // If the fields differ, then a reference was removed from the function's field's type
141 |                 // to make it static.
142 |                 // Otherwise it is assumed that the type is not a reference on the function and it
143 |                 // implements clone, and that when calling the function, the type should be cloned again.
144 |                 if field.ty != new_field.ty {
145 |                     quote! {
146 |                         &self.#field_name
147 |                     }
148 |                 } else {
149 |                     quote! {
150 |                         self.#field_name.clone()
151 |                     }
152 |                 }
153 |             })
154 |             .collect::<Punctuated<_, Token![,]>>();
155 | 
156 |         let pure_component_impl = quote! {
157 |             impl ::yewtil::PureComponent for #impl_name {
158 |                 fn render(&self) -> ::yew::Html {
159 |                      #name(#arguments)
160 |                 }
161 |             }
162 |         };
163 | 
164 | 
165 |         tokens.extend(quote!{
166 |             #function_token_stream
167 |             #alias
168 |             #component_struct
169 |             #pure_component_impl
170 |         })
171 |     }
172 | }


--------------------------------------------------------------------------------
/crates/yewtil-macro/src/lib.rs:
--------------------------------------------------------------------------------
 1 | extern crate proc_macro;
 2 | use proc_macro::TokenStream;
 3 | 
 4 | 
 5 | use crate::function_component::function_component_handler;
 6 | 
 7 | mod function_component;
 8 | #[proc_macro_attribute]
 9 | pub fn function_component(attr: TokenStream, item: TokenStream) -> TokenStream {
10 |     function_component_handler(attr.into(), item.into()).into()
11 | }
12 | 


--------------------------------------------------------------------------------
/examples/dsl/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "dsl"
 3 | version = "0.1.0"
 4 | authors = ["Henry Zimmerman <zimhen7@gmail.com>"]
 5 | edition = "2018"
 6 | license = "MIT/Apache-2.0"
 7 | 
 8 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 9 | 
10 | [dependencies]
11 | yew = { git = "https://github.com/yewstack/yew", branch="master" }
12 | yewtil = {path="../..", features=["dsl"]}
13 | web_logger = "0.2.0"
14 | log = "0.4.8"
15 | 


--------------------------------------------------------------------------------
/examples/dsl/src/main.rs:
--------------------------------------------------------------------------------
 1 | use yew::{Component, ComponentLink, Html, ShouldRender};
 2 | 
 3 | use yewtil::dsl::{list, populated_list, tag, text, BoxedVNodeProducer};
 4 | 
 5 | pub struct Model {}
 6 | 
 7 | pub enum Msg {
 8 |     DoIt,
 9 | }
10 | 
11 | impl Component for Model {
12 |     type Message = Msg;
13 |     type Properties = ();
14 | 
15 |     fn create(_: Self::Properties, _: ComponentLink<Self>) -> Self {
16 |         Model {}
17 |     }
18 | 
19 |     fn update(&mut self, msg: Self::Message) -> ShouldRender {
20 |         match msg {
21 |             Msg::DoIt => {
22 |                 log::info!("got message");
23 |                 true
24 |             }
25 |         }
26 |     }
27 | 
28 |     fn view(&self) -> Html {
29 |         BoxedVNodeProducer::from(
30 |             list()
31 |                 .child(text("Hello there"))
32 |                 .child(tag("p").child(text("Paragraph content")))
33 |                 .child(populated_list(vec![
34 |                     tag("b").child(text("Bolded")).into(),
35 |                     text("Normal text").into(),
36 |                 ])),
37 |         )
38 |         .build()
39 |     }
40 | }
41 | 
42 | fn main() {
43 |     web_logger::init();
44 |     yew::start_app::<Model>();
45 | }
46 | 


--------------------------------------------------------------------------------
/examples/effect/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "effect"
 3 | version = "0.1.0"
 4 | authors = ["Henry Zimmerman <zimhen7@gmail.com>"]
 5 | edition = "2018"
 6 | 
 7 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 8 | 
 9 | [dependencies]
10 | yew = { git = "https://github.com/yewstack/yew", branch="master" }
11 | yewtil = {path="../..", features=["effect"]}
12 | web_logger = "0.2.0"
13 | log = "0.4.8"
14 | 


--------------------------------------------------------------------------------
/examples/effect/src/main.rs:
--------------------------------------------------------------------------------
 1 | use yew::{html, Component, ComponentLink, Html, ShouldRender};
 2 | use yewtil::{Effect, effect};
 3 | 
 4 | pub struct Model {
 5 |     value: bool
 6 | }
 7 | 
 8 | 
 9 | impl Component for Model {
10 |     type Message = Effect<Self>;
11 |     type Properties = ();
12 | 
13 |     fn create(_: Self::Properties, _: ComponentLink<Self>) -> Self {
14 |         Model {
15 |             value: false
16 |         }
17 |     }
18 | 
19 |     fn update(&mut self, msg: Self::Message) -> ShouldRender {
20 |         msg.call(self)
21 |     }
22 | 
23 |     fn view(&self) -> Html {
24 |         html! {
25 |             <>
26 |                 <div>
27 |                    {self.value}
28 |                 </div>
29 |                 <div>
30 |                     <button
31 |                         onclick=|_| effect(|model: &mut Self| {
32 |                             model.value = !model.value;
33 |                             true
34 |                         })
35 |                     >
36 |                         {"Toggle"}
37 |                     </button>
38 |                 </div>
39 |             </>
40 |         }
41 |     }
42 | }
43 | 
44 | fn main() {
45 |     web_logger::init();
46 |     yew::start_app::<Model>();
47 | }


--------------------------------------------------------------------------------
/examples/fetch/.cargo/config:
--------------------------------------------------------------------------------
1 | # Allow cargo-check to work as expected.
2 | [build]
3 | target = "wasm32-unknown-unknown"
4 | 


--------------------------------------------------------------------------------
/examples/fetch/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "fetch"
 3 | version = "0.1.0"
 4 | authors = ["Henry Zimmerman <zimhen7@gmail.com>"]
 5 | edition = "2018"
 6 | 
 7 | [lib]
 8 | crate-type = ["cdylib", "rlib"]
 9 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
10 | 
11 | [dependencies]
12 | yew = { git = "https://github.com/yewstack/yew", branch="master" }
13 | yewtil = {path="../..", features=["fetch"]}
14 | web_logger = "0.2.0"
15 | log = "0.4.8"
16 | serde = "1.0.102"
17 | wasm-bindgen = "0.2.51"
18 | 


--------------------------------------------------------------------------------
/examples/fetch/Readme.md:
--------------------------------------------------------------------------------
 1 | Shows off ergonomic JSON deserialization fetch abstraction.
 2 | 
 3 | Run with:
 4 | 
 5 | ```shell script
 6 | wasm-pack build --target web && rollup ./main.js --format iife --file ./pkg/bundle.js && python -m SimpleHTTPServer 8080
 7 | ```
 8 | 
 9 | It is expected that you have a setup with wasm-pack, rollup, and python installed.
10 | 


--------------------------------------------------------------------------------
/examples/fetch/index.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html lang="en">
 3 | <head>
 4 |     <meta charset="utf-8" />
 5 |     <title>Yewtil • Fetch</title>
 6 | </head>
 7 | <body>
 8 | <script src="/pkg/bundle.js"></script>
 9 | </body>
10 | </html>


--------------------------------------------------------------------------------
/examples/fetch/main.js:
--------------------------------------------------------------------------------
1 | import init, { run_app } from './pkg/fetch.js';
2 | async function main() {
3 |   await init('./pkg/fetch_bg.wasm');
4 |   run_app();
5 | }
6 | main()


--------------------------------------------------------------------------------
/examples/fetch/src/lib.rs:
--------------------------------------------------------------------------------
  1 | use crate::Msg::SetMarkdownFetchState;
  2 | use yew::{html, Component, ComponentLink, Html, ShouldRender};
  3 | use yewtil::fetch::{FetchAction, FetchRequest, MethodBody, Json, Fetch, FetchState};
  4 | use serde::{Serialize, Deserialize};
  5 | use wasm_bindgen::prelude::*;
  6 | use yewtil::future::ComponentLinkFuture;
  7 | 
  8 | #[wasm_bindgen]
  9 | pub fn run_app() {
 10 |     yew::start_app::<Model>();
 11 | }
 12 | 
 13 | struct Model {
 14 |     markdown: Fetch<Request, Vec<Employee>>,
 15 |     link: ComponentLink<Self>,
 16 | }
 17 | 
 18 | #[derive(Default, Debug, Clone)]
 19 | pub struct Request;
 20 | #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 21 | pub struct Employee {
 22 |     id: String,
 23 |     employee_name: String,
 24 |     employee_salary: String,
 25 |     employee_age: String,
 26 |     profile_image: String
 27 | }
 28 | 
 29 | impl FetchRequest for Request {
 30 |     type RequestBody = ();
 31 |     type ResponseBody = Vec<Employee>;
 32 |     type Format = Json;
 33 | 
 34 |     fn url(&self) -> String {
 35 |         // Given that this is an external resource, this may fail sometime in the future.
 36 |         // Please report any regressions related to this.
 37 |         "http://dummy.restapiexample.com/api/v1/employees".to_string()
 38 |     }
 39 | 
 40 |     fn method(&self) -> MethodBody<Self::RequestBody> {
 41 |         MethodBody::Get
 42 |     }
 43 | 
 44 |     fn headers(&self) -> Vec<(String, String)> {
 45 |         vec![]
 46 |     }
 47 | 
 48 |     fn use_cors(&self) -> bool {
 49 |         true
 50 |     }
 51 | }
 52 | 
 53 | 
 54 | enum Msg {
 55 |     SetMarkdownFetchState(FetchAction<Vec<Employee>>),
 56 |     GetMarkdown,
 57 | }
 58 | 
 59 | impl Component for Model {
 60 |     // Some details omitted. Explore the examples to see more.
 61 | 
 62 |     type Message = Msg;
 63 |     type Properties = ();
 64 | 
 65 |     fn create(_: Self::Properties, link: ComponentLink<Self>) -> Self {
 66 |         Model {
 67 |             markdown: Default::default(),
 68 |             link,
 69 |         }
 70 |     }
 71 | 
 72 |     fn update(&mut self, msg: Self::Message) -> ShouldRender {
 73 |         match msg {
 74 |             Msg::SetMarkdownFetchState(fetch_state) => {
 75 |                 self.markdown.apply(fetch_state);
 76 |                 true
 77 |             }
 78 |             Msg::GetMarkdown => {
 79 |                 self.link.send_future(self.markdown.fetch(Msg::SetMarkdownFetchState));
 80 |                 self.link.send_message(SetMarkdownFetchState(FetchAction::Fetching));
 81 |                 false
 82 |             }
 83 |         }
 84 |     }
 85 | 
 86 |     fn view(&self) -> Html {
 87 |         match self.markdown.as_ref().state() {
 88 |             FetchState::NotFetching(_) => {
 89 |                 html! {<button onclick=self.link.callback(|_| Msg::GetMarkdown)>{"Get employees"}</button>}
 90 |             }
 91 |             FetchState::Fetching(_) => html! {"Fetching"},
 92 |             FetchState::Fetched(data) => data.iter().map(render_employee).collect(),
 93 |             FetchState::Failed(_, err) => html! {&err},
 94 |         }
 95 |     }
 96 | }
 97 | 
 98 | fn render_employee(e: &Employee) -> Html {
 99 |     html! {
100 |         <div>
101 |             <div>
102 |                 {"Name: "}
103 |                 {&e.employee_name}
104 |             </div>
105 |             <div>
106 |                 {"Salary: "}
107 |                 {&e.employee_salary}
108 |             </div>
109 | 
110 |             <div>
111 |                 {"Age: "}
112 |                 {&e.employee_age}
113 |             </div>
114 |             <br/>
115 |         </div>
116 |     }
117 | }
118 | 
119 | 
120 | 


--------------------------------------------------------------------------------
/examples/function_component/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "function_component"
 3 | version = "0.1.0"
 4 | authors = ["Henry Zimmerman <zimhen7@gmail.com>"]
 5 | edition = "2018"
 6 | 
 7 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 8 | 
 9 | [dependencies]
10 | yew = { git = "https://github.com/yewstack/yew", branch="master" }
11 | yewtil = {path="../.."}
12 | web_logger = "0.2.0"
13 | log = "0.4.8"
14 | 


--------------------------------------------------------------------------------
/examples/function_component/src/button.rs:
--------------------------------------------------------------------------------
 1 | use yew::{html, Callback, ClickEvent, Html};
 2 | use yewtil::{function_component};
 3 | 
 4 | #[function_component(Button)]
 5 | pub fn button(
 6 |     #[props(required)]
 7 |     callback: &Callback<ClickEvent>,
 8 |     text: &String,
 9 |     _num: usize
10 | ) -> Html {
11 |     html! {
12 |         <button onclick=callback>{ text }</button>
13 |     }
14 | }
15 | 
16 | 
17 | 


--------------------------------------------------------------------------------
/examples/function_component/src/main.rs:
--------------------------------------------------------------------------------
 1 | 
 2 | use yew::{html, Component, ComponentLink, Html, ShouldRender};
 3 | 
 4 | mod button;
 5 | use crate::button::Button;
 6 | 
 7 | pub struct Model {link: ComponentLink<Self>}
 8 | 
 9 | pub enum Msg {
10 |     DoIt,
11 | }
12 | 
13 | impl Component for Model {
14 |     type Message = Msg;
15 |     type Properties = ();
16 | 
17 |     fn create(_: Self::Properties, link: ComponentLink<Self>) -> Self {
18 |         Model {link}
19 |     }
20 | 
21 |     fn update(&mut self, msg: Self::Message) -> ShouldRender {
22 |         match msg {
23 |             Msg::DoIt => {
24 |                 log::info!("got message");
25 |                 true
26 |             }
27 |         }
28 |     }
29 | 
30 |     fn view(&self) -> Html {
31 |         html! {
32 |             <Button callback=self.link.callback(|_| Msg::DoIt) text = "Click me!" />
33 |         }
34 |     }
35 | }
36 | 
37 | fn main() {
38 |     web_logger::init();
39 |     yew::start_app::<Model>();
40 | }


--------------------------------------------------------------------------------
/examples/futures/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "futures"
 3 | version = "0.1.0"
 4 | authors = ["Henry Zimmerman <zimhen7@gmail.com>"]
 5 | edition = "2018"
 6 | description = "web_sys fetching and futures demonstration"
 7 | license = "MIT/Apache"
 8 | repository = "https://github.com/yewstack/yew"
 9 | 
10 | [lib]
11 | crate-type = ["cdylib", "rlib"]
12 | 
13 | [dependencies]
14 | yew = { git = "https://github.com/yewstack/yew", branch="master" }
15 | yewtil = {path="../.."}
16 | wasm-bindgen-futures = "0.4.3"
17 | 
18 | [dependencies.web-sys]
19 | version = "0.3.30"
20 | features = [
21 |   'Headers',
22 |   'Request',
23 |   'RequestInit',
24 |   'RequestMode',
25 |   'Response',
26 |   'Window',
27 | ]
28 | 
29 | [target.'cfg(all(target_arch = "wasm32", not(cargo_web)))'.dependencies]
30 | wasm-bindgen = "0.2.51"
31 | 


--------------------------------------------------------------------------------
/examples/futures/README.md:
--------------------------------------------------------------------------------
 1 | # Futures Example
 2 | This example shows off how to make a asynchronous fetch request using web_sys and Yew's futures support.
 3 | 
 4 | Because this example uses features not allowed by cargo web, it cannot be included in the showcase, and must be built with a different toolchain instead.
 5 | 
 6 | ### How to run:
 7 | This example requires rustc v1.39.0 or above to compile due to its use of async/.await syntax.
 8 | 
 9 | ```sh
10 | wasm-pack build --target web && rollup ./main.js --format iife --file ./pkg/bundle.js && python -m SimpleHTTPServer 8080
11 | ```
12 | This will compile the project, bundle up the compiler output and static assets, and start a http server on port 8080 so you can access the example at localhost:8080.
13 | 
14 | It is expected that you have a setup with wasm-pack, rollup, and python installed.
15 | 


--------------------------------------------------------------------------------
/examples/futures/index.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html lang="en">
 3 | <head>
 4 |     <meta charset="utf-8" />
 5 |     <title>Yew • Futures</title>
 6 | </head>
 7 | <body>
 8 | <script src="/pkg/bundle.js"></script>
 9 | </body>
10 | </html>


--------------------------------------------------------------------------------
/examples/futures/main.js:
--------------------------------------------------------------------------------
1 | import init, { run_app } from './pkg/futures.js';
2 | async function main() {
3 |    await init('./pkg/futures_bg.wasm');
4 |    run_app();
5 | }
6 | main()


--------------------------------------------------------------------------------
/examples/futures/src/lib.rs:
--------------------------------------------------------------------------------
  1 | use crate::Msg::SetMarkdownFetchState;
  2 | use std::fmt::{Error, Formatter};
  3 | use wasm_bindgen::prelude::*;
  4 | use wasm_bindgen::JsCast;
  5 | use wasm_bindgen_futures::JsFuture;
  6 | use web_sys::{Request, RequestInit, RequestMode, Response, Window};
  7 | use yew::{html, Component, ComponentLink, Html, ShouldRender};
  8 | use yewtil::future::ComponentLinkFuture;
  9 | 
 10 | /// Something wrong has occurred while fetching an external resource.
 11 | #[derive(Debug, Clone, PartialEq)]
 12 | pub struct FetchError {
 13 |     err: JsValue,
 14 | }
 15 | impl std::fmt::Display for FetchError {
 16 |     fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
 17 |         std::fmt::Debug::fmt(&self.err, f)
 18 |     }
 19 | }
 20 | impl std::error::Error for FetchError {}
 21 | 
 22 | impl From<JsValue> for FetchError {
 23 |     fn from(value: JsValue) -> Self {
 24 |         FetchError { err: value }
 25 |     }
 26 | }
 27 | 
 28 | /// The possible states a fetch request can be in.
 29 | pub enum FetchState<T> {
 30 |     NotFetching,
 31 |     Fetching,
 32 |     Success(T),
 33 |     Failed(FetchError),
 34 | }
 35 | 
 36 | /// Fetches markdown from Yew's README.md.
 37 | ///
 38 | /// Consult the following for an example of the fetch api by the team behind web_sys:
 39 | /// https://rustwasm.github.io/wasm-bindgen/examples/fetch.html
 40 | async fn fetch_markdown() -> Result<String, FetchError> {
 41 |     let mut opts = RequestInit::new();
 42 |     opts.method("GET");
 43 |     opts.mode(RequestMode::Cors);
 44 | 
 45 |     let request = Request::new_with_str_and_init(
 46 |         "https://raw.githubusercontent.com/yewstack/yew/master/README.md",
 47 |         &opts,
 48 |     )?;
 49 | 
 50 |     let window: Window = web_sys::window().unwrap();
 51 |     let resp_value = JsFuture::from(window.fetch_with_request(&request)).await?;
 52 |     assert!(resp_value.is_instance_of::<Response>());
 53 | 
 54 |     let resp: Response = resp_value.dyn_into().unwrap();
 55 | 
 56 |     let text = JsFuture::from(resp.text()?).await?;
 57 |     Ok(text.as_string().unwrap())
 58 | }
 59 | 
 60 | struct Model {
 61 |     markdown: FetchState<String>,
 62 |     link: ComponentLink<Self>,
 63 | }
 64 | 
 65 | enum Msg {
 66 |     SetMarkdownFetchState(FetchState<String>),
 67 |     GetMarkdown,
 68 | }
 69 | 
 70 | impl Component for Model {
 71 |     // Some details omitted. Explore the examples to see more.
 72 | 
 73 |     type Message = Msg;
 74 |     type Properties = ();
 75 | 
 76 |     fn create(_: Self::Properties, link: ComponentLink<Self>) -> Self {
 77 |         Model {
 78 |             markdown: FetchState::NotFetching,
 79 |             link,
 80 |         }
 81 |     }
 82 | 
 83 |     fn update(&mut self, msg: Self::Message) -> ShouldRender {
 84 |         match msg {
 85 |             Msg::SetMarkdownFetchState(fetch_state) => {
 86 |                 self.markdown = fetch_state;
 87 |                 true
 88 |             }
 89 |             Msg::GetMarkdown => {
 90 |                 let future = async {
 91 |                     match fetch_markdown().await {
 92 |                         Ok(md) => Msg::SetMarkdownFetchState(FetchState::Success(md)),
 93 |                         Err(err) => Msg::SetMarkdownFetchState(FetchState::Failed(err)),
 94 |                     }
 95 |                 };
 96 |                 self.link.send_future(future);
 97 |                 self.link
 98 |                     .send_message(SetMarkdownFetchState(FetchState::Fetching));
 99 |                 false
100 |             }
101 |         }
102 |     }
103 | 
104 |     fn view(&self) -> Html {
105 |         match &self.markdown {
106 |             FetchState::NotFetching => html! {
107 |                 <button onclick=self.link.callback(|_| Msg::GetMarkdown)>
108 |                     {"Get Markdown"}
109 |                 </button>
110 |             },
111 |             FetchState::Fetching => html! {"Fetching"},
112 |             FetchState::Success(data) => html! {&data},
113 |             FetchState::Failed(err) => html! {&err},
114 |         }
115 |     }
116 | }
117 | 
118 | #[wasm_bindgen]
119 | pub fn run_app() {
120 |     yew::start_app::<Model>();
121 | }
122 | 


--------------------------------------------------------------------------------
/examples/history/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "history"
 3 | version = "0.1.0"
 4 | authors = ["Henry Zimmerman <zimhen7@gmail.com>"]
 5 | edition = "2018"
 6 | license = "MIT/Apache-2.0"
 7 | 
 8 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 9 | 
10 | [dependencies]
11 | yew = { git = "https://github.com/yewstack/yew", branch="master" }
12 | yewtil = {path="../.."}
13 | web_logger = "0.2.0"
14 | log = "0.4.8"
15 | 


--------------------------------------------------------------------------------
/examples/history/src/main.rs:
--------------------------------------------------------------------------------
 1 | use yew::{html, Component, ComponentLink, Html, ShouldRender};
 2 | use yewtil::History;
 3 | 
 4 | pub struct Model {
 5 |     text: History<String>,
 6 | }
 7 | 
 8 | pub enum Msg {
 9 |     SetText(String),
10 |     Reset,
11 |     Forget,
12 | }
13 | 
14 | impl Component for Model {
15 |     type Message = Msg;
16 |     type Properties = ();
17 | 
18 |     fn create(_: Self::Properties, _: ComponentLink<Self>) -> Self {
19 |         Model {
20 |             text: History::new("".to_string()),
21 |         }
22 |     }
23 | 
24 |     fn update(&mut self, msg: Self::Message) -> ShouldRender {
25 |         match msg {
26 |             Msg::SetText(text) => self.text.neq_set(text),
27 |             Msg::Reset => self.text.reset(),
28 |             Msg::Forget => {
29 |                 self.text.forget();
30 |                 false
31 |             }
32 |         }
33 |     }
34 | 
35 |     fn view(&self) -> Html {
36 |         html! {
37 |             <>
38 |                 <div>
39 |                    {&*self.text}
40 |                 </div>
41 |                 <div>
42 |                     <input
43 |                         type = "text"
44 |                         value = &*self.text,
45 |                         oninput = |x| Msg::SetText(x.value)
46 |                     />
47 |                     <button onclick=|_| Msg::Reset >{"Reset to the oldest value"} </button>
48 |                     <button onclick=|_| Msg::Forget>{"Forget prior values"} </button>
49 |                 </div>
50 |             </>
51 |         }
52 |     }
53 | }
54 | 
55 | fn main() {
56 |     web_logger::init();
57 |     yew::start_app::<Model>();
58 | }
59 | 


--------------------------------------------------------------------------------
/examples/lrc/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "lrc"
 3 | version = "0.1.0"
 4 | authors = ["Henry Zimmerman <zimhen7@gmail.com>"]
 5 | edition = "2018"
 6 | license = "MIT/Apache-2.0"
 7 | 
 8 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 9 | 
10 | [dependencies]
11 | yew = { git = "https://github.com/yewstack/yew", branch="master" }
12 | yewtil = {path="../..", features = ["lrc"]}
13 | web_logger = "0.2.0"
14 | log = "0.4.8"
15 | 


--------------------------------------------------------------------------------
/examples/lrc/src/child.rs:
--------------------------------------------------------------------------------
 1 | use yew::{
 2 |     events::InputData, html, Callback, Component, ComponentLink, Html, Properties, ShouldRender,
 3 | };
 4 | use yewtil::ptr::Lrc;
 5 | use yewtil::NeqAssign;
 6 | 
 7 | #[derive(PartialEq, Properties)]
 8 | pub struct Props {
 9 |     #[props(required)]
10 |     pub text: Lrc<String>,
11 |     #[props(required)]
12 |     pub callback: Callback<()>,
13 | }
14 | 
15 | pub struct Child {
16 |     props: Props,
17 | }
18 | 
19 | pub enum Msg {
20 |     UpdateText(InputData),
21 |     SendCallback,
22 | }
23 | 
24 | impl Component for Child {
25 |     type Message = Msg;
26 |     type Properties = Props;
27 | 
28 |     fn create(props: Self::Properties, _: ComponentLink<Self>) -> Self {
29 |         Child { props }
30 |     }
31 | 
32 |     fn update(&mut self, msg: Self::Message) -> ShouldRender {
33 |         match msg {
34 |             Msg::UpdateText(input) => {
35 |                 // Only update the Lrc if the new value is different.
36 |                 self.props.text.neq_set(input.value);
37 |                 true
38 |             }
39 |             Msg::SendCallback => {
40 |                 self.props.callback.emit(());
41 |                 false
42 |             }
43 |         }
44 |     }
45 | 
46 |     fn change(&mut self, props: Self::Properties) -> ShouldRender {
47 |         self.props.neq_assign(props)
48 |     }
49 | 
50 |     fn view(&self) -> Html {
51 |         html! {
52 |             <>
53 |                 <input
54 |                     type = "text"
55 |                     value = self.props.text.as_ref(),
56 |                     oninput = |x| Msg::UpdateText(x)
57 |                 />
58 |                 <button onclick=|_| Msg::SendCallback >{"Update parent"} </button>
59 |             </>
60 |         }
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/examples/lrc/src/main.rs:
--------------------------------------------------------------------------------
 1 | use yew::{html, Component, ComponentLink, Html, ShouldRender};
 2 | use yewtil::ptr::Lrc;
 3 | 
 4 | mod child;
 5 | use crate::child::Child;
 6 | 
 7 | pub struct Model {
 8 |     text: Lrc<String>,
 9 | }
10 | 
11 | pub enum Msg {
12 |     UpdateTextAtADistance,
13 | }
14 | 
15 | impl Component for Model {
16 |     type Message = Msg;
17 |     type Properties = ();
18 | 
19 |     fn create(_: Self::Properties, _: ComponentLink<Self>) -> Self {
20 |         Model {
21 |             text: Lrc::new("".to_string()),
22 |         }
23 |     }
24 | 
25 |     fn update(&mut self, msg: Self::Message) -> ShouldRender {
26 |         match msg {
27 |             Msg::UpdateTextAtADistance => self.text.update(),
28 |         }
29 |     }
30 | 
31 |     fn view(&self) -> Html {
32 |         html! {
33 |             <>
34 |                 <div>
35 |                    {&*self.text}
36 |                 </div>
37 |                 // Either of the children's update buttons will cause this component's text
38 |                 // to update to the most recently edited text.
39 |                 <div>
40 |                     <Child text=&self.text callback = |_| Msg::UpdateTextAtADistance />
41 |                 </div>
42 |                 <div>
43 |                     <Child text=&self.text callback = |_| Msg::UpdateTextAtADistance />
44 |                 </div>
45 |             </>
46 |         }
47 |     }
48 | }
49 | 
50 | fn main() {
51 |     web_logger::init();
52 |     yew::start_app::<Model>();
53 | }
54 | 


--------------------------------------------------------------------------------
/examples/mrc_irc/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "mrc_irc"
 3 | version = "0.1.0"
 4 | authors = ["Henry Zimmerman <zimhen7@gmail.com>"]
 5 | edition = "2018"
 6 | license = "MIT/Apache-2.0"
 7 | 
 8 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 9 | 
10 | [dependencies]
11 | yew = { git = "https://github.com/yewstack/yew", branch="master" }
12 | yewtil = {path="../.."}
13 | web_logger = "0.2.0"
14 | log = "0.4.8"
15 | 


--------------------------------------------------------------------------------
/examples/mrc_irc/src/child.rs:
--------------------------------------------------------------------------------
 1 | use yew::{
 2 |     events::InputData, html, Callback, Component, ComponentLink, Html, Properties, ShouldRender,
 3 | };
 4 | use yewtil::ptr::Irc;
 5 | use yewtil::NeqAssign;
 6 | 
 7 | #[derive(PartialEq, Properties)]
 8 | pub struct Props {
 9 |     /// This value can't be altered.
10 |     #[props(required)]
11 |     pub text: Irc<String>,
12 |     /// This heavily implies the only way to update the text field is to send a message back
13 |     /// to the parent to have the parent component update it.
14 |     #[props(required)]
15 |     pub callback: Callback<String>,
16 | }
17 | 
18 | pub struct Child {
19 |     props: Props,
20 | }
21 | 
22 | pub enum Msg {
23 |     UpdateText(InputData),
24 | }
25 | 
26 | impl Component for Child {
27 |     type Message = Msg;
28 |     type Properties = Props;
29 | 
30 |     fn create(props: Self::Properties, _: ComponentLink<Self>) -> Self {
31 |         Child { props }
32 |     }
33 | 
34 |     fn update(&mut self, msg: Self::Message) -> ShouldRender {
35 |         match msg {
36 |             Msg::UpdateText(input) => {
37 |                 self.props.callback.emit(input.value);
38 |                 false
39 |             }
40 |         }
41 |     }
42 | 
43 |     fn change(&mut self, props: Self::Properties) -> ShouldRender {
44 |         self.props.neq_assign(props)
45 |     }
46 | 
47 |     fn view(&self) -> Html {
48 |         html! {
49 |             <>
50 |                 <input
51 |                     type = "text"
52 |                     value = &*self.props.text,
53 |                     oninput = |x| Msg::UpdateText(x)
54 |                 />
55 |             </>
56 |         }
57 |     }
58 | }
59 | 


--------------------------------------------------------------------------------
/examples/mrc_irc/src/main.rs:
--------------------------------------------------------------------------------
 1 | use yew::{html, Component, ComponentLink, Html, ShouldRender};
 2 | use yewtil::ptr::Mrc;
 3 | 
 4 | mod child;
 5 | use crate::child::Child;
 6 | use yewtil::NeqAssign;
 7 | 
 8 | pub struct Model {
 9 |     text: Mrc<String>,
10 | }
11 | 
12 | pub enum Msg {
13 |     UpdateText(String),
14 | }
15 | 
16 | impl Component for Model {
17 |     type Message = Msg;
18 |     type Properties = ();
19 | 
20 |     fn create(_: Self::Properties, _: ComponentLink<Self>) -> Self {
21 |         Model {
22 |             text: Mrc::new("".to_string()),
23 |         }
24 |     }
25 | 
26 |     fn update(&mut self, msg: Self::Message) -> ShouldRender {
27 |         match msg {
28 |             Msg::UpdateText(text) => {
29 |                 // Because Mrc<T> implements BorrowMut<T>, neq assign can be used here.
30 |                 self.text.neq_assign(text)
31 |             }
32 |         }
33 |     }
34 | 
35 |     fn view(&self) -> Html {
36 |         html! {
37 |             <>
38 |                 <div>
39 |                    {&*self.text}
40 |                 </div>
41 |                 <div>
42 |                     // By passing an `Irc`, we strongly imply that the value should not be updated
43 |                     // by the child. An effort to modify the value downstream is easily identified
44 |                     // as subverting the contract implied by using `Irc`s.
45 |                     <Child text=&self.text.irc() callback = Msg::UpdateText />
46 |                 </div>
47 |             </>
48 |         }
49 |     }
50 | }
51 | 
52 | fn main() {
53 |     web_logger::init();
54 |     yew::start_app::<Model>();
55 | }
56 | 


--------------------------------------------------------------------------------
/examples/pure_component/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "pure_component"
 3 | version = "0.1.0"
 4 | authors = ["Henry Zimmerman <zimhen7@gmail.com>"]
 5 | edition = "2018"
 6 | license = "MIT/Apache-2.0"
 7 | 
 8 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 9 | 
10 | [dependencies]
11 | #yew = "0.9.0"
12 | yew = { git = "https://github.com/yewstack/yew", branch="master" }
13 | yewtil = {path="../.."}
14 | web_logger = "0.2.0"
15 | log = "0.4.8"
16 | 


--------------------------------------------------------------------------------
/examples/pure_component/src/button.rs:
--------------------------------------------------------------------------------
 1 | use yew::virtual_dom::VNode;
 2 | use yew::{html, Callback, Properties, ClickEvent};
 3 | use yewtil::{Pure, PureComponent};
 4 | 
 5 | /// Alias to make usability better.
 6 | pub type Button = Pure<PureButton>;
 7 | 
 8 | #[derive(PartialEq, Properties)]
 9 | pub struct PureButton {
10 |     #[props(required)]
11 |     pub callback: Callback<ClickEvent>,
12 |     pub text: String,
13 | }
14 | 
15 | impl PureComponent for PureButton {
16 |     fn render(&self) -> VNode {
17 |         html! {
18 |             <button onclick=&self.callback>{ &self.text }</button>
19 |         }
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/examples/pure_component/src/main.rs:
--------------------------------------------------------------------------------
 1 | use yew::{html, Component, ComponentLink, Html, ShouldRender};
 2 | 
 3 | mod button;
 4 | use crate::button::Button;
 5 | 
 6 | pub struct Model {link: ComponentLink<Self>}
 7 | 
 8 | pub enum Msg {
 9 |     DoIt,
10 | }
11 | 
12 | impl Component for Model {
13 |     type Message = Msg;
14 |     type Properties = ();
15 | 
16 |     fn create(_: Self::Properties, link: ComponentLink<Self>) -> Self {
17 |         Model {link}
18 |     }
19 | 
20 |     fn update(&mut self, msg: Self::Message) -> ShouldRender {
21 |         match msg {
22 |             Msg::DoIt => {
23 |                 log::info!("got message");
24 |                 true
25 |             }
26 |         }
27 |     }
28 | 
29 |     fn view(&self) -> Html {
30 |         html! {
31 |             <Button callback=self.link.callback(|_| Msg::DoIt) text = "Click me!" />
32 |         }
33 |     }
34 | }
35 | 
36 | fn main() {
37 |     web_logger::init();
38 |     yew::start_app::<Model>();
39 | }
40 | 


--------------------------------------------------------------------------------
/src/dsl.rs:
--------------------------------------------------------------------------------
 1 | pub use crate::dsl::vcomp::VCompProducer;
 2 | use crate::dsl::vlist::VListProducer;
 3 | pub use crate::dsl::vtag::VTagProducer;
 4 | pub use crate::dsl::vtext::VTextProducer;
 5 | use yew::virtual_dom::vcomp::ScopeHolder;
 6 | use yew::virtual_dom::VNode;
 7 | use yew::Component;
 8 | 
 9 | mod vcomp;
10 | mod vlist;
11 | mod vtag;
12 | mod vtext;
13 | 
14 | /// Wrapper around a function that produces a vnode.
15 | pub struct BoxedVNodeProducer<COMP: Component>(Box<dyn FnOnce(ScopeHolder<COMP>) -> VNode<COMP>>);
16 | 
17 | impl<COMP: Component> BoxedVNodeProducer<COMP> {
18 |     fn wrap(f: impl FnOnce(ScopeHolder<COMP>) -> VNode<COMP> + 'static) -> Self {
19 |         BoxedVNodeProducer(Box::new(f))
20 |     }
21 |     fn execute(self, scope: &ScopeHolder<COMP>) -> VNode<COMP> {
22 |         (self.0)(scope.clone())
23 |     }
24 |     pub fn build(self) -> VNode<COMP> {
25 |         let scope = ScopeHolder::default();
26 |         self.execute(&scope)
27 |     }
28 | }
29 | 
30 | impl<COMP: Component> Into<VNode<COMP>> for BoxedVNodeProducer<COMP> {
31 |     fn into(self) -> VNode<COMP> {
32 |         self.build()
33 |     }
34 | }
35 | 
36 | /// Creates a tag node.
37 | pub fn tag<COMP: Component>(tag: &'static str) -> VTagProducer<COMP> {
38 |     VTagProducer::new(tag)
39 | }
40 | 
41 | /// Creates a component (Specified by the second type parameter).
42 | pub fn comp<COMP: Component, CHILD: Component>(props: CHILD::Properties) -> VCompProducer<COMP> {
43 |     VCompProducer::new::<CHILD>(props)
44 | }
45 | 
46 | /// Creates a text node
47 | pub fn text<COMP: Component, T: Into<String> + 'static>(text: T) -> VTextProducer<COMP> {
48 |     VTextProducer::new::<T>(text)
49 | }
50 | 
51 | /// Creates a new vlist, populated with the provided vnodes
52 | pub fn populated_list<COMP: Component>(list: Vec<BoxedVNodeProducer<COMP>>) -> VListProducer<COMP> {
53 |     VListProducer::populated_new(list)
54 | }
55 | 
56 | /// Creates a new vlist
57 | pub fn list<COMP: Component>() -> VListProducer<COMP> {
58 |     VListProducer::new()
59 | }
60 | 


--------------------------------------------------------------------------------
/src/dsl/vcomp.rs:
--------------------------------------------------------------------------------
 1 | use crate::dsl::BoxedVNodeProducer;
 2 | use yew::virtual_dom::vcomp::ScopeHolder;
 3 | use yew::virtual_dom::VComp;
 4 | use yew::{Component, NodeRef};
 5 | 
 6 | pub struct VCompProducer<COMP: Component>(Box<dyn FnOnce(ScopeHolder<COMP>) -> VComp<COMP>>);
 7 | 
 8 | impl<COMP: Component> VCompProducer<COMP> {
 9 |     pub fn new<CHILD: Component>(props: CHILD::Properties) -> Self {
10 |         // TODO allow getting the noderef as a parameter somewhere.
11 |         VCompProducer(Box::new(move |scope| VComp::new::<CHILD>(props, scope, NodeRef::default())))
12 |     }
13 | }
14 | 
15 | impl<COMP: Component> From<VCompProducer<COMP>> for BoxedVNodeProducer<COMP> {
16 |     fn from(vcomp_prod: VCompProducer<COMP>) -> Self {
17 |         BoxedVNodeProducer::wrap(move |scope| (vcomp_prod.0)(scope).into())
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/dsl/vlist.rs:
--------------------------------------------------------------------------------
 1 | use crate::dsl::BoxedVNodeProducer;
 2 | use yew::virtual_dom::VList;
 3 | use yew::Component;
 4 | 
 5 | pub struct VListProducer<COMP: Component> {
 6 |     children: Vec<BoxedVNodeProducer<COMP>>,
 7 | }
 8 | 
 9 | impl<COMP: Component> VListProducer<COMP> {
10 |     pub fn new() -> Self {
11 |         VListProducer { children: vec![] }
12 |     }
13 | 
14 |     pub fn child<T: Into<BoxedVNodeProducer<COMP>>>(mut self, child: T) -> Self {
15 |         self.children.push(child.into());
16 |         self
17 |     }
18 | 
19 |     pub fn populated_new(children: Vec<BoxedVNodeProducer<COMP>>) -> Self {
20 |         VListProducer { children }
21 |     }
22 | }
23 | 
24 | impl<COMP: Component> From<VListProducer<COMP>> for BoxedVNodeProducer<COMP> {
25 |     fn from(vlist_prod: VListProducer<COMP>) -> Self {
26 |         BoxedVNodeProducer(Box::new(move |scope| {
27 |             let mut vlist = VList::new();
28 |             for child in vlist_prod.children {
29 |                 let child = child.execute(&scope);
30 |                 vlist.add_child(child);
31 |             }
32 |             vlist.into()
33 |         }))
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/dsl/vtag.rs:
--------------------------------------------------------------------------------
 1 | use crate::dsl::BoxedVNodeProducer;
 2 | use yew::virtual_dom::vcomp::ScopeHolder;
 3 | use yew::virtual_dom::{Listener, VTag};
 4 | use yew::{Classes, Component};
 5 | 
 6 | pub struct Effect<T, COMP: Component>(Box<dyn FnOnce(T, &ScopeHolder<COMP>) -> T>);
 7 | impl<T, COMP: Component> Effect<T, COMP> {
 8 |     fn new(f: impl FnOnce(T, &ScopeHolder<COMP>) -> T + 'static) -> Self {
 9 |         Effect(Box::new(f))
10 |     }
11 | }
12 | 
13 | pub struct VTagProducer<COMP: Component> {
14 |     tag_type: &'static str,
15 |     effects: Vec<Effect<VTag<COMP>, COMP>>,
16 | }
17 | 
18 | impl<COMP: Component> VTagProducer<COMP> {
19 |     pub fn new(tag_type: &'static str) -> Self {
20 |         VTagProducer {
21 |             tag_type,
22 |             effects: vec![],
23 |         }
24 |     }
25 | 
26 |     // TODO, consider making this T: Into<VNode> - The whole dsl doesn't need to be lazy. - although being generic over an additional argument that is either () OR Scope is problematic.
27 |     pub fn child<T: Into<BoxedVNodeProducer<COMP>> + 'static>(mut self, child: T) -> Self {
28 |         let effect = Effect::new(move |mut vtag: VTag<COMP>, scope: &ScopeHolder<COMP>| {
29 |             let child = child.into().execute(scope);
30 |             vtag.add_child(child);
31 |             vtag
32 |         });
33 |         self.effects.push(effect);
34 |         self
35 |     }
36 | 
37 |     pub fn attribute(mut self, name: String, value: String) -> Self {
38 |         let effect = Effect::new(move |mut vtag: VTag<COMP>, _scope: &ScopeHolder<COMP>| {
39 |             vtag.add_attribute(&name, &value);
40 |             vtag
41 |         });
42 |         self.effects.push(effect);
43 |         self
44 |     }
45 | 
46 |     pub fn listener(mut self, listener: Box<dyn Listener<COMP>>) -> Self {
47 |         let effect = Effect::new(move |mut vtag: VTag<COMP>, _scope: &ScopeHolder<COMP>| {
48 |             vtag.add_listener(listener);
49 |             vtag
50 |         });
51 |         self.effects.push(effect);
52 |         self
53 |     }
54 | 
55 |     pub fn classes(mut self, classes: Classes) -> Self {
56 |         let effect = Effect::new(move |mut vtag: VTag<COMP>, _scope: &ScopeHolder<COMP>| {
57 |             vtag.set_classes(classes);
58 |             vtag
59 |         });
60 |         self.effects.push(effect);
61 |         self
62 |     }
63 | }
64 | 
65 | impl<COMP: Component> From<VTagProducer<COMP>> for BoxedVNodeProducer<COMP> {
66 |     fn from(vtag_prod: VTagProducer<COMP>) -> Self {
67 |         BoxedVNodeProducer::wrap(move |scope| {
68 |             let mut vtag = VTag::new(vtag_prod.tag_type);
69 |             for effect in vtag_prod.effects.into_iter() {
70 |                 vtag = (effect.0)(vtag, &scope)
71 |             }
72 |             vtag.into()
73 |         })
74 |     }
75 | }
76 | 


--------------------------------------------------------------------------------
/src/dsl/vtext.rs:
--------------------------------------------------------------------------------
 1 | use crate::dsl::BoxedVNodeProducer;
 2 | use yew::virtual_dom::VText;
 3 | use yew::Component;
 4 | 
 5 | pub struct VTextProducer<COMP: Component>(Box<dyn FnOnce() -> VText<COMP>>);
 6 | 
 7 | impl<COMP: Component> VTextProducer<COMP> {
 8 |     pub fn new<T: Into<String> + 'static>(text: T) -> Self {
 9 |         VTextProducer(Box::new(move || VText::new(text.into())))
10 |     }
11 | }
12 | 
13 | impl<COMP: Component> From<VTextProducer<COMP>> for BoxedVNodeProducer<COMP> {
14 |     fn from(vtext_prod: VTextProducer<COMP>) -> Self {
15 |         BoxedVNodeProducer::wrap(move |_scope| (vtext_prod.0)().into())
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/effect.rs:
--------------------------------------------------------------------------------
 1 | use yew::ShouldRender;
 2 | use std::rc::Rc;
 3 | 
 4 | /// Alternative to using Message enums.
 5 | ///
 6 | /// Using Effects instead of Messages allows you to define the mutation to your component's state
 7 | /// from inside `html!` macros instead of from within update functions.
 8 | pub struct Effect<COMP>(Box<dyn Fn(&mut COMP) -> ShouldRender>);
 9 | 
10 | impl <COMP> Default for Effect<COMP> {
11 |     fn default() -> Self {
12 |         Effect::new(|_| false)
13 |     }
14 | }
15 | 
16 | impl <COMP> Effect<COMP> {
17 |     /// Wraps a function in an Effect wrapper.
18 |     pub fn new(f: impl Fn(&mut COMP)-> ShouldRender + 'static) -> Self {
19 |         Effect(Box::new(f))
20 |     }
21 | 
22 |     /// Runs the effect, causing a mutation to the component state.
23 |     pub fn call(self, component: &mut COMP) -> ShouldRender {
24 |         (self.0)(component)
25 |     }
26 | }
27 | 
28 | /// Terser wrapper function to be used instead of `Effect::new()`.
29 | pub fn effect<COMP>(f: impl Fn(&mut COMP) -> ShouldRender + 'static ) -> Effect<COMP>
30 | {
31 |     Effect::new(f)
32 | }
33 | 
34 | 
35 | #[allow(dead_code)]
36 | mod wip {
37 |     use super::*;
38 | 
39 | // TODO, once function_traits stabalize, this `to_effect()` will be able to be replaced with just a () call, making this more ergonomic.
40 | // https://github.com/rust-lang/rust/issues/29625
41 | // TODO, change naming of this.
42 | 
43 | 
44 | // TODO. Consider an arbitrary state holder: Hashmap<&str, Box<dyn Any + 'static>. It might be possible to write a function that returns a &T, and a StateHook<COMP, T>
45 | // TODO for any given T that could be inserted into the holder. This might work well if the state holder itself is a component.
46 | // Actually, as long as order is preserved, a Vec<Box<dyn Any + 'static>>, might work just as well.
47 | // This would replicate the useState hook in react https://reactjs.org/docs/hooks-state.html
48 | 
49 |     /// Wrapper around a mutable accessor to one of the component's (or another construct capabale of storing state's) fields.
50 |     pub struct StateHook<STORE, T>(Rc<dyn Fn(&mut STORE) -> &mut T>);
51 | 
52 |     impl<STORE: 'static, T: 'static> StateHook<STORE, T> {
53 |         /// Creates a new state hook.
54 |         pub fn new(mutable_accessor: impl Fn(&mut STORE) -> &mut T + 'static) -> Self {
55 |             StateHook(Rc::new(mutable_accessor))
56 |         }
57 | 
58 |         /// Creates an effect using the wrapped accessor and a mutation function for the `T`.
59 |         pub fn to_effect(&self, f: impl Fn(&mut T) -> ShouldRender + 'static) -> Effect<STORE> {
60 |             let mutable_accessor = self.0.clone();
61 |             Effect::new(move |comp| {
62 |                 let t = (mutable_accessor)(comp);
63 |                 f(t)
64 |             })
65 |         }
66 |     }
67 | }


--------------------------------------------------------------------------------
/src/fetch.rs:
--------------------------------------------------------------------------------
  1 | //! Feature to enable fetching using web_sys-based fetch requests.
  2 | //!
  3 | //! This feature makes use of JSON for the request and response bodies.
  4 | //!
  5 | //! # Note
  6 | //! Because this makes use of futures, enabling this feature will require the use of a
  7 | //! web_sys compatible build environment and will prevent you from using `cargo web`.
  8 | 
  9 | 
 10 | use crate::NeqAssign; // requires "neq" feature.
 11 | 
 12 | mod action;
 13 | mod error;
 14 | mod state;
 15 | mod request;
 16 | 
 17 | pub use self::action::*;
 18 | pub use self::error::*;
 19 | pub use self::state::*;
 20 | pub use self::request::*;
 21 | use wasm_bindgen::__rt::core::marker::PhantomData;
 22 | use std::future::Future;
 23 | 
 24 | /// Indicates that a change was caused by a set function.
 25 | pub type DidChange = bool;
 26 | 
 27 | 
 28 | /// A fetch type that is useful for when you don't hold any request directly.
 29 | ///
 30 | /// This is useful for GET and DELETE requests where additional information needed to create the request object
 31 | /// can be provided by a closure.
 32 | pub type AcquireFetch<T> = Fetch<(), T>;
 33 | 
 34 | /// A fetch type that is useful for when the request type is the same as the response type.
 35 | ///
 36 | /// This makes sense to use when the request and response bodies are exactly the same.
 37 | /// Some PUT requests are amenable to this arrangement.
 38 | pub type ModifyFetch<T> = Fetch<T, T>;
 39 | 
 40 | 
 41 | #[derive(Clone, Debug, PartialEq, Default)]
 42 | pub struct Fetch<REQ, RES> {
 43 |     request: REQ,
 44 |     response: FetchState<RES>
 45 | }
 46 | 
 47 | 
 48 | impl <REQ: PartialEq, RES> Fetch<REQ, RES> {
 49 | 
 50 |     /// Sets the request without changing the variant.
 51 |     pub fn set_req(&mut self, request: REQ) -> DidChange {
 52 |         self.request.neq_assign(request)
 53 |     }
 54 | }
 55 | 
 56 | impl <REQ: Default, RES: PartialEq> Fetch<REQ, RES> {
 57 | 
 58 |     /// Sets the Fetch wrapper to indicate that a request was successfully fetched.
 59 |     pub fn set_fetched(&mut self, res: RES) -> DidChange {
 60 |         let will_change = match &self.response {
 61 |             FetchState::Fetched(old_res) => {
 62 |                 &res == old_res
 63 |             },
 64 |             _ => true
 65 |         };
 66 | 
 67 |         // TODO replace this with std::mem::take when it stabilizes.
 68 |         let old = std::mem::replace(&mut self.response, FetchState::default());
 69 |         let new = old.fetched(res);
 70 |         std::mem::replace(&mut self.response, new);
 71 | 
 72 |         will_change
 73 |     }
 74 | 
 75 |     /// Apply a FetchAction to alter the Fetch wrapper to perform a state change.
 76 |     pub fn apply(&mut self, action: FetchAction<RES>) -> DidChange {
 77 |         match action {
 78 |             FetchAction::NotFetching => self.set_not_fetching(),
 79 |             FetchAction::Fetching => self.set_fetching(),
 80 |             FetchAction::Success(res) => self.set_fetched(res),
 81 |             FetchAction::Failed(err) => self.set_failed(err),
 82 |         }
 83 |     }
 84 | }
 85 | 
 86 | impl <REQ, RES> Fetch<REQ, RES> {
 87 |     /// Creates a new Fetch wrapper around the request.
 88 |     ///
 89 |     /// It will default the response field to be put in a NotFetching state.
 90 |     pub fn new(request: REQ) -> Self {
 91 |         Self {
 92 |             request,
 93 |             response: Default::default()
 94 |         }
 95 |     }
 96 | 
 97 |     /// Sets the response field to indicate that no fetch request is in flight.
 98 |     pub fn set_not_fetching(&mut self) -> DidChange {
 99 |         let will_change = self.response.discriminant_differs(&FetchState::NotFetching(None));
100 | 
101 |         let old = std::mem::replace(&mut self.response, FetchState::default());
102 |         let new = old.not_fetching();
103 |         std::mem::replace(&mut self.response, new);
104 | 
105 |         will_change
106 |     }
107 | 
108 |     /// Sets the response field to indicate that a fetch request is currently being made.
109 |     pub fn set_fetching(&mut self) -> DidChange {
110 |         let will_change = self.response.discriminant_differs(&FetchState::Fetching(None));
111 | 
112 |         let old = std::mem::replace(&mut self.response, FetchState::default());
113 |         let new = old.fetching();
114 |         std::mem::replace(&mut self.response, new);
115 | 
116 |         will_change
117 |     }
118 | 
119 |     /// Sets the response field to indicate that a fetch request failed to complete.
120 |     pub fn set_failed(&mut self, err: FetchError) -> DidChange {
121 |         let will_change = match &self.response {
122 |             FetchState::Failed(_, old_err) => {
123 |                 &err == old_err
124 |             }
125 |             _ => true
126 |         };
127 | 
128 |         let old = std::mem::replace(&mut self.response, FetchState::default());
129 |         let new = old.failed(err);
130 |         std::mem::replace(&mut self.response, new);
131 | 
132 |         will_change
133 |     }
134 | 
135 | 
136 | 
137 |     // TODO need tests to make sure that this is ergonomic.
138 |     /// Makes an asynchronous fetch request, which will produce a message that makes use of a
139 |     /// `FetchAction` when it completes.
140 |     pub fn fetch_convert<T: FetchRequest, Msg>(
141 |         &self,
142 |         to_request: impl Fn(&Self) -> &T,
143 |         to_msg: impl Fn(FetchAction<T::ResponseBody>) -> Msg
144 |     ) -> impl Future<Output=Msg> {
145 |         let request: &T = to_request(self);
146 |         let request = create_request(request);
147 |         let req_type: PhantomData<T> = PhantomData;
148 |         async move {
149 |             let fetch_state = match fetch_resource(request, req_type).await {
150 |                 Ok(response) => FetchAction::Success(response),
151 |                 Err(err) => FetchAction::Failed(err)
152 |             };
153 | 
154 |             to_msg(fetch_state)
155 |         }
156 |     }
157 | 
158 |     /// Transforms the type of the response held by the fetch state (if any exists).
159 |     pub fn map<NewRes, F: Fn(Fetch<REQ, RES>) -> Fetch<REQ, NewRes> >(self, f:F) -> Fetch<REQ, NewRes> {
160 |         f(self)
161 |     }
162 | 
163 |     /// Unwraps the Fetch wrapper to produce the response it may contain.
164 |     ///
165 |     /// # Panics
166 |     /// If the Fetch wrapper doesn't contain an instance of a response, this function will panic.
167 |     pub fn unwrap(self) -> RES {
168 |         // TODO, actually provide some diagnostic here.
169 |         self.res().unwrap()
170 |     }
171 | 
172 |     /// Gets the response body (if present).
173 |     pub fn res(self) -> Option<RES> {
174 |         match self.response {
175 |             FetchState::NotFetching(res) => res,
176 |             FetchState::Fetching(res) => res,
177 |             FetchState::Fetched(res) => Some(res),
178 |             FetchState::Failed(res, _) => res,
179 |         }
180 |     }
181 | 
182 |     /// Gets the request body.
183 |     pub fn req(self) -> REQ {
184 |         self.request
185 |     }
186 | 
187 |     pub fn state(self) -> FetchState<RES> {
188 |         self.response
189 |     }
190 | 
191 |     /// Converts the wrapped values to references.
192 |     ///
193 |     /// # Note
194 |     /// This may be expensive if a Failed variant made into a reference, as the FetchError is cloned.
195 |     pub fn as_ref(&self) -> Fetch<&REQ, &RES> {
196 |         let response = match &self.response {
197 |             FetchState::NotFetching(res) => FetchState::NotFetching(res.as_ref()),
198 |             FetchState::Fetching(res) => FetchState::Fetching(res.as_ref()),
199 |             FetchState::Fetched(res) => FetchState::Fetched(res),
200 |             FetchState::Failed(res, err) => FetchState::Failed(res.as_ref(), err.clone()),
201 |         };
202 | 
203 |         Fetch {
204 |             request: &self.request,
205 |             response
206 |         }
207 |     }
208 | 
209 |     /// Converts the wrapped values to mutable references.
210 |     ///
211 |     /// # Note
212 |     /// This may be expensive if a Failed variant made into a reference, as the FetchError is cloned.
213 |     pub fn as_mut(&mut self) -> Fetch<&mut REQ, &mut RES> {
214 |         let response = match &mut self.response {
215 |             FetchState::NotFetching(res) => FetchState::NotFetching(res.as_mut()),
216 |             FetchState::Fetching(res) => FetchState::Fetching(res.as_mut()),
217 |             FetchState::Fetched(res) => FetchState::Fetched(res),
218 |             FetchState::Failed(res, err) => FetchState::Failed(res.as_mut(), err.clone()),
219 |         };
220 |         Fetch {
221 |             request: &mut self.request,
222 |             response
223 |         }
224 |     }
225 | }
226 | 
227 | impl <REQ: FetchRequest> Fetch<REQ, REQ::ResponseBody>{
228 | 
229 |     /// Makes an asynchronous fetch request, which will produce a message that makes use of a
230 |     /// `FetchAction` when it completes.
231 |     pub fn fetch<Msg>(
232 |         &self,
233 |         to_msg: impl Fn(FetchAction<REQ::ResponseBody>) -> Msg
234 |     )-> impl Future<Output=Msg> {
235 |         let request = self.as_ref().req();
236 |         let request = create_request(request);
237 |         let req_type: PhantomData<REQ> = PhantomData;
238 |         async move {
239 |             let fetch_state = match fetch_resource(request, req_type).await {
240 |                 Ok(response) => FetchAction::Success(response),
241 |                 Err(err) => FetchAction::Failed(err)
242 |             };
243 | 
244 |             to_msg(fetch_state)
245 |         }
246 |     }
247 | }
248 | 
249 | 
250 | #[cfg(test)]
251 | mod test {
252 |     use super::*;
253 |     use std::sync::Arc;
254 | 
255 |     #[test]
256 |     fn setting_fetching_state_doesnt_change_strong_count() {
257 |         // This is done to detect if a leak occurred.
258 |         let data: Arc<i32> = Arc::new(22);
259 |         let cloned_data: Arc<i32> = data.clone();
260 |         assert_eq!(Arc::strong_count(&data), 2);
261 |         let mut fs: Fetch<Arc<i32>, ()> = Fetch::new(cloned_data);
262 |         fs.set_fetching();
263 | 
264 |         assert_eq!(Arc::strong_count(&data), 2);
265 |         assert_eq!(FetchState::Fetching(None), fs.response)
266 |     }
267 | 
268 |     #[test]
269 |     fn setting_fetched_state() {
270 |         let mut fs = Fetch {
271 |             request: (),
272 |             response: FetchState::Fetching(None)
273 |         };
274 |         assert!(fs.set_fetched("SomeValue".to_string()));
275 |         assert_eq!(fs.response, FetchState::Fetched("SomeValue".to_string()));
276 |     }
277 | 
278 |     #[test]
279 |     fn setting_fetching_from_fetched() {
280 |         let mut fs = Fetch {
281 |             request: (),
282 |             response: FetchState::Fetched("Lorem".to_string())
283 |         };
284 |         assert!(fs.set_fetching());
285 |         assert_eq!(fs.response, FetchState::Fetching(Some("Lorem".to_string())));
286 |     }
287 | }
288 | 


--------------------------------------------------------------------------------
/src/fetch/action.rs:
--------------------------------------------------------------------------------
 1 | use crate::NeqAssign;
 2 | use crate::fetch::FetchError;
 3 | 
 4 | /// Represents a state change to Fetch wrapper.
 5 | #[derive(Clone, PartialEq, Debug)]
 6 | pub enum FetchAction<T> {
 7 |     NotFetching,
 8 |     Fetching,
 9 |     Success(T), // TODO rename to Fetched(T)
10 |     Failed(FetchError),
11 | }
12 | 
13 | impl <T> Default for FetchAction<T> {
14 |     fn default() -> Self {
15 |         FetchAction::NotFetching
16 |     }
17 | }
18 | 
19 | impl <T> FetchAction<T> {
20 |     /// Returns a reference to the Success case
21 |     pub fn success(&self) -> Option<&T> {
22 |         match self {
23 |             FetchAction::Success(value) => Some(value),
24 |             _ => None
25 |         }
26 |     }
27 | 
28 |     /// Gets the value out of the fetch state if it is a `Success` variant.
29 |     pub fn unwrap(self) -> T {
30 |         if let FetchAction::Success(value) = self {
31 |             value
32 |         } else {
33 |             panic!("Could not unwrap value of FetchState");
34 |         }
35 |     }
36 | 
37 |     /// Transforms the FetchState into another FetchState using the given function.
38 |     pub fn map<U, F: Fn(T)-> U>(self, f: F ) -> FetchAction<U> {
39 |         match self {
40 |             FetchAction::NotFetching => FetchAction::NotFetching,
41 |             FetchAction::Fetching => FetchAction::NotFetching,
42 |             FetchAction::Success(t) => FetchAction::Success(f(t)),
43 |             FetchAction::Failed(e) => FetchAction::Failed(e)
44 |         }
45 |     }
46 | 
47 |     /// Applies a function that mutates the response if the Action is the success case.
48 |     pub fn alter<F: Fn(&mut T)>(&mut self, f: F) {
49 |         match self {
50 |             FetchAction::Success(t) => f(t),
51 |             _ => {}
52 |         }
53 |     }
54 | 
55 |     /// Converts the FetchAction to contain a reference to the success case.
56 |     pub fn as_ref(&self) -> FetchAction<&T>  {
57 |         match self {
58 |             FetchAction::NotFetching => FetchAction::NotFetching,
59 |             FetchAction::Fetching => FetchAction::NotFetching,
60 |             FetchAction::Success(t) => FetchAction::Success(t),
61 |             FetchAction::Failed(e) => FetchAction::Failed(e.clone())
62 |         }
63 |     }
64 | }
65 | 
66 | impl <T: PartialEq> FetchAction<T> {
67 |     /// Sets the fetch state to be fetching.
68 |     /// If it wasn't already in a fetch state, it will return `true`,
69 |     /// to indicate that the component should re-render.
70 |     pub fn set_fetching(&mut self) -> bool {
71 |         self.neq_assign(FetchAction::Fetching)
72 |     }
73 | }


--------------------------------------------------------------------------------
/src/fetch/error.rs:
--------------------------------------------------------------------------------
 1 | use wasm_bindgen::JsValue;
 2 | 
 3 | /// A representation of an error that may occur when making a fetch request.
 4 | #[derive(Debug, PartialEq, Clone)]
 5 | pub enum FetchError {
 6 |     /// The response could not be deserialized.
 7 |     DeserializeError{error: String, content: String},
 8 |     /// The response had an error code.
 9 |     ResponseError{status_code: u16, response_body: String},
10 |     /// Text was not available on the response.
11 |     // TODO, this might get thrown in unexpected circumstances.
12 |     TextNotAvailable,
13 |     /// The Fetch Future could not be created due to a misconfiguration.
14 |     CouldNotCreateFetchFuture,
15 |     /// The request could cont be created due to a misconfiguration.
16 |     CouldNotCreateRequest(JsValue), // TODO, convert this to a string or more structured error - implement Hash on this and related structs.
17 |     /// Could not serialize the request body.
18 |     CouldNotSerializeRequestBody
19 | }
20 | 
21 | impl std::fmt::Display for FetchError {
22 |     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
23 |         match self {
24 |             FetchError::DeserializeError {error, content} => {
25 |                 f.write_str(&format!("Could not deserialize a successful request. With error: {}, and content: {}", error, content))
26 |             }
27 |             FetchError::ResponseError { status_code, response_body} => {
28 |                 f.write_str(&format!("The server returned a response with code: {}, and body: {}", status_code, response_body))
29 |             }
30 |             FetchError::TextNotAvailable => {
31 |                 f.write_str("The text could not be extracted from the response.")
32 |             }
33 |             FetchError::CouldNotCreateFetchFuture => {
34 |                 f.write_str("Could not create a fetch future.")
35 |             }
36 |             FetchError::CouldNotCreateRequest(_) => {
37 |                 f.write_str("Could not create a fetch request.")
38 |             }
39 |             FetchError::CouldNotSerializeRequestBody => {
40 |                 f.write_str("Could not serialize the body in the fetch request.")
41 |             }
42 |         }
43 |     }
44 | }
45 | 
46 | impl std::error::Error for FetchError {
47 | }


--------------------------------------------------------------------------------
/src/fetch/request.rs:
--------------------------------------------------------------------------------
  1 | use crate::fetch::{FetchError};
  2 | use wasm_bindgen::JsValue;
  3 | use serde::{Serialize};
  4 | use serde::de::DeserializeOwned;
  5 | use web_sys::{Request, RequestInit, RequestMode, Response, Window};
  6 | use wasm_bindgen::JsCast;
  7 | use wasm_bindgen_futures::JsFuture;
  8 | use std::marker::PhantomData;
  9 | 
 10 | /// An enum representing what method to use for the request,
 11 | /// as well as a body if the method is able to have a body.
 12 | ///
 13 | /// Connect, Options, Trace are omitted because they are unlikely to be used in this scenario.
 14 | /// Please open an issue if their absence is a problem for you.
 15 | pub enum MethodBody<'a, T> {
 16 |     Head,
 17 |     Get,
 18 |     Delete,
 19 |     Post(&'a T),
 20 |     Put(&'a T),
 21 |     Patch(&'a T),
 22 | }
 23 | 
 24 | impl <'a, T> MethodBody<'a, T> {
 25 |     pub fn as_method(&self) -> &'static str {
 26 |         match self {
 27 |             MethodBody::Get => "GET",
 28 |             MethodBody::Delete => "DELETE",
 29 |             MethodBody::Post(_) => "POST",
 30 |             MethodBody::Put(_) => "PUT",
 31 |             MethodBody::Patch(_) => "PATCH",
 32 |             MethodBody::Head => "HEAD",
 33 |         }
 34 |     }
 35 | }
 36 | 
 37 | impl <'a, T: Serialize> MethodBody<'a, T> {
 38 |     pub fn as_body<FORMAT: Format>(&self) -> Result<Option<JsValue>, FetchError> {
 39 |         let body: Option<String> = match self {
 40 |             MethodBody::Get
 41 |             | MethodBody::Delete
 42 |             | MethodBody::Head => None,
 43 |             MethodBody::Put(data)
 44 |             | MethodBody::Post(data)
 45 |             | MethodBody::Patch(data) => {
 46 |                 let body = FORMAT::serialize(data)
 47 |                     .ok_or_else(|| FetchError::CouldNotSerializeRequestBody)?;
 48 |                 Some(body)
 49 |             }
 50 |         };
 51 | 
 52 |         let body = body
 53 |             .map(|data| JsValue::from_str(data.as_str()));
 54 |         Ok(body)
 55 |     }
 56 | }
 57 | 
 58 | // TODO, this is only works with String/&str. It would be a good addition if  Vec<u8>/&[u8] were supported.
 59 | /// Determines what format the data will be transmitted in.
 60 | pub trait Format {
 61 |     fn serialize<T: Serialize>(t: &T) -> Option<String>;
 62 |     fn deserialize<T: DeserializeOwned>(s: &str) -> Option<T>;
 63 | }
 64 | 
 65 | /// Transport data using the JSON format
 66 | pub struct Json;
 67 | impl Format for Json {
 68 | //    type Transport = Text;
 69 | 
 70 |     fn serialize<T: Serialize>(t: &T) -> Option<String> {
 71 |         serde_json::to_string(t).ok()
 72 |     }
 73 | 
 74 |     fn deserialize<T: DeserializeOwned>(s: &str) -> Option<T> {
 75 |         serde_json::from_str(s).ok()
 76 |     }
 77 | }
 78 | 
 79 | 
 80 | /// Trait used to declare how a fetch request shall be made using a type.
 81 | ///
 82 | ///
 83 | /// Because it would be of little benefit to have to implement all details of this trait for every
 84 | /// request you make, the following should provide a template for reducing the amount of boilerplate
 85 | /// per request.
 86 | ///
 87 | /// # Simplifying Example
 88 | /// ```
 89 | /// use yewtil::fetch::{FetchRequest, MethodBody, Json, Fetch};
 90 | /// use serde::Serialize;
 91 | /// use serde::de::DeserializeOwned;
 92 | ///
 93 | /// pub trait MyFetchRequest {
 94 | ///     type RequestBody: Serialize;
 95 | ///     type ResponseBody: DeserializeOwned;
 96 | ///     fn path(&self) -> String;
 97 | ///     fn method(&self) -> MethodBody<Self::RequestBody>;
 98 | /// }
 99 | /// /// A wrapper to allow implementing a foreign trait generically for anything wrapped by it that meets
100 | /// /// the specified type bounds.
101 | /// /// This isn't ideal, and will not be required in the future after coherence rules are changed.
102 | /// /// https://github.com/rust-lang/rfcs/blob/master/text/2451-re-rebalancing-coherence.md
103 | /// pub struct LocalWrapper<T>(T);
104 | ///
105 | /// impl <T: MyFetchRequest> FetchRequest for LocalWrapper<T> {
106 | ///     type RequestBody = T::RequestBody;
107 | ///     type ResponseBody = T::ResponseBody;
108 | ///     type Format = Json; // Always serialize using json
109 | ///
110 | ///     fn url(&self) -> String {
111 | ///         // The origin will always be the same
112 | ///         format!("http://some_host_website.com/{}", self.0.path())
113 | ///     }
114 | ///
115 | ///     fn method(&self) -> MethodBody<Self::RequestBody> {
116 | ///         self.0.method()
117 | ///     }
118 | ///
119 | ///     fn headers(&self) -> Vec<(String, String)> {
120 | ///         // Always attach the same headers.
121 | ///         vec![
122 | ///             ("Content-Type".to_string(), "application/json".to_string())
123 | ///         ]
124 | ///     }
125 | /// }
126 | ///
127 | /// pub struct ApplesRequest;
128 | /// impl MyFetchRequest for ApplesRequest {
129 | ///     type RequestBody = (); type ResponseBody = ();
130 | ///     fn path(&self) -> String { "apples".to_string()}
131 | ///     fn method(&self) -> MethodBody<Self::RequestBody> {MethodBody::Get}
132 | /// }
133 | ///
134 | /// pub enum Msg {
135 | ///     Variant
136 | /// }
137 | ///
138 | /// let fetch_wrapper = Fetch::new(LocalWrapper(ApplesRequest));
139 | /// fetch_wrapper.fetch(|_| Msg::Variant); // Kicks off an async request.
140 | /// ```
141 | pub trait FetchRequest {
142 |     /// The Request Body (if any).
143 |     type RequestBody: Serialize;
144 |     /// The Response Body (if any).
145 |     type ResponseBody: DeserializeOwned;
146 | 
147 |     /// What format to use for serialization and deserialization.
148 |     ///
149 |     /// Ideally default to serde_json::Deserializer once
150 |     /// https://github.com/rust-lang/rust/issues/29661
151 |     type Format: Format;
152 | 
153 |     /// The URL of the resource to fetch.
154 |     fn url(&self) -> String;
155 | 
156 |     /// The HTTP method and body (if any) to be used in constructing the request.
157 |     fn method(&self) -> MethodBody<Self::RequestBody>;
158 | 
159 |     /// The headers to attach to the request .
160 |     fn headers(&self) -> Vec<(String, String)>;
161 | 
162 |     /// Use CORS for the request. By default, it will not.
163 |     fn use_cors(&self) -> bool {
164 |         false
165 |     }
166 | }
167 | 
168 | pub fn create_request<T: FetchRequest>(request: &T) -> Result<Request, FetchError> {
169 |     let method = request.method();
170 |     let headers = request.headers();
171 |     let headers = JsValue::from_serde(&headers).expect("Convert Headers to Tuple");
172 | 
173 |     // configure options for the request
174 |     let mut opts = RequestInit::new();
175 |     opts.method(method.as_method());
176 |     opts.body(method.as_body::<T::Format>()?.as_ref());
177 |     opts.headers(&headers);
178 | 
179 |     // TODO, see if there are more options that can be specified.
180 |     if request.use_cors() {
181 |         opts.mode(RequestMode::Cors);
182 |     }
183 | 
184 |     // Create the request
185 |     Request::new_with_str_and_init(
186 |         &request.url(),
187 |         &opts,
188 |     )
189 |         .map_err(|e| FetchError::CouldNotCreateRequest(e)) // TODO make this a Rust value instead.
190 | 
191 | }
192 | 
193 | /// Fetch a resource, returning a result of the expected response,
194 | /// or an error indicating what went wrong.
195 | pub async fn fetch_resource<T: FetchRequest>(request: Result<Request, FetchError>, _req_type: PhantomData<T>) -> Result<T::ResponseBody, FetchError> {
196 | 
197 |     let request = request?;
198 |     // Send the request, resolving it to a response.
199 |     let window: Window = web_sys::window().unwrap();
200 |     let resp_value = JsFuture::from(window.fetch_with_request(&request))
201 |         .await
202 |         .map_err(|_| FetchError::CouldNotCreateFetchFuture)?;
203 |     debug_assert!(resp_value.is_instance_of::<Response>());
204 |     let resp: Response = resp_value.dyn_into().unwrap();
205 | 
206 | 
207 |     // Process the response
208 |     let text = JsFuture::from(resp.text().map_err(|_| FetchError::TextNotAvailable)?)
209 |         .await
210 |         .map_err(|_| FetchError::TextNotAvailable)?;
211 | 
212 |     let text_string = text.as_string().unwrap();
213 | 
214 |     // If the response isn't ok, then return an error without trying to deserialize.
215 |     if !resp.ok() {
216 |         return Err(FetchError::ResponseError {status_code: resp.status(), response_body: text_string})
217 |     }
218 | 
219 | 
220 |     let deserialized = <T::Format>::deserialize(&text_string)
221 |         .ok_or_else(|| {
222 |             FetchError::DeserializeError{error: "".to_string(), content: text_string}
223 |         })?;
224 | 
225 |     Ok(deserialized)
226 | }
227 | 


--------------------------------------------------------------------------------
/src/fetch/state.rs:
--------------------------------------------------------------------------------
 1 | use crate::fetch::FetchError;
 2 | 
 3 | /// Holds the state of the request being made and response
 4 | /// (if any has been made successfully at any prior point).
 5 | #[derive(Clone, Debug, PartialEq)]
 6 | pub enum FetchState<RES> {
 7 |     NotFetching(Option<RES>),
 8 |     Fetching(Option<RES>),
 9 |     Fetched(RES),
10 |     Failed(Option<RES>, FetchError)
11 | }
12 | 
13 | impl <RES> Default for FetchState<RES> {
14 |     fn default() -> Self {
15 |         FetchState::NotFetching(None)
16 |     }
17 | }
18 | 
19 | impl <RES> FetchState<RES> {
20 | 
21 |     /// Determines if there is a different discriminant between the fetch states.
22 |     pub(crate) fn discriminant_differs(&self, other: &Self) -> bool {
23 |         std::mem::discriminant(self) != std::mem::discriminant(other)
24 |     }
25 | 
26 |     pub(crate) fn not_fetching(self) -> Self {
27 |         match self {
28 |             FetchState::NotFetching(res) => {
29 |                 FetchState::NotFetching( res)
30 |             }
31 |             FetchState::Fetching(res) => {
32 |                 FetchState::NotFetching( res)
33 |             }
34 |             FetchState::Fetched(res) => {
35 |                 FetchState::NotFetching( Some(res))
36 |             }
37 |             FetchState::Failed(res, _err) => {
38 |                 FetchState::NotFetching( res)
39 |             }
40 |         }
41 |     }
42 | 
43 |     pub(crate) fn fetching(self) -> Self {
44 |         match self {
45 |             FetchState::NotFetching(res) => {
46 |                 FetchState::Fetching(res)
47 |             }
48 |             FetchState::Fetching(res) => {
49 |                 FetchState::Fetching(res)
50 |             }
51 |             FetchState::Fetched(res) => {
52 |                 FetchState::Fetching(Some(res))
53 |             }
54 |             FetchState::Failed(res, _err) => {
55 |                 FetchState::Fetching(res)
56 |             }
57 |         }
58 |     }
59 | 
60 |     pub(crate) fn fetched(self, res: RES) -> Self {
61 |         match self {
62 |             FetchState::NotFetching(_res) => {
63 |                 FetchState::Fetched(res)
64 |             }
65 |             FetchState::Fetching(_res) => {
66 |                 FetchState::Fetched(res)
67 |             }
68 |             FetchState::Fetched(_res) => {
69 |                 FetchState::Fetched(res)
70 |             }
71 |             FetchState::Failed(_res, _err) => {
72 |                 FetchState::Fetched(res)
73 |             }
74 |         }
75 |     }
76 | 
77 |     pub(crate) fn failed(self, err: FetchError) -> Self {
78 |         match self {
79 |             FetchState::NotFetching(res) => {
80 |                 FetchState::Failed(res, err)
81 |             }
82 |             FetchState::Fetching(res) => {
83 |                 FetchState::Failed(res, err)
84 |             }
85 |             FetchState::Fetched(res) => {
86 |                 FetchState::Failed(Some(res), err)
87 |             }
88 |             FetchState::Failed(res, _err) => {
89 |                 FetchState::Failed(res, err)
90 |             }
91 |         }
92 |     }
93 | }


--------------------------------------------------------------------------------
/src/future.rs:
--------------------------------------------------------------------------------
 1 | use std::future::Future;
 2 | use yew::{ComponentLink, Component, agent::{AgentLink, Agent}};
 3 | use stdweb::spawn_local;
 4 | 
 5 | 
 6 | /// Trait that allows you to use `ComponentLink` and `AgentLink` to register futures.
 7 | pub trait LinkFuture {
 8 |     type Message;
 9 |     /// This method processes a Future that returns a message and sends it back to the component's
10 |     /// loop.
11 |     ///
12 |     /// # Panics
13 |     /// If the future panics, then the promise will not resolve, and will leak.
14 |     fn send_future<F>(&self, future: F) where F: Future<Output = Self::Message> + 'static;
15 | 
16 |     /// Registers a future that resolves to multiple messages.
17 |     /// # Panics
18 |     /// If the future panics, then the promise will not resolve, and will leak.
19 |     fn send_future_batch<F>(&self, future: F) where F: Future<Output=Vec<Self::Message>> + 'static;
20 | }
21 | 
22 | impl <COMP: Component> LinkFuture for ComponentLink<COMP> {
23 |     type Message = COMP::Message;
24 | 
25 |     fn send_future<F>(&self, future: F) where F: Future<Output=Self::Message> + 'static {
26 |         let mut link: ComponentLink<COMP>  = self.clone();
27 |         let js_future = async move{
28 |             let message: COMP::Message = future.await;
29 |             link.send_message(message);
30 |         };
31 |         spawn_local(js_future);
32 | 
33 |     }
34 | 
35 |     fn send_future_batch<F>(&self, future: F) where F: Future<Output=Vec<Self::Message>> + 'static {
36 |         let mut link: ComponentLink<COMP> = self.clone();
37 |         let js_future = async move {
38 |             let messages: Vec<COMP::Message> = future.await;
39 |             link.send_message_batch(messages);
40 |         };
41 |         spawn_local(js_future);
42 |     }
43 | }
44 | 
45 | impl <AGN: Agent> LinkFuture for AgentLink<AGN> {
46 |     type Message = AGN::Message;
47 | 
48 |     fn send_future<F>(&self, future: F) where F: Future<Output=Self::Message> + 'static {
49 |         let link: AgentLink<AGN>  = self.clone();
50 |         let js_future = async move{
51 |             let message: AGN::Message = future.await;
52 |             let cb = link.callback(|m: AGN::Message| m);
53 |             cb.emit(message);
54 |         };
55 |         spawn_local(js_future);
56 |     }
57 | 
58 |     fn send_future_batch<F>(&self, _future: F) where F: Future<Output=Vec<Self::Message>> + 'static {
59 |         unimplemented!("Agents don't support batching their messages.")
60 |     }
61 | }
62 | 


--------------------------------------------------------------------------------
/src/history.rs:
--------------------------------------------------------------------------------
  1 | use std::collections::VecDeque;
  2 | use std::ops::Deref;
  3 | 
  4 | // TODO when const generics lands, it would be useful to add a usize type parameter over the max number of elements.
  5 | 
  6 | // It would also be interesting to see if a diffing history implementation could be built over types
  7 | // that can represent themselves as diffs - where reversible transitions can be recorded instead of values
  8 | // and the transitions can be rolled back.
  9 | // That would probably have worse performance in exchange for smaller size.
 10 | 
 11 | /// Wrapper that keeps track of prior values that have been assigned to it.
 12 | ///
 13 | /// It keeps values that have been `set` for it around for the duration of its lifetime,
 14 | /// or until they are dropped by calling `reset` or `forget`.
 15 | ///
 16 | /// Prior values can be iterated over as well.
 17 | pub struct History<T>(VecDeque<T>);
 18 | 
 19 | impl<T> History<T> {
 20 |     /// Creates a new history wrapper.
 21 |     pub fn new(value: T) -> Self {
 22 |         let mut vec = VecDeque::new();
 23 |         vec.push_front(value);
 24 |         Self(vec)
 25 |     }
 26 | 
 27 |     /// Set the value represented by the `History` struct.
 28 |     ///
 29 |     /// This pushes the new value into the front of a list,
 30 |     /// where the front-most value represents the most recent value.
 31 |     ///
 32 |     /// # Example
 33 |     /// ```
 34 |     ///# use yewtil::History;
 35 |     /// let mut history = History::new(0);
 36 |     /// history.set(1);
 37 |     ///
 38 |     /// assert_eq!(*history, 1);
 39 |     /// assert_eq!(history.count(), 2);
 40 |     /// ```
 41 |     pub fn set(&mut self, value: T) {
 42 |         self.0.push_front(value)
 43 |     }
 44 | 
 45 |     /// Replaces the current value without creating a history entry.
 46 |     ///
 47 |     /// # Example
 48 |     /// ```
 49 |     ///# use yewtil::History;
 50 |     /// let mut history = History::new(0);
 51 |     /// history.replace(1);
 52 |     ///
 53 |     /// assert_eq!(*history, 1);
 54 |     /// assert_eq!(history.count(), 1);
 55 |     /// ```
 56 |     pub fn replace(&mut self, value: T) {
 57 |         self.0[0] = value;
 58 |     }
 59 | 
 60 |     /// Removes all prior values.
 61 |     ///
 62 |     /// This effectively sets a new "checkpoint" that can be restored by calling `reset`.
 63 |     ///
 64 |     /// The returned bool indicates if any entries were removed.
 65 |     ///
 66 |     /// # Example
 67 |     /// ```
 68 |     ///# use yewtil::History;
 69 |     /// let mut history = History::new(0);
 70 |     /// history.set(1);
 71 |     /// history.set(2);
 72 |     ///
 73 |     /// history.forget();
 74 |     /// assert_eq!(*history, 2);
 75 |     /// assert_eq!(history.count(), 1);
 76 |     /// ```
 77 |     pub fn forget(&mut self) -> bool {
 78 |         if self.dirty() {
 79 |             self.0.drain(1..);
 80 |             true
 81 |         } else {
 82 |             false
 83 |         }
 84 |     }
 85 | 
 86 |     /// Remove all elements except the last one, making the oldest entry the "current value".
 87 |     ///
 88 |     /// The returned bool indicates if any entries were removed.
 89 |     ///
 90 |     /// # Example
 91 |     /// ```
 92 |     ///# use yewtil::History;
 93 |     /// let mut history = History::new(0);
 94 |     /// history.set(1);
 95 |     /// history.set(2);
 96 |     ///
 97 |     /// history.reset();
 98 |     /// assert_eq!(*history, 0);
 99 |     /// assert_eq!(history.count(), 1);
100 |     /// ```
101 |     pub fn reset(&mut self) -> bool {
102 |         if self.dirty() {
103 |             self.0.drain(..self.0.len() - 1);
104 |             true
105 |         } else {
106 |             false
107 |         }
108 |     }
109 | 
110 |     /// Returns true if there is more than one entry in the history.
111 |     ///
112 |     /// # Example
113 |     /// ```
114 |     ///# use yewtil::History;
115 |     /// let mut history = History::new(0);
116 |     /// history.set(1);
117 |     /// assert!(history.dirty());
118 |     /// ```
119 |     pub fn dirty(&mut self) -> bool {
120 |         self.count() > 1
121 |     }
122 | 
123 |     /// Returns the number of entries in the history.
124 |     ///
125 |     /// This will never be less than 1, as the first entry of the backing VecDeque is always occupied by the
126 |     /// "current value" in the `History` struct.
127 |     ///
128 |     /// # Example
129 |     /// ```
130 |     ///# use yewtil::History;
131 |     /// let mut history = History::new(0);
132 |     /// assert_eq!(history.count(), 1);
133 |     ///
134 |     /// history.set(1);
135 |     /// assert_eq!(history.count(), 2);
136 |     /// ```
137 |     pub fn count(&self) -> usize {
138 |         self.0.len()
139 |     }
140 | 
141 |     /// Produces an iterator over references to history items ordered from newest to oldest.
142 |     pub fn iter(&self) -> std::collections::vec_deque::Iter<T> {
143 |         self.0.iter()
144 |     }
145 | 
146 |     /// Gets the current value.
147 |     pub fn into_inner(mut self) -> T {
148 |         self.0
149 |             .pop_front()
150 |             .expect("History should have at least one item")
151 |     }
152 | }
153 | 
154 | impl<T: PartialEq> History<T> {
155 |     /// Will only `set` the value if the provided value is different than the current value.
156 |     ///
157 |     /// It returns true to indicate if the history's current value was updated to be the provided value.
158 |     /// # Example
159 |     /// ```
160 |     ///# use yewtil::History;
161 |     /// let mut history = History::new(0);
162 |     /// let did_set = history.neq_set(0);
163 |     /// assert!(!did_set);
164 |     ///
165 |     /// let did_set = history.neq_set(1);
166 |     /// assert!(did_set);
167 |     /// ```
168 |     pub fn neq_set(&mut self, value: T) -> bool {
169 |         if self.0[0] != value {
170 |             self.set(value);
171 |             true
172 |         } else {
173 |             false
174 |         }
175 |     }
176 | }
177 | 
178 | impl<T> IntoIterator for History<T> {
179 |     type Item = T;
180 |     type IntoIter = std::collections::vec_deque::IntoIter<T>;
181 | 
182 |     fn into_iter(self) -> Self::IntoIter {
183 |         self.0.into_iter()
184 |     }
185 | }
186 | 
187 | impl<T> AsRef<T> for History<T> {
188 |     fn as_ref(&self) -> &T {
189 |         // Get the first element
190 |         &self.0[0]
191 |     }
192 | }
193 | 
194 | impl<T> Deref for History<T> {
195 |     type Target = T;
196 | 
197 |     fn deref(&self) -> &Self::Target {
198 |         self.as_ref()
199 |     }
200 | }
201 | 


--------------------------------------------------------------------------------
/src/lib.rs:
--------------------------------------------------------------------------------
 1 | //! Utility library for the Yew frontend web framework.
 2 | //!
 3 | //! All features:
 4 | //!
 5 | //! * "neq" - NeqAssign trait
 6 | //! * "pure" - Pure components and function components.
 7 | //! * "future" - Async support for Yew Messages
 8 | //! * "fetch" - Wrapper that holds requests and responses.
 9 | //! * "mrc_irc" - Ergonomic Rc pointers.
10 | //! * "lrc" - Linked-list Rc pointer.
11 | //! * "history" - History tracker
12 | // //! * "dsl" - Use functions instead of Yew's `html!` macro.
13 | 
14 | //#[cfg(feature = "dsl")]
15 | //pub mod dsl;
16 | 
17 | #[cfg(feature = "neq")]
18 | mod not_equal_assign;
19 | 
20 | #[cfg(feature = "pure")]
21 | mod pure;
22 | 
23 | #[cfg(any(feature = "mrc_irc", feature = "lrc"))]
24 | pub mod ptr;
25 | 
26 | #[cfg(feature = "history")]
27 | mod history;
28 | 
29 | #[cfg(feature = "history")]
30 | pub use history::History;
31 | 
32 | #[cfg(feature = "neq")]
33 | pub use not_equal_assign::NeqAssign;
34 | 
35 | #[cfg(feature = "pure")]
36 | pub use pure::{Pure, PureComponent};
37 | 
38 | 
39 | #[cfg(feature = "pure")]
40 | pub use yewtil_macro::function_component;
41 | 
42 | #[cfg(feature = "fetch")]
43 | pub mod fetch;
44 | 
45 | #[cfg(feature = "effect")]
46 | mod effect;
47 | #[cfg(feature = "effect")]
48 | pub use effect::{Effect, effect};
49 | 
50 | #[cfg(feature = "future")]
51 | pub mod future;
52 | 
53 | 


--------------------------------------------------------------------------------
/src/not_equal_assign.rs:
--------------------------------------------------------------------------------
 1 | //! Module for `neq_assign` utility function.
 2 | 
 3 | use std::borrow::BorrowMut;
 4 | use yew::html::ShouldRender;
 5 | 
 6 | /// Blanket trait to provide a convenience method for assigning props in `changed` or updating values in `update`.
 7 | pub trait NeqAssign<NEW> {
 8 |     /// If `self` and `new` aren't equal, assigns `new` to `self` and returns true, otherwise returns false.
 9 |     ///
10 |     /// Short for "Not equal assign".
11 |     ///
12 |     /// # Example
13 |     /// ```
14 |     /// # use yew::{Component, ShouldRender, ComponentLink};
15 |     /// # use yewtil::NeqAssign;
16 |     /// # use yew::Properties;
17 |     ///# use yew::virtual_dom::VNode;
18 |     /// ##[derive(Properties, PartialEq)]
19 |     ///  struct Props {
20 |     ///     field1: String,
21 |     ///     field2: usize
22 |     ///  }
23 |     ///  struct Model {
24 |     ///     props: Props
25 |     ///  }
26 |     ///  impl Component for Model {
27 |     /// #    type Message = ();
28 |     ///     type Properties = Props;
29 |     ///     // ...
30 |     /// #
31 |     /// #    fn create(props: Self::Properties, link: ComponentLink<Self>) -> Self {
32 |     /// #        unimplemented!()
33 |     /// #    }
34 |     /// #    fn update(&mut self, msg: ()) -> ShouldRender {
35 |     /// #        unimplemented!()
36 |     /// #    }
37 |     /// #
38 |     ///     fn change(&mut self, props: Self::Properties) -> ShouldRender{
39 |     ///         self.props.neq_assign(props)
40 |     ///     }
41 |     ///#
42 |     ///#     fn view(&self) -> VNode {
43 |     ///#         unimplemented!()
44 |     ///#     }
45 |     ///  }
46 |     /// ```
47 |     fn neq_assign(&mut self, new: NEW) -> ShouldRender;
48 | }
49 | 
50 | impl<T: BorrowMut<U>, U: PartialEq> NeqAssign<U> for T {
51 |     fn neq_assign(&mut self, new: U) -> bool {
52 |         if self.borrow() != &new {
53 |             *self.borrow_mut() = new;
54 |             true
55 |         } else {
56 |             false
57 |         }
58 |     }
59 | }
60 | 


--------------------------------------------------------------------------------
/src/ptr/irc.rs:
--------------------------------------------------------------------------------
  1 | use crate::ptr::rc_box::{
  2 |     clone_impl, clone_inner, decrement_and_possibly_deallocate, get_count, get_ref_boxed_content,
  3 |     is_exclusive, try_unwrap, unwrap_clone, RcBox,
  4 | };
  5 | use std::borrow::Borrow;
  6 | use std::cmp::Ordering;
  7 | use std::fmt;
  8 | use std::hash::{Hash, Hasher};
  9 | use std::ops::Deref;
 10 | use std::ptr::NonNull;
 11 | 
 12 | /// Immutable Reference Counted pointer.
 13 | ///
 14 | /// The `Irc` points to a value that cannot be mutated.
 15 | /// If a `Mrc` and `Irc` point to the same value, mutating the value via the `Mrc` will
 16 | /// clone and allocate, _then_ mutate the value, leaving the value pointed to by the `Irc` alone.
 17 | ///
 18 | /// Unless the `Irc` is unwrapped, that value is mutated, and another `Irc` is created using that value
 19 | /// the `Irc` will guarantee that the value is not changed, and can be transparently passed to child components
 20 | /// with knowledge that its value matches that of an original `Mrc` or `Irc` that it was cloned from.
 21 | ///
 22 | /// This makes `Irc`s ideal for passing around immutable views to data through components in Yew, as
 23 | /// cloning the `Irc` itself is cheap, and the `Irc` guarantees that its data cannot be changed by
 24 | /// some intermediate component without obvious unwrap --> modify --> rewrap operations.
 25 | pub struct Irc<T> {
 26 |     /// Pointer to the value and reference counter.
 27 |     pub(crate) ptr: NonNull<RcBox<T>>,
 28 | }
 29 | 
 30 | impl<T> Irc<T> {
 31 |     /// Allocates the value behind an `Irc` pointer.
 32 |     pub fn new(value: T) -> Self {
 33 |         let rc_box = RcBox::new(value);
 34 |         let ptr = rc_box.into_non_null();
 35 |         Self { ptr }
 36 |     }
 37 | 
 38 |     /// Tries to extract the value from the `Irc`, returning the `Irc` if there is one or
 39 |     /// more other smart pointers to the value.
 40 |     ///
 41 |     /// # Example
 42 |     /// ```
 43 |     /// use yewtil::ptr::Irc;
 44 |     /// let irc = Irc::new(0);
 45 |     ///
 46 |     /// let clone = irc.clone();
 47 |     /// let irc = irc.try_unwrap().expect_err("Should not be able to unwrap");
 48 |     ///
 49 |     /// std::mem::drop(clone);
 50 |     /// let value = irc.try_unwrap().expect("Should get value");
 51 |     /// ```
 52 |     pub fn try_unwrap(self) -> Result<T, Self> {
 53 |         try_unwrap(self.ptr).map_err(|ptr| {
 54 |             Self { ptr } // Recover the ptr
 55 |         })
 56 |     }
 57 | 
 58 |     /// Gets the reference count of the `Irc`.
 59 |     ///
 60 |     /// An exclusive `Irc` will have a count of `1`.
 61 |     /// The count is incremented on any cloning action and is decremented when `drop` is called.
 62 |     ///
 63 |     /// # Example
 64 |     /// ```
 65 |     /// use yewtil::ptr::Irc;
 66 |     /// let irc = Irc::new(0);
 67 |     /// assert_eq!(irc.get_count(), 1);
 68 |     ///
 69 |     /// let _clone = irc.clone();
 70 |     /// assert_eq!(irc.get_count(), 2);
 71 |     ///
 72 |     /// std::mem::drop(_clone);
 73 |     /// assert_eq!(irc.get_count(), 1);
 74 |     /// ```
 75 |     pub fn get_count(&self) -> usize {
 76 |         get_count(self.ptr)
 77 |     }
 78 | 
 79 |     //
 80 |     /// ```
 81 |     /// use yewtil::ptr::Irc;
 82 |     /// let irc = Irc::new(0);
 83 |     /// assert!(irc.is_exclusive());
 84 |     ///
 85 |     /// let _clone = irc.clone();
 86 |     /// assert!(!irc.is_exclusive());
 87 |     ///
 88 |     /// std::mem::drop(_clone);
 89 |     /// assert!(irc.is_exclusive());
 90 |     /// ```
 91 |     pub fn is_exclusive(&self) -> bool {
 92 |         is_exclusive(self.ptr)
 93 |     }
 94 | }
 95 | 
 96 | impl<T: Clone> Irc<T> {
 97 |     /// Unwraps the value from the `Irc`, cloning the value instead if another `Irc` or `Mrc` points
 98 |     /// to the same value.
 99 |     pub fn unwrap_clone(self) -> T {
100 |         unwrap_clone(self.ptr)
101 |     }
102 |     /// Clones the wrapped value of the `Irc`.
103 |     pub fn clone_inner(&self) -> T {
104 |         clone_inner(self.ptr)
105 |     }
106 | }
107 | 
108 | impl<T> Drop for Irc<T> {
109 |     fn drop(&mut self) {
110 |         unsafe { decrement_and_possibly_deallocate(self.ptr) }
111 |     }
112 | }
113 | 
114 | impl <T: Default> Default for Irc<T> {
115 |     fn default() -> Self {
116 |         Irc::new(T::default())
117 |     }
118 | }
119 | 
120 | impl<T> Clone for Irc<T> {
121 |     fn clone(&self) -> Self {
122 |         Self {
123 |             ptr: clone_impl(self.ptr),
124 |         }
125 |     }
126 | }
127 | 
128 | impl<T> AsRef<T> for Irc<T> {
129 |     fn as_ref(&self) -> &T {
130 |         get_ref_boxed_content(&self.ptr).value.as_ref()
131 |     }
132 | }
133 | 
134 | impl<T> Deref for Irc<T> {
135 |     type Target = T;
136 | 
137 |     fn deref(&self) -> &Self::Target {
138 |         self.as_ref()
139 |     }
140 | }
141 | 
142 | impl<T> Borrow<T> for Irc<T> {
143 |     fn borrow(&self) -> &T {
144 |         self.as_ref()
145 |     }
146 | }
147 | 
148 | impl<T: PartialEq> PartialEq for Irc<T> {
149 |     fn eq(&self, other: &Self) -> bool {
150 |         self.as_ref().eq(other.as_ref())
151 |     }
152 | }
153 | 
154 | impl<T: Eq> Eq for Irc<T> {}
155 | 
156 | impl<T: PartialOrd> PartialOrd for Irc<T> {
157 |     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
158 |         self.as_ref().partial_cmp(other.as_ref())
159 |     }
160 | }
161 | 
162 | impl<T: Ord> Ord for Irc<T> {
163 |     fn cmp(&self, other: &Self) -> Ordering {
164 |         self.as_ref().cmp(other.as_ref())
165 |     }
166 | }
167 | 
168 | impl<T: Hash> Hash for Irc<T> {
169 |     fn hash<H: Hasher>(&self, state: &mut H) {
170 |         self.as_ref().hash(state)
171 |     }
172 | }
173 | 
174 | impl<T: fmt::Debug> fmt::Debug for Irc<T> {
175 |     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
176 |         let rc_box = get_ref_boxed_content(&self.ptr);
177 |         f.debug_struct("Irc")
178 |             .field("value", rc_box.value.as_ref())
179 |             .field("count", &rc_box.get_count())
180 |             .finish()
181 |     }
182 | }
183 | 
184 | #[cfg(test)]
185 | mod test {
186 |     use super::*;
187 | 
188 |     #[test]
189 |     fn create_new() {
190 |         let _irc = Irc::new(0);
191 |     }
192 | }
193 | 


--------------------------------------------------------------------------------
/src/ptr/lrc.rs:
--------------------------------------------------------------------------------
   1 | //! A Reference Counted Pointer optimized for use with Yew.
   2 | 
   3 | use std::borrow::Borrow;
   4 | use std::cell::Cell;
   5 | use std::cmp::Ordering;
   6 | use std::fmt;
   7 | use std::hash::{Hash, Hasher};
   8 | use std::ops::Deref;
   9 | use std::ptr::NonNull;
  10 | 
  11 | use crate::ptr::takeable::Takeable;
  12 | 
  13 | type IsZero = bool;
  14 | 
  15 | // TODO consider renaming prev and next to new and old respectively.
  16 | #[derive(PartialEq, Debug)]
  17 | struct Node<T> {
  18 |     /// Ptr to previous node
  19 |     prev: Option<NonNull<Node<T>>>,
  20 |     /// The value at this node
  21 |     value: Takeable<T>,
  22 |     /// The reference count.
  23 |     /// **It keeps track of how many LRCs have this node as their heads**
  24 |     count: Cell<usize>,
  25 |     /// Ptr to next node.
  26 |     next: Option<NonNull<Node<T>>>,
  27 | }
  28 | 
  29 | impl<T> Node<T> {
  30 |     /// Creates a new node
  31 |     fn new(value: T) -> Self {
  32 |         Node {
  33 |             prev: None,
  34 |             value: Takeable::new(value),
  35 |             count: Cell::new(1),
  36 |             next: None,
  37 |         }
  38 |     }
  39 | 
  40 |     /// Puts the node behind a non-null pointer.
  41 |     fn into_not_null(self) -> NonNull<Self> {
  42 |         unsafe { NonNull::new_unchecked(Box::into_raw(Box::new(self))) }
  43 |     }
  44 | 
  45 |     /// Gets the reference count of the node
  46 |     fn get_count(&self) -> usize {
  47 |         self.count.get()
  48 |     }
  49 | 
  50 |     /// Increments the reference count of the node.
  51 |     fn inc_count(&self) {
  52 |         let mut count = self.count.get();
  53 |         count += 1;
  54 |         self.count.set(count);
  55 |     }
  56 | 
  57 |     /// Decrements the reference count of the node.
  58 |     /// It will return true if the count hits zero.
  59 |     /// This can be used to determine if the node should be deallocated.
  60 |     fn dec_count(&self) -> IsZero {
  61 |         let mut count = self.count.get();
  62 |         count -= 1;
  63 |         self.count.set(count);
  64 |         count == 0
  65 |     }
  66 | }
  67 | 
  68 | /// Decrement the ref count of a node, and deallocate the node if the ref-count reaches 0.
  69 | ///
  70 | /// Deallocating involves attaching the node's prev's next to the node's next ptr,
  71 | /// and attaching the node's next's prev to the node's prev ptr.
  72 | /// This connects the nodes surrounding the provided node with each other.
  73 | unsafe fn decrement_and_possibly_deallocate<T>(node: NonNull<Node<T>>) {
  74 |     // If the heads ref-count is 0
  75 |     if node.as_ref().dec_count() {
  76 |         // Attach surrounding nodes to each other as this one is removed.
  77 |         if let Some(prev) = (*node.as_ptr()).prev.as_mut() {
  78 |             prev.as_mut().next = (*node.as_ptr()).next.take();
  79 |         }
  80 | 
  81 |         if let Some(next) = (*node.as_ptr()).next.as_mut() {
  82 |             next.as_mut().prev = (*node.as_ptr()).prev.take();
  83 |         }
  84 | 
  85 |         std::ptr::drop_in_place(node.as_ptr());
  86 |     }
  87 | }
  88 | 
  89 | // TODO: missing methods
  90 | //
  91 | // These linking operations could possibly create cycles. - I'm not sure if they should be exposed - or if they are, tagged with unsafe.
  92 | // possibly have safe variants that check for ptr_equality along every node, but that makes linking a O(n^2) operation, which is so bad that you would almost never want to use it.
  93 | // link_next - Join another Lrc as a next node. Both nodes must be terminating on the respective ends that are being linked.
  94 | // link_prev - Join another Lrc as a prev node. Both nodes must be terminating on the respective ends that are being linked.
  95 | //
  96 | // unlink_next, unlink_prev - Unlinks the lrc from other linked lrcs.
  97 | // into_raw - same as RC
  98 | // from_raw - same as RC
  99 | 
 100 | /// Linked List Reference Counted Pointer
 101 | ///
 102 | /// A doubly linked list where the head node is used to represent the value contained by the pointer.
 103 | /// The remaining nodes represent shared pointers whose values have changed.
 104 | /// A `Lrc` pointer can swap its head node to point to the head node of another `Lrc` that it
 105 | /// is linked to.
 106 | ///
 107 | /// The `Lrc` allows cheap cloning like an `Rc` pointer.
 108 | /// Like `Rc`, `Lrc` will need to allocate a new copy when mutating an instance that has been shared.
 109 | /// Unlike `Rc`, the newly allocated node will also have a pointer to the old node because another `Lrc` still exists that
 110 | /// has that node as its head.
 111 | /// Either `Lrc` is free to walk its head along this linked list, allowing it to update itself
 112 | /// to newer or older still-live nodes.
 113 | ///
 114 | /// # Comparison
 115 | ///
 116 | /// |        | Clone copies the | Reference Counted | Mutation                                         | Data of Cloned Smart Pointers |
 117 | /// |--------|------------------|-------------------|--------------------------------------------------|-------------------------------|
 118 | /// | `Lrc`  | Pointer          | Yes               | Allocate a linked copy of data, or edit in place | Can differ                    |
 119 | /// | `Rc`   | Pointer          | Yes               | Allocate a copy of data, or edit in place        | Always identical              |
 120 | /// | `Box`  | Data             | No                | Edit in place                                    | Can differ                    |
 121 | ///
 122 | /// `Lrc` functions similarly to `Rc`, but has a small size and performance overhead due to dealing with
 123 | /// forward and back pointers, in addition to the reference counters they both have.
 124 | /// `Lrc` should be slightly easier to use than `Rc` for `Yew` related tasks,
 125 | /// and also gains the ability to perform "action at a distance" operations with `update`,
 126 | /// `advance_next`, and `advance_prev`.
 127 | ///
 128 | /// # Terminology
 129 | /// * `Lrc` - Linked \[List\] Reference Counted Pointer.
 130 | /// * Node - A link that holds data, a reference counter, and prev and next pointers to other nodes.
 131 | /// * Head - The node held by a `Lrc`. The head holds the value that represents the `Lrc`,
 132 | /// even though the `Lrc`'s connected nodes may contain many other values.
 133 | ///
 134 | /// # Example
 135 | /// ```
 136 | /// use yewtil::ptr::Lrc;
 137 | /// let mut lrc = Lrc::new("Some String".to_string());
 138 | ///
 139 | /// let mut clone = lrc.clone();
 140 | ///
 141 | /// assert!(Lrc::ptr_eq(&lrc, &clone));
 142 | /// assert_eq!(lrc.get_count(), 2);
 143 | /// assert_eq!(lrc.len(), 1);
 144 | ///
 145 | /// lrc.set("Some new String".to_string());
 146 | ///
 147 | /// assert_eq!(lrc.as_ref(), "Some new String");
 148 | /// assert_eq!(clone.as_ref(), "Some String");
 149 | /// assert!(!Lrc::ptr_eq(&lrc, &clone));
 150 | /// assert_eq!(lrc.get_count(), 1);
 151 | /// assert_eq!(lrc.len(), 2);
 152 | ///
 153 | /// clone.update();
 154 | ///
 155 | /// assert_eq!(lrc.as_ref(), "Some new String");
 156 | /// assert_eq!(clone.as_ref(), "Some new String");
 157 | /// assert!(Lrc::ptr_eq(&lrc, &clone));
 158 | /// assert_eq!(lrc.get_count(), 2);
 159 | /// assert_eq!(lrc.len(), 1);
 160 | ///
 161 | /// std::mem::drop(clone);
 162 | ///
 163 | /// assert_eq!(lrc.get_count(), 1);
 164 | /// assert_eq!(lrc.len(), 1);
 165 | /// ```
 166 | pub struct Lrc<T> {
 167 |     head: Option<NonNull<Node<T>>>,
 168 | }
 169 | 
 170 | #[allow(clippy::len_without_is_empty)] // If it is empty, the Lrc is destroyed, therefore is_empty is useless
 171 | impl<T> Lrc<T> {
 172 |     /// Allocates a value behind a `Lrc` pointer.
 173 |     ///
 174 |     /// This is done by allocating the `Lrc` on the heap next to a reference counter and next and previous pointers.
 175 |     pub fn new(value: T) -> Self {
 176 |         let node = Node::new(value);
 177 |         Lrc {
 178 |             head: Some(node.into_not_null()),
 179 |         }
 180 |     }
 181 | 
 182 |     /// Sets a new value as the head, making the previous head to the second node in the list.
 183 |     ///
 184 |     /// This will not allocate if this `Lrc` has exclusive access to the node whose value is being set.
 185 |     /// It will update the head nodes value in that case.
 186 |     ///
 187 |     /// If the Lrc's head is shared with another `Lrc`, it will push a new node onto its head containing
 188 |     /// the new value. Unless the `Lrc` is cloned, or another Lrc updates to point to this node, it will have
 189 |     /// exclusive access over this node, and calling `set` will remain cheap.
 190 |     ///
 191 |     /// # Example
 192 |     /// ```
 193 |     ///# use yewtil::ptr::Lrc;
 194 |     /// let mut lrc = Lrc::new(0);
 195 |     /// lrc.set(1);
 196 |     /// assert_eq!(lrc.as_ref(), &1);
 197 |     /// ```
 198 |     pub fn set(&mut self, value: T) {
 199 |         if self.is_exclusive() {
 200 |             // Directly assign the value if the ptr has exclusive access.
 201 |             *self.get_mut_head_node().value.as_mut() = value;
 202 |         } else {
 203 |             // If the ptr is shared, allocate a new node.
 204 |             self.push_head(Node::new(value));
 205 |         }
 206 |     }
 207 | 
 208 |     /// Gets a mutable reference to the owned value if this `Lrc` has exclusive ownership over its data.
 209 |     ///
 210 |     /// # Example
 211 |     /// ```
 212 |     ///# use yewtil::ptr::Lrc;
 213 |     /// let mut lrc = Lrc::new(1);
 214 |     ///
 215 |     /// let inner = lrc.get_mut();
 216 |     /// assert_eq!(inner, Some(&mut 1));
 217 |     ///
 218 |     /// let lrc_clone = lrc.clone();
 219 |     ///
 220 |     /// let inner = lrc.get_mut();
 221 |     /// assert_eq!(inner, None, "Can't get reference because lrc doesn't have exclusive ownership.");
 222 |     /// ```
 223 |     pub fn get_mut(&mut self) -> Option<&mut T> {
 224 |         if self.is_exclusive() {
 225 |             let node = self.get_mut_head_node();
 226 |             // Only this node has ownership, or it is marked dead.
 227 |             Some(node.value.as_mut())
 228 |         } else {
 229 |             None
 230 |         }
 231 |     }
 232 | 
 233 |     /// Tries to get the value at the head of this `Lrc`.
 234 |     /// If it has exclusive access, then it will return the value.
 235 |     /// If it does not have exclusive access, then the whole `Lrc` will be returned as the Error.
 236 |     ///
 237 |     /// # Example
 238 |     /// ```
 239 |     ///# use yewtil::ptr::Lrc;
 240 |     /// let lrc = Lrc::new(0);
 241 |     /// assert_eq!(lrc.try_unwrap(), Ok(0));
 242 |     ///
 243 |     /// let lrc = Lrc::new(0);
 244 |     /// let _cloned_lrc = lrc.clone();
 245 |     /// assert!(lrc.try_unwrap().is_err())
 246 |     /// ```
 247 |     pub fn try_unwrap(self) -> Result<T, Self> {
 248 |         if self.is_exclusive() {
 249 |             let head: NonNull<Node<T>> = self.head.unwrap();
 250 |             unsafe {
 251 |                 let value = (*head.as_ptr()).value.take();
 252 | 
 253 |                 if let Some(prev) = (*head.as_ptr()).prev.as_mut() {
 254 |                     prev.as_mut().next = (*head.as_ptr()).next.take();
 255 |                 }
 256 | 
 257 |                 if let Some(next) = (*head.as_ptr()).next.as_mut() {
 258 |                     next.as_mut().prev = (*head.as_ptr()).prev.take();
 259 |                 }
 260 | 
 261 |                 // No need to decrement the count, it already is 1
 262 |                 std::ptr::drop_in_place(head.as_ptr());
 263 | 
 264 |                 Ok(value)
 265 |             }
 266 |         } else {
 267 |             Err(self)
 268 |         }
 269 |     }
 270 | 
 271 |     /// Indicates that the `Lrc` has linked nodes that are newer than its head.
 272 |     pub fn has_prev(&self) -> bool {
 273 |         self.get_ref_head_node().prev.is_some()
 274 |     }
 275 | 
 276 |     /// Indicates that the `Lrc` has linked nodes that are older than its head.
 277 |     pub fn has_next(&self) -> bool {
 278 |         self.get_ref_head_node().next.is_some()
 279 |     }
 280 | 
 281 |     /// If this `Lrc` is shared, and one or more of its shared `Lrc`s has been modified,
 282 |     /// this will update this `Lrc`'s head to have the most up-to-date node (held currently by one of its clones).
 283 |     ///
 284 |     /// The returned boolean will be `true` if the call did change the head pointer.
 285 |     ///
 286 |     /// # Note
 287 |     /// This method constitutes an example of [action at a distance](https://en.wikipedia.org/wiki/Action_at_a_distance_(computer_programming)),
 288 |     /// as it may not be obvious what value you are setting your `Lrc` to when you call this.
 289 |     /// While useful, be wary to not overuse this mechanism, as it can make control-flow difficult to follow.
 290 |     ///
 291 |     ///
 292 |     /// # Example
 293 |     /// ```
 294 |     ///# use yewtil::ptr::Lrc;
 295 |     /// let mut lrc = Lrc::new(0);
 296 |     ///
 297 |     /// let mut cloned_lrc = lrc.clone();
 298 |     /// cloned_lrc.set(1);
 299 |     /// assert_eq!(lrc.as_ref(), &0);
 300 |     ///
 301 |     /// lrc.update();
 302 |     /// assert_eq!(lrc.as_ref(), &1);
 303 |     /// ```
 304 |     pub fn update(&mut self) -> bool {
 305 |         let did_update = self.has_prev();
 306 |         while let Some(prev) = self.next_back() {
 307 |             *self = prev;
 308 |         }
 309 |         did_update
 310 |     }
 311 | 
 312 |     /// Advances to the next node. The next node will be a node older than the current one.
 313 |     ///
 314 |     /// The returned boolean indicates if the attempt to advance to a new position was successful.
 315 |     ///
 316 |     /// Because advancing decrements the reference count as you move this `Lrc`'s head away from a node,
 317 |     /// if there are no other `Lrc`s with their heads pointing at that node, than that node will be deallocated.
 318 |     /// If you want an operation that advances to the next node, but doesn't risk deallocating the current node,
 319 |     /// try `next` instead, which returns a new `Lrc` instead of mutating one.
 320 |     ///
 321 |     /// # Note
 322 |     /// This method constitutes an example of [action at a distance](https://en.wikipedia.org/wiki/Action_at_a_distance_(computer_programming)),
 323 |     /// as it may not be obvious what value you are setting your `Lrc` to when you call this.
 324 |     /// While useful, be wary to not overuse this mechanism, as it can make control-flow difficult to follow.
 325 |     ///
 326 |     /// # Example
 327 |     /// ```
 328 |     ///# use yewtil::ptr::Lrc;
 329 |     /// let mut lrc = Lrc::new(0);
 330 |     /// let mut clone = lrc.clone();
 331 |     /// lrc.set(1);
 332 |     /// lrc.advance_next();
 333 |     ///
 334 |     /// assert_eq!(lrc.as_ref(), &0);
 335 |     /// ```
 336 |     pub fn advance_next(&mut self) -> bool {
 337 |         unsafe {
 338 |             let head_node: &mut NonNull<Node<T>> = self.head.as_mut().unwrap();
 339 |             let next: Option<NonNull<Node<T>>> = (*head_node.as_ptr()).next;
 340 |             if let Some(next) = next {
 341 |                 decrement_and_possibly_deallocate(*head_node);
 342 | 
 343 |                 // Increment the count, because the Lrc now has this node as its head
 344 |                 next.as_ref().inc_count();
 345 |                 self.head = Some(next);
 346 | 
 347 |                 true
 348 |             } else {
 349 |                 false
 350 |             }
 351 |         }
 352 |     }
 353 | 
 354 |     /// Advances to the previous node. The previous node will be a node newer than the current one.
 355 |     ///
 356 |     /// The returned boolean indicates if the attempt to advance to a new position was successful.
 357 |     ///
 358 |     /// Because advancing decrements the reference count as you move this `Lrc`'s head away from a node,
 359 |     /// if there are no other `Lrc`s with their heads pointing at that node, than that node will be deallocated.
 360 |     /// If you want an operation that advances to the next node, but doesn't risk deallocating the current node,
 361 |     /// try `next_back` instead, which returns a new `Lrc` instead of mutating one.
 362 |     ///
 363 |     /// # Note
 364 |     /// This method constitutes an example of [action at a distance](https://en.wikipedia.org/wiki/Action_at_a_distance_(computer_programming)),
 365 |     /// as it may not be obvious what value you are setting your `Lrc` to when you call this.
 366 |     /// While useful, be wary to not overuse this mechanism, as it can make control-flow difficult to follow.
 367 |     ///
 368 |     /// # Example
 369 |     /// ```
 370 |     ///# use yewtil::ptr::Lrc;
 371 |     /// let mut lrc = Lrc::new(0);
 372 |     /// let mut clone = lrc.clone();
 373 |     /// lrc.set(1);
 374 |     /// clone.advance_back();
 375 |     ///
 376 |     /// assert_eq!(clone.as_ref(), &1);
 377 |     /// ```
 378 |     pub fn advance_back(&mut self) -> bool {
 379 |         unsafe {
 380 |             let head_node: &mut NonNull<Node<T>> = self.head.as_mut().unwrap();
 381 |             let prev: Option<NonNull<Node<T>>> = (*head_node.as_ptr()).prev;
 382 |             if let Some(prev) = prev {
 383 |                 decrement_and_possibly_deallocate(*head_node);
 384 | 
 385 |                 // Increment the count, because a new Lrc has this node as the head
 386 |                 prev.as_ref().inc_count();
 387 |                 self.head = Some(prev);
 388 | 
 389 |                 true
 390 |             } else {
 391 |                 false
 392 |             }
 393 |         }
 394 |     }
 395 | 
 396 |     /// Compares head pointers for equality.
 397 |     ///
 398 |     /// # Example
 399 |     /// ```
 400 |     ///# use yewtil::ptr::Lrc;
 401 |     /// let lrc1 = Lrc::new(10);
 402 |     /// let lrc2 = Lrc::new(10);
 403 |     ///
 404 |     /// assert!(lrc1 == lrc2, "Values are the same");
 405 |     /// assert!(!Lrc::ptr_eq(&lrc1, &lrc2), "But they are behind different pointers");
 406 |     /// ```
 407 |     pub fn ptr_eq(lhs: &Self, rhs: &Self) -> bool {
 408 |         lhs.head.unwrap().eq(&rhs.head.unwrap())
 409 |     }
 410 | 
 411 |     /// Push a new node to the head of the `Lrc`.
 412 |     ///
 413 |     /// This guarantees that the new node will be pushed to head,
 414 |     /// and that the old **most previous (newest)** node will be attached to the new
 415 |     /// head's next ptr.
 416 |     ///
 417 |     /// This means that for any `Lrc`, navigating to prev nodes
 418 |     /// (`Lrc::update`, `Lrc::advance_back`, `<Lrc as DoubleEndedIterator>::next_back`)
 419 |     /// will eventually terminate at the new head of _this_ `Lrc`.
 420 |     fn push_head(&mut self, mut node: Node<T>) {
 421 |         // Make the head point to the absolutely newest node in the list.
 422 |         self.update();
 423 | 
 424 |         // Assign make the new node's next ptr point to the current head.
 425 |         node.next = self.head;
 426 |         let node = Some(node.into_not_null());
 427 | 
 428 |         let head = self.head.unwrap();
 429 |         unsafe {
 430 |             // Connect the head to the new node.
 431 |             (*head.as_ptr()).prev = node;
 432 |             decrement_and_possibly_deallocate(head)
 433 |         }
 434 | 
 435 |         // Make the new node the head for this Lrc.
 436 |         self.head = node;
 437 |         // Other nodes will still point to the same heads as they did before,
 438 |         // but now calling `update` will cause them to navigate to the same head as this Lrc
 439 |     }
 440 | 
 441 |     /// Gets the reference count of the head node.
 442 |     /// ```
 443 |     ///# use yewtil::ptr::Lrc;
 444 |     /// let lrc = Lrc::new(1);
 445 |     /// let count = (&lrc).get_count();
 446 |     /// assert_eq!(count, 1);
 447 |     ///
 448 |     /// let _lrc_clone_1 = lrc.clone();
 449 |     /// let count = (&lrc).get_count();
 450 |     /// assert_eq!(count, 2);
 451 |     ///
 452 |     /// let _lrc_clone_2 = lrc.clone();
 453 |     /// let count = (&lrc).get_count();
 454 |     /// assert_eq!(count, 3);
 455 |     /// ```
 456 |     pub fn get_count(&self) -> usize {
 457 |         self.get_ref_head_node().get_count()
 458 |     }
 459 | 
 460 |     /// Returns `true` if no other `Lrc`s point to the head node.
 461 |     /// ```
 462 |     ///# use yewtil::ptr::Lrc;
 463 |     /// let lrc = Lrc::new(1);
 464 |     /// assert!(lrc.is_exclusive());
 465 |     /// let _lrc_clone = lrc.clone();
 466 |     /// assert!(!lrc.is_exclusive());
 467 |     /// ```
 468 |     pub fn is_exclusive(&self) -> bool {
 469 |         self.get_count() == 1
 470 |     }
 471 | 
 472 |     /// Returns how many nodes are contained within the list this `Lrc`'s head is a part of.
 473 |     ///
 474 |     /// It is a `O(n)` operation, dependent on how many nodes are connected to this `Lrc`'s head.
 475 |     /// Or put another way, how many `Lrc`s exist in the program that were cloned from this `Lrc`
 476 |     /// (or this `Lrc` was cloned from one of them), that have differing head nodes.
 477 |     pub fn len(&self) -> usize {
 478 |         // This node, plus the length of its next nodes and its prev nodes
 479 |         1 + self.next_len() + self.prev_len()
 480 |     }
 481 | 
 482 |     /// Gets the number of nodes that are older than the head.
 483 |     pub fn next_len(&self) -> usize {
 484 |         let mut count = 0;
 485 |         unsafe {
 486 |             let mut node = self.get_ref_head_node();
 487 |             while let Some(next_node) = node.next.as_ref() {
 488 |                 count += 1;
 489 |                 node = next_node.as_ref()
 490 |             }
 491 |         }
 492 |         count
 493 |     }
 494 | 
 495 |     /// Gets the number of nodes that are newer than the head.
 496 |     pub fn prev_len(&self) -> usize {
 497 |         let mut count = 0;
 498 |         unsafe {
 499 |             let mut node = self.get_ref_head_node();
 500 |             while let Some(prev_node) = node.prev.as_ref() {
 501 |                 count += 1;
 502 |                 node = prev_node.as_ref()
 503 |             }
 504 |         }
 505 |         count
 506 |     }
 507 | 
 508 |     /// Gets a mutable reference to the head node.
 509 |     fn get_mut_head_node(&mut self) -> &mut Node<T> {
 510 |         unsafe { self.head.as_mut().unwrap().as_mut() }
 511 |     }
 512 | 
 513 |     /// Gets a reference to the head node.
 514 |     fn get_ref_head_node(&self) -> &Node<T> {
 515 |         unsafe { self.head.as_ref().unwrap().as_ref() }
 516 |     }
 517 | }
 518 | 
 519 | impl<T: Clone> Lrc<T> {
 520 |     /// Provides a mutable reference to the head's value.
 521 |     /// If the head is shared with another LRC, this will clone the head to ensure exclusive access.
 522 |     ///
 523 |     /// # Example
 524 |     /// ```
 525 |     ///# use yewtil::ptr::Lrc;
 526 |     /// let mut lrc = Lrc::new(1);
 527 |     /// let _lrc_clone = lrc.clone();
 528 |     ///
 529 |     /// assert_eq!((&lrc).get_count(), 2, "There are two Lrcs pointing to the same data.");
 530 |     /// assert_eq!(lrc.len(), 1, "The Lrc has a single node.");
 531 |     ///
 532 |     /// *lrc.make_mut() = 2;
 533 |     /// assert_eq!((&lrc).get_count(), 1, "This Lrc has exclusive ownership of this data.");
 534 |     /// assert_eq!(lrc.len(), 2, "The other lrc is pointing to the node that holds the value '1'.");
 535 |     ///
 536 |     /// *lrc.make_mut() = 3;
 537 |     /// assert_eq!(lrc.len(), 2, "This Lrc is still exclusive, so no more allocations are needed.");
 538 |     /// ```
 539 |     pub fn make_mut(&mut self) -> &mut T {
 540 |         if !self.is_exclusive() {
 541 |             // Clone to ensure unique ownership
 542 |             let cloned_value: T = self.clone_inner();
 543 |             self.push_head(Node::new(cloned_value))
 544 |         }
 545 |         self.get_mut_head_node().value.as_mut()
 546 |     }
 547 | 
 548 |     /// Consumes this Lrc, returning its wrapped value.
 549 |     ///
 550 |     /// If this Lrc doesn't have exclusive access, it will clone the value.
 551 |     pub fn clone_unwrap(self) -> T {
 552 |         if self.is_exclusive() {
 553 |             let head: NonNull<Node<T>> = self.head.unwrap();
 554 |             unsafe {
 555 |                 let value = (*head.as_ptr()).value.take();
 556 | 
 557 |                 if let Some(prev) = (*head.as_ptr()).prev.as_mut() {
 558 |                     prev.as_mut().next = (*head.as_ptr()).next.take();
 559 |                 }
 560 | 
 561 |                 if let Some(next) = (*head.as_ptr()).next.as_mut() {
 562 |                     next.as_mut().prev = (*head.as_ptr()).prev.take();
 563 |                 }
 564 | 
 565 |                 // No need to decrement the count, it already is 1
 566 |                 std::ptr::drop_in_place(head.as_ptr());
 567 | 
 568 |                 value
 569 |             }
 570 |         } else {
 571 |             self.clone_inner()
 572 |         }
 573 |     }
 574 | 
 575 |     /// Clones the wrapped value at the `Lrc`'s head.
 576 |     pub fn clone_inner(&self) -> T {
 577 |         self.get_ref_head_node().value.as_ref().clone()
 578 |     }
 579 | }
 580 | 
 581 | impl<T: PartialEq> Lrc<T> {
 582 |     /// Only sets if the new value is different than the current value.
 583 |     ///
 584 |     /// It will return true if they were not equal, indicating that an assignment has occurred.
 585 |     ///
 586 |     /// This is better than `lrc.make_mut().neq_assign(value)` because this will
 587 |     /// not allocate a copy if the current value if the current value and the new value don't match,
 588 |     /// while `make_mut()` will do that up front, before the equality check.
 589 |     pub fn neq_set(&mut self, value: T) -> bool {
 590 |         if self.get_ref_head_node().value.as_ref() != &value {
 591 |             self.set(value);
 592 |             true
 593 |         } else {
 594 |             false
 595 |         }
 596 |     }
 597 | }
 598 | 
 599 | impl<T> Drop for Lrc<T> {
 600 |     fn drop(&mut self) {
 601 |         let head = self.head.expect("Head should always be present.");
 602 |         unsafe {
 603 |             decrement_and_possibly_deallocate(head);
 604 |         }
 605 |     }
 606 | }
 607 | impl<T> Clone for Lrc<T> {
 608 |     fn clone(&self) -> Self {
 609 |         if let Some(head) = self.head {
 610 |             unsafe {
 611 |                 head.as_ref().inc_count();
 612 |             }
 613 |         }
 614 |         Lrc { head: self.head }
 615 |     }
 616 | }
 617 | 
 618 | impl<T: PartialEq> PartialEq for Lrc<T> {
 619 |     fn eq(&self, other: &Self) -> bool {
 620 |         // TODO refactor this to remove the unsafe block.
 621 |         unsafe {
 622 |             match (self.head, other.head) {
 623 |                 (Some(lhs), Some(rhs)) => lhs.as_ref().value.eq(&rhs.as_ref().value),
 624 |                 _ => false,
 625 |             }
 626 |         }
 627 |     }
 628 | }
 629 | 
 630 | impl<T: Eq> Eq for Lrc<T> {}
 631 | 
 632 | impl<T: PartialOrd> PartialOrd for Lrc<T> {
 633 |     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
 634 |         self.get_ref_head_node()
 635 |             .value
 636 |             .partial_cmp(&other.get_ref_head_node().value)
 637 |     }
 638 | }
 639 | impl<T: Ord> Ord for Lrc<T> {
 640 |     fn cmp(&self, other: &Self) -> Ordering {
 641 |         self.get_ref_head_node()
 642 |             .value
 643 |             .cmp(&other.get_ref_head_node().value)
 644 |     }
 645 | }
 646 | 
 647 | impl<T: Hash> Hash for Lrc<T> {
 648 |     fn hash<H: Hasher>(&self, state: &mut H) {
 649 |         self.get_ref_head_node().value.hash(state)
 650 |     }
 651 | }
 652 | 
 653 | impl<T> AsRef<T> for Lrc<T> {
 654 |     fn as_ref(&self) -> &T {
 655 |         &self.get_ref_head_node().value.as_ref()
 656 |     }
 657 | }
 658 | 
 659 | impl<T> Deref for Lrc<T> {
 660 |     type Target = T;
 661 | 
 662 |     fn deref(&self) -> &Self::Target {
 663 |         &self.get_ref_head_node().value.as_ref()
 664 |     }
 665 | }
 666 | 
 667 | impl<T> Borrow<T> for Lrc<T> {
 668 |     fn borrow(&self) -> &T {
 669 |         &self.get_ref_head_node().value.as_ref()
 670 |     }
 671 | }
 672 | 
 673 | impl<T: fmt::Debug> fmt::Debug for Lrc<T> {
 674 |     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 675 |         f.debug_tuple("Lrc").field(&self.head).finish()
 676 |     }
 677 | }
 678 | 
 679 | impl<T> Iterator for Lrc<T> {
 680 |     type Item = Lrc<T>;
 681 | 
 682 |     fn next(&mut self) -> Option<Self::Item> {
 683 |         self.get_ref_head_node().next.map(|ptr| {
 684 |             unsafe {
 685 |                 ptr.as_ref().inc_count();
 686 |             }
 687 |             Lrc { head: Some(ptr) }
 688 |         })
 689 |     }
 690 | }
 691 | 
 692 | impl<T> DoubleEndedIterator for Lrc<T> {
 693 |     fn next_back(&mut self) -> Option<Self::Item> {
 694 |         self.get_ref_head_node().prev.map(|ptr| {
 695 |             unsafe {
 696 |                 ptr.as_ref().inc_count();
 697 |             }
 698 |             Lrc { head: Some(ptr) }
 699 |         })
 700 |     }
 701 | }
 702 | 
 703 | #[cfg(test)]
 704 | mod test {
 705 |     use super::*;
 706 | 
 707 |     #[test]
 708 |     fn lrc_new() {
 709 |         let lrc = Lrc::new(25);
 710 |         assert_eq!(
 711 |             lrc,
 712 |             Lrc {
 713 |                 head: Some(Node::new(25).into_not_null())
 714 |             }
 715 |         );
 716 |         assert_eq!(lrc.as_ref(), &25)
 717 |     }
 718 | 
 719 |     #[test]
 720 |     fn clone_lrc() {
 721 |         let lrc = Lrc::new(25);
 722 |         let copy = lrc.clone();
 723 |         assert_eq!(copy.as_ref(), &25)
 724 |     }
 725 | 
 726 |     #[test]
 727 |     fn set_lrc() {
 728 |         let mut lrc = Lrc::new(25);
 729 |         lrc.set(30);
 730 | 
 731 |         assert_eq!(lrc.as_ref(), &30)
 732 |     }
 733 | 
 734 |     #[test]
 735 |     fn len_not_changed_by_setting_exclusive_lrc() {
 736 |         let mut lrc = Lrc::new(25);
 737 |         lrc.set(24);
 738 |         assert_eq!(lrc.len(), 1);
 739 |     }
 740 | 
 741 |     #[test]
 742 |     fn make_mut_will_clone_if_shared() {
 743 |         let mut lrc = Lrc::new(0);
 744 |         let _shared = lrc.clone();
 745 |         lrc.make_mut();
 746 | 
 747 |         assert_eq!(lrc.len(), 2);
 748 |     }
 749 | 
 750 |     #[test]
 751 |     fn exclusive_set_equivalent_to_exclusive_make_mut() {
 752 |         let mut lrc = Lrc::new(0);
 753 |         lrc.set(1);
 754 |         assert_eq!(lrc.as_ref(), &1);
 755 |         assert_eq!(lrc.len(), 1);
 756 |         assert_eq!(lrc.get_count(), 1);
 757 | 
 758 |         let mut lrc = Lrc::new(0);
 759 |         *lrc.make_mut() = 1;
 760 |         assert_eq!(lrc.as_ref(), &1);
 761 |         assert_eq!(lrc.len(), 1);
 762 |         assert_eq!(lrc.get_count(), 1);
 763 |     }
 764 | 
 765 |     #[test]
 766 |     fn droping_middle_connects_prev_and_next() {
 767 |         let mut lrc = Lrc::new(0);
 768 |         assert_eq!(
 769 |             lrc.get_ref_head_node().count,
 770 |             Cell::new(1),
 771 |             "exclusive ownership"
 772 |         );
 773 | 
 774 |         // Clone the initial value so it will stick around towards the end of this test
 775 |         let _og_clone = lrc.clone();
 776 |         assert_eq!(
 777 |             lrc.get_ref_head_node().count,
 778 |             Cell::new(2),
 779 |             "shared ownership"
 780 |         );
 781 | 
 782 |         lrc.set(1);
 783 | 
 784 |         assert_eq!(lrc.get_ref_head_node().prev, None);
 785 |         assert_eq!(lrc.get_ref_head_node().value.as_ref(), &1);
 786 |         assert_eq!(lrc.get_ref_head_node().count, Cell::new(1));
 787 |         assert!(
 788 |             lrc.get_ref_head_node().next.is_some(),
 789 |             "Should have pointer to previous head"
 790 |         );
 791 | 
 792 |         unsafe {
 793 |             let lrcs_next = lrc
 794 |                 .get_ref_head_node()
 795 |                 .next
 796 |                 .as_ref()
 797 |                 .expect("Should have next node")
 798 |                 .as_ref();
 799 |             let lrcs_nexts_prev = lrcs_next
 800 |                 .prev
 801 |                 .as_ref()
 802 |                 .expect("next.prev should be some")
 803 |                 .as_ref();
 804 | 
 805 |             assert_eq!(lrcs_next.value.as_ref(), &0);
 806 |             assert_eq!(
 807 |                 lrcs_next.count,
 808 |                 Cell::new(1),
 809 |                 "Should still be owned by the Og Clone"
 810 |             );
 811 |             assert!(lrcs_next.prev.is_some(), "Should point to head");
 812 | 
 813 |             assert_eq!(
 814 |                 lrcs_nexts_prev,
 815 |                 lrc.get_ref_head_node(),
 816 |                 "the head's next ptr's prev ptr should point back to the head"
 817 |             );
 818 |         }
 819 | 
 820 |         // Clone the head.
 821 |         let cloned_lrc = lrc.clone();
 822 |         assert_eq!(lrc.len(), 2);
 823 | 
 824 |         assert_eq!(cloned_lrc.get_ref_head_node().prev, None);
 825 |         assert_eq!(cloned_lrc.get_ref_head_node().value.as_ref(), &1);
 826 |         assert_eq!(cloned_lrc.get_ref_head_node().count, Cell::new(2));
 827 |         assert!(
 828 |             cloned_lrc.get_ref_head_node().next.is_some(),
 829 |             "Should have pointer to previous head"
 830 |         );
 831 | 
 832 |         // Replace the head again
 833 |         lrc.set(2);
 834 | 
 835 |         assert_eq!(lrc.get_ref_head_node().prev, None);
 836 |         assert_eq!(
 837 |             lrc.get_ref_head_node().value.as_ref(),
 838 |             &2,
 839 |             "value should now be updated to 2"
 840 |         );
 841 |         assert_eq!(
 842 |             lrc.get_ref_head_node().count,
 843 |             Cell::new(1),
 844 |             "there should only be one owner of this node"
 845 |         );
 846 |         assert!(
 847 |             lrc.get_ref_head_node().next.is_some(),
 848 |             "Should have pointer to previous head"
 849 |         );
 850 | 
 851 |         unsafe {
 852 |             // This should have modified the cloned_lrc's head's prev ptr to point to the head of the lrc
 853 |             let cloned_lrcs_heads_prev_value = cloned_lrc
 854 |                 .get_ref_head_node()
 855 |                 .prev
 856 |                 .as_ref()
 857 |                 .expect("Should point to head")
 858 |                 .as_ref();
 859 |             assert_eq!(cloned_lrcs_heads_prev_value, lrc.get_ref_head_node());
 860 |         }
 861 | 
 862 |         assert_eq!(lrc.len(), 3);
 863 | 
 864 |         // Drop the cloned_lrc, which in cleanup,
 865 |         // should attach the head node of lrc (currently of value 2),
 866 |         // with the lail node of lrc (value of 0)
 867 |         std::mem::drop(cloned_lrc);
 868 | 
 869 |         assert_eq!(lrc.len(), 2);
 870 | 
 871 |         unsafe {
 872 |             let lrcs_next = lrc
 873 |                 .get_ref_head_node()
 874 |                 .next
 875 |                 .as_ref()
 876 |                 .expect("Should have next node")
 877 |                 .as_ref();
 878 |             assert_eq!(lrcs_next.value.as_ref(), &0);
 879 |         }
 880 |     }
 881 | 
 882 |     #[test]
 883 |     fn single_node_older_yeilds_none() {
 884 |         let mut lrc = Lrc::new(25);
 885 |         let older = lrc.next();
 886 |         assert_eq!(older, None)
 887 |     }
 888 | 
 889 |     #[test]
 890 |     fn single_node_newer_yeilds_none() {
 891 |         let mut lrc = Lrc::new(25);
 892 |         let newer = lrc.next_back();
 893 |         assert_eq!(newer, None)
 894 |     }
 895 | 
 896 |     #[test]
 897 |     fn older_traverses_to_previous_lrc() {
 898 |         let mut lrc = Lrc::new(25);
 899 |         let _clone = lrc.clone();
 900 |         lrc.set(26);
 901 |         let older = lrc.next();
 902 |         assert_eq!(older, Some(Lrc::new(25)))
 903 |     }
 904 | 
 905 |     #[test]
 906 |     fn newer_traverses_back_to_original_head_lrc() {
 907 |         let mut lrc = Lrc::new(25);
 908 |         let _clone = lrc.clone();
 909 |         lrc.set(26);
 910 |         let older = lrc.next();
 911 |         assert_eq!(older, Some(Lrc::new(25)));
 912 |         let newer = older.unwrap().next_back();
 913 |         assert_eq!(newer, Some(lrc));
 914 |     }
 915 | 
 916 |     #[test]
 917 |     fn attempt_to_dangle_ref() {
 918 |         let lrc = Lrc::new(vec![25]);
 919 |         let mut cloned_lrc = lrc.clone();
 920 |         let first_item_ref = &lrc.as_ref()[0];
 921 |         cloned_lrc.set(vec![22, 23]);
 922 |         assert_eq!(first_item_ref, &25)
 923 |     }
 924 | 
 925 |     #[test]
 926 |     fn ptr_eq_positive() {
 927 |         let lrc = Lrc::new(24);
 928 |         let cloned_lrc = lrc.clone();
 929 | 
 930 |         assert!(Lrc::ptr_eq(&lrc, &cloned_lrc));
 931 |     }
 932 | 
 933 |     #[test]
 934 |     fn ptr_eq_negative() {
 935 |         let lrc = Lrc::new(24);
 936 |         let other_lrc = Lrc::new(24);
 937 | 
 938 |         assert!(!Lrc::ptr_eq(&lrc, &other_lrc));
 939 |     }
 940 | 
 941 |     #[test]
 942 |     fn update_sets_lrc_to_have_newest_value() {
 943 |         let mut lrc = Lrc::new(0);
 944 |         let mut cloned_lrc = lrc.clone();
 945 | 
 946 |         cloned_lrc.set(1);
 947 |         assert_eq!(cloned_lrc.as_ref(), &1);
 948 |         assert_eq!(lrc.as_ref(), &0);
 949 | 
 950 |         let did_update = lrc.update();
 951 |         assert!(did_update);
 952 |         assert_eq!(lrc.as_ref(), &1);
 953 |     }
 954 | 
 955 |     #[test]
 956 |     fn advance_back() {
 957 |         let mut lrc = Lrc::new(0);
 958 |         let mut clone = lrc.clone();
 959 |         lrc.set(1);
 960 |         // Move to a newer value
 961 |         let did_advance = clone.advance_back();
 962 | 
 963 |         assert!(did_advance);
 964 |         assert_eq!(clone.as_ref(), &1);
 965 |         assert_eq!(clone.len(), 1);
 966 |         assert_eq!(clone.get_count(), 2);
 967 | 
 968 |         let did_advance = clone.advance_back();
 969 |         assert!(!did_advance, "No newer values to advance to.");
 970 | 
 971 |         let did_advance = clone.advance_next();
 972 |         assert!(
 973 |             !did_advance,
 974 |             "can't restore old value, as it has be dropped."
 975 |         );
 976 |     }
 977 | 
 978 |     #[test]
 979 |     fn advance_next() {
 980 |         let mut lrc = Lrc::new(0);
 981 |         let mut clone = lrc.clone();
 982 |         lrc.set(1);
 983 |         // Move to the older value.
 984 |         let did_advance = lrc.advance_next();
 985 | 
 986 |         assert!(did_advance);
 987 |         assert_eq!(lrc.as_ref(), &0);
 988 |         assert_eq!(lrc.len(), 1);
 989 |         assert_eq!(lrc.get_count(), 2);
 990 | 
 991 |         let did_advance = clone.advance_next();
 992 |         assert!(!did_advance, "No older values to advance to.");
 993 | 
 994 |         let did_advance = clone.advance_back();
 995 |         assert!(
 996 |             !did_advance,
 997 |             "Can't restore old value, as it has be dropped."
 998 |         );
 999 |     }
1000 | 
1001 |     #[test]
1002 |     fn size_of_node_overhead() {
1003 |         let lrc = Lrc::new(());
1004 |         let node_size_overhead_bytes = std::mem::size_of_val(lrc.get_ref_head_node());
1005 |         let usize_size = std::mem::size_of::<usize>();
1006 |         assert_eq!(node_size_overhead_bytes, usize_size * 4);
1007 |     }
1008 | 
1009 |     #[test]
1010 |     fn size_of_node_for_not_null() {
1011 |         let lrc = Lrc::new(Box::new(0));
1012 |         let node_size_overhead_bytes = std::mem::size_of_val(lrc.get_ref_head_node());
1013 |         let usize_size = std::mem::size_of::<usize>();
1014 |         assert_eq!(node_size_overhead_bytes, usize_size * 4);
1015 |     }
1016 | 
1017 |     #[test]
1018 |     fn size_of_node_for_usize() {
1019 |         let lrc = Lrc::new(0usize);
1020 |         let node_size_overhead_bytes = std::mem::size_of_val(lrc.get_ref_head_node());
1021 |         let usize_size = std::mem::size_of::<usize>();
1022 |         assert_eq!(node_size_overhead_bytes, usize_size * 5);
1023 |     }
1024 | }
1025 | 


--------------------------------------------------------------------------------
/src/ptr/mod.rs:
--------------------------------------------------------------------------------
 1 | //! Smart pointers for use within Yew.
 2 | //!
 3 | //! These all offer similar semantics to `std::rc::Rc`, but offer better ergonomics within Yew,
 4 | //! or functionality not available in `Rc`.
 5 | #[cfg(feature = "mrc_irc")]
 6 | mod irc;
 7 | #[cfg(feature = "lrc")]
 8 | mod lrc;
 9 | #[cfg(feature = "mrc_irc")]
10 | mod mrc;
11 | mod rc_box;
12 | mod takeable;
13 | 
14 | #[cfg(feature = "mrc_irc")]
15 | pub use irc::Irc;
16 | #[cfg(feature = "mrc_irc")]
17 | pub use mrc::Mrc;
18 | #[cfg(feature = "lrc")]
19 | pub use lrc::Lrc;
20 | 
21 | pub(crate) type IsZero = bool;
22 | 


--------------------------------------------------------------------------------
/src/ptr/mrc.rs:
--------------------------------------------------------------------------------
  1 | use crate::ptr::rc_box::{
  2 |     clone_impl, clone_inner, decrement_and_possibly_deallocate, get_count, get_mut_boxed_content,
  3 |     get_ref_boxed_content, is_exclusive, try_unwrap, unwrap_clone, RcBox,
  4 | };
  5 | use crate::ptr::Irc;
  6 | use std::borrow::{Borrow, BorrowMut};
  7 | use std::cmp::Ordering;
  8 | use std::fmt;
  9 | use std::hash::{Hash, Hasher};
 10 | use std::ops::Deref;
 11 | use std::ops::DerefMut;
 12 | use std::ptr::NonNull;
 13 | 
 14 | /// Mutable Reference Counted pointer
 15 | ///
 16 | /// The `Mrc` has similar semantics to `std::rc::Rc` pointer,
 17 | /// with notable differences that it does not support `Weak` pointers,
 18 | /// it supports `std::ops::DerefMut` via the possibly allocating `make_mut` function,
 19 | /// and that it can create immutable handles to its data (`Irc`).
 20 | ///
 21 | /// This should make it just slightly more size efficient and performant than `Rc`,
 22 | /// and should be more ergonomic to use than `Rc` given that you can mutably
 23 | /// assign to it without much ceremony.
 24 | ///
 25 | /// Passing `Irc` pointers to children guarantee that no intermediate component can modify the value
 26 | /// behind the pointer.
 27 | /// This makes it ideal for passing around configuration data where some components can ergonomicly
 28 | /// "modify" and cheaply pass the pointers back to parent components, while other components can only read it.
 29 | ///
 30 | /// # Note
 31 | /// Assigning to an `Mrc` within Yew when you have passed shared copies of the ptr to child components,
 32 | /// will always end up cloning the value stored in the `Mrc`. `Rc` makes this performance cost explicit,
 33 | /// by making you use `Rc::make_mut()`. Because cloning is unavoidable in the context it was designed for,
 34 | /// `Mrc` opts to provide nicer ergonomics around assignment.
 35 | ///
 36 | /// # Example
 37 | /// ```
 38 | /// use yewtil::ptr::Mrc;
 39 | ///
 40 | /// let mut mrc = Mrc::new(5);
 41 | /// *mrc = 10; // This just replaces the value because the mrc isn't shared.
 42 | ///
 43 | /// assert_eq!(*mrc, 10);
 44 | ///
 45 | /// let clone = mrc.clone();
 46 | /// *mrc = 20; // This operation clones the value and allocates space for it.
 47 | ///
 48 | /// assert_eq!(*clone, 10);
 49 | /// assert_eq!(*mrc, 20);
 50 | /// ```
 51 | pub struct Mrc<T> {
 52 |     /// Pointer to the value and reference counter.
 53 |     ptr: NonNull<RcBox<T>>,
 54 | }
 55 | 
 56 | impl<T> Mrc<T> {
 57 |     /// Allocates a value behind a `Mrc` pointer.
 58 |     pub fn new(value: T) -> Self {
 59 |         let rc_box = RcBox::new(value);
 60 |         let ptr = rc_box.into_non_null();
 61 |         Self { ptr }
 62 |     }
 63 | 
 64 |     /// Attempts to get a mutable reference to the wrapped value.
 65 |     ///
 66 |     /// If the pointer is not shared, it will return `Some`,
 67 |     /// whereas if multiple `Mrc`s or `Irc`s point to the value, this will return None.
 68 |     ///
 69 |     /// # Example
 70 |     /// ```
 71 |     /// use yewtil::ptr::Mrc;
 72 |     /// let mut mrc = Mrc::new(0);
 73 |     /// assert!(mrc.get_mut().is_some());
 74 |     ///
 75 |     /// let _clone = mrc.clone();
 76 |     /// assert!(mrc.get_mut().is_none());
 77 |     /// ```
 78 |     pub fn get_mut(&mut self) -> Option<&mut T> {
 79 |         if self.is_exclusive() {
 80 |             Some(get_mut_boxed_content(&mut self.ptr).value.as_mut())
 81 |         } else {
 82 |             None
 83 |         }
 84 |     }
 85 | 
 86 |     /// Tries to extract the value from the Mrc, returning the Mrc if there is one or
 87 |     /// more other pointers to the value.
 88 |     ///
 89 |     /// # Example
 90 |     /// ```
 91 |     /// use yewtil::ptr::Mrc;
 92 |     /// let mrc = Mrc::new(0);
 93 |     ///
 94 |     /// let clone = mrc.clone();
 95 |     /// let mrc = mrc.try_unwrap().expect_err("Should not be able to unwrap");
 96 |     ///
 97 |     /// std::mem::drop(clone);
 98 |     /// let value = mrc.try_unwrap().expect("Should get value");
 99 |     /// ```
100 |     pub fn try_unwrap(self) -> Result<T, Self> {
101 |         try_unwrap(self.ptr).map_err(|ptr| {
102 |             Self { ptr } // Recover the ptr
103 |         })
104 |     }
105 | 
106 |     /// Gets the reference count of the `Mrc`.
107 |     ///
108 |     /// An exclusive `Mrc` will have a count of `1`.
109 |     /// The count is incremented on any cloning action and is decremented when `drop` is called.
110 |     ///
111 |     /// # Example
112 |     /// ```
113 |     /// use yewtil::ptr::Mrc;
114 |     /// let mrc = Mrc::new(0);
115 |     /// assert_eq!(mrc.get_count(), 1);
116 |     ///
117 |     /// let _clone = mrc.clone();
118 |     /// assert_eq!(mrc.get_count(), 2);
119 |     ///
120 |     /// std::mem::drop(_clone);
121 |     /// assert_eq!(mrc.get_count(), 1);
122 |     /// ```
123 |     pub fn get_count(&self) -> usize {
124 |         get_count(self.ptr)
125 |     }
126 | 
127 |     /// Returns `true` if no other pointers to the value exist.
128 |     ///
129 |     /// ```
130 |     /// use yewtil::ptr::Mrc;
131 |     /// let mrc = Mrc::new(0);
132 |     /// assert!(mrc.is_exclusive());
133 |     ///
134 |     /// let _clone = mrc.clone();
135 |     /// assert!(!mrc.is_exclusive());
136 |     ///
137 |     /// std::mem::drop(_clone);
138 |     /// assert!(mrc.is_exclusive());
139 |     /// ```
140 |     pub fn is_exclusive(&self) -> bool {
141 |         is_exclusive(self.ptr)
142 |     }
143 | 
144 |     /// Returns an immutable reference counted pointer,
145 |     /// pointing to the same value and reference count.
146 |     ///
147 |     /// # Example
148 |     /// ```
149 |     /// use yewtil::ptr::{Mrc, Irc};
150 |     /// let mrc: Mrc<usize> =  Mrc::new(0);
151 |     /// let _irc: Irc<usize> = mrc.irc();
152 |     ///
153 |     /// assert!(!mrc.is_exclusive());
154 |     /// ```
155 |     pub fn irc(&self) -> Irc<T> {
156 |         get_ref_boxed_content(&self.ptr).inc_count();
157 |         Irc { ptr: self.ptr }
158 |     }
159 | 
160 |     /// Converts this Mrc into an Irc.
161 |     /// # Example
162 |     /// ```
163 |     /// use yewtil::ptr::{Mrc, Irc};
164 |     /// let mrc: Mrc<usize> =  Mrc::new(0);
165 |     /// let irc: Irc<usize> = mrc.into_irc();
166 |     ///
167 |     /// assert!(irc.is_exclusive());
168 |     /// ```
169 |     pub fn into_irc(self) -> Irc<T> {
170 |         // Because the Mrc is dropped, decrementing the count,
171 |         // the count needs to be restored here.
172 |         get_ref_boxed_content(&self.ptr).inc_count();
173 |         Irc { ptr: self.ptr }
174 |     }
175 | 
176 |     /// Checks pointers for equality.
177 |     ///
178 |     /// # Example
179 |     /// ```
180 |     /// use yewtil::ptr::Mrc;
181 |     /// let mrc1 = Mrc::new(0);
182 |     /// let mrc2 = Mrc::new(0);
183 |     /// assert_eq!(mrc1, mrc2);
184 |     /// assert!(!Mrc::ptr_eq(&mrc1, &mrc2))
185 |     /// ```
186 |     pub fn ptr_eq(lhs: &Self, rhs: &Self) -> bool {
187 |         std::ptr::eq(lhs.ptr.as_ptr(), rhs.ptr.as_ptr())
188 |     }
189 | }
190 | 
191 | impl<T: Clone> Mrc<T> {
192 |     /// Returns a mutable reference to the value if it has exclusive access.
193 |     /// If it does not have exclusive access, it will make a clone of the data to acquire exclusive access.
194 |     ///
195 |     /// # Example
196 |     /// ```
197 |     ///# use yewtil::ptr::Mrc;
198 |     /// let mut mrc: Mrc<usize> = Mrc::new(0);
199 |     ///
200 |     /// let _mut_ref: &mut usize = mrc.make_mut();
201 |     /// assert_eq!(mrc.get_count(), 1);
202 |     ///
203 |     /// let clone = mrc.clone();
204 |     /// assert_eq!(mrc.get_count(), 2);
205 |     ///
206 |     /// let _mut_ref: &mut usize = mrc.make_mut();
207 |     /// assert_eq!(mrc.get_count(), 1);
208 |     /// assert!(!Mrc::ptr_eq(&mrc, &clone))
209 |     /// ```
210 |     pub fn make_mut(&mut self) -> &mut T {
211 |         if !self.is_exclusive() {
212 |             let rc_box = RcBox::new(self.clone_inner());
213 |             let ptr = rc_box.into_non_null();
214 | 
215 |             // decrement the count for the boxed content at the current pointer
216 |             // because this Mrc will point to a new value.
217 | 
218 |             // This doesn't need to check to deallocate, because the count is guaranteed to be > 1.
219 |             get_ref_boxed_content(&self.ptr).dec_count();
220 | 
221 |             // Replace the pointers
222 |             self.ptr = ptr;
223 |         }
224 | 
225 |         get_mut_boxed_content(&mut self.ptr).value.as_mut()
226 |     }
227 | 
228 |     /// Consumes the `Mrc` and returns the value from the `Mrc` if it is not shared
229 |     /// or clones the value if another `Mrc` or `Irc` has access to it.
230 |     pub fn unwrap_clone(self) -> T {
231 |         unwrap_clone(self.ptr)
232 |     }
233 |     /// Clones the value wrapped by the `Mrc`..
234 |     pub fn clone_inner(&self) -> T {
235 |         clone_inner(self.ptr)
236 |     }
237 | }
238 | 
239 | impl<T> Drop for Mrc<T> {
240 |     fn drop(&mut self) {
241 |         unsafe { decrement_and_possibly_deallocate(self.ptr) }
242 |     }
243 | }
244 | 
245 | impl<T> Clone for Mrc<T> {
246 |     fn clone(&self) -> Self {
247 |         Self {
248 |             ptr: clone_impl(self.ptr),
249 |         }
250 |     }
251 | }
252 | 
253 | 
254 | impl <T: Default> Default for Mrc<T> {
255 |     fn default() -> Self {
256 |         Mrc::new(T::default())
257 |     }
258 | }
259 | 
260 | impl<T: Clone> DerefMut for Mrc<T> {
261 |     fn deref_mut(&mut self) -> &mut Self::Target {
262 |         self.make_mut()
263 |     }
264 | }
265 | 
266 | impl<T: Clone> AsMut<T> for Mrc<T> {
267 |     fn as_mut(&mut self) -> &mut T {
268 |         self.make_mut()
269 |     }
270 | }
271 | 
272 | impl<T: Clone> BorrowMut<T> for Mrc<T> {
273 |     fn borrow_mut(&mut self) -> &mut T {
274 |         self.make_mut()
275 |     }
276 | }
277 | 
278 | impl<T> AsRef<T> for Mrc<T> {
279 |     fn as_ref(&self) -> &T {
280 |         get_ref_boxed_content(&self.ptr).value.as_ref()
281 |     }
282 | }
283 | 
284 | impl<T> Deref for Mrc<T> {
285 |     type Target = T;
286 | 
287 |     fn deref(&self) -> &Self::Target {
288 |         self.as_ref()
289 |     }
290 | }
291 | 
292 | impl<T> Borrow<T> for Mrc<T> {
293 |     fn borrow(&self) -> &T {
294 |         self.as_ref()
295 |     }
296 | }
297 | 
298 | impl<T: PartialEq> PartialEq for Mrc<T> {
299 |     fn eq(&self, other: &Self) -> bool {
300 |         self.as_ref().eq(other.as_ref())
301 |     }
302 | }
303 | 
304 | impl<T: Eq> Eq for Mrc<T> {}
305 | 
306 | impl<T: PartialOrd> PartialOrd for Mrc<T> {
307 |     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
308 |         self.as_ref().partial_cmp(other.as_ref())
309 |     }
310 | }
311 | 
312 | impl<T: Ord> Ord for Mrc<T> {
313 |     fn cmp(&self, other: &Self) -> Ordering {
314 |         self.as_ref().cmp(other.as_ref())
315 |     }
316 | }
317 | 
318 | impl<T: Hash> Hash for Mrc<T> {
319 |     fn hash<H: Hasher>(&self, state: &mut H) {
320 |         self.as_ref().hash(state)
321 |     }
322 | }
323 | 
324 | impl<T: fmt::Debug> fmt::Debug for Mrc<T> {
325 |     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
326 |         let rc_box = get_ref_boxed_content(&self.ptr);
327 |         f.debug_struct("Irc")
328 |             .field("value", rc_box.value.as_ref())
329 |             .field("count", &rc_box.get_count())
330 |             .finish()
331 |     }
332 | }
333 | 


--------------------------------------------------------------------------------
/src/ptr/rc_box.rs:
--------------------------------------------------------------------------------
  1 | use crate::ptr::takeable::Takeable;
  2 | use crate::ptr::IsZero;
  3 | use std::cell::Cell;
  4 | use std::ptr::NonNull;
  5 | 
  6 | #[derive(Debug)]
  7 | pub(crate) struct RcBox<T> {
  8 |     pub(crate) value: Takeable<T>,
  9 |     count: Cell<usize>,
 10 | }
 11 | 
 12 | /// The boxed content used in Irc and Mrc.
 13 | impl<T> RcBox<T> {
 14 |     #[inline]
 15 |     pub(crate) fn new(value: T) -> Self {
 16 |         Self {
 17 |             value: Takeable::new(value),
 18 |             count: Cell::new(1),
 19 |         }
 20 |     }
 21 | 
 22 |     #[inline]
 23 |     pub(crate) fn into_non_null(self) -> NonNull<Self> {
 24 |         unsafe { NonNull::new_unchecked(Box::into_raw(Box::new(self))) }
 25 |     }
 26 | 
 27 |     /// Gets the reference count of the node
 28 |     pub(crate) fn get_count(&self) -> usize {
 29 |         self.count.get()
 30 |     }
 31 | 
 32 |     /// Increments the reference count of the node.
 33 |     #[inline]
 34 |     pub(crate) fn inc_count(&self) {
 35 |         let mut count = self.count.get();
 36 |         count += 1;
 37 |         self.count.set(count);
 38 |     }
 39 | 
 40 |     /// Decrements the reference count of the node.
 41 |     /// It will return true if the count hits zero.
 42 |     /// This can be used to determine if the node should be deallocated.
 43 |     #[inline]
 44 |     pub(crate) fn dec_count(&self) -> IsZero {
 45 |         let mut count = self.count.get();
 46 |         count -= 1;
 47 |         self.count.set(count);
 48 |         count == 0
 49 |     }
 50 | 
 51 |     #[inline]
 52 |     pub(crate) fn is_exclusive(&self) -> bool {
 53 |         self.get_count() == 1
 54 |     }
 55 | }
 56 | 
 57 | #[inline]
 58 | pub(crate) unsafe fn decrement_and_possibly_deallocate<T>(node: NonNull<RcBox<T>>) {
 59 |     // If the ref-count becomes 0
 60 |     if node.as_ref().dec_count() {
 61 |         std::ptr::drop_in_place(node.as_ptr());
 62 |     }
 63 | }
 64 | 
 65 | #[inline(always)]
 66 | pub(crate) fn get_mut_boxed_content<T>(ptr: &mut NonNull<RcBox<T>>) -> &mut RcBox<T> {
 67 |     unsafe { ptr.as_mut() }
 68 | }
 69 | #[inline(always)]
 70 | pub(crate) fn get_ref_boxed_content<T>(ptr: &NonNull<RcBox<T>>) -> &RcBox<T> {
 71 |     unsafe { ptr.as_ref() }
 72 | }
 73 | 
 74 | #[inline]
 75 | pub(crate) fn get_count<T>(ptr: NonNull<RcBox<T>>) -> usize {
 76 |     get_ref_boxed_content(&ptr).get_count()
 77 | }
 78 | 
 79 | #[inline]
 80 | pub(crate) fn is_exclusive<T>(ptr: NonNull<RcBox<T>>) -> bool {
 81 |     get_ref_boxed_content(&ptr).is_exclusive()
 82 | }
 83 | 
 84 | #[inline]
 85 | pub(crate) fn try_unwrap<T>(mut ptr: NonNull<RcBox<T>>) -> Result<T, NonNull<RcBox<T>>> {
 86 |     if is_exclusive(ptr) {
 87 |         Ok(get_mut_boxed_content(&mut ptr).value.take())
 88 |     } else {
 89 |         // The ptr's drop has ran, decrementing the count
 90 |         // This restores the value.
 91 |         get_ref_boxed_content(&ptr).inc_count();
 92 |         Err(ptr)
 93 |     }
 94 | }
 95 | 
 96 | #[inline]
 97 | pub(crate) fn clone_inner<T: Clone>(ptr: NonNull<RcBox<T>>) -> T {
 98 |     get_ref_boxed_content(&ptr).value.as_ref().clone()
 99 | }
100 | 
101 | #[inline]
102 | pub(crate) fn unwrap_clone<T: Clone>(mut ptr: NonNull<RcBox<T>>) -> T {
103 |     if is_exclusive(ptr) {
104 |         get_mut_boxed_content(&mut ptr).value.take()
105 |     } else {
106 |         clone_inner(ptr)
107 |     }
108 | }
109 | 
110 | /// Clones the pointer after incrementing the reference count.
111 | #[inline]
112 | pub(crate) fn clone_impl<T>(ptr: NonNull<RcBox<T>>) -> NonNull<RcBox<T>> {
113 |     // Increment the ref count
114 |     get_ref_boxed_content(&ptr).inc_count();
115 |     // rerturn the ptr
116 |     ptr
117 | }
118 | 


--------------------------------------------------------------------------------
/src/ptr/takeable.rs:
--------------------------------------------------------------------------------
 1 | use std::fmt;
 2 | /// A wrapper around Option<T> that only allows items to be taken.
 3 | ///
 4 | /// # Panics
 5 | /// It is expected to only take items from this structure in a way that
 6 | /// it will never be accessed after items have been taken.
 7 | ///
 8 | /// Accessing this via `as_ref` or `as_mut` after taking the value will cause a panic.
 9 | #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
10 | pub struct Takeable<T>(Option<T>);
11 | 
12 | impl<T> Takeable<T> {
13 |     pub(crate) fn new(item: T) -> Self {
14 |         Takeable(Some(item))
15 |     }
16 | 
17 |     /// This should only be called once.
18 |     pub(crate) fn take(&mut self) -> T {
19 |         self.0.take().expect("Can't take twice")
20 |     }
21 | }
22 | 
23 | impl<T> AsRef<T> for Takeable<T> {
24 |     fn as_ref(&self) -> &T {
25 |         self.0.as_ref().expect("Can't reference taken value")
26 |     }
27 | }
28 | 
29 | impl<T> AsMut<T> for Takeable<T> {
30 |     fn as_mut(&mut self) -> &mut T {
31 |         self.0.as_mut().expect("Can't reference taken value")
32 |     }
33 | }
34 | 
35 | impl<T: fmt::Debug> fmt::Debug for Takeable<T> {
36 |     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
37 |         self.0.as_ref().expect("Can't reference taken value").fmt(f)
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/pure.rs:
--------------------------------------------------------------------------------
 1 | //! Shortcut for terse component definitions.
 2 | use crate::NeqAssign;
 3 | use yew::{Component, ComponentLink, Html, Properties, ShouldRender};
 4 | 
 5 | /// Allows immutable components to be declared using a single struct and a single method.
 6 | pub trait PureComponent: Properties +  PartialEq + Sized + 'static {
 7 |     /// Renders self to `Html`.
 8 |     fn render(&self) -> Html;
 9 | }
10 | 
11 | 
12 | /// Wrapper component for pure components.
13 | ///
14 | /// Due to constraints in Rust's coherence rules, `Component` can't be implemented for any `T` that implements
15 | /// `PureComponent`, so instead this struct wraps a `T: PureComponent` and `Component` is implemented
16 | /// for this instead.
17 | ///
18 | /// # Example
19 | /// It is reasonable practice to use `Pure` as a prefix or `Impl` as a suffix to your pure component model
20 | /// and use an alias to provide a terser name to be used by other components:
21 | ///
22 | /// ```
23 | /// use yew::Properties;
24 | /// use yew::Html;
25 | /// use yewtil::{PureComponent, Pure};
26 | ///
27 | /// #[derive(Properties, PartialEq)]
28 | /// pub struct PureMyComponent {
29 | ///     pub data: String
30 | /// }
31 | ///
32 | /// impl PureComponent for PureMyComponent {
33 | /// fn render(&self) -> Html {
34 | ///#        unimplemented!()
35 | ///        // ...
36 | ///     }
37 | /// }
38 | ///
39 | /// /// Use this from within `html!` macros.
40 | /// pub type MyComponent = Pure<PureMyComponent>;
41 | /// ```
42 | #[derive(Debug)]
43 | pub struct Pure<T>(T);
44 | 
45 | impl<T: PureComponent + 'static> Component for Pure<T> {
46 |     type Message = ();
47 |     type Properties = T;
48 | 
49 |     fn create(props: Self::Properties, _link: ComponentLink<Self>) -> Self {
50 |         Pure(props)
51 |     }
52 | 
53 |     fn update(&mut self, _msg: Self::Message) -> ShouldRender {
54 |         false
55 |     }
56 | 
57 |     fn change(&mut self, props: Self::Properties) -> ShouldRender {
58 |         self.0.neq_assign(props)
59 |     }
60 | 
61 |     fn view(&self) -> Html {
62 |         self.0.render()
63 |     }
64 | }
65 | 


--------------------------------------------------------------------------------