Changeset 483

Timestamp:

01/08/11 06:09:01 (14 years ago)

Author:

sean

Message:

Added new core.time. Tested on OSX. Still need to test on Windows.

Files:

• trunk/src/core/sync/condition.d (modified) (1 diff)
• trunk/src/core/sync/config.d (modified) (1 diff)
• trunk/src/core/sync/semaphore.d (modified) (2 diffs)
• trunk/src/core/thread.d (modified) (3 diffs)
• trunk/src/core/time.d (modified) (1 diff)

trunk/src/core/sync/condition.d

@@ -207 +207 @@
-     * Returns:
-     *  true if notified before the timeout and false if not.
-     */
-    bool wait( long period )
-    in
-    {
-        assert( period >= 0 );
-    }
-    body
-    {
-
-
-
-
-
-
+
-    }
-
-
-    /**
-     * Notifies one waiter.
-     *
-     * Throws:
-     *  SyncException on error.
-     */
-    void notify()

trunk/src/core/sync/config.d

@@ -43 +43 @@
-
-    void mktspec( ref timespec t, Duration delta )
-    {
-        mktspec( t );
-        mvtspec( t, delta );
-    }
-
-
-    void mvtspec( ref timespec t, Duration delta )
-    {
-        enum : uint
-        {
-            NANOS_PER_SECOND = 1000_000_000
-        }
-
-        auto val  = delta;
-
-
-
-
+
+
-        
-
+
+
+
+
-        {
-            t.tv_sec  = t.tv_sec.max;
-(val.totalNanoseconds % NANOS_PER_SECOND)
+val.fracSec.nsecs
-        }
-        else
-        {
-Seconds
-(val.totalNanoseconds % NANOS_PER_SECOND)
+!("seconds")()
+val.fracSec.nsecs
-        }
-    }
-}

trunk/src/core/sync/semaphore.d

