mirror of
https://github.com/EnderIce2/Fennix.git
synced 2025-06-07 20:27:59 +00:00
fix(kernel/std): 🎨 implementation for <chrono>, <ratio> & <thread> were broken
This commit is contained in:
parent
07d0ca0438
commit
905b6933c9
GPG Key ID:
FEB6B8A8507BA62E
@ -28,22 +28,25 @@ namespace std
|
||||
class duration
|
||||
{
|
||||
private:
|
||||
Rep rep_;
|
||||
std::ratio<Period::num, Period::denom> period_;
|
||||
Rep _rep;
|
||||
std::ratio<Period::num, Period::den> _period;
|
||||
|
||||
public:
|
||||
using rep = Rep;
|
||||
using period = Period;
|
||||
|
||||
constexpr duration() = default;
|
||||
duration(const duration &) = default;
|
||||
|
||||
template <class Rep2>
|
||||
constexpr explicit duration(const Rep2 &r) { rep_ = r; }
|
||||
constexpr explicit duration(const Rep2 &r) { _rep = r; }
|
||||
|
||||
template <class Rep2, class Period2>
|
||||
constexpr duration(const duration<Rep2, Period2> &d);
|
||||
|
||||
duration &operator=(const duration &other) = default;
|
||||
|
||||
constexpr Rep count() const { return rep_; }
|
||||
constexpr Rep count() const { return _rep; }
|
||||
|
||||
static constexpr duration zero() noexcept;
|
||||
static constexpr duration min() noexcept;
|
||||
@ -51,54 +54,54 @@ namespace std
|
||||
constexpr std::common_type_t<duration> operator+() const;
|
||||
constexpr std::common_type_t<duration> operator-() const;
|
||||
|
||||
constexpr duration operator++(int) { return duration(rep_++); }
|
||||
constexpr duration operator--(int) { return duration(rep_--); }
|
||||
constexpr duration operator++(int) { return duration(_rep++); }
|
||||
constexpr duration operator--(int) { return duration(_rep--); }
|
||||
|
||||
constexpr duration &operator++()
|
||||
{
|
||||
++rep_;
|
||||
++_rep;
|
||||
return *this;
|
||||
}
|
||||
|
||||
constexpr duration &operator--()
|
||||
{
|
||||
--rep_;
|
||||
--_rep;
|
||||
return *this;
|
||||
}
|
||||
|
||||
constexpr duration &operator+=(const duration &d)
|
||||
{
|
||||
rep_ += d.count();
|
||||
_rep += d.count();
|
||||
return *this;
|
||||
}
|
||||
|
||||
constexpr duration &operator-=(const duration &d)
|
||||
{
|
||||
rep_ -= d.count();
|
||||
_rep -= d.count();
|
||||
return *this;
|
||||
}
|
||||
|
||||
constexpr duration &operator*=(const Rep &rhs)
|
||||
{
|
||||
rep_ *= rhs;
|
||||
_rep *= rhs;
|
||||
return *this;
|
||||
}
|
||||
|
||||
constexpr duration &operator/=(const Rep &rhs)
|
||||
{
|
||||
rep_ /= rhs;
|
||||
_rep /= rhs;
|
||||
return *this;
|
||||
}
|
||||
|
||||
constexpr duration &operator%=(const Rep &rhs)
|
||||
{
|
||||
rep_ %= rhs;
|
||||
_rep %= rhs;
|
||||
return *this;
|
||||
}
|
||||
|
||||
constexpr duration &operator%=(const duration &rhs)
|
||||
{
|
||||
rep_ %= rhs.count();
|
||||
_rep %= rhs.count();
|
||||
return *this;
|
||||
}
|
||||
};
|
||||
@ -120,7 +123,91 @@ namespace std
|
||||
template <class ToDuration, class Rep, class Period>
|
||||
constexpr ToDuration duration_cast(const std::chrono::duration<Rep, Period> &d)
|
||||
{
|
||||
return ToDuration(d.count());
|
||||
typedef typename ToDuration::rep ToRep;
|
||||
typedef typename ToDuration::period ToPeriod;
|
||||
typedef std::ratio_divide<Period, ToPeriod> CF;
|
||||
typedef typename std::common_type<Rep, ToRep, intmax_t>::type CR;
|
||||
CR cr_count = static_cast<CR>(d.count());
|
||||
CR cr_num = static_cast<CR>(CF::num);
|
||||
CR cr_den = static_cast<CR>(CF::den);
|
||||
|
||||
if constexpr (CF::num == 1 && CF::den == 1)
|
||||
return ToDuration(static_cast<ToRep>(cr_count));
|
||||
else if constexpr (CF::den == 1)
|
||||
return ToDuration(static_cast<ToRep>(cr_count * cr_num));
|
||||
else if constexpr (CF::num == 1)
|
||||
return ToDuration(static_cast<ToRep>(cr_count / cr_den));
|
||||
else
|
||||
return ToDuration(static_cast<ToRep>(cr_count * cr_num / cr_den));
|
||||
}
|
||||
}
|
||||
|
||||
inline namespace literals
|
||||
{
|
||||
inline namespace chrono_literals
|
||||
{
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wliteral-suffix"
|
||||
constexpr std::chrono::hours operator""h(unsigned long long h)
|
||||
{
|
||||
return std::chrono::hours(h);
|
||||
}
|
||||
|
||||
constexpr std::chrono::duration<long double, std::ratio<3600, 1>> operator""h(long double h)
|
||||
{
|
||||
return std::chrono::duration<long double, std::ratio<3600, 1>>(h);
|
||||
}
|
||||
|
||||
constexpr std::chrono::minutes operator""min(unsigned long long m)
|
||||
{
|
||||
return std::chrono::minutes(m);
|
||||
}
|
||||
|
||||
constexpr std::chrono::duration<long double, std::ratio<60, 1>> operator""min(long double m)
|
||||
{
|
||||
return std::chrono::duration<long double, std::ratio<60, 1>>(m);
|
||||
}
|
||||
|
||||
constexpr std::chrono::seconds operator""s(unsigned long long s)
|
||||
{
|
||||
return std::chrono::seconds(s);
|
||||
}
|
||||
|
||||
constexpr std::chrono::duration<long double> operator""s(long double s)
|
||||
{
|
||||
return std::chrono::duration<long double>(s);
|
||||
}
|
||||
|
||||
constexpr std::chrono::milliseconds operator""ms(unsigned long long ms)
|
||||
{
|
||||
return std::chrono::milliseconds(ms);
|
||||
}
|
||||
|
||||
constexpr std::chrono::duration<long double, std::milli> operator""ms(long double ms)
|
||||
{
|
||||
return std::chrono::duration<long double, std::milli>(ms);
|
||||
}
|
||||
|
||||
constexpr std::chrono::microseconds operator""us(unsigned long long us)
|
||||
{
|
||||
return std::chrono::microseconds(us);
|
||||
}
|
||||
|
||||
constexpr std::chrono::duration<long double, std::micro> operator""us(long double us)
|
||||
{
|
||||
return std::chrono::duration<long double, std::micro>(us);
|
||||
}
|
||||
|
||||
constexpr std::chrono::nanoseconds operator""ns(unsigned long long ns)
|
||||
{
|
||||
return std::chrono::nanoseconds(ns);
|
||||
}
|
||||
|
||||
constexpr std::chrono::duration<long double, std::nano> operator""ns(long double ns)
|
||||
{
|
||||
return std::chrono::duration<long double, std::nano>(ns);
|
||||
}
|
||||
#pragma GCC diagnostic pop
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -17,40 +17,173 @@
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <types.h>
|
||||
#include <type_traits>
|
||||
|
||||
namespace std
|
||||
{
|
||||
namespace detail
|
||||
{
|
||||
template <intmax_t A, intmax_t B>
|
||||
struct GCD
|
||||
{
|
||||
static constexpr intmax_t value = GCD<B, A % B>::value;
|
||||
};
|
||||
|
||||
template <intmax_t A>
|
||||
struct GCD<A, 0>
|
||||
{
|
||||
static constexpr intmax_t value = A;
|
||||
};
|
||||
}
|
||||
|
||||
template <intmax_t Num, intmax_t Denom = 1>
|
||||
class ratio
|
||||
{
|
||||
private:
|
||||
static_assert(Denom != 0, "Denominator cannot be zero");
|
||||
static_assert(Num >= -__INTMAX_MAX__ && Denom >= -__INTMAX_MAX__, "Overflow");
|
||||
|
||||
private:
|
||||
static constexpr intmax_t __first = Num < 0 ? -Num : Num;
|
||||
static constexpr intmax_t __second = Denom < 0 ? -Denom : Denom;
|
||||
static constexpr intmax_t __gcd = detail::GCD<__first, __second>::value;
|
||||
|
||||
public:
|
||||
typedef ratio<Num, Denom> type;
|
||||
static constexpr intmax_t num = Num;
|
||||
static constexpr intmax_t denom = Denom;
|
||||
static constexpr intmax_t num = Denom < 0 ? -Num / __gcd : Num / __gcd;
|
||||
static constexpr intmax_t den = Denom < 0 ? -Denom / __gcd : Denom / __gcd;
|
||||
};
|
||||
|
||||
namespace detail
|
||||
{
|
||||
template <typename _Tp>
|
||||
constexpr bool __ta_is_ratio = false;
|
||||
|
||||
template <intmax_t _Num, intmax_t _Den>
|
||||
constexpr bool __ta_is_ratio<ratio<_Num, _Den>> = true;
|
||||
|
||||
template <class R1, class R2>
|
||||
constexpr bool __is_equal()
|
||||
{
|
||||
return R1::num == R2::num && R1::den == R2::den;
|
||||
}
|
||||
|
||||
template <class R1, class R2>
|
||||
constexpr bool __is_less()
|
||||
{
|
||||
return R1::num * R2::den < R2::num * R1::den;
|
||||
}
|
||||
|
||||
template <class R1, class R2>
|
||||
constexpr bool __is_less_or_equal()
|
||||
{
|
||||
return R1::num * R2::den <= R2::num * R1::den;
|
||||
}
|
||||
|
||||
template <class R1, class R2>
|
||||
constexpr bool __is_greater()
|
||||
{
|
||||
return R1::num * R2::den > R2::num * R1::den;
|
||||
}
|
||||
|
||||
template <class R1, class R2>
|
||||
constexpr bool __is_greater_or_equal()
|
||||
{
|
||||
return R1::num * R2::den >= R2::num * R1::den;
|
||||
}
|
||||
};
|
||||
|
||||
template <class R1, class R2>
|
||||
using ratio_add = ratio<R1::num * R2::denom + R2::num * R1::denom, R1::denom * R2::denom>;
|
||||
template <class R1, class R2>
|
||||
using ratio_subtract = ratio<R1::num * R2::denom - R2::num * R1::denom, R1::denom * R2::denom>;
|
||||
template <class R1, class R2>
|
||||
using ratio_multiply = ratio<R1::num * R2::num, R1::denom * R2::denom>;
|
||||
template <class R1, class R2>
|
||||
using ratio_divide = ratio<R1::num * R2::denom, R1::denom * R2::num>;
|
||||
struct ratio_add
|
||||
{
|
||||
static_assert(detail::__ta_is_ratio<R1> && detail::__ta_is_ratio<R2>, "Both template arguments must be std::ratio");
|
||||
|
||||
static constexpr intmax_t num = R1::num * R2::den + R2::num * R1::den;
|
||||
static constexpr intmax_t den = R1::den * R2::den;
|
||||
|
||||
using type = ratio<num, den>;
|
||||
};
|
||||
|
||||
template <class R1, class R2>
|
||||
struct ratio_equal;
|
||||
struct ratio_subtract
|
||||
{
|
||||
static_assert(detail::__ta_is_ratio<R1> && detail::__ta_is_ratio<R2>, "Both template arguments must be std::ratio");
|
||||
|
||||
static constexpr intmax_t num = R1::num * R2::den - R2::num * R1::den;
|
||||
static constexpr intmax_t den = R1::den * R2::den;
|
||||
|
||||
using type = ratio<num, den>;
|
||||
};
|
||||
|
||||
template <class R1, class R2>
|
||||
struct ratio_not_equal;
|
||||
struct ratio_multiply
|
||||
{
|
||||
static_assert(detail::__ta_is_ratio<R1> && detail::__ta_is_ratio<R2>, "Both templates must be ratios");
|
||||
|
||||
static constexpr intmax_t num = R1::num * R2::num;
|
||||
static constexpr intmax_t den = R1::den * R2::den;
|
||||
|
||||
using type = ratio<num, den>;
|
||||
};
|
||||
|
||||
template <class R1, class R2>
|
||||
struct ratio_less;
|
||||
struct ratio_divide
|
||||
{
|
||||
static_assert(R2::num != 0, "Divide by zero");
|
||||
|
||||
static constexpr intmax_t num = R1::num * R2::den;
|
||||
static constexpr intmax_t den = R1::den * R2::num;
|
||||
|
||||
using type = ratio<num, den>;
|
||||
};
|
||||
|
||||
template <class R1, class R2>
|
||||
struct ratio_less_equal;
|
||||
struct ratio_equal : public std::integral_constant<bool, detail::__is_equal<R1, R2>()>
|
||||
{
|
||||
};
|
||||
|
||||
template <class R1, class R2>
|
||||
struct ratio_greater;
|
||||
struct ratio_not_equal : public std::integral_constant<bool, !detail::__is_equal<R1, R2>()>
|
||||
{
|
||||
};
|
||||
|
||||
template <class R1, class R2>
|
||||
struct ratio_greater_equal;
|
||||
struct ratio_less : public std::integral_constant<bool, detail::__is_less<R1, R2>()>
|
||||
{
|
||||
};
|
||||
|
||||
template <class R1, class R2>
|
||||
struct ratio_less_equal : public std::integral_constant<bool, detail::__is_less_or_equal<R1, R2>()>
|
||||
{
|
||||
};
|
||||
|
||||
template <class R1, class R2>
|
||||
struct ratio_greater : public std::integral_constant<bool, detail::__is_greater<R1, R2>()>
|
||||
{
|
||||
};
|
||||
|
||||
template <class R1, class R2>
|
||||
struct ratio_greater_equal : public std::integral_constant<bool, detail::__is_greater_or_equal<R1, R2>()>
|
||||
{
|
||||
};
|
||||
|
||||
template <class R1, class R2>
|
||||
constexpr bool ratio_equal_v = ratio_equal<R1, R2>::value;
|
||||
|
||||
template <class R1, class R2>
|
||||
constexpr bool ratio_not_equal_v = ratio_not_equal<R1, R2>::value;
|
||||
|
||||
template <class R1, class R2>
|
||||
constexpr bool ratio_less_v = ratio_less<R1, R2>::value;
|
||||
|
||||
template <class R1, class R2>
|
||||
constexpr bool ratio_less_equal_v = ratio_less_equal<R1, R2>::value;
|
||||
|
||||
template <class R1, class R2>
|
||||
constexpr bool ratio_greater_v = ratio_greater<R1, R2>::value;
|
||||
|
||||
template <class R1, class R2>
|
||||
constexpr bool ratio_greater_equal_v = ratio_greater_equal<R1, R2>::value;
|
||||
|
||||
// typedef ratio<1, 1000000000000000000000000000000> quecto;
|
||||
// typedef ratio<1, 1000000000000000000000000000> ronto;
|
||||
|
||||
@ -21,6 +21,7 @@
|
||||
#include <task.hpp>
|
||||
#include <debug.h>
|
||||
#include <smp.hpp>
|
||||
#include <ostream>
|
||||
#include <chrono>
|
||||
|
||||
extern Tasking::Task *TaskManager;
|
||||
@ -84,17 +85,26 @@ namespace std
|
||||
|
||||
namespace this_thread
|
||||
{
|
||||
thread::id get_id() noexcept;
|
||||
|
||||
void yield() noexcept;
|
||||
|
||||
template <class Clock, class Duration>
|
||||
void sleep_until(const chrono::time_point<Clock, Duration> &abs_time);
|
||||
thread::id get_id() noexcept;
|
||||
|
||||
template <class Rep, class Period>
|
||||
void sleep_for(const chrono::duration<Rep, Period> &rel_time)
|
||||
void sleep_for(const chrono::duration<Rep, Period> &sleep_duration)
|
||||
{
|
||||
TaskManager->Sleep(chrono::duration_cast<std::chrono::milliseconds>(rel_time).count());
|
||||
TaskManager->Sleep(chrono::duration_cast<std::chrono::nanoseconds>(sleep_duration).count());
|
||||
}
|
||||
|
||||
template <class Clock, class Duration>
|
||||
void sleep_until(const std::chrono::time_point<Clock, Duration> &sleep_time)
|
||||
{
|
||||
TaskManager->Sleep(chrono::duration_cast<std::chrono::nanoseconds>(sleep_time - Clock::now()).count());
|
||||
}
|
||||
}
|
||||
|
||||
template <class CharT, class Traits>
|
||||
std::basic_ostream<CharT, Traits> &operator<<(std::basic_ostream<CharT, Traits> &ost, std::thread::id id)
|
||||
{
|
||||
return ost << id;
|
||||
}
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user