diff --git a/lib/common/src/integer.rs b/lib/common/src/integer.rs
index 670102f..6d4d69f 100644
--- a/lib/common/src/integer.rs
+++ b/lib/common/src/integer.rs
@@ -2,19 +2,25 @@ pub use fixed_wide::fixed::{Fixed,Fix};
pub use ratio_ops::ratio::{Ratio,Divide};
//integer units
+
+/// specific example of a "default" time type
#[derive(Clone,Copy,Hash,Eq,PartialEq,PartialOrd,Debug)]
-pub struct Time(i64);
-impl Time{
- pub const MIN:Self=Self(i64::MIN);
- pub const MAX:Self=Self(i64::MAX);
- pub const ZERO:Self=Self(0);
- pub const ONE_SECOND:Self=Self(1_000_000_000);
- pub const ONE_MILLISECOND:Self=Self(1_000_000);
- pub const ONE_MICROSECOND:Self=Self(1_000);
- pub const ONE_NANOSECOND:Self=Self(1);
+pub enum TimeInner{}
+pub type RawTime=Time<TimeInner>;
+
+#[derive(Clone,Copy,Hash,Eq,PartialEq,PartialOrd,Debug)]
+pub struct Time<T>(i64,core::marker::PhantomData<T>);
+impl<T> Time<T>{
+ pub const MIN:Self=Self::raw(i64::MIN);
+ pub const MAX:Self=Self::raw(i64::MAX);
+ pub const ZERO:Self=Self::raw(0);
+ pub const ONE_SECOND:Self=Self::raw(1_000_000_000);
+ pub const ONE_MILLISECOND:Self=Self::raw(1_000_000);
+ pub const ONE_MICROSECOND:Self=Self::raw(1_000);
+ pub const ONE_NANOSECOND:Self=Self::raw(1);
#[inline]
pub const fn raw(num:i64)->Self{
- Self(num)
+ Self(num,core::marker::PhantomData)
}
#[inline]
pub const fn get(self)->i64{
@@ -22,19 +28,19 @@ impl Time{
}
#[inline]
pub const fn from_secs(num:i64)->Self{
- Self(Self::ONE_SECOND.0*num)
+ Self::raw(Self::ONE_SECOND.0*num)
}
#[inline]
pub const fn from_millis(num:i64)->Self{
- Self(Self::ONE_MILLISECOND.0*num)
+ Self::raw(Self::ONE_MILLISECOND.0*num)
}
#[inline]
pub const fn from_micros(num:i64)->Self{
- Self(Self::ONE_MICROSECOND.0*num)
+ Self::raw(Self::ONE_MICROSECOND.0*num)
}
#[inline]
pub const fn from_nanos(num:i64)->Self{
- Self(Self::ONE_NANOSECOND.0*num)
+ Self::raw(Self::ONE_NANOSECOND.0*num)
}
//should I have checked subtraction? force all time variables to be positive?
#[inline]
@@ -45,14 +51,18 @@ impl Time{
pub const fn to_ratio(self)->Ratio<Planar64,Planar64>{
Ratio::new(Planar64::raw(self.0),Planar64::raw(1_000_000_000))
}
-}
-impl From<Planar64> for Time{
#[inline]
- fn from(value:Planar64)->Self{
- Time((value*Planar64::raw(1_000_000_000)).fix_1().to_raw())
+ pub const fn coerce<U>(self)->Time<U>{
+ Time::raw(self.0)
}
}
-impl<Num,Den,N1,T1> From<Ratio<Num,Den>> for Time
+impl<T> From<Planar64> for Time<T>{
+ #[inline]
+ fn from(value:Planar64)->Self{
+ Self::raw((value*Planar64::raw(1_000_000_000)).fix_1().to_raw())
+ }
+}
+impl<T,Num,Den,N1,T1> From<Ratio<Num,Den>> for Time<T>
where
Num:core::ops::Mul<Planar64,Output=N1>,
N1:Divide<Den,Output=T1>,
@@ -60,34 +70,34 @@ impl<Num,Den,N1,T1> From<Ratio<Num,Den>> for Time
{
#[inline]
fn from(value:Ratio<Num,Den>)->Self{
- Time((value*Planar64::raw(1_000_000_000)).divide().fix().to_raw())
+ Self::raw((value*Planar64::raw(1_000_000_000)).divide().fix().to_raw())
}
}
-impl std::fmt::Display for Time{
+impl<T> std::fmt::Display for Time<T>{
#[inline]
fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
write!(f,"{}s+{:09}ns",self.0/Self::ONE_SECOND.0,self.0%Self::ONE_SECOND.0)
}
}
-impl std::default::Default for Time{
+impl<T> std::default::Default for Time<T>{
fn default()->Self{
- Self(0)
+ Self::raw(0)
}
}
-impl std::ops::Neg for Time{
- type Output=Time;
+impl<T> std::ops::Neg for Time<T>{
+ type Output=Self;
#[inline]
fn neg(self)->Self::Output {
- Time(-self.0)
+ Self::raw(-self.0)
}
}
macro_rules! impl_time_additive_operator {
($trait:ty, $method:ident) => {
- impl $trait for Time{
- type Output=Time;
+ impl<T> $trait for Time<T>{
+ type Output=Self;
#[inline]
fn $method(self,rhs:Self)->Self::Output {
- Time(self.0.$method(rhs.0))
+ Self::raw(self.0.$method(rhs.0))
}
}
};
@@ -97,7 +107,7 @@ impl_time_additive_operator!(core::ops::Sub,sub);
impl_time_additive_operator!(core::ops::Rem,rem);
macro_rules! impl_time_additive_assign_operator {
($trait:ty, $method:ident) => {
- impl $trait for Time{
+ impl<T> $trait for Time<T>{
#[inline]
fn $method(&mut self,rhs:Self){
self.0.$method(rhs.0)
@@ -108,53 +118,60 @@ macro_rules! impl_time_additive_assign_operator {
impl_time_additive_assign_operator!(core::ops::AddAssign,add_assign);
impl_time_additive_assign_operator!(core::ops::SubAssign,sub_assign);
impl_time_additive_assign_operator!(core::ops::RemAssign,rem_assign);
-impl std::ops::Mul for Time{
+impl<T> std::ops::Mul for Time<T>{
type Output=Ratio<fixed_wide::fixed::Fixed<2,64>,fixed_wide::fixed::Fixed<2,64>>;
#[inline]
fn mul(self,rhs:Self)->Self::Output{
Ratio::new(Fixed::raw(self.0)*Fixed::raw(rhs.0),Fixed::raw_digit(1_000_000_000i64.pow(2)))
}
}
-impl std::ops::Div<i64> for Time{
- type Output=Time;
+impl<T> std::ops::Div<i64> for Time<T>{
+ type Output=Self;
#[inline]
fn div(self,rhs:i64)->Self::Output{
- Time(self.0/rhs)
+ Self::raw(self.0/rhs)
}
}
-impl std::ops::Mul<i64> for Time{
- type Output=Time;
+impl<T> std::ops::Mul<i64> for Time<T>{
+ type Output=Self;
#[inline]
fn mul(self,rhs:i64)->Self::Output{
- Time(self.0*rhs)
+ Self::raw(self.0*rhs)
}
}
-impl core::ops::Mul<Time> for Planar64{
+impl<T> core::ops::Mul<Time<T>> for Planar64{
type Output=Ratio<Fixed<2,64>,Planar64>;
- fn mul(self,rhs:Time)->Self::Output{
+ fn mul(self,rhs:Time<T>)->Self::Output{
Ratio::new(self*Fixed::raw(rhs.0),Planar64::raw(1_000_000_000))
}
}
-#[test]
-fn time_from_planar64(){
- let a:Time=Planar64::from(1).into();
- assert_eq!(a,Time::ONE_SECOND);
-}
-#[test]
-fn time_from_ratio(){
- let a:Time=Ratio::new(Planar64::from(1),Planar64::from(1)).into();
- assert_eq!(a,Time::ONE_SECOND);
-}
-#[test]
-fn time_squared(){
- let a=Time::from_secs(2);
- assert_eq!(a*a,Ratio::new(Fixed::<2,64>::raw_digit(1_000_000_000i64.pow(2))*4,Fixed::<2,64>::raw_digit(1_000_000_000i64.pow(2))));
-}
-#[test]
-fn time_times_planar64(){
- let a=Time::from_secs(2);
- let b=Planar64::from(2);
- assert_eq!(b*a,Ratio::new(Fixed::<2,64>::raw_digit(1_000_000_000*(1<<32))<<2,Fixed::<1,32>::raw_digit(1_000_000_000)));
+#[cfg(test)]
+mod test_time{
+ use super::*;
+ #[derive(Clone,Copy,Hash,Eq,PartialEq,PartialOrd,Debug)]
+ struct Test;
+ type Time=super::Time<Test>;
+ #[test]
+ fn time_from_planar64(){
+ let a:Time=Planar64::from(1).into();
+ assert_eq!(a,Time::ONE_SECOND);
+ }
+ #[test]
+ fn time_from_ratio(){
+ let a:Time=Ratio::new(Planar64::from(1),Planar64::from(1)).into();
+ assert_eq!(a,Time::ONE_SECOND);
+ }
+ #[test]
+ fn time_squared(){
+ let a=Time::from_secs(2);
+ assert_eq!(a*a,Ratio::new(Fixed::<2,64>::raw_digit(1_000_000_000i64.pow(2))*4,Fixed::<2,64>::raw_digit(1_000_000_000i64.pow(2))));
+ }
+ #[test]
+ fn time_times_planar64(){
+ let a=Time::from_secs(2);
+ let b=Planar64::from(2);
+ assert_eq!(b*a,Ratio::new(Fixed::<2,64>::raw_digit(1_000_000_000*(1<<32))<<2,Fixed::<1,32>::raw_digit(1_000_000_000)));
+ }
}
#[inline]