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);
}