1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103
use cfg_if::cfg_if; cfg_if! { if #[cfg(feature = "enable-interning")] { use std::thread_local; use std::string::String; use std::borrow::ToOwned; use std::cell::RefCell; use std::collections::HashMap; use crate::JsValue; struct Cache { entries: RefCell<HashMap<String, JsValue>>, } thread_local! { static CACHE: Cache = Cache { entries: RefCell::new(HashMap::new()), }; } /// This returns the raw index of the cached JsValue, so you must take care /// so that you don't use it after it is freed. pub(crate) fn unsafe_get_str(s: &str) -> Option<u32> { CACHE.with(|cache| { let cache = cache.entries.borrow(); cache.get(s).map(|x| x.idx) }) } fn intern_str(key: &str) { CACHE.with(|cache| { let mut cache = cache.entries.borrow_mut(); // Can't use `entry` because `entry` requires a `String` if !cache.contains_key(key) { cache.insert(key.to_owned(), JsValue::from(key)); } }) } fn unintern_str(key: &str) { CACHE.with(|cache| { let mut cache = cache.entries.borrow_mut(); cache.remove(key); }) } } } /// Interns Rust strings so that it's much faster to send them to JS. /// /// Sending strings from Rust to JS is slow, because it has to do a full `O(n)` /// copy and *also* encode from UTF-8 to UTF-16. This must be done every single /// time a string is sent to JS. /// /// If you are sending the same string multiple times, you can call this `intern` /// function, which simply returns its argument unchanged: /// /// ```rust /// # use wasm_bindgen::intern; /// intern("foo") // returns "foo" /// # ; /// ``` /// /// However, if you enable the `"enable-interning"` feature for wasm-bindgen, /// then it will add the string into an internal cache. /// /// When you send that cached string to JS, it will look it up in the cache, /// which completely avoids the `O(n)` copy and encoding. This has a significant /// speed boost (as high as 783%)! /// /// However, there is a small cost to this caching, so you shouldn't cache every /// string. Only cache strings which have a high likelihood of being sent /// to JS multiple times. /// /// Also, keep in mind that this function is a *performance hint*: it's not /// *guaranteed* that the string will be cached, and the caching strategy /// might change at any time, so don't rely upon it. #[inline] pub fn intern(s: &str) -> &str { #[cfg(feature = "enable-interning")] intern_str(s); s } /// Removes a Rust string from the intern cache. /// /// This does the opposite of the [`intern`](fn.intern.html) function. /// /// If the [`intern`](fn.intern.html) function is called again then it will re-intern the string. #[allow(unused_variables)] #[inline] pub fn unintern(s: &str) { #[cfg(feature = "enable-interning")] unintern_str(s); }