Ticket #568: iso8601.d

import tango.util.time.Date;

/// Returns the number of chars used to compose a valid date: 0 if no date can be composed.
/// Fields in date will either be correct (e.g. months will be >= 1 and <= 12) or zero.

size_t iso8601Date(T)(T[] src, inout Date date, size_t expanded = 0) {
    ubyte dummy = void;
    T* p = src.ptr;
    return doIso8601Date(p, src, date, expanded, dummy);
}

private size_t doIso8601Date(T)(inout T* p, T[] src, inout Date date, size_t expanded, out ubyte separators)
out {
    assert (!date.month || (              date.month >= 1 && date.month <= 12));
    assert (!date.day   || (date.month && date.day   >= 1 && date.day   <= daysPerMonth(date.month, date.year)));
} body {

    size_t eaten() { return p - src.ptr; }
    bool done(T[] s) { return .done(eaten(), src.length, *p, s); }

    if (!parseYear(p, expanded, date.year))
        return (date.year = 0);

    auto onlyYear = eaten();

    // /([+-]Y{expanded})?(YYYY|YY)/
    if (done("-0123W"))
        return onlyYear;

    if (accept(p, '-'))
        separators = true;

    if (accept(p, 'W')) {
        // (year)-Www-D

        T* p2 = p;

        int i = parseInt(p, 3u);

        if (i) if (p - p2 == 2) {

            // (year)-Www
            if (done("-")) {
                if (getMonthAndDayFromWeek(date, i))
                    return eaten();

            // (year)-Www-D
            } else if (demand(p, '-'))
                if (getMonthAndDayFromWeek(date, i, *p++ - '0'))
                    return eaten();

        } else if (p - p2 == 3)
            // (year)WwwD
            if (getMonthAndDayFromWeek(date, i / 10, i % 10))
                return eaten();

        return onlyYear;
    }

    // next up, MM or MM[-]DD or DDD

    T* p2 = p;

    int i = parseInt(p);
    if (!i)
        return onlyYear;

    switch (p - p2) {
        case 2:
            date.month = i;

            if (!(date.month >= 1 && date.month <= 12)) {
                date.month = 0;
                return onlyYear;
            }

            auto onlyMonth = eaten();

            // (year)-MM
            if (done("-"))
                return onlyMonth;

            // (year)-MM-DD
            if (!(
                demand(p, '-') &&
                (date.day = parseInt(p, 2u)) != 0 && date.day <= daysPerMonth(date.month, date.year)
            )) {
                date.day = 0;
                return onlyMonth;
            }

            break;

        case 4:
            // e.g. 20010203, i = 203 now

            date.month = i / 100;
            date.day   = i % 100;

            // (year)MMDD
            if (!(
                date.month >= 1 && date.month <= 12 &&
                date.day   >= 0 && date.day   <= daysPerMonth(date.month, date.year)
            )) {
                date.month = date.day = 0;
                return onlyYear;
            }

            break;

        case 3:
            // (year)-DDD
            // i is the ordinal of the day within the year

            bool leap = isLeapYear(date.year);

            if (i > 365 + leap)
                return onlyYear;

            if (i <= 31) {
                date.month = 1;
                date.day   = i;

            } else if (i <= 59 + leap) {
                date.month = 2;
                date.day   = i - 31 - leap;

            } else if (i <= 90 + leap) {
                date.month = 3;
                date.day   = i - 59 - leap;

            } else if (i <= 120 + leap) {
                date.month = 4;
                date.day   = i - 90 - leap;

            } else if (i <= 151 + leap) {
                date.month = 5;
                date.day   = i - 120 - leap;

            } else if (i <= 181 + leap) {
                date.month = 6;
                date.day   = i - 151 - leap;

            } else if (i <= 212 + leap) {
                date.month = 7;
                date.day   = i - 181 - leap;

            } else if (i <= 243 + leap) {
                date.month = 8;
                date.day   = i - 212 - leap;

            } else if (i <= 273 + leap) {
                date.month = 9;
                date.day   = i - 243 - leap;

            } else if (i <= 304 + leap) {
                date.month = 10;
                date.day   = i - 273 - leap;

            } else if (i <= 334 + leap) {
                date.month = 11;
                date.day   = i - 304 - leap;

            } else {
                if (i > 365 + leap)
                    assert (false);

                date.month = 12;
                date.day   = i - 334 - leap;
            }

        default: break;
    }

    return eaten();
}

