Added namespace Bk

src/bakatools/time/time_point.h

@@ -1,48 +1,50 @@
 #pragma once
 
-#include <spch.h>
+#include <bakatoolspch.h>
 #include "time_span.h"
 
-template<typename C, typename P>
+namespace Bk {
-struct TimePoint
+    template<typename C, typename P>
-{
+    struct TimePoint
-    TimePoint() = default;
-    TimePoint(std::chrono::time_point<C> point)
     {
-        this->point = std::chrono::time_point_cast<std::chrono::duration<long int, P>>(point);
+        TimePoint() = default;
-    }
+        TimePoint(std::chrono::time_point<C> point)
-
+        {
-    template<typename Pi>
+            this->point = std::chrono::time_point_cast<std::chrono::duration<long int, P>>(point);
-    TimePoint<C, Pi> as_unit()
+        }
-    {
+
-        return TimePoint<C, Pi>(std::chrono::time_point_cast<std::chrono::duration<long int, Pi>>(point));
+        template<typename Pi>
-    }
+        TimePoint<C, Pi> as_unit()
-
+        {
-    template<typename Ci>
+            return TimePoint<C, Pi>(std::chrono::time_point_cast<std::chrono::duration<long int, Pi>>(point));
-    TimePoint<Ci, P> as_clock()
+        }
-    {
+
-        return TimePoint(std::chrono::clock_cast<Ci>(point));
+        template<typename Ci>
-    }
+        TimePoint<Ci, P> as_clock()
-
+        {
-    TimeSpan<P> elasped()
+            return TimePoint(std::chrono::clock_cast<Ci>(point));
-    {
+        }
-        return TimeSpan<P>(point.time_since_epoch());
+
-    }
+        TimeSpan<P> elasped()
-
+        {
-    bool is_steady()
+            return TimeSpan<P>(point.time_since_epoch());
-    {
+        }
-        return C::is_steady;
+
-    }
+        bool is_steady()
-
+        {
-    TimeSpan<P> operator-(TimePoint<C, P>& tp)
+            return C::is_steady;
-    {
+        }
-        return TimeSpan<P>(point - tp.point);
+
-    }
+        TimeSpan<P> operator-(TimePoint<C, P>& tp)
-
+        {
-    static TimePoint<C, P> now() 
+            return TimeSpan<P>(point - tp.point);
-    {
+        }
-        return TimePoint<C, P>(C::now());
+
-    }
+        static TimePoint<C, P> now() 
-
+        {
-    std::chrono::time_point<C, std::chrono::duration<long int, P>> point;
+            return TimePoint<C, P>(C::now());
-};
+        }
+
+        std::chrono::time_point<C, std::chrono::duration<long int, P>> point;
+    };
+}

src/bakatools/time/time_span.h

@@ -1,40 +1,42 @@
 #pragma once
 
-#include <spch.h>
+#include <bakatoolspch.h>
-
+
-using Nanosecond = std::ratio<1,1000000000>;
+namespace Bk {
-using Microsecond = std::ratio<1,1000000>;
+    using Nanosecond = std::ratio<1,1000000000>;
-using Millisecond = std::ratio<1,1000>;
+    using Microsecond = std::ratio<1,1000000>;
-using Second = std::ratio<1,1>;
+    using Millisecond = std::ratio<1,1000>;
-using Minute = std::ratio<60, 1>;
+    using Second = std::ratio<1,1>;
-using Hour = std::ratio<3600, 1>;
+    using Minute = std::ratio<60, 1>;
-using Day = std::ratio<84600, 1>;
+    using Hour = std::ratio<3600, 1>;
-
+    using Day = std::ratio<84600, 1>;
-using SysClock = std::chrono::system_clock;
+
-using SteadyClock = std::chrono::steady_clock;
+    using SysClock = std::chrono::system_clock;
-using FileClock = std::chrono::file_clock;
+    using SteadyClock = std::chrono::steady_clock;
-using UtcClock = std::chrono::utc_clock;
+    using FileClock = std::chrono::file_clock;
-
+    using UtcClock = std::chrono::utc_clock;
-template<typename P>
+
-struct TimeSpan 
+    template<typename P>
-{
+    struct TimeSpan 
-    TimeSpan(int interval = 0) 
-    : interval(std::chrono::duration<long int, P>(interval)) {}
-    TimeSpan(std::chrono::duration<long int, P> interval)
-    : interval(interval) {}
-
-    template<typename T>
-    TimeSpan<T> as_unit()
     {
-        return TimeSpan<T>(std::chrono::duration_cast<std::chrono::duration<long int, T>>(interval));
+        TimeSpan(int interval = 0) 
-    }
+        : interval(std::chrono::duration<long int, P>(interval)) {}
-
+        TimeSpan(std::chrono::duration<long int, P> interval)
-    int count() { return interval.count(); }
+        : interval(interval) {}
-
+
-    TimeSpan<P> operator-(TimeSpan<P>& time_span)
+        template<typename T>
-    {
+        TimeSpan<T> as_unit()
-        return TimeSpan<P>(interval - time_span.interval);
+        {
-    }
+            return TimeSpan<T>(std::chrono::duration_cast<std::chrono::duration<long int, T>>(interval));
-
+        }
-    std::chrono::duration<long int, P> interval;
+
-};
+        int count() { return interval.count(); }
+
+        TimeSpan<P> operator-(TimeSpan<P>& time_span)
+        {
+            return TimeSpan<P>(interval - time_span.interval);
+        }
+
+        std::chrono::duration<long int, P> interval;
+    };
+}