@@ -178 +178 @@
-     */
-    bool wait( Duration val )
-    in
-    {
-        assert( !val.isNegative );
-    }
-    body
-    {
-        version( Win32 )
-        {
-milliseconds
+dur!("msecs")
-
-            while( val > maxWaitMillis )
-            {
-                auto rc = WaitForSingleObject( m_hndl, cast(uint)
-Milliseconds
+!("msecs")()
-                switch( rc )
-                {
-                case WAIT_OBJECT_0:
-                    return true;
-                case WAIT_TIMEOUT:
-                    val -= maxWaitMillis;
-                    continue;
-                default:
-                    throw new SyncException( "Unable to wait for semaphore" );
-                }
-            }
-Milliseconds
+!("msecs")()
-            {
-            case WAIT_OBJECT_0:
-                return true;
-            case WAIT_TIMEOUT:
-                return false;
-            default:
-                throw new SyncException( "Unable to wait for semaphore" );
-            }
-        }
-        else version( OSX )
-        {            
-            mach_timespec_t t = void;
-            (cast(byte*) &t)[0 .. t.sizeof] = 0;
-
-
-
-
-
-
-
-
-
+
+
+
-                {
-                    t.tv_sec  = t.tv_sec.max;
-(val.totalNanoseconds % NANOS_PER_SECOND)
+val.fracSec.nsecs
-                }
-                else
-                {
-Seconds
-(val.totalNanoseconds % NANOS_PER_SECOND)
+!("seconds")()
+val.fracSec.nsecs
-                }
-            }
-            while( true )
-            {
-                auto rc = semaphore_timedwait( m_hndl, t );
-                if( !rc )
-                    return true;
-                if( rc == KERN_OPERATION_TIMED_OUT )
-                    return false;
-                if( rc != KERN_ABORTED || errno != EINTR )
@@ -285 +280 @@
-     * Returns:
-     *  true if notified before the timeout and false if not.
-     */
-    bool wait( long period )
-    in
-    {
-        assert( period >= 0 );
-    }
-    body
-    {
-
-
-
-
-
-
+
-    }
-
-
-    /**
-     * Atomically increment the current count by one.  This will notify one
-     * waiter, if there are any in the queue.
-     *
-     * Throws:
-     *  SyncException on error.
-     */

trunk/src/core/thread.d

@@ -1095 +1095 @@
-                Sleep( cast(uint)
-                       maxSleepMillis.totalMilliseconds );
-                val -= maxSleepMillis;
-            }
-            Sleep( cast(uint) val.totalMilliseconds );
-        }
-        else version( Posix )
-        {
-            timespec tin  = void;
-            timespec tout = void;
-
-            enum : uint
-            {
-                NANOS_PER_SECOND = 1000_000_000
-            }
-            
-Seconds
+!("seconds")()
-            {
-                tin.tv_sec  = tin.tv_sec.max;
-(val.totalNanoseconds % NANOS_PER_SECOND)
+val.fracSec.nsecs
-            }
-            else
-            {
-Seconds
-(val.totalNanoseconds % NANOS_PER_SECOND)
+!("seconds")()
+val.fracSec.nsecs
-            }
-            while( true )
-            {
-                if( !nanosleep( &tin, &tout ) )
-                    return;
-                if( getErrno() != EINTR )
-                    throw new ThreadException( "Unable to sleep for the specified duration" );
-                tin = tout;
-            }
-        }
@@ -1150 +1145 @@
-     *
-     * ------------------------------------------------------------------------
-     */
-    static void sleep( long period )
-    in
-    {
-        assert( period >= 0 );
-    }
-    body
-    {
-
-
-
-
-
-
+
-    }
-
-
-    /**
-     * Forces a context switch to occur away from the calling thread.
-     */
-    static void yield()
-    {
-        version( Windows )
-        {
@@ -1680 +1670 @@
-    //
-    static void add( Thread t )
-    in
-    {
-        assert( t );
-        assert( !t.next && !t.prev );
-        assert( t.isRunning );
-    }
-    body
-    {
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        }
-    }
-
-
-    //
-    // Remove a thread from the global thread list.
-    //
-    static void remove( Thread t )
-    in
-    {

trunk/src/core/time.d

@@ -1 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-module core.time;
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-struct Duration
-{
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        {
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        }
-        else
-        static if( op == "+" )
-        {
-
+
+
+
-        }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        {
-
+
+
-        }
+
+        if(ticksPerSec >= 1)
+            assert(TickDuration.from!"seconds"(7).seconds == 7);
+    }
+
+    //test from!"msecs"().
+    unittest
+    {
+        auto t = TickDuration.from!"msecs"(1_000_000);
+        assert(t.msecs == 1_000_000);
+        t = TickDuration.from!"msecs"(2_000_000);
+        assert(t.msecs == 2_000_000);
+
+        if(ticksPerSec >= 1000)
+        {
+            t.length -= 1;
+            assert(t.msecs == 1_999_999);
+        }
+
+        if(ticksPerSec >= 1_000)
+            assert(TickDuration.from!"msecs"(7).msecs == 7);
+    }
+
+    //test from!"usecs"().
+    unittest
+    {
+        auto t = TickDuration.from!"usecs"(1_000_000);
+        assert(t.usecs == 1_000_000);
+        t = TickDuration.from!"usecs"(2_000_000);
+        assert(t.usecs == 2_000_000);
+
+        if(ticksPerSec >= 1_000_000)
+        {
+            t.length -= 1;
+            assert(t.usecs == 1_999_999);
+        }
+
+        if(ticksPerSec >= 1_000_000)
+            assert(TickDuration.from!"usecs"(7).usecs == 7);
+    }
+
+    //test from!"hnsecs"().
+    unittest
+    {
+        auto t = TickDuration.from!"hnsecs"(10_000_000);
+        assert(t.hnsecs == 10_000_000);
+        t = TickDuration.from!"hnsecs"(20_000_000);
+        assert(t.hnsecs == 20_000_000);
+
+        if(ticksPerSec == 1_000_000)
+        {
+            t.length -= 1;
+            assert(t.hnsecs == 19999990);
+            assert(TickDuration.from!"hnsecs"(70).hnsecs == 70);
+            assert(TickDuration.from!"hnsecs"(7).hnsecs == 0);
+        }
+
+        if(ticksPerSec >= 10_000_000)
+        {
+            t.length -= 1;
+            assert(t.hnsecs == 19999999);
+            assert(TickDuration.from!"hnsecs"(70).hnsecs == 70);
+            assert(TickDuration.from!"hnsecs"(7).hnsecs == 7);
+        }
+    }
+
+    //test from!"nsecs"().
+    unittest
+    {
+        auto t = TickDuration.from!"nsecs"(1_000_000_000);
+        assert(t.nsecs == 1_000_000_000);
+        t = TickDuration.from!"nsecs"(2_000_000_000);
+        assert(t.nsecs == 2_000_000_000);
+
+        if(ticksPerSec == 1_000_000)
+        {
+            t.length -= 1;
+            assert(t.nsecs == 1999999000);
+        }
+
+        if(ticksPerSec >= 1_000_000_000)
+        {
+            t.length -= 1;
+            assert(t.nsecs == 1999999999);
+        }
+    }
+
+
+    /++
+        Returns a Duration with the same number of hnsecs as this TickDuration.
+      +/
+    Duration opCast(T)() const pure nothrow
+        if(is(T == Duration))
+    {
+        return Duration(hnsecs);
+    }
+
+    unittest
+    {
+        auto t = TickDuration.from!"hnsecs"(10000000);
+        assert(cast(Duration)t == Duration(10000000));
+        t = TickDuration.from!"hnsecs"(20000000);
+        assert(cast(Duration)t == Duration(20000000));
+
+        if(ticksPerSec == 1_000_000)
+        {
+            t.length -= 1;
+            assert(cast(Duration)t == Duration(19999990));
+            assert(cast(Duration)TickDuration.from!"hnsecs"(70) == Duration(70));
+            assert(cast(Duration)TickDuration.from!"hnsecs"(7) == Duration(0));
+        }
+
+        if(ticksPerSec >= 10_000_000)
+        {
+            t.length -= 1;
+            assert(cast(Duration)t == Duration(19999999));
+            assert(cast(Duration)TickDuration.from!"hnsecs"(70) == Duration(70));
+            assert(cast(Duration)TickDuration.from!"hnsecs"(7) == Duration(7));
+        }
+    }
+
+
+    /++
+       operator overloading "-=, +="
+
+       BUG: This should be return "ref TickDuration", but bug2460 prevents that.
+      +/
+    /+ref TickDuration+/ void opOpAssign(string op)(in TickDuration rhs) pure nothrow
+        if(op == "+" || op == "-")
+    {
+        mixin("length " ~ op ~ "= rhs.length;");
+        //return this;
+    }
+
+    unittest
+    {
+        TickDuration a = TickDuration.currSystemTick, b = TickDuration.currSystemTick;
+        a += TickDuration.currSystemTick;
+        assert(a.to!("seconds", real)() >= 0);
+        b -= TickDuration.currSystemTick;
+        assert(b.to!("seconds", real)() <= 0);
+    }
+
+
+    /++
+       operator overloading "-, +"
+      +/
+    TickDuration opBinary(string op)(in TickDuration rhs) const pure nothrow
+        if(op == "-" || op == "+")
+    {
+        return TickDuration(mixin("length " ~ op ~ " rhs.length"));
+    }
+
+    unittest
+    {
+        auto a = TickDuration.currSystemTick;
+        auto b = TickDuration.currSystemTick;
+        assert((a + b).to!("seconds", real) > 0);
+        assert((a - b).to!("seconds", real) <= 0);
+    }
+
+
+    /++
+        Returns the negation of this TickDuration.
+      +/
+    TickDuration opUnary(string op)() const pure nothrow
+        if(op == "-")
+    {
+        return TickDuration(-length);
+    }
+
+    unittest
+    {
+        assert(-TickDuration(7) == TickDuration(-7));
+        assert(-TickDuration(5) == TickDuration(-5));
+        assert(-TickDuration(-7) == TickDuration(7));
+        assert(-TickDuration(-5) == TickDuration(5));
+        assert(-TickDuration(0) == TickDuration(0));
+
+        const cdur = TickDuration(12);
+        immutable idur = TickDuration(12);
+        static assert(__traits(compiles, -cdur));
+        static assert(__traits(compiles, -idur));
+    }
+
+
+    /++
+       operator overloading "=="
+      +/
+    bool opEquals(ref const TickDuration rhs) const pure nothrow
+    {
+        return length == rhs.length;
+    }
+
+    unittest
+    {
+        auto t1 = TickDuration.currSystemTick;
+        assert(t1 == t1);
+    }
+
+
+    /++
+       operator overloading "<, >, <=, >="
+      +/
+    int opCmp(ref const TickDuration rhs) const pure nothrow
+    {
+        return length < rhs.length ? -1 : (length == rhs.length ? 0 : 1);
+    }
+
+    unittest
+    {
+        auto t1 = TickDuration.currSystemTick;
+        auto t2 = TickDuration.currSystemTick;
+        assert(t1 <= t2);
+        assert(t2 >= t1);
+    }
+
+
+    /++
+        The legal types of arithmetic for TickDuration using this operator overload are
+
+        $(TABLE
+        $(TR $(TD TickDuration) $(TD *) $(TD long) $(TD -->) $(TD TickDuration))
+        $(TR $(TD TickDuration) $(TD *) $(TD floating point) $(TD -->) $(TD TickDuration))
+        )
+
+        Params:
+            value = The value to divide from this duration.
+      +/
+    void opOpAssign(string op, T)(T value) pure nothrow
+        if(op == "*" &&
+           (__traits(isIntegral, T) || __traits(isFloating, T)))
+    {
+        length *= value;
+    }
+
+    unittest
+    {
+        immutable t = TickDuration.currSystemTick;
+        TickDuration t1 = t, t2 = t;
+        t1 /= 2;
+        assert(t1 < t);
+        t2 /= 2.1L;
+        assert(t2 < t1);
+    }
+
+
+    /++
+        The legal types of arithmetic for TickDuration using this operator overload are
+
+        $(TABLE
+        $(TR $(TD TickDuration) $(TD /) $(TD long) $(TD -->) $(TD TickDuration))
+        $(TR $(TD TickDuration) $(TD /) $(TD floating point) $(TD -->) $(TD TickDuration))
+        )
+
+        Params:
+            value = The value to divide from this duration.
+
+        Throws:
+            TimeException if an attempt to divide by 0 is made.
+      +/
+    void opOpAssign(string op, T)(T value) pure
+        if(op == "/" &&
+           (__traits(isIntegral, T) || __traits(isFloating, T)))
+    {
+        if(value == 0)
+            throw new TimeException("Attempted division by 0.");
+
+        length /= value;
+    }
+
+    unittest
+    {
+        immutable t = TickDuration.currSystemTick;
+        TickDuration t1 = t, t2 = t;
+        t1 /= 2;
+        assert(t1 < t);
+        t2 /= 2.1L;
+        assert(t2 < t1);
+    }
+
+
+    /++
+        The legal types of arithmetic for TickDuration using this operator overload are
+
+        $(TABLE
+        $(TR $(TD TickDuration) $(TD *) $(TD long) $(TD -->) $(TD TickDuration))
+        $(TR $(TD TickDuration) $(TD *) $(TD floating point) $(TD -->) $(TD TickDuration))
+        )
+
+        Params:
+            value = The value to divide from this duration.
+      +/
+    TickDuration opBinary(string op, T)(T value) const pure nothrow
+        if(op == "*" &&
+           (__traits(isIntegral, T) || __traits(isFloating, T)))
+    {
+        return TickDuration(cast(long)(length * value));
+    }
+
+    unittest
+    {
+        auto t = TickDuration.currSystemTick;
+        auto t2 = t*2;
+        assert(t < t2);
+        assert(t*3.5 > t2);
+    }
+
+
+    /++
+        The legal types of arithmetic for TickDuration using this operator overload are
+
+        $(TABLE
+        $(TR $(TD TickDuration) $(TD /) $(TD long) $(TD -->) $(TD TickDuration))
+        $(TR $(TD TickDuration) $(TD /) $(TD floating point) $(TD -->) $(TD TickDuration))
+        )
+
+        Params:
+            value = The value to divide from this duration.
+
+        Throws:
+            TimeException if an attempt to divide by 0 is made.
+      +/
+    TickDuration opBinary(string op, T)(T value) const pure
+        if(op == "/" &&
+           (__traits(isIntegral, T) || __traits(isFloating, T)))
+    {
+        if(value == 0)
+            throw new TimeException("Attempted division by 0.");
+
+        return TickDuration(cast(long)(length / value));
+    }
+
+
+    /++
+        Params:
+            ticks = The number of ticks in the TickDuration.
+      +/
+    this(long ticks) pure nothrow
+    {
+        this.length = ticks;
+    }
+
+
+    /++
+        The current system tick. The number of ticks per second varies from
+        system to system. This uses a monotonic clock, so it's intended for
+        precision timing by comparing relative time values, not for getting
+        the current system time.
+
+        On Windows, QueryPerformanceCounter() is used. On Mac OS X,
+        mach_absolute_time() is used, while on other Posix systems,
+        clock_gettime() is used. If mach_absolute_time() or clock_gettime()
+        is unavailable, then Posix systems use gettimeofday(), which
+        unfortunately, is not monotonic, but without
+        mach_absolute_time()/clock_gettime() available, gettimeofday() is the
+        the best that you can do.
+
+        Warning:
+            On some systems, the monotonic clock may stop counting when
+            the computer goes to sleep or hibernates. So, the monotonic
+            clock could be off if that occurs. This is known to happen
+            on Mac OS X. It has not been tested whether it occurs on
+            either Windows or on Linux.
+
+        Throws:
+            TimeException if it fails to get the time.
+      +/
+    @trusted
+    static @property TickDuration currSystemTick()
+    {
+        version(Windows)
+        {
+            ulong ticks;
+
+            if(QueryPerformanceCounter(cast(long*)&ticks) == 0)
+                throw new TimeException(sysErrorString(GetLastError()));
+
+            return TickDuration(ticks);
+        }
+        else version(OSX)
+        {
+            static if(is(typeof(mach_absolute_time)))
+                return TickDuration(cast(long)mach_absolute_time());
+            else
+            {
+                timeval tv;
+                if(gettimeofday(&tv, null) != 0)
+                    throw new TimeException("Failed in gettimeofday().");
+
+                return TickDuration(tv.tv_sec * TickDuration.ticksPerSec +
+                                    tv.tv_usec * TickDuration.ticksPerSec / 1000 / 1000);
+            }
+        }
+        else version(Posix)
+        {
+            static if(is(typeof(clock_gettime)))
+            {
+                timespec ts;
+
+                if(clock_gettime(CLOCK_MONOTONIC, &ts) != 0)
+                    throw new TimeException("Failed in clock_gettime().");
+
+                return TickDuration(ts.tv_sec * TickDuration.ticksPerSec +
+                                    ts.tv_nsec * TickDuration.ticksPerSec / 1000 / 1000 / 1000);
+            }
+            else
+            {
+                timeval tv;
+                if(gettimeofday(&tv, null) != 0)
+                    throw new TimeException("Failed in gettimeofday().");
+
+                return TickDuration(tv.tv_sec * TickDuration.ticksPerSec +
+                                    tv.tv_usec * TickDuration.ticksPerSec / 1000 / 1000);
+            }
+        }
+    }
+
+    @trusted
+    unittest
+    {
+        auto t = TickDuration.currSystemTick;
+        assert(t.length > 0);
+    }
+}
+
+
+/++
+    Generic way of converting between two time units. Conversions to smaller
+    units use truncating division.
+
+    Params:
+        tuFrom = The units of time to covert from.
+        tuFrom = The units of time to covert type.
+        value  = The value to convert.
+
+    Examples:
+--------------------
+assert(convert!("years", "months")(1) == 12);
+assert(convert!("months", "years")(12) == 1);
+--------------------
+  +/
+@safe
+long convert(string from, string to)(long value) pure nothrow
+    if((from == "years" || from == "months") &&
+       (to == "years" || to == "months"))
+{
+    static if(from == "years")
+    {
+        static if(to == "years")
+            return value;
+        else static if(to == "months")
+            return value * 12;
-        else
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        {
-
+
+
+
+
+
+
-        }
+
+        tAssertExThrown!TimeException(testFS(-1));
+        tAssertExThrown!TimeException(testFS(1000));
+
+        testFS(0, FracSec(0));
+        testFS(1, FracSec(10_000));
+        testFS(999, FracSec(9_990_000));
+
+        auto fs = FracSec(12);
+        const cfs = FracSec(12);
+        immutable ifs = FracSec(12);
+        static assert(__traits(compiles, fs.msecs = 54));
+        static assert(!__traits(compiles, cfs.msecs = 54));
+        static assert(!__traits(compiles, ifs.msecs = 54));
+    }
+
+
+    /++
+        The value of this FracSec as microseconds.
+      +/
+    @property int usecs() const pure nothrow
+    {
+        return cast(int)convert!("hnsecs", "usecs")(_hnsecs);
+    }
+
+    unittest
+    {
+        assert(FracSec(0).usecs == 0);
+        assert(FracSec(1).usecs == 0);
+        assert(FracSec(999).usecs == 99);
+        assert(FracSec(999_999).usecs == 99_999);
+        assert(FracSec(9_999_999).usecs == 999_999);
+
+        auto fs = FracSec(12);
+        const cfs = FracSec(12);
+        immutable ifs = FracSec(12);
+        static assert(__traits(compiles, fs.usecs));
+        static assert(__traits(compiles, cfs.usecs));
+        static assert(__traits(compiles, ifs.usecs));
+    }
+
+
+    /++
+        The value of this FracSec as microseconds.
+
+        Params:
+            microseconds = The number of microseconds passed the second.
+
+        Throws:
+            TimeException if the given value is not less than one second.
+      +/
+    @property void usecs(int microseconds) pure
+    {
+        immutable hnsecs = cast(int)convert!("usecs", "hnsecs")(microseconds);
+
+        _enforceValid(hnsecs);
+        _hnsecs = hnsecs;
+    }
+
+    unittest
+    {
+        static void testFS(int ms, in FracSec expected = FracSec.init, size_t line = __LINE__)
+        {
+            FracSec fs;
+
+            fs.usecs = ms;
+
+            if(fs != expected)
+                throw new AssertError("", __FILE__, line);
+        }
+
+        tAssertExThrown!TimeException(testFS(-1));
+        tAssertExThrown!TimeException(testFS(1_000_000));
+
+        testFS(0, FracSec(0));
+        testFS(1, FracSec(10));
+        testFS(999, FracSec(9990));
+        testFS(999_999, FracSec(9_999_990));
+
+        auto fs = FracSec(12);
+        const cfs = FracSec(12);
+        immutable ifs = FracSec(12);
+        static assert(__traits(compiles, fs.usecs = 54));
+        static assert(!__traits(compiles, cfs.usecs = 54));
+        static assert(!__traits(compiles, ifs.usecs = 54));
+    }
+
+
+    /++
+        The value of this FracSec as hnsecs.
+      +/
+    @property int hnsecs() const pure nothrow
+    {
+        return _hnsecs;
+    }
+
+    unittest
+    {
+        assert(FracSec(0).hnsecs == 0);
+        assert(FracSec(1).hnsecs == 1);
+        assert(FracSec(999).hnsecs == 999);
+        assert(FracSec(999_999).hnsecs == 999_999);
+        assert(FracSec(9_999_999).hnsecs == 9_999_999);
+
+        auto fs = FracSec(12);
+        const cfs = FracSec(12);
+        immutable ifs = FracSec(12);
+        static assert(__traits(compiles, fs.hnsecs));
+        static assert(__traits(compiles, cfs.hnsecs));
+        static assert(__traits(compiles, ifs.hnsecs));
+    }
+
+
+    /++
+        The value of this FracSec as hnsecs.
+
+        Params:
+            hnsecs = The number of hnsecs passed the second.
+
+        Throws:
+            TimeException if the given value is not less than one second.
+      +/
+    @property void hnsecs(int hnsecs) pure
+    {
+        _enforceValid(hnsecs);
+        _hnsecs = hnsecs;
+    }
+
+    unittest
+    {
+        static void testFS(int hnsecs, in FracSec expected = FracSec.init, size_t line = __LINE__)
+        {
+            FracSec fs;
+
+            fs.hnsecs = hnsecs;
+
+            if(fs != expected)
+                throw new AssertError("", __FILE__, line);
+        }
+
+        tAssertExThrown!TimeException(testFS(-1));
+        tAssertExThrown!TimeException(testFS(10_000_000));
+
+        testFS(0, FracSec(0));
+        testFS(1, FracSec(1));
+        testFS(999, FracSec(999));
+        testFS(999_999, FracSec(999_999));
+        testFS(9_999_999, FracSec(9_999_999));
+
+        auto fs = FracSec(12);
+        const cfs = FracSec(12);
+        immutable ifs = FracSec(12);
+        static assert(__traits(compiles, fs.hnsecs = 54));
+        static assert(!__traits(compiles, cfs.hnsecs = 54));
+        static assert(!__traits(compiles, ifs.hnsecs = 54));
+    }
+
+
+    /++
+        The value of this FracSec as nsecs.
+
+        Note that this does not give you any greater precision
+        than getting the value of this FracSec as hnsecs.
+      +/
+    @property int nsecs() const pure nothrow
+    {
+        return cast(int)convert!("hnsecs", "nsecs")(_hnsecs);
+    }
+
+    unittest
+    {
+        assert(FracSec(0).nsecs == 0);
+        assert(FracSec(1).nsecs == 100);
+        assert(FracSec(999).nsecs == 99_900);
+        assert(FracSec(999_999).nsecs == 99_999_900);
+        assert(FracSec(9_999_999).nsecs == 999_999_900);
+
+        auto fs = FracSec(12);
+        const cfs = FracSec(12);
+        immutable ifs = FracSec(12);
+        static assert(__traits(compiles, fs.nsecs));
+        static assert(__traits(compiles, cfs.nsecs));
+        static assert(__traits(compiles, ifs.nsecs));
+    }
+
+
+    /++
+        The value of this FracSec as nsecs.
+
+        Note that this does not give you any greater precision
+        than setting the value of this FracSec as hnsecs.
+
+        Params:
+            nsecs = The number of nsecs passed the second.
+
+        Throws:
+            TimeException if the given value is not less than one second.
+      +/
+    @property void nsecs(int nsecs) pure
+    {
+        //So that -99 through -1 throw instead of result in FracSec(0).
+        if(nsecs < 0)
+            _enforceValid(-1);
+
+        immutable hnsecs = cast(int)convert!("nsecs", "hnsecs")(nsecs);
+
+        _enforceValid(hnsecs);
+        _hnsecs = hnsecs;
+    }
+
+    unittest
+    {
+        static void testFS(int nsecs, in FracSec expected = FracSec.init, size_t line = __LINE__)
+        {
+            FracSec fs;
+
+            fs.nsecs = nsecs;
+
+            if(fs != expected)
+                throw new AssertError("", __FILE__, line);
+        }
+
+        tAssertExThrown!TimeException(testFS(-1));
+        tAssertExThrown!TimeException(testFS(1_000_000_000));
+
+        testFS(0, FracSec(0));
+        testFS(1, FracSec(0));
+        testFS(10, FracSec(0));
+        testFS(100, FracSec(1));
+        testFS(999, FracSec(9));
+        testFS(999_999, FracSec(9999));
+        testFS(9_999_999, FracSec(99_999));
+
+        auto fs = FracSec(12);
+        const cfs = FracSec(12);
+        immutable ifs = FracSec(12);
+        static assert(__traits(compiles, fs.nsecs = 54));
+        static assert(!__traits(compiles, cfs.nsecs = 54));
+        static assert(!__traits(compiles, ifs.nsecs = 54));
+    }
+
+
+    /+
+        Converts this duration to a string.
+      +/
+    //Due to bug http://d.puremagic.com/issues/show_bug.cgi?id=3715 , we can't
+    //have versions of toString() with extra modifiers, so we define one version
+    //with modifiers and one without.
+    string toString()
+    {
+        return _toStringImpl();
+    }
+
+
+    /++
+        Converts this duration to a string.
+      +/
+    //Due to bug http://d.puremagic.com/issues/show_bug.cgi?id=3715 , we can't
+    //have versions of toString() with extra modifiers, so we define one version
+    //with modifiers and one without.
+    string toString() const pure nothrow
+    {
+        return _toStringImpl();
+    }
+
+    unittest
+    {
+        auto fs = FracSec(12);
+        const cfs = FracSec(12);
+        immutable ifs = FracSec(12);
+        static assert(__traits(compiles, fs.toString()));
+        static assert(__traits(compiles, cfs.toString()));
+        static assert(__traits(compiles, ifs.toString()));
+    }
+
+
+private:
+
+    /++
+        Since we have two versions of toString(), we have _toStringImpl()
+        so that they can share implementations.
+      +/
+    string _toStringImpl() const pure nothrow
+    {
+        try
+        {
+            long hnsecs = _hnsecs;
+
+            immutable milliseconds = splitUnitsFromHNSecs!"msecs"(hnsecs);
+            immutable microseconds = splitUnitsFromHNSecs!"usecs"(hnsecs);
+
+            if(hnsecs == 0)
+            {
+                if(microseconds == 0)
+                {
+                    if(milliseconds == 0)
+                        return "0 hnsecs";
+                    else
+                    {
+                        if(milliseconds == 1)
+                            return "1 ms";
+                        else
+                            return numToString(milliseconds) ~ " ms";
+                    }
+                }
+                else
+                {
+                    immutable fullMicroseconds = getUnitsFromHNSecs!"usecs"(_hnsecs);
+
+                    if(fullMicroseconds == 1)
+                        return "1 ÎŒs";
+                    else
+                        return numToString(fullMicroseconds) ~ " ÎŒs";
+                }
+            }
+            else
+            {
+                if(_hnsecs == 1)
+                    return "1 hnsec";
+                else
+                    return numToString(_hnsecs) ~ " hnsecs";
+            }
+        }
+        catch(Exception e)
+            assert(0, "Something threw when nothing can throw.");
+    }
+
+    unittest
+    {
+        assert(FracSec.from!"msecs"(0).toString() == "0 hnsecs");
+        assert(FracSec.from!"msecs"(1).toString() == "1 ms");
+        assert(FracSec.from!"msecs"(2).toString() == "2 ms");
+        assert(FracSec.from!"msecs"(100).toString() == "100 ms");
+        assert(FracSec.from!"msecs"(999).toString() == "999 ms");
+
+        assert(FracSec.from!"usecs"(0).toString() == "0 hnsecs");
+        assert(FracSec.from!"usecs"(1).toString() == "1 ÎŒs");
+        assert(FracSec.from!"usecs"(2).toString() == "2 ÎŒs");
+        assert(FracSec.from!"usecs"(100).toString() == "100 ÎŒs");
+        assert(FracSec.from!"usecs"(999).toString() == "999 ÎŒs");
+        assert(FracSec.from!"usecs"(1000).toString() == "1 ms");
+        assert(FracSec.from!"usecs"(2000).toString() == "2 ms");
+        assert(FracSec.from!"usecs"(9999).toString() == "9999 ÎŒs");
+        assert(FracSec.from!"usecs"(10_000).toString() == "10 ms");
+        assert(FracSec.from!"usecs"(20_000).toString() == "20 ms");
+        assert(FracSec.from!"usecs"(100_000).toString() == "100 ms");
+        assert(FracSec.from!"usecs"(100_001).toString() == "100001 ÎŒs");
+        assert(FracSec.from!"usecs"(999_999).toString() == "999999 ÎŒs");
+
+        assert(FracSec.from!"hnsecs"(0).toString() == "0 hnsecs");
+        assert(FracSec.from!"hnsecs"(1).toString() == "1 hnsec");
+        assert(FracSec.from!"hnsecs"(2).toString() == "2 hnsecs");
+        assert(FracSec.from!"hnsecs"(100).toString() == "10 ÎŒs");
+        assert(FracSec.from!"hnsecs"(999).toString() == "999 hnsecs");
+        assert(FracSec.from!"hnsecs"(1000).toString() == "100 ÎŒs");
+        assert(FracSec.from!"hnsecs"(2000).toString() == "200 ÎŒs");
+        assert(FracSec.from!"hnsecs"(9999).toString() == "9999 hnsecs");
+        assert(FracSec.from!"hnsecs"(10_000).toString() == "1 ms");
+        assert(FracSec.from!"hnsecs"(20_000).toString() == "2 ms");
+        assert(FracSec.from!"hnsecs"(100_000).toString() == "10 ms");
+        assert(FracSec.from!"hnsecs"(100_001).toString() == "100001 hnsecs");
+        assert(FracSec.from!"hnsecs"(200_000).toString() == "20 ms");
+        assert(FracSec.from!"hnsecs"(999_999).toString() == "999999 hnsecs");
+        assert(FracSec.from!"hnsecs"(1_000_001).toString() == "1000001 hnsecs");
+        assert(FracSec.from!"hnsecs"(9_999_999).toString() == "9999999 hnsecs");
+    }
+
+
+    /++
+        Returns whether the given number of hnsecs fits within the range of FracSec.
+
+        Params:
+            hnsecs = The number of hnsecs.
+      +/
+    static bool _valid(int hnsecs) pure
+    {
+        return hnsecs >= 0 && hnsecs < convert!("seconds", "hnsecs")(1);
+    }
+
+
+    /++
+        Throws:
+            TimeException if valid(hnsecs) is false.
+      +/
+    static void _enforceValid(int hnsecs) pure
+    {
+        if(!_valid(hnsecs))
+            throw new TimeException("FracSec must be greater than equal to 0 and less than 1 second.");
+    }
+
+
+    /++
+        Params:
+            hnsecs = The number of hnsecs passed the second.
+
+        Throws:
+            TimeException if the given hnsecs less than 0 or would result in a
+            FracSec greater than or equal to 1 second.
+      +/
+    this(int hnsecs) pure
+    {
+        _enforceValid(hnsecs);
+        _hnsecs = hnsecs;
+    }
+
+
+    pure invariant()
+    {
+        if(!_valid(_hnsecs))
+            throw new AssertError("Invaliant Failure: hnsecs [" ~ numToString(_hnsecs) ~ "]", __FILE__, __LINE__);
+    }
+
+
+    int _hnsecs;
+}
+
+
+/++
+    Exception type used by core.time.
+  +/
+class TimeException : Exception
+{
+    /++
+        Params:
+            msg  = The message for the exception.
+            file = The file where the exception occurred.
+            line = The line number where the exception occurred.
+            next = The previous exception in the chain of exceptions, if any.
+      +/
+    this(string msg, string file = __FILE__, size_t line = __LINE__, Throwable next = null) nothrow
+    {
+        super(msg, file, line, next);
+    }
+}
+
+
+//==============================================================================
+// Private Section.
+//
+// Much of this is a copy or simplified copy of what's in std.datetime.
+//==============================================================================
+private:
+
+
+/+
+    Template to help with converting between time units.
+ +/
+template hnsecsPer(string units)
+    if(units == "weeks" ||
+       units == "days" ||
+       units == "hours" ||
+       units == "minutes" ||
+       units == "seconds" ||
+       units == "msecs" ||
+       units == "usecs" ||
+       units == "hnsecs")
+{
+    static if(units == "hnsecs")
+        enum hnsecsPer = 1L;
+    else static if(units == "usecs")
+        enum hnsecsPer = 10L;
+    else static if(units == "msecs")
+        enum hnsecsPer = 1000 * hnsecsPer!"usecs";
+    else static if(units == "seconds")
+        enum hnsecsPer = 1000 * hnsecsPer!"msecs";
+    else static if(units == "minutes")
+        enum hnsecsPer = 60 * hnsecsPer!"seconds";
+    else static if(units == "hours")
+        enum hnsecsPer = 60 * hnsecsPer!"minutes";
+    else static if(units == "days")
+        enum hnsecsPer = 24 * hnsecsPer!"hours";
+    else static if(units == "weeks")
+        enum hnsecsPer = 7 * hnsecsPer!"days";
+}
+
+/+
+    Splits out a particular unit from hnsecs and gives you the value for that
+    unit and the remaining hnsecs. It really shouldn't be used unless unless
+    all units larger than the given units have already been split out.
+
+    Params:
+        units  = The units to split out.
+        hnsecs = The current total hnsecs. Upon returning, it is the hnsecs left
+                 after splitting out the given units.
+
+    Returns:
+        The number of the given units from converting hnsecs to those units.
+
+    Examples:
+--------------------
+auto hnsecs = 2595000000007L;
+immutable days = splitUnitsFromHNSecs!"days"(hnsecs);
+assert(days == 3);
+assert(hnsecs == 3000000007);
+
+immutable minutes = splitUnitsFromHNSecs!"minutes"(hnsecs);
+assert(minutes == 5);
+assert(hnsecs == 7);
+--------------------
+  +/
+long splitUnitsFromHNSecs(string units)(ref long hnsecs) pure nothrow
+    if(units == "weeks" ||
+       units == "days" ||
+       units == "hours" ||
+       units == "minutes" ||
+       units == "seconds" ||
+       units == "msecs" ||
+       units == "usecs" ||
+       units == "hnsecs")
+{
+    immutable value = convert!("hnsecs", units)(hnsecs);
+    hnsecs -= convert!(units, "hnsecs")(value);
+
+    return value;
+}
+
+unittest
+{
+    //Verify Example.
+    auto hnsecs = 2595000000007L;
+    immutable days = splitUnitsFromHNSecs!"days"(hnsecs);
+    assert(days == 3);
+    assert(hnsecs == 3000000007);
+
+    immutable minutes = splitUnitsFromHNSecs!"minutes"(hnsecs);
+    assert(minutes == 5);
+    assert(hnsecs == 7);
+}
+
+
+/+
+    This function is used to split out the units without getting the remaining
+    hnsecs.
+
+    See_Also:
+        splitUnitsFromHNSecs()
+
+    Params:
+        units  = The units to split out.
+        hnsecs = The current total hnsecs.
+
+    Returns:
+        The split out value.
+
+    Examples:
+--------------------
+auto hnsecs = 2595000000007L;
+immutable days = getUnitsFromHNSecs!"days"(hnsecs);
+assert(days == 3);
+assert(hnsecs == 2595000000007L);
+--------------------
+  +/
+long getUnitsFromHNSecs(string units)(long hnsecs) pure nothrow
+    if(units == "weeks" ||
+       units == "days" ||
+       units == "hours" ||
+       units == "minutes" ||
+       units == "seconds" ||
+       units == "msecs" ||
+       units == "usecs" ||
+       units == "hnsecs")
+{
+    return convert!("hnsecs", units)(hnsecs);
+}
+
+unittest
+{
+    //Verify Example.
+    auto hnsecs = 2595000000007L;
+    immutable days = getUnitsFromHNSecs!"days"(hnsecs);
+    assert(days == 3);
+    assert(hnsecs == 2595000000007L);
+}
+
+
+/+
+    This function is used to split out the units without getting the units but
+    just the remaining hnsecs.
+
+    See_Also:
+        splitUnitsFromHNSecs()
+
+    Params:
+        units  = The units to split out.
+        hnsecs = The current total hnsecs.
+
+    Returns:
+        The remaining hnsecs.
+
+    Examples:
+--------------------
+auto hnsecs = 2595000000007L;
+auto returned = removeUnitsFromHNSecs!"days"(hnsecs);
+assert(returned == 3000000007);
+assert(hnsecs == 2595000000007L);
+--------------------
+  +/
+long removeUnitsFromHNSecs(string units)(long hnsecs) pure nothrow
+    if(units == "weeks" ||
+       units == "days" ||
+       units == "hours" ||
+       units == "minutes" ||
+       units == "seconds" ||
+       units == "msecs" ||
+       units == "usecs" ||
+       units == "hnsecs")
+{
+    immutable value = convert!("hnsecs", units)(hnsecs);
+
+    return hnsecs - convert!(units, "hnsecs")(value);
+}
+
+unittest
+{
+    //Verify Example.
+    auto hnsecs = 2595000000007L;
+    auto returned = removeUnitsFromHNSecs!"days"(hnsecs);
+    assert(returned == 3000000007);
+    assert(hnsecs == 2595000000007L);
+}
+
+
+/++
+    Whether all of the given strings are valid units of time.
+  +/
+bool validTimeUnits(string[] units...)
+{
+    foreach(str; units)
+    {
+        switch(str)
+        {
+            case "years":
+            case "months":
+            case "weeks":
+            case "days":
+            case "hours":
+            case "minutes":
+            case "seconds":
+            case "msecs":
+            case "usecs":
+            case "hnsecs":
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    return false;
+}
+
+
+/+
+    The time units which are one step larger than the given units.
+
+    Examples:
+--------------------
+assert(nextLargerTimeUnits!"minutes" == "hours");
+assert(nextLargerTimeUnits!"hnsecs" == "usecs");
+--------------------
+  +/
+template nextLargerTimeUnits(string units)
+    if(units == "days" ||
+       units == "hours" ||
+       units == "minutes" ||
+       units == "seconds" ||
+       units == "msecs" ||
+       units == "usecs" ||
+       units == "hnsecs" ||
+       units == "nsecs")
+{
+    static if(units == "days")
+        enum nextLargerTimeUnits = "weeks";
+    else static if(units == "hours")
+        enum nextLargerTimeUnits = "days";
+    else static if(units == "minutes")
+        enum nextLargerTimeUnits = "hours";
+    else static if(units == "seconds")
+        enum nextLargerTimeUnits = "minutes";
+    else static if(units == "msecs")
+        enum nextLargerTimeUnits = "seconds";
+    else static if(units == "usecs")
+        enum nextLargerTimeUnits = "msecs";
+    else static if(units == "hnsecs")
+        enum nextLargerTimeUnits = "usecs";
+    else static if(units == "nsecs")
+        enum nextLargerTimeUnits = "hnsecs";
+    else
+        static assert(0, "Broken template constraint");
+}
+
+unittest
+{
+    assert(nextLargerTimeUnits!"nsecs" == "hnsecs");
+    assert(nextLargerTimeUnits!"hnsecs" == "usecs");
+    assert(nextLargerTimeUnits!"usecs" == "msecs");
+    assert(nextLargerTimeUnits!"msecs" == "seconds");
+    assert(nextLargerTimeUnits!"seconds" == "minutes");
+    assert(nextLargerTimeUnits!"minutes" == "hours");
+    assert(nextLargerTimeUnits!"hours" == "days");
+    assert(nextLargerTimeUnits!"days" == "weeks");
+
+    static assert(!__traits(compiles, nextLargerTimeUnits!"weeks"));
+    static assert(!__traits(compiles, nextLargerTimeUnits!"months"));
+    static assert(!__traits(compiles, nextLargerTimeUnits!"years"));
+
+    //Verify Examples
+    assert(nextLargerTimeUnits!"minutes" == "hours");
+    assert(nextLargerTimeUnits!"hnsecs" == "usecs");
+}
+
+
+/++
+    Unfortunately, snprintf is not pure, so here's a way to convert
+    a number to a string which is.
+  +/
+string numToString(long value) pure nothrow
+{
+    try
+    {
+        immutable negative = value < 0;
+        char[25] str;
+        size_t i = str.length;
+
+        if(negative)
+            value = -value;
+
+        while(1)
+        {
+            char digit = cast(char)('0' + value % 10);
+            value /= 10;
+
+            str[--i] = digit;
+            assert(i > 0);
+
+            if(value == 0)
+                break;
+        }
+
+        if(negative)
+            return "-" ~ str[i .. $].idup;
-        else
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        else
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+