/// Returns the number of chars used to compose a valid date: 0 if no date can be composed.
/// Fields in date will be zero if incorrect: since 00:00:00,000 is a valid time, the return value must be checked to be sure of the result.
/// date.sec may be 60 if the hours and minutes are 23 and 59, as leap seconds are occasionally added to UTC time.
/// date.hour may be 0 or 24: the latter marks the end of a day, the former the beginning.

size_t iso8601Time(T)(T[] src, inout Date date) {
    bool dummy = void;
    T* p = src.ptr;
    return doIso8601Time(p, src, date, WHATEVER, dummy);
}

private enum : ubyte { NO = 0, YES = 1, WHATEVER }

// bothValid is used only to get iso8601() to catch errors correctly
private size_t doIso8601Time(T)(inout T* p, T[] src, inout Date date, ubyte separators, out bool bothValid)
out {
    // yes, I could just write >= 0, but this emphasizes the difference between == 0 and != 0
    assert (!date.hour || (date.hour > 0 && date.hour <=  24));
    assert (!date.min  || (date.min  > 0 && date.min  <=  59));
    assert (!date.sec  || (date.sec  > 0 && date.sec  <=  60));
    assert (!date.ms   || (date.ms   > 0 && date.ms   <= 999));
} body {

    size_t eaten() { return p - src.ptr; }
    bool done(T[] s) { return .done(eaten(), src.length, *p, s); }

    bool checkColon() {
        if (separators == WHATEVER)
            accept(p, ':');

        else if (accept(p, ':') != separators)
            return false;

        return true;
    }

    byte getTimeZone() { return .getTimeZone(p, date, separators, &done); }

    // TODO/BUG: need to convert from local time if got T
    // however, Tango provides nothing like Phobos's std.date.getLocalTZA
    // (which doesn't look like it should work on Windows, it should use tzi.bias only, and GetTimeZoneInformationForYear)
    // (and which uses too complicated code for Posix, tzset should be enough)
    // and I'm not interested in delving into system-specific code right now
    // remember also that -1 BC is the year zero in ISO 8601... -2 BC is -1, etc
    if (separators == WHATEVER)
        accept(p, 'T');

    if (parseInt(p, 2u, date.hour) != 2 || date.hour > 24)
        return (date.hour = 0);

    auto onlyHour = eaten();

    // hh
    if (done("+,-.012345:"))
        return onlyHour;

    switch (getDecimal(p, date, HOUR)) {
        case NOTFOUND: break;
        case    FOUND:
            auto onlyDecimal = eaten();
            if (getTimeZone() == BAD)
                return onlyDecimal;

            // /hh,h+/
            return eaten();

        case BAD: return onlyHour;
        default: assert (false);
    }

    switch (getTimeZone()) {
        case NOTFOUND: break;
        case    FOUND: return eaten();
        case BAD:      return onlyHour;
        default: assert (false);
    }

    if (
        !checkColon() ||

        parseInt(p, 2u, date.min) != 2 || date.min > 59 ||

        // hour 24 is only for 24:00:00
        (date.hour == 24 && date.min != 0)
    ) {
        date.min = 0;
        return onlyHour;
    }

    auto onlyMinute = eaten();

    // hh:mm
    if (done("+,-.0123456:")) {
        bothValid = true;
        return onlyMinute;
    }

    switch (getDecimal(p, date, MINUTE)) {
        case NOTFOUND: break;
        case    FOUND:
            auto onlyDecimal = eaten();
            if (getTimeZone() == BAD)
                return onlyDecimal;

            // /hh:mm,m+/
            bothValid = true;
            return eaten();

        case BAD: return onlyMinute;
        default: assert (false);
    }

    switch (getTimeZone()) {
        case NOTFOUND: break;
        case    FOUND: bothValid = true; return eaten();
        case BAD:      return onlyMinute;
        default: assert (false);
    }

    if (
        !checkColon() ||

        parseInt(p, 2u, date.sec) != 2 || date.sec > 60 ||

        (date.hour == 24 && date.sec  != 0) ||
        (date.sec  == 60 && date.hour != 23 && date.min != 59)
    ) {
        date.sec = 0;
        return onlyMinute;
    }

    auto onlySecond = eaten();

    // hh:mm:ss
    if (done("+,-.Z")) {
        bothValid = true;
        return onlySecond;
    }

    switch (getDecimal(p, date, SECOND)) {
        case NOTFOUND: break;
        case    FOUND:
            auto onlyDecimal = eaten();
            if (getTimeZone() == BAD)
                return onlyDecimal;

            // /hh:mm:ss,s+/
            bothValid = true;
            return eaten();

        case BAD: return onlySecond;
        default: assert (false);
    }

    if (getTimeZone() == BAD)
        return onlySecond;
    else {
        bothValid = true;
        return eaten(); // hh:mm:ss with timezone
    }
}

