instant-0.1.12/.cargo_vcs_info.json0000644000000001120000000000100125670ustar { "git": { "sha1": "9a486adeee119bdf7ecb85ba627b8112fb7eff86" } } instant-0.1.12/.circleci/config.yml000064400000000000000000000021120072674642500152340ustar 00000000000000version: 2.1 executors: rust-executor: docker: - image: rust:latest jobs: build: executor: rust-executor steps: - checkout - run: name: install cargo-web command: cargo install -f cargo-web; - run: name: build command: cargo build --verbose; - run: name: build --features stdweb command: cargo web build --verbose --target wasm32-unknown-unknown --features "stdweb"; - run: name: build --features wasm-bindgen command: cargo build --verbose --target wasm32-unknown-unknown --features "wasm-bindgen"; - run: name: build --features now command: cargo build --verbose --features now; - run: name: build --features now stdweb command: cargo web build --verbose --target wasm32-unknown-unknown --features "now stdweb"; - run: name: build --features now wasm-bindgen command: cargo build --verbose --target wasm32-unknown-unknown --features "now wasm-bindgen";instant-0.1.12/.gitignore000064400000000000000000000001500072674642500134010ustar 00000000000000*.swp *.swo *.so *.rlib *.dSYM *.dylib cargo.lock Cargo.lock target .idea wasm-pack.log bin instant-0.1.12/AUTHORS000064400000000000000000000000760072674642500124700ustar 00000000000000Main developer: * Sébastien Crozet instant-0.1.12/CHANGELOGS.md000064400000000000000000000004520072674642500133520ustar 00000000000000# v0.1.12 ## Added - Add `SystemTime` which works in both native and WASM environments. ## Modified - The `now` function is always available now: there is no need to enable the `now` feature any more. The `now` feature still exists (but doesn’t do anything) for backwards compatibility.instant-0.1.12/Cargo.toml0000644000000043570000000000100106040ustar # THIS FILE IS AUTOMATICALLY GENERATED BY CARGO # # When uploading crates to the registry Cargo will automatically # "normalize" Cargo.toml files for maximal compatibility # with all versions of Cargo and also rewrite `path` dependencies # to registry (e.g., crates.io) dependencies. # # If you are reading this file be aware that the original Cargo.toml # will likely look very different (and much more reasonable). # See Cargo.toml.orig for the original contents. [package] edition = "2018" name = "instant" version = "0.1.12" authors = ["sebcrozet "] description = "A partial replacement for std::time::Instant that works on WASM too." readme = "README.md" keywords = ["time", "wasm"] license = "BSD-3-Clause" repository = "https://github.com/sebcrozet/instant" [dependencies.cfg-if] version = "1.0" [dev-dependencies.wasm-bindgen-test] version = "0.3" [features] inaccurate = [] now = [] wasm-bindgen = ["js-sys", "wasm-bindgen_rs", "web-sys"] [target.asmjs-unknown-emscripten.dependencies.js-sys] version = "0.3" optional = true [target.asmjs-unknown-emscripten.dependencies.stdweb] version = "0.4" optional = true [target.asmjs-unknown-emscripten.dependencies.wasm-bindgen_rs] version = "0.2" optional = true package = "wasm-bindgen" [target.asmjs-unknown-emscripten.dependencies.web-sys] version = "0.3" features = ["Window", "Performance", "PerformanceTiming"] optional = true [target.wasm32-unknown-emscripten.dependencies.js-sys] version = "0.3" optional = true [target.wasm32-unknown-emscripten.dependencies.stdweb] version = "0.4" optional = true [target.wasm32-unknown-emscripten.dependencies.wasm-bindgen_rs] version = "0.2" optional = true package = "wasm-bindgen" [target.wasm32-unknown-emscripten.dependencies.web-sys] version = "0.3" features = ["Window", "Performance", "PerformanceTiming"] optional = true [target.wasm32-unknown-unknown.dependencies.js-sys] version = "0.3" optional = true [target.wasm32-unknown-unknown.dependencies.stdweb] version = "0.4" optional = true [target.wasm32-unknown-unknown.dependencies.wasm-bindgen_rs] version = "0.2" optional = true package = "wasm-bindgen" [target.wasm32-unknown-unknown.dependencies.web-sys] version = "0.3" features = ["Window", "Performance", "PerformanceTiming"] optional = true instant-0.1.12/Cargo.toml.orig000064400000000000000000000027470072674642500143160ustar 00000000000000[package] name = "instant" version = "0.1.12" authors = ["sebcrozet "] description = "A partial replacement for std::time::Instant that works on WASM too." repository = "https://github.com/sebcrozet/instant" readme = "README.md" license = "BSD-3-Clause" keywords = [ "time", "wasm" ] edition = "2018" [features] wasm-bindgen = ["js-sys", "wasm-bindgen_rs", "web-sys"] inaccurate = [] now = [] [dependencies] cfg-if = "1.0" [target.wasm32-unknown-unknown.dependencies] js-sys = { version = "0.3", optional = true } stdweb = { version = "0.4", optional = true } wasm-bindgen_rs = { package = "wasm-bindgen", version = "0.2", optional = true } web-sys = { version = "0.3", optional = true, features = ['Window', 'Performance', 'PerformanceTiming'] } [target.wasm32-unknown-emscripten.dependencies] js-sys = { version = "0.3", optional = true } stdweb = { version = "0.4", optional = true } wasm-bindgen_rs = { package = "wasm-bindgen", version = "0.2", optional = true } web-sys = { version = "0.3", optional = true, features = ['Window', 'Performance', 'PerformanceTiming'] } [target.asmjs-unknown-emscripten.dependencies] js-sys = { version = "0.3", optional = true } stdweb = { version = "0.4", optional = true } wasm-bindgen_rs = { package = "wasm-bindgen", version = "0.2", optional = true } web-sys = { version = "0.3", optional = true, features = ['Window', 'Performance', 'PerformanceTiming'] } [dev-dependencies] wasm-bindgen-test = "0.3" instant-0.1.12/LICENSE000064400000000000000000000027600072674642500124270ustar 00000000000000Copyright (c) 2019, Sébastien Crozet All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of the author nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. instant-0.1.12/README.md000064400000000000000000000075420072674642500127040ustar 00000000000000# Instant If you call `std::time::Instant::now()` on a WASM platform, it will panic. This crate provides a partial replacement for `std::time::Instant` that works on WASM too. This defines the type `instant::Instant` which is: * A struct emulating the behavior of **std::time::Instant** if you are targeting `wasm32-unknown-unknown` or `wasm32-unknown-asmjs` **and** you enabled either the `stdweb` or the `wasm-bindgen` feature. This emulation is based on the javascript `performance.now()` function. * A type alias for `std::time::Instant` otherwise. Note that even if the **stdweb** or **wasm-bindgen** feature is enabled, this crate will continue to rely on `std::time::Instant` as long as you are not targeting wasm32. This allows for portable code that will work on both native and WASM platforms. This crate also exports the function `instant::now()` which returns a representation of the current time as an `f64`, expressed in milliseconds, in a platform-agnostic way. `instant::now()` will either: * Call `performance.now()` when compiling for a WASM platform with the features **stdweb** or **wasm-bindgen** enabled, or using a custom javascript function. * Return the time elapsed since the *Unix Epoch* on *native*, *non-WASM* platforms. *Note*: The old feature, `now`, has been deprecated. `instant::now()` is always exported and the `now` feature flag no longer has any effect. It remains listed in `Cargo.toml` to avoid introducing breaking changes and may be removed in future versions. ## Examples ### Using `instant` for a native platform. _Cargo.toml_: ```toml [dependencies] instant = "0.1" ``` _main.rs_: ```rust fn main() { // Will be the same as `std::time::Instant`. let now = instant::Instant::now(); } ``` ----- ### Using `instant` for a WASM platform. This example shows the use of the `stdweb` feature. It would be similar with `wasm-bindgen`. _Cargo.toml_: ```toml [dependencies] instant = { version = "0.1", features = [ "stdweb" ] } ``` _main.rs_: ```rust fn main() { // Will emulate `std::time::Instant` based on `performance.now()`. let now = instant::Instant::now(); } ``` ----- ### Using `instant` for a WASM platform where `performance.now()` is not available. This example shows the use of the `inaccurate` feature. _Cargo.toml_: ```toml [dependencies] instant = { version = "0.1", features = [ "wasm-bindgen", "inaccurate" ] } ``` _main.rs_: ```rust fn main() { // Will emulate `std::time::Instant` based on `Date.now()`. let now = instant::Instant::now(); } ``` ----- ### Using `instant` for any platform enabling a feature transitively. _Cargo.toml_: ```toml [features] stdweb = [ "instant/stdweb" ] wasm-bindgen = [ "instant/wasm-bindgen" ] [dependencies] instant = "0.1" ``` _lib.rs_: ```rust fn my_function() { // Will select the proper implementation depending on the // feature selected by the user. let now = instant::Instant::now(); } ``` ----- ### Using `instant::now()` _Cargo.toml_: ```toml [features] stdweb = [ "instant/stdweb" ] wasm-bindgen = [ "instant/wasm-bindgen" ] [dependencies] instant = "0.1" ``` _lib.rs_: ```rust fn my_function() { // Will select the proper implementation depending on the // feature selected by the user. let now_instant = instant::Instant::now(); let now_milliseconds = instant::now(); // In milliseconds. } ``` ### Using the feature `now` without `stdweb` or `wasm-bindgen`. _Cargo.toml_: ```toml [dependencies] instant = "0.1" ``` _lib.rs_: ```rust fn my_function() { // Will use the 'now' javascript implementation. let now_instant = instant::Instant::now(); let now_milliseconds = instant::now(); // In milliseconds. } ``` _javascript WASM bindings file_: ```js function now() { return Date.now() / 1000.0; } ``` instant-0.1.12/src/lib.rs000064400000000000000000000010700072674642500133160ustar 00000000000000cfg_if::cfg_if! { if #[cfg(any( all(target_arch = "wasm32", not(target_os = "wasi")), target_arch = "asmjs" ))] { #[cfg(all(feature = "stdweb", not(feature = "wasm-bindgen")))] #[macro_use] extern crate stdweb; mod wasm; pub use wasm::Instant; pub use crate::wasm::now; pub use wasm::SystemTime; } else { mod native; pub use native::Instant; pub use native::now; pub use native::SystemTime; } } pub use std::time::Duration; instant-0.1.12/src/native.rs000064400000000000000000000006200072674642500140360ustar 00000000000000pub type Instant = std::time::Instant; pub type SystemTime = std::time::SystemTime; /// The current time, expressed in milliseconds since the Unix Epoch. pub fn now() -> f64 { std::time::SystemTime::now().duration_since(std::time::SystemTime::UNIX_EPOCH) .expect("System clock was before 1970.") .as_secs_f64() * 1000.0 } instant-0.1.12/src/wasm.rs000064400000000000000000000154310072674642500135250ustar 00000000000000use std::cmp::Ordering; use std::ops::{Add, AddAssign, Sub, SubAssign}; use std::time::Duration; #[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Hash)] pub struct Instant(Duration); impl Ord for Instant { fn cmp(&self, other: &Self) -> std::cmp::Ordering { self.partial_cmp(other) .expect("an instant should never be NaN or Inf.") } } impl Eq for Instant {} impl Instant { #[inline] pub fn now() -> Self { Instant(duration_from_f64(now())) } #[inline] pub fn duration_since(&self, earlier: Instant) -> Duration { assert!( earlier.0 <= self.0, "`earlier` cannot be later than `self`." ); self.0 - earlier.0 } #[inline] pub fn elapsed(&self) -> Duration { Self::now().duration_since(*self) } /// Returns `Some(t)` where `t` is the time `self + duration` if `t` can be represented as /// `Instant` (which means it's inside the bounds of the underlying data structure), `None` /// otherwise. #[inline] pub fn checked_add(&self, duration: Duration) -> Option { self.0.checked_add(duration).map(Instant) } /// Returns `Some(t)` where `t` is the time `self - duration` if `t` can be represented as /// `Instant` (which means it's inside the bounds of the underlying data structure), `None` /// otherwise. #[inline] pub fn checked_sub(&self, duration: Duration) -> Option { self.0.checked_sub(duration).map(Instant) } /// Returns the amount of time elapsed from another instant to this one, or None if that /// instant is later than this one. #[inline] pub fn checked_duration_since(&self, earlier: Instant) -> Option { if earlier.0 > self.0 { None } else { Some(self.0 - earlier.0) } } /// Returns the amount of time elapsed from another instant to this one, or zero duration if /// that instant is later than this one. #[inline] pub fn saturating_duration_since(&self, earlier: Instant) -> Duration { self.checked_duration_since(earlier).unwrap_or_default() } } impl Add for Instant { type Output = Self; #[inline] fn add(self, rhs: Duration) -> Self { Instant(self.0 + rhs) } } impl AddAssign for Instant { #[inline] fn add_assign(&mut self, rhs: Duration) { self.0 += rhs } } impl Sub for Instant { type Output = Self; #[inline] fn sub(self, rhs: Duration) -> Self { Instant(self.0 - rhs) } } impl Sub for Instant { type Output = Duration; #[inline] fn sub(self, rhs: Instant) -> Duration { self.duration_since(rhs) } } impl SubAssign for Instant { #[inline] fn sub_assign(&mut self, rhs: Duration) { self.0 -= rhs } } fn duration_from_f64(millis: f64) -> Duration { Duration::from_millis(millis.trunc() as u64) + Duration::from_nanos((millis.fract() * 1.0e6) as u64) } #[cfg(all(feature = "stdweb", not(feature = "wasm-bindgen")))] #[allow(unused_results)] // Needed because the js macro triggers it. pub fn now() -> f64 { use stdweb::unstable::TryInto; // https://developer.mozilla.org/en-US/docs/Web/API/Performance/now #[cfg(not(feature = "inaccurate"))] let v = js! { return performance.now(); }; #[cfg(feature = "inaccurate")] let v = js! { return Date.now(); }; v.try_into().unwrap() } #[cfg(feature = "wasm-bindgen")] pub fn now() -> f64 { #[cfg(not(feature = "inaccurate"))] let now = { use wasm_bindgen_rs::prelude::*; use wasm_bindgen_rs::JsCast; js_sys::Reflect::get(&js_sys::global(), &JsValue::from_str("performance")) .expect("failed to get performance from global object") .unchecked_into::() .now() }; #[cfg(feature = "inaccurate")] let now = js_sys::Date::now(); now } // The JS now function is in a module so it won't have to be renamed #[cfg(not(any(feature = "wasm-bindgen", feature = "stdweb")))] mod js { extern "C" { #[cfg(not(target_os = "emscripten"))] pub fn now() -> f64; #[cfg(target_os = "emscripten")] pub fn _emscripten_get_now() -> f64; } } // Make the unsafe extern function "safe" so it can be called like the other 'now' functions #[cfg(not(any(feature = "wasm-bindgen", feature = "stdweb")))] pub fn now() -> f64 { #[cfg(not(target_os = "emscripten"))] return unsafe { js::now() }; #[cfg(target_os = "emscripten")] return unsafe { js::_emscripten_get_now() }; } /// Returns the number of millisecods elapsed since January 1, 1970 00:00:00 UTC. #[cfg(any(feature = "wasm-bindgen", feature = "stdweb"))] fn get_time() -> f64 { #[cfg(feature = "wasm-bindgen")] return js_sys::Date::now(); #[cfg(all(feature = "stdweb", not(feature = "wasm-bindgen")))] { let v = js! { return Date.now(); }; return v.try_into().unwrap(); } } #[derive(Copy, Clone, Debug, PartialEq, PartialOrd)] pub struct SystemTime(f64); impl SystemTime { pub const UNIX_EPOCH: SystemTime = SystemTime(0.0); pub fn now() -> SystemTime { cfg_if::cfg_if! { if #[cfg(any(feature = "wasm-bindgen", feature = "stdweb"))] { SystemTime(get_time()) } else { SystemTime(now()) } } } pub fn duration_since(&self, earlier: SystemTime) -> Result { let dur_ms = self.0 - earlier.0; if dur_ms < 0.0 { return Err(()); } Ok(Duration::from_millis(dur_ms as u64)) } pub fn elapsed(&self) -> Result { self.duration_since(SystemTime::now()) } pub fn checked_add(&self, duration: Duration) -> Option { Some(*self + duration) } pub fn checked_sub(&self, duration: Duration) -> Option { Some(*self - duration) } } impl Add for SystemTime { type Output = SystemTime; fn add(self, other: Duration) -> SystemTime { SystemTime(self.0 + other.as_millis() as f64) } } impl Sub for SystemTime { type Output = SystemTime; fn sub(self, other: Duration) -> SystemTime { SystemTime(self.0 - other.as_millis() as f64) } } impl AddAssign for SystemTime { fn add_assign(&mut self, rhs: Duration) { *self = *self + rhs; } } impl SubAssign for SystemTime { fn sub_assign(&mut self, rhs: Duration) { *self = *self - rhs; } } instant-0.1.12/tests/wasm.rs000064400000000000000000000030170072674642500140750ustar 00000000000000extern crate wasm_bindgen_test; use instant::{Instant, SystemTime}; use std::time::Duration; use wasm_bindgen_test::*; wasm_bindgen_test_configure!(run_in_browser); // run these tests using: wasm-pack test --chrome --headless -- --features wasm-bindgen #[wasm_bindgen_test] fn test_instant_now() { let now = Instant::now(); #[cfg(feature = "inaccurate")] while now.elapsed().as_millis() == 0 {} #[cfg(not(feature = "inaccurate"))] assert!(now.elapsed().as_nanos() > 0); } #[wasm_bindgen_test] fn test_duration() { let now = Instant::now(); let one_sec = Duration::from_secs(1); assert!(now.elapsed() < one_sec); } // Duration::new will overflow when you have u64::MAX seconds and one billion nanoseconds. // const ONE_BILLION: u32 = 1_000_000_000; #[wasm_bindgen_test] fn test_checked_add() { let now = Instant::now(); assert!(now.checked_add(Duration::from_millis(1)).is_some()); assert_eq!( None, now.checked_add(Duration::new(u64::MAX, ONE_BILLION - 1)) ); } #[wasm_bindgen_test] fn test_checked_sub() { let now = Instant::now(); assert!(now.checked_sub(Duration::from_millis(1)).is_some()); assert!(now .checked_sub(Duration::new(u64::MAX, ONE_BILLION - 1)) .is_none()); } #[wasm_bindgen_test] fn test_system_time() { assert!(SystemTime::UNIX_EPOCH .duration_since(SystemTime::now()) .is_err()); }