Ticket #671: TimeSpan.d

/*******************************************************************************

        copyright:      Copyright (c) 2007 Kris Bell. All rights reserved

        license:        BSD style: $(LICENSE)
        
        version:        Oct 2007: Initial release
        
        author:         Steve Schveighoffer

        Common types used by Tango

*******************************************************************************/

module tango.core.TimeSpan;

struct TimeSpan
{
        long ticks;

        //
        // enum to allow specifying standard measurements
        //
        enum Measure
        {
                Day,
                Hour,
                Minute,
                Second,
                Millisecond,
                Microsecond,
                Nanosecond,
        }

        //
        // useful constants
        //
        static const long NanosecondsPerTick = 100;
        static const long TicksPerMicrosecond = 1000 / NanosecondsPerTick;
        static const long TicksPerMillisecond = TicksPerMicrosecond * 1000;
        static const long TicksPerSecond = TicksPerMillisecond * 1000;
        static const long TicksPerMinute = TicksPerSecond * 60;
        static const long TicksPerHour = TicksPerMinute * 60;
        static const long TicksPerDay = TicksPerHour * 24;

        static const long MillisPerSecond = 1000;
        static const long MillisPerMinute = MillisPerSecond * 60;
        static const long MillisPerHour = MillisPerMinute * 60;
        static const long MillisPerDay = MillisPerHour * 24;

        static const long DaysPerYear = 365;
        static const long DaysPer4Years = DaysPerYear * 4 + 1;
        static const long DaysPer100Years = DaysPer4Years * 25 - 1;
        static const long DaysPer400Years = DaysPer100Years * 4 + 1;

        static const long DaysTo1601 = DaysPer400Years * 4;
        static const long DaysTo10000 = DaysPer400Years * 25 - 366;

        static const TimeSpan    min = {long.min},
                                 max = {long.max};

        //
        // this causes problems with old compilers (DMD 1.018)
        //
        /*static TimeSpan opCall(long ticks)
        {
                TimeSpan t;
                t.ticks = ticks;
                return t;
        }*/

        //
        // common operators
        //
        bool opEquals(TimeSpan t)
        {
                return ticks is t.ticks;
        }

        long opCmp(TimeSpan t)
        {
                return ticks - t.ticks;
        }

        TimeSpan opAdd(TimeSpan t)
        {
                return TimeSpan(ticks + t.ticks);
        }

        TimeSpan opAddAssign(TimeSpan t)
        {
                ticks += t.ticks;
                return *this;
        }

        TimeSpan opSub(TimeSpan t)
        {
                return TimeSpan(ticks - t.ticks);
        }

        TimeSpan opSubAssign(TimeSpan t)
        {
                ticks -= t.ticks;
                return *this;
        }

        TimeSpan opMul(long v)
        {
                return TimeSpan(ticks * v);
        }

        TimeSpan opMulAssign(long v)
        {
                ticks *= v;
                return *this;
        }

        //
        // should not be used for scaling to other units.  Use the toXXX
        // methods for that.  This is more for using to sleep for half a
        // duration instead of the full duration.
        //
        TimeSpan opDiv(long v)
        {
                return TimeSpan(ticks / v);
        }

        TimeSpan opDivAssign(long v)
        {
                ticks /= v;
                return *this;
        }

        //
        // conversion routines.  Converts to the specific measure.  This does
        // not return only the part of the timespan that is in that
        // measurement.  For example, if a timespan represents 1.5 seconds,
        // toMilliseconds returns 1500, not 500.
        //
        long convertTo(Measure m)
        {
                switch(m)
                {
                case Measure.Day:
                        return ticks / TicksPerDay;
                case Measure.Hour:
                        return ticks / TicksPerHour;
                case Measure.Minute:
                        return ticks / TicksPerMinute;
                case Measure.Second:
                        return ticks / TicksPerSecond;
                case Measure.Millisecond:
                        return ticks / TicksPerMillisecond;
                case Measure.Microsecond:
                        return ticks / TicksPerMicrosecond;
                case Measure.Nanosecond:
                        return ticks * NanosecondsPerTick;
                }
                return long.max;
        }

        long toDays()
        {
                return convertTo(Measure.Day);
        }

        long toHours()
        {
                return convertTo(Measure.Hour);
        }

        long toMinutes()
        {
                return convertTo(Measure.Minute);
        }

        long toSeconds()
        {
                return convertTo(Measure.Second);
        }

        long toMilliseconds()
        {
                return convertTo(Measure.Millisecond);
        }

        long toMicroseconds()
        {
                return convertTo(Measure.Microsecond);
        }

        long toNanoseconds()
        {
                return convertTo(Measure.Nanosecond);
        }

        //
        //  Construction routines.  Build a timespan from common measurements
        //

        //  TODO: need a better name for this
        //  this is useful for converting from other structures which have
        //  representations of time in multiple measurement types.  For
        //  example, a timeval which has a seconds member and a microseconds
        //  member.
        static TimeSpan fromStandard(long days, long hours = 0, long minutes = 0, long seconds = 0, long milliseconds = 0, long microseconds = 0, long nanoseconds = 0)
        {
                return TimeSpan(days * TicksPerDay +
                                hours * TicksPerHour +
                                minutes * TicksPerMinute +
                                seconds * TicksPerSecond +
                                milliseconds * TicksPerMillisecond +
                                microseconds * TicksPerMicrosecond +
                                nanoseconds / NanosecondsPerTick);
        }

        static TimeSpan convertFrom(long value, Measure m)
        {
                long ticks = long.max;
                switch(m)
                {
                case Measure.Day:
                        ticks = value * TicksPerDay;
                        break;
                case Measure.Hour:
                        ticks = value * TicksPerHour;
                        break;
                case Measure.Minute:
                        ticks = value * TicksPerMinute;
                        break;
                case Measure.Second:
                        ticks = value * TicksPerSecond;
                        break;
                case Measure.Millisecond:
                        ticks = value * TicksPerMillisecond;
                        break;
                case Measure.Microsecond:
                        ticks = value * TicksPerMicrosecond;
                        break;
                case Measure.Nanosecond:
                        ticks = value / NanosecondsPerTick;
                        break;
                }
                return TimeSpan(ticks);
        }

        static TimeSpan fromDays(long days)
        {
                return convertFrom(days, Measure.Day);
        }

        static TimeSpan fromHours(long hours)
        {
                return convertFrom(hours, Measure.Hour);
        }

        static TimeSpan fromMinutes(long minutes)
        {
                return convertFrom(minutes, Measure.Minute);
        }

        static TimeSpan fromSeconds(long seconds)
        {
                return convertFrom(seconds, Measure.Second);
        }

        static TimeSpan fromMilliseconds(long milliseconds)
        {
                return convertFrom(milliseconds, Measure.Millisecond);
        }

        static TimeSpan fromMicroseconds(long microseconds)
        {
                return convertFrom(microseconds, Measure.Microsecond);
        }

        static TimeSpan fromNanoseconds(long nanoseconds)
        {
                return convertFrom(nanoseconds, Measure.Nanosecond);
        }

        // TODO: need a toUtf8 routine here?
}