// combination of date and time
// stricter than just date followed by time:
//  can't have an expanded or reduced date
//  either use separators everywhere or not at all

/// This function is very strict: either a complete date and time can be extracted, or nothing can.
/// If this function returns zero, the fields of date are undefined.

size_t iso8601(T)(T[] src, inout Date date) {
    T* p = src.ptr;
    ubyte sep;
    bool bothValid = false;

    if (
        doIso8601Date(p, src, date, 0u, sep) &&
        date.year && date.month && date.day &&

        // by mutual agreement this T may be omitted
        // but this is just a convenience method for date+time anyway
        demand(p, 'T') &&

        doIso8601Time(p, src, date, sep, bothValid) &&
        bothValid
    )
        return p - src.ptr;
    else
        return 0;
}

/+ +++++++++++++++++++++++++++++++++++++++ +\

   Privates used by date

\+ +++++++++++++++++++++++++++++++++++++++ +/

// /([+-]Y{expanded})?(YYYY|YY)/
private bool parseYear(T)(inout T* p, size_t expanded, out int year) {

    bool doParse() {
        T* p2 = p;

        if (!parseInt(p, expanded + 4u, year))
            return false;

        // it's Y{expanded}YY, Y{expanded}YYYY, or unacceptable

        if (p - p2 - expanded == 2u)
            year *= 100;
        else if (p - p2 - expanded != 4u)
            return false;

        return true;
    }

    if (accept(p, '-')) {
        if (!doParse())
            return false;
        year = -year;
    } else {
        accept(p, '+');
        if (!doParse())
            return false;
    }

    return true;
}

// find the month and day based on the calendar week
// uses date.year for leap year calculations
// returns false if week and date.year are incompatible
// based on the VBA function at http://www.probabilityof.com/ISO8601.shtml
private bool getMonthAndDayFromWeek(inout Date date, int week, int day = 1) {
    if (week < 1 || week > 53 || day < 1 || day > 7)
        return false;

    bool leap = isLeapYear(date.year);

    // only years starting with Thursday and
    // leap years starting with Wednesday have 53 weeks

    if (week == 53) {
        int startingDay = dayOfWeek(date.year, 1, 1, leap);

        if (!(startingDay == 4 || (leap && startingDay == 3)))
            return false;
    }

    // days since year-01-04
    int delta = 7*(week - 1) - dayOfWeek(date.year, 1, 4, leap) + day;

    if (delta <= -4) {
        if (delta < -7)
            assert (false);

        --date.year;
        date.month = 12;
        date.day   = delta + 4 + 31;

    } else if (delta <= 27) {
        date.month = 1;
        date.day   = delta + 4;

    } else if (delta <= 56 + leap) {
        date.month = 2;
        date.day   = delta - 27;

    } else if (delta <= 87 + leap) {
        date.month = 3;
        date.day   = delta - 55 - leap;

    } else if (delta <= 117 + leap) {
        date.month = 4;
        date.day   = delta - 86 - leap;

    } else if (delta <= 148 + leap) {
        date.month = 5;
        date.day   = delta - 116 - leap;

    } else if (delta <= 178 + leap) {
        date.month = 6;
        date.day   = delta - 147 - leap;

    } else if (delta <= 209 + leap) {
        date.month = 7;
        date.day   = delta - 177 - leap;

    } else if (delta <= 240 + leap) {
        date.month = 8;
        date.day   = delta - 208 - leap;

    } else if (delta <= 270 + leap) {
        date.month = 9;
        date.day   = delta - 239 - leap;

    } else if (delta <= 301 + leap) {
        date.month = 10;
        date.day   = delta - 269 - leap;

    } else if (delta <= 331 + leap) {
        date.month = 11;
        date.day   = delta - 300 - leap;

    } else if (delta <= 361 + leap) {
        date.month = 12;
        date.day   = delta - 330 - leap;

    } else {
        if (delta > 365 + leap)
            assert (false);

        ++date.year;
        date.month = 1;
        date.day   = delta - 365 - leap + 4;
    }

    return true;
}

