#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(dead_code)]
use time;
use std::time::{self as std_time, SystemTime};
pub mod errcode;
pub mod tsidallocator;
pub use tsidallocator::TsIdAllocator;
pub mod tsmap;
pub use tsmap::TsHashMap;
pub mod tsqueue;
pub use tsqueue::TsDequeue;
pub mod indexring;
pub mod rawstring;
pub mod atomicqueue;
pub use atomicqueue::AtomicDequeue;
pub mod spin_lock;
pub use spin_lock::spin_lock_t;
pub mod sched;
pub mod bitmap;
pub use bitmap::bitmap_t;
pub mod ringbuf;
pub use ringbuf::ring_buffer_t;
pub use ringbuf::ts_ring_buffer_t;
pub mod uuid;
pub use uuid::uuid_t;
pub type rsm_time_t = time::OffsetDateTime;
pub const UNIX_EPOCH_STRING:&str = "1970-1-1 00:00:00.000";
#[inline(always)]
pub fn get_now_usec64() -> u64 {
match SystemTime::UNIX_EPOCH.elapsed() {
Err(_) => 0,
Ok(d) => d.as_micros() as u64,
}
}
#[inline(always)]
pub fn get_time_from_usec(usec: u64) -> SystemTime {
match SystemTime::UNIX_EPOCH.checked_add(std_time::Duration::from_micros(usec)) {
None => std_time::SystemTime::UNIX_EPOCH,
Some(t) => t,
}
}
const INVALID_MONTH:u16=0xFFFF;
fn get_month(day_in_year:u16,leap_year:bool)->(u16,u16) {
const days_per_mon1:[u16;12]=[31,28,31,30,31,30,31,31,30,31,30,31];
const days_per_mon2:[u16;12]=[31,29,31,30,31,30,31,31,30,31,30,31];
let days=if leap_year {&days_per_mon2} else {&days_per_mon1};
let mut cuml = 0;
for i in 0..12 {
cuml+=days[i];
if day_in_year<cuml {
return ((i+1) as u16,day_in_year+1 -(cuml-days[i]));
}
}
return (INVALID_MONTH,0);
}
pub fn is_leap_year(year:u64)->bool {
if ((year % 4 ==0) && (year % 100!=0)) || (year % 400==0) {
return true
} else {
return false;
}
}
fn get_years_of_days(days:u64)->u64 {
if days % 365 >58 {
return days/365
} else {
days/365+1
}
}
pub fn ceiling(a:u64,b:u64)->u64 {
if a % b==0 {
return a/b
} else {
return a/b+1
}
}
fn get_years_since_1970(days:u64)->(u64,u64) {
let mut years = get_years_of_days(days);
let leap_years = (years+2)/4 - (70+years)/100+(370+years)/400;
years = (days-leap_years)/365;
return (years,years*365+leap_years);
}
const SECS_PER_DAY:u64=24*3600;
#[derive(Clone)]
pub struct datetime_t {
systime:std_time::SystemTime,
year:u32,
mon:u8,
day:u8,
hour:u8,
min:u8,
sec:u8,
msec:u16,
}
impl datetime_t {
pub fn new()->Self {
return datetime_t{
systime:std_time::UNIX_EPOCH,
year:1970,
mon:1,
day:1,
hour:0,
min:0,
sec:0,
msec:0,
}
}
pub fn get_year(&self)->u32 {
self.year
}
pub fn get_mon_in_year(&self)->u8 {
self.mon
}
pub fn get_day_in_mon(&self)->u8 {
self.day
}
pub fn get_hour_in_day(&self)->u8 {
self.hour
}
pub fn get_min_in_hour(&self)->u8 {
self.min
}
pub fn get_secs_in_min(&self)->u8 {
self.sec
}
pub fn get_day_in_year(&self)->u16 {
const days_per_mon1:[u16;12]=[31,28,31,30,31,30,31,31,30,31,30,31];
const days_per_mon2:[u16;12]=[31,29,31,30,31,30,31,31,30,31,30,31];
let pCount = if is_leap_year(self.year as u64) {
&days_per_mon2
} else {
&days_per_mon1
};
let mut days_in_year = 0;
for i in 0..self.mon as usize {
days_in_year+=pCount[i];
}
return days_in_year+self.day as u16;
}
pub fn prev_ndays(&self,days:u64)->Self {
let prev_time=match self.systime.checked_sub(std_time::Duration::from_secs(SECS_PER_DAY*days)) {
Some(d)=>d,
None=>self.systime.clone(),
};
return get_datetime_from_std(&prev_time)
}
pub fn prev_secs(&self,secs:u64)->Self {
let prev_time=match self.systime.checked_sub(std_time::Duration::from_secs(secs)) {
Some(d)=>d,
None=>self.systime.clone(),
};
return get_datetime_from_std(&prev_time)
}
pub fn to_usecs(&self)->u64 {
match self.systime.duration_since(std_time::UNIX_EPOCH) {
Err(_) => return 0,
Ok(d) => d.as_micros() as u64,
}
}
}
pub fn get_datetime_from_std(dt:&std_time::SystemTime) ->datetime_t {
let mut offset = 0;
if let Ok(local) = time::UtcOffset::current_local_offset() {
offset=local.whole_seconds();
}
let dur = (dt.duration_since(std_time::UNIX_EPOCH).unwrap().as_millis() as i64 + (offset as i64)*1000) as u64 ;
if dur==0 {
return datetime_t::new();
}
let total_days = dur/(SECS_PER_DAY*1000);
let (years,days_elapsed)=get_years_since_1970(total_days);
let days_in_year= total_days-days_elapsed;
let leap_year = is_leap_year(1970+years);
let (mon,day_in_mon) = get_month(days_in_year as u16, leap_year);
let mut msec = dur % (SECS_PER_DAY*1000);
let hour = msec /(3600*1000);
msec-=hour*3600*1000;
let min = msec / (60*1000);
msec-=min*60*1000;
let sec=msec/1000;
msec = msec %1000;
return datetime_t{
systime:dt.clone(),
year:(years+1970) as u32,
mon:mon as u8,
day:day_in_mon as u8,
hour:hour as u8,
min:min as u8,
sec:sec as u8,
msec:msec as u16,
}
}
pub fn format_datetime(dt:&std_time::SystemTime) ->String {
let t = get_datetime_from_std(dt);
format!("{:04}-{:02}-{:02} {:02}:{:02}:{:02}.{:03}",
t.year,t.mon,t.day,t.hour,t.min,t.sec,t.msec)
}
pub fn format_datetime2(dt:&std_time::SystemTime) ->String {
let tm = time::OffsetDateTime::from(*dt);
format!("{}",tm)
}
pub fn format_datetime_golang(dt:&std_time::SystemTime) ->String {
let t = get_datetime_from_std(dt);
format!("{:04}-{:02}-{:02}T{:02}:{:02}:{:02}Z",
t.year,t.mon,t.day,t.hour,t.min,t.sec)
}