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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

// #![doc(html_logo_url = "https://rin.rs/logo.svg")]
// #![doc(html_favicon_url = "https://rin.rs/favicon.ico")]

pub use self::lazy_value::{Lazy, LazyUpdate};
pub use self::value_cache::*;
pub use self::error::Error;
pub use self::error::Result;
pub use self::error::LogErr;
pub use self::enum_set::{EnumSet,CLike};

#[cfg(not(target_os="unknown"))]
pub use self::autoloader::AutoLoader;

use std::{path::{Path, PathBuf}, time::Instant};

#[cfg(not(target_os="unknown"))]
mod autoloader;

mod lazy_value;
mod value_cache;
mod error;
#[cfg(feature="async")]
pub mod async_fs;
mod enum_set;
use chrono::prelude::*;

/// fps from time interval and frames passed
pub fn calc_fps(curr_time: Instant, prev_time: Instant, frames: u64) -> f64{
    frames as f64 / (curr_time - prev_time).as_secs_f64()
}

#[macro_export]
/// quick macro to log times that a section of code takes to run
///
/// ```
/// rin::util::timed!("some operation", {
///     // do something
/// });
/// ```
/// will run the code inside the curly braces and at the end print the time it took to run
macro_rules! timed{
    ($descr: expr, $func: block) => (
        {
            use time;
            let then = time::precise_time_ns() as f32/1000000f32;
            let ret = $func;
            let now = time::precise_time_ns() as f32/1000000f32;
            println!("{} time: {}ms", $descr, now - then);
            ret
        }
    );
}


//TODO: this is really hacky and probably slow but seems the only way to find out the real
// path when a project is inside a workspace
#[cfg(feature = "debug_paths")]
pub fn workspace_dir() -> std::path::PathBuf {
    let cargo = std::process::Command::new("cargo")
        .args(&["locate-project", "--workspace", "--message-format", "plain",])
        .output()
        .unwrap()
        .stdout;
    let cargo = String::from_utf8(cargo).unwrap();
    std::path::Path::new(&cargo).parent().unwrap().to_owned()
}

#[cfg(not(feature = "debug_paths"))]
pub fn workspace_dir() -> std::path::PathBuf {
    std::path::PathBuf::new()
}

lazy_static::lazy_static! {
    pub static ref WORKSPACE_DIR: std::path::PathBuf = workspace_dir();
}


pub fn timestamp_string_tz<TZ: chrono::TimeZone>(prefix: &str, timestamp: chrono::DateTime<TZ>, suffix: &str) -> String{
    format!("{}{}_{}_{}_{}_{}_{}_{}{}",
        prefix,
        timestamp.year(),
        timestamp.month(),
        timestamp.day(),
        timestamp.hour(),
        timestamp.minute(),
        timestamp.second(),
        timestamp.nanosecond() / 1_000_000,
        suffix,
    )
}

pub fn timestamp_string<T: Into<chrono::DateTime<Local>>>(prefix: &str, timestamp: T, suffix: &str) -> String{
    let timestamp = timestamp.into();
    format!("{}{:02}_{:02}_{:02}_{:02}_{:02}_{:02}_{:03}{}",
        prefix,
        timestamp.year(),
        timestamp.month(),
        timestamp.day(),
        timestamp.hour(),
        timestamp.minute(),
        timestamp.second(),
        timestamp.nanosecond() / 1_000_000,
        suffix,
    )
}

pub fn timestamp_path_tz<P,TZ>(folder: P, prefix: &str, timestamp: chrono::DateTime<TZ>, suffix: &str, extension: &str) -> PathBuf
where
    P: AsRef<Path>,
    TZ: chrono::TimeZone
{
    let string = timestamp_string_tz(prefix, timestamp, suffix);
    let mut path = folder.as_ref().join(string);
    path.set_extension(extension);
    path
}

pub fn timestamp_path<P,T>(folder: P, prefix: &str, timestamp: T, suffix: &str, extension: &str) -> PathBuf
where
    P: AsRef<Path>,
    T: Into<chrono::DateTime<Local>>
{
    let string = timestamp_string(prefix, timestamp, suffix);
    let mut path = folder.as_ref().join(string);
    path.set_extension(extension);
    path
}