private bool isLeapYear(int year) {
    return year % 4 == 0 && (year % 100 != 0 || year % 400 == 0);
}

// Babwani's Congruence
private int dayOfWeek(int year, int month, int day, bool leap)
in {
    assert (month  >= 1 && month  <= 12);
    assert (day    >= 1 && day    <= 31);

    // BUG: only works for 1900-3-1 to 2100-2-28
    assert (year >= 1901 && year <= 2099, "iso8601 :: Can't calculate day of week outside the years 1900-2099");

} out(result) {
    assert (result >= 1 && result <= 7);

} body {
    int f() {
        if (leap && month <= 2)
            return [6,2][month-1];

        return [0,3,3,6,1,4,6,2,5,0,3,5][month-1];
    }

    int d = ((5*(year % 100) / 4) - 2*((year / 100) % 4) + f() + day) % 7;

    // defaults to Saturday=0, Friday=6: convert to Monday=1, Sunday=7
    return (d <= 1 ? d+6 : d-1);
}

/+ +++++++++++++++++++++++++++++++++++++++ +\

   Privates used by time

\+ +++++++++++++++++++++++++++++++++++++++ +/

private enum : ubyte { HOUR, MINUTE, SECOND }
private enum :  byte { BAD, FOUND, NOTFOUND }

private byte getDecimal(T)(inout T* p, inout Date date, ubyte which) {
    if (accept(p, ',') || accept(p, '.')) {

        T* p2 = p;

        int i;
        size_t iLen = parseInt(p, i);

        if (
            iLen == 0 ||

            // if i is 0, must have at least 3 digits
            // ... or at least that's what I think the standard means
            // when it says "[i]f the magnitude of the number is less
            // than unity, the decimal sign shall be preceded by two
            // zeros"...
            // surely that should read "followed" and not "preceded"

            (i == 0 && iLen < 3)
        )
            return BAD;

        // 10 to the power of (iLen - 1)
        int pow = 1;
        while (--iLen)
            pow *= 10;

        switch (which) {
            case HOUR:
                date.min = 6 * i / pow;
                date.sec = 6 * i % pow;
                break;
            case MINUTE:
                date.sec = 6    * i / pow;
                date.ms  = 6000 * i / pow % 1000;
                break;
            case SECOND:
                date.ms = 100 * i / pow;
                break;

            default: assert (false);
        }

        return FOUND;
    }

    return NOTFOUND;
}

// the Date is always UTC, so this just adds the offset to the date fields
// another option would be to add time zone fields to Date and have this fill them

private byte getTimeZone(T)(inout T* p, inout Date date, ubyte separators, bool delegate(T[]) done) {
    if (accept(p, 'Z'))
        return FOUND;

    int factor = -1;

    if (accept(p, '-'))
        factor = 1;

    else if (!accept(p, '+'))
        return NOTFOUND;

    int hour;
    if (parseInt(p, 2u, hour) != 2 || hour > 12 || (hour == 0 && factor == 1))
        return BAD;

    date.hour += factor * hour;

    void hourCheck() {
        if (date.hour > 24 || (date.hour == 24 && (date.min || date.sec))) {
            date.hour -= 24;

            // BUG? what should be done?
            // if we get a time like 20:00-05:00
            // which needs to be converted to UTC by adding 05:00 to 20:00
            // we just set the time to 01:00 and the day to 1
            // even though this is time, which really has nothing to do with the day, which is part of the date
            
            // if this isn't a bug, it needs to be documented: it's not necessarily obvious

            if (date.day++ && date.day > daysPerMonth(date.month, date.year)) {
                date.day = 1;
                if (++date.month > 12) {
                    date.month = 1;
                    ++date.year;
                }
            }
        } else if (date.hour < 0) {
            date.hour += 24;

            // ditto above BUG?

            if (date.day-- && date.day < 1) {
                if (--date.month < 1) {
                    date.month = 12;
                    --date.year;
                }

                date.day = daysPerMonth(date.month, date.year);
            }
        }
    }

    if (done("012345:")) {
        hourCheck();
        return FOUND;
    }

    if (separators == WHATEVER)
        accept(p, ':');

    else if (accept(p, ':') != separators)
        return BAD;

    int minute;
    if (parseInt(p, 2u, minute) != 2)
        return BAD;

    assert (minute <= 59);

    date.min += factor * minute;

    if (date.min > 59) {
        date.min -= 60;
        ++date.hour;

    } else if (date.min < 0) {
        date.min += 60;
        --date.hour;
    }

    hourCheck();
    return FOUND;
}

/+ +++++++++++++++++++++++++++++++++++++++ +\

   Privates used by both date and time

\+ +++++++++++++++++++++++++++++++++++++++ +/

private bool accept(T)(inout T* p, char c) {
    if (*p == c) {
        ++p;
        return true;
    }
    return false;
}

private bool demand(T)(inout T* p, char c) {
    return (*p++ == c);
}

private bool done(T)(size_t eaten, size_t srcLen, T p, T[] s) {
    if (eaten == srcLen)
        return true;

    // s is the array of characters which may come next
    // (i.e. which p may be)
    // sorted in ascending order
    foreach (c; s) {
        if (p < c)
            return true;
        else if (p == c)
            break;
    }

    return false;
}

private int daysPerMonth(int month, int year) {
    if (month == 2 && isLeapYear(year))
        return 29;
    else
        return [31,28,31,30,31,30,31,31,30,31,30,31][month-1];
}

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

        Extract an integer from the input

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

// note: ISO 8601 code relies on these values always being positive, failing if *p == '-'

private int parseInt(T) (inout T* p) {
    int value = 0;
    while (*p >= '0' && *p <= '9')
        value = value * 10 + *p++ - '0';
    return value;
}

// ... but accept no more than max digits

private int parseInt(T)(inout T* p, size_t max) {
    size_t i = 0;
    int value = 0;
    while (p[i] >= '0' && p[i] <= '9' && i < max)
        value = value * 10 + p[i++] - '0';
    p += i;
    return value;
}

// ... and return the amount of digits processed

private size_t parseInt(T)(inout T* p, out int i) {
    T* p2 = p;
    i = parseInt(p);
    return p - p2;
}

private size_t parseInt(T)(inout T* p, size_t max, out int i) {
    T* p2 = p;
    i = parseInt(p, max);
    return p - p2;
}

////////////////////

debug (UnitTest) {
    import tango.io.Stdout;

    void main() { }

    unittest {
        Date date;

        // date

        size_t d(char[] s, size_t e = 0) {
            date = date.init;
            return iso8601Date(s, date, e);
        }

        assert (d("20abc") == 2);
        assert (date.year == 2000);

        assert (d("2004") == 4);
        assert (date.year == 2004);

        assert (d("+0019", 2) == 5);
        assert (date.year == 1900);

        assert (d("+111985", 2) == 7);
        assert (date.year == 111985);

        assert (d("+111985", 1) == 6);
        assert (date.year == 11198);

        assert (d("+111985", 3) == 0);
        assert (!date.year);

        assert (d("+111985", 4) == 7);
        assert (date.year == 11198500);

        assert (d("-111985", 5) == 0);
        assert (!date.year);

        assert (d("abc") == 0);
        assert (!date.year);

        assert (d("abc123") == 0);
        assert (!date.year);

        assert (d("2007-08") == 7);
        assert (date.year  == 2007);
        assert (date.month ==    8);

        assert (d("+001985-04", 2) == 10);
        assert (date.year  == 1985);
        assert (date.month ==    4);

        assert (d("2007-08-07") == 10);
        assert (date.year  == 2007);
        assert (date.month ==    8);
        assert (date.day   ==    7);

        assert (d("2008-20-30") == 4);
        assert (date.year == 2008);
        assert (!date.month);

        assert (d("2007-02-30") == 7);
        assert (date.year  == 2007);
        assert (date.month ==    2);

        assert (d("20060708") == 8);
        assert (date.year  == 2006);
        assert (date.month ==    7);
        assert (date.day   ==    8);

        assert (d("19953080") == 4);
        assert (date.year == 1995);
        assert (!date.month);

        assert (d("+001985-04-12", 2) == 13);
        assert (date.year  == 1985);
        assert (date.month ==    4);
        assert (date.day   ==   12);

        assert (d("-0123450607", 2) == 11);
        assert (date.year  == -12345);
        assert (date.month ==      6);
        assert (date.day   ==      7);

        assert (d("1985W15") == 7);
        assert (date.year  == 1985);
        assert (date.month ==    4);
        assert (date.day   ==    8);

        assert (d("2008-W01") == 8);
        assert (date.year  == 2007);
        assert (date.month ==   12);
        assert (date.day   ==   31);

        assert (d("2008-W01-2") == 10);
        assert (date.year  == 2008);
        assert (date.month ==    1);
        assert (date.day   ==    1);

        assert (d("2009-W53-4") == 10);
        assert (date.year  == 2009);
        assert (date.month ==   12);
        assert (date.day   ==   31);

        assert (d("2009-W01-1") == 10);
        assert (date.year  == 2008);
        assert (date.month ==   12);
        assert (date.day   ==   29);

        assert (d("2009W537") == 8);
        assert (date.year  == 2010);
        assert (date.month ==    1);
        assert (date.day   ==    3);

        assert (d("2010W537") == 4);
        assert (date.year  == 2010);
        assert (!date.month);

        assert (d("2009-W01-3") == 10);
        assert (date.year  == 2008);
        assert (date.month ==   12);
        assert (date.day   ==   31);

        assert (d("2009-W01-4") == 10);
        assert (date.year  == 2009);
        assert (date.month ==    1);
        assert (date.day   ==    1);

        /+ BUG: these don't work due to dayOfWeek being crap

        assert (d("1000-W07-7") == 10);
        assert (date.year  == 1000);
        assert (date.month ==    2);
        assert (date.day   ==   16);

        assert (d("1500-W11-1") == 10);
        assert (date.year  == 1500);
        assert (date.month ==    3);
        assert (date.day   ==   12);

        assert (d("1700-W14-2") == 10);
        assert (date.year  == 1700);
        assert (date.month ==    4);
        assert (date.day   ==    6);

        assert (d("1800-W19-3") == 10);
        assert (date.year  == 1800);
        assert (date.month ==    5);
        assert (date.day   ==    7);

        assert (d("1900-W25-4") == 10);
        assert (date.year  == 1900);
        assert (date.month ==    6);
        assert (date.day   ==   21);

        assert (d("0900-W27-5") == 10);
        assert (date.year  ==  900);
        assert (date.month ==    7);
        assert (date.day   ==    9);

        assert (d("0800-W33-6") == 10);
        assert (date.year  ==  800);
        assert (date.month ==    8);
        assert (date.day   ==   19);

        assert (d("0700-W37-7") == 10);
        assert (date.year  ==  700);
        assert (date.month ==    9);
        assert (date.day   ==   16);

        assert (d("0600-W41-4") == 10);
        assert (date.year  ==  600);
        assert (date.month ==   10);
        assert (date.day   ==    9);

        assert (d("0500-W45-7") == 10);
        assert (date.year  ==  500);
        assert (date.month ==   11);
        assert (date.day   ==   14);+/

        assert (d("2000-W55") == 4);
        assert (date.year == 2000);

        assert (d("1980-002") == 8);
        assert (date.year  == 1980);
        assert (date.month ==    1);
        assert (date.day   ==    2);

        assert (d("1981-034") == 8);
        assert (date.year  == 1981);
        assert (date.month ==    2);
        assert (date.day   ==    3);

        assert (d("1982-063") == 8);
        assert (date.year  == 1982);
        assert (date.month ==    3);
        assert (date.day   ==    4);

        assert (d("1983-095") == 8);
        assert (date.year  == 1983);
        assert (date.month ==    4);
        assert (date.day   ==    5);

        assert (d("1984-127") == 8);
        assert (date.year  == 1984);
        assert (date.month ==    5);
        assert (date.day   ==    6);

        assert (d("1985-158") == 8);
        assert (date.year  == 1985);
        assert (date.month ==    6);
        assert (date.day   ==    7);

        assert (d("1986-189") == 8);
        assert (date.year  == 1986);
        assert (date.month ==    7);
        assert (date.day   ==    8);

        assert (d("1987-221") == 8);
        assert (date.year  == 1987);
        assert (date.month ==    8);
        assert (date.day   ==    9);

        assert (d("1988-254") == 8);
        assert (date.year  == 1988);
        assert (date.month ==    9);
        assert (date.day   ==   10);

        assert (d("1989-284") == 8);
        assert (date.year  == 1989);
        assert (date.month ==   10);
        assert (date.day   ==   11);

        assert (d("1990316") == 7);
        assert (date.year  == 1990);
        assert (date.month ==   11);
        assert (date.day   ==   12);

        assert (d("1991-347") == 8);
        assert (date.year  == 1991);
        assert (date.month ==   12);
        assert (date.day   ==   13);

        assert (d("1992-000") == 4);
        assert (date.year == 1992);

        assert (d("1993-370") == 4);
        assert (date.year == 1993);

        // time

        size_t t(char[] s) {
            date = date.init;
            return iso8601Time(s, date);
        }

        assert (t("20") == 2);
        assert (date.hour == 20);
        assert (date.min  ==  0);
        assert (date.sec  ==  0);

        assert (t("30") == 0);

        assert (t("2004") == 4);
        assert (date.hour == 20);
        assert (date.min  ==  4);
        assert (date.sec  ==  0);

        assert (t("200406") == 6);
        assert (date.hour == 20);
        assert (date.min  ==  4);
        assert (date.sec  ==  6);

        assert (t("24:00") == 5);
        assert (date.hour == 24); // should compare equal with 0... can't just set to 0, loss of information
        assert (date.min  ==  0);
        assert (date.sec  ==  0);

        assert (t("00:00") == 5);
        assert (date.hour == 0);
        assert (date.min  == 0);
        assert (date.sec  == 0);

        assert (t("23:59:60") == 8);
        assert (date.hour == 23);
        assert (date.min  == 59);
        assert (date.sec  == 60); // leap second

        assert (t("16:49:30,001") == 12);
        assert (date.hour == 16);
        assert (date.min  == 49);
        assert (date.sec  == 30);
        assert (date.ms   ==  1);

        assert (t("15:48:29,1") == 10);
        assert (date.hour ==  15);
        assert (date.min  ==  48);
        assert (date.sec  ==  29);
        assert (date.ms   == 100);

        assert (t("02:10:34,a") ==  8);
        assert (date.hour ==  2);
        assert (date.min  == 10);
        assert (date.sec  == 34);

        assert (t("14:50,5") == 7);
        assert (date.hour == 14);
        assert (date.min  == 50);
        assert (date.sec  == 30);

        assert (t("1540,4") == 6);
        assert (date.hour == 15);
        assert (date.min  == 40);
        assert (date.sec  == 24);

        assert (t("1250,") == 4);
        assert (date.hour == 12);
        assert (date.min  == 50);

        assert (t("14,5") == 4);
        assert (date.hour == 14);
        assert (date.min  == 30);

        assert (t("12,") == 2);
        assert (date.hour == 12);
        assert (date.min  ==  0);

        assert (t("24:00:01") == 5);
        assert (date.hour == 24);
        assert (date.min  ==  0);
        assert (date.sec  ==  0);

        assert (t("12:34+:56") == 5);
        assert (date.hour == 12);
        assert (date.min  == 34);
        assert (date.sec  ==  0);

        // just convert to UTC time for time zones?

        assert (t("14:45:15Z") == 9);
        assert (date.hour == 14);
        assert (date.min  == 45);
        assert (date.sec  == 15);

        assert (t("23Z") == 3);
        assert (date.hour == 23);
        assert (date.min  ==  0);
        assert (date.sec  ==  0);

        assert (t("21:32:43-12:34") == 14);
        assert (date.hour == 10);
        assert (date.min  ==  6);
        assert (date.sec  == 43);

        assert (t("12:34,5+0000") == 12);
        assert (date.hour == 12);
        assert (date.min  == 34);
        assert (date.sec  == 30);

        assert (t("03:04+07") == 8);
        assert (date.hour == 20);
        assert (date.min  ==  4);
        assert (date.sec  ==  0);

        assert (t("11,5+") == 4);
        assert (date.hour == 11);
        assert (date.min  == 30);

        assert (t("07-") == 2);
        assert (date.hour == 7);

        assert (t("06:12,7-") == 7);
        assert (date.hour ==  6);
        assert (date.min  == 12);
        assert (date.sec  == 42);

        assert (t("050403,2+") == 8);
        assert (date.hour ==   5);
        assert (date.min  ==   4);
        assert (date.sec  ==   3);
        assert (date.ms   == 200);

        assert (t("061656-") == 6);
        assert (date.hour ==   6);
        assert (date.min  ==  16);
        assert (date.sec  ==  56);

        // date and time together

        size_t b(char[] s) {
            date = date.init;
            return iso8601(s, date);
        }

        assert (b("2007-08-09T12:34:56") == 19);
        assert (date.year  == 2007);
        assert (date.month ==    8);
        assert (date.day   ==    9);
        assert (date.hour  ==   12);
        assert (date.min   ==   34);
        assert (date.sec   ==   56);

        assert (b("1985W155T235030,768") == 19);
        assert (date.year  == 1985);
        assert (date.month ==    4);
        assert (date.day   ==   12);
        assert (date.hour  ==   23);
        assert (date.min   ==   50);
        assert (date.sec   ==   30);
        assert (date.ms    ==  768);

        // just convert to UTC time for time zones?

        assert (b("2009-08-07T01:02:03Z") == 20);
        assert (date.year  == 2009);
        assert (date.month ==    8);
        assert (date.day   ==    7);
        assert (date.hour  ==    1);
        assert (date.min   ==    2);
        assert (date.sec   ==    3);

        assert (b("2007-08-09T03:02,5+04:56") == 24);
        assert (date.year  == 2007);
        assert (date.month ==    8);
        assert (date.day   ==    8);
        assert (date.hour  ==   22);
        assert (date.min   ==    6);
        assert (date.sec   ==   30);

        assert (b("20000228T2330-01") == 16);
        assert (date.year  == 2000);
        assert (date.month ==    2);
        assert (date.day   ==   29);
        assert (date.hour  ==    0);
        assert (date.min   ==   30);
        assert (date.sec   ==    0);
        
        assert (b("2007-01-01T00:00+01") == 19);
        assert (date.year  == 2006);
        assert (date.month ==   12);
        assert (date.day   ==   31);
        assert (date.hour  ==   23);
        assert (date.min   ==    0);
        assert (date.sec   ==    0);

        assert (b("2007-12-31T23:00-01") == 19);
        assert (date.year  == 2007);
        assert (date.month ==   12);
        assert (date.day   ==   31);
        assert (date.hour  ==   24);
        assert (date.min   ==    0);
        assert (date.sec   ==    0);

        assert (b("2007-12-31T23:01-01") == 19);
        assert (date.year  == 2008);
        assert (date.month ==    1);
        assert (date.day   ==    1);
        assert (date.hour  ==    0);
        assert (date.min   ==    1);
        assert (date.sec   ==    0);

        assert (b("1902-03-04T1a") == 0);
        assert (b("1902-03-04T10:aa") == 0);
        assert (b("1902-03-04T10:1aa") == 0);
        assert (b("1985-04-12T10:15:30+0400") == 0);
        assert (b("1985-04-12T10:15:30-05:4") == 0);
        assert (b("1985-04-12T10:15:30-06:4b") == 0);
        assert (b("19020304T05:06:07") == 0);
        assert (b("1902-03-04T050607") == 0);
        assert (b("19020304T05:06:07abcd") == 0);
        assert (b("1902-03-04T050607abcd") == 0);

        // unimplemented: intervals, durations, recurring intervals
    }
}