Index: src/OFDate.h ================================================================== --- src/OFDate.h +++ src/OFDate.h @@ -21,46 +21,46 @@ /** * \brief A class for storing, accessing and comparing dates. */ @interface OFDate: OFObject { - int64_t sec; - uint32_t usec; + int64_t seconds; + uint32_t microseconds; } /** * \return A new, autoreleased OFDate with the current date and time */ + date; /** - * \param sec The seconds since 1970-01-01T00:00:00Z - * \return A new, autoreleased OFDate with the specified date and time - */ -+ dateWithTimeIntervalSince1970: (int64_t)sec; - -/** - * \param sec The seconds since 1970-01-01T00:00:00Z - * \param usec The microsecond part of the time - * \return A new, autoreleased OFDate with the specified date and time - */ -+ dateWithTimeIntervalSince1970: (int64_t)sec - microseconds: (uint32_t)usec; - -/** - * \param sec The seconds since now - * \return A new, autoreleased OFDate with the specified date and time - */ -+ dateWithTimeIntervalSinceNow: (int64_t)sec; - -/** - * \param sec The seconds since now - * \param usec The microsecond part of the time - * \return A new, autoreleased OFDate with the specified date and time - */ -+ dateWithTimeIntervalSinceNow: (int64_t)sec - microseconds: (uint32_t)usec; + * \param seconds The seconds since 1970-01-01T00:00:00Z + * \return A new, autoreleased OFDate with the specified date and time + */ ++ dateWithTimeIntervalSince1970: (int64_t)seconds; + +/** + * \param seconds The seconds since 1970-01-01T00:00:00Z + * \param microseconds The microsecond part of the time + * \return A new, autoreleased OFDate with the specified date and time + */ ++ dateWithTimeIntervalSince1970: (int64_t)seconds + microseconds: (uint32_t)microseconds; + +/** + * \param seconds The seconds since now + * \return A new, autoreleased OFDate with the specified date and time + */ ++ dateWithTimeIntervalSinceNow: (int64_t)seconds; + +/** + * \param seconds The seconds since now + * \param microseconds The microsecond part of the time + * \return A new, autoreleased OFDate with the specified date and time + */ ++ dateWithTimeIntervalSinceNow: (int64_t)seconds + microseconds: (uint32_t)microseconds; /** * Returns a date in the distant future. The date is system-dependant. * * \return A date in the distant future @@ -75,51 +75,50 @@ + distantPast; /** * Initializes an already allocated OFDate with the specified date and time. * - * \param sec The seconds since 1970-01-01T00:00:00Z - * \return An initialized OFDate with the specified date and time - */ -- initWithTimeIntervalSince1970: (int64_t)sec; - -/** - * Initializes an already allocated OFDate with the specified date and time. - * - * \param sec The seconds since 1970-01-01T00:00:00Z - * \param usec The microsecond part of the time - * \return An initialized OFDate with the specified date and time - */ -- initWithTimeIntervalSince1970: (int64_t)sec - microseconds: (uint32_t)usec; - -/** - * Initializes an already allocated OFDate with the specified date and time. - * - * \param sec The seconds since now - * \param usec The microsecond part of the time - * \return A new, autoreleased OFDate with the specified date and time - */ -- initWithTimeIntervalSinceNow: (int64_t)sec; - -/** - * Initializes an already allocated OFDate with the specified date and time. - * - * \param sec The seconds since now - * \param usec The microsecond part of the time - * \return A new, autoreleased OFDate with the specified date and time - */ -- initWithTimeIntervalSinceNow: (int64_t)sec - microseconds: (uint32_t)usec; + * \param seconds The seconds since 1970-01-01T00:00:00Z + * \return An initialized OFDate with the specified date and time + */ +- initWithTimeIntervalSince1970: (int64_t)seconds; + +/** + * Initializes an already allocated OFDate with the specified date and time. + * + * \param seconds The seconds since 1970-01-01T00:00:00Z + * \param microseconds The microsecond part of the time + * \return An initialized OFDate with the specified date and time + */ +- initWithTimeIntervalSince1970: (int64_t)seconds + microseconds: (uint32_t)microseconds; + +/** + * Initializes an already allocated OFDate with the specified date and time. + * + * \param seconds The seconds since now + * \return A new, autoreleased OFDate with the specified date and time + */ +- initWithTimeIntervalSinceNow: (int64_t)seconds; + +/** + * Initializes an already allocated OFDate with the specified date and time. + * + * \param seconds The seconds since now + * \param microseconds The microsecond part of the time + * \return A new, autoreleased OFDate with the specified date and time + */ +- initWithTimeIntervalSinceNow: (int64_t)seconds + microseconds: (uint32_t)microseconds; /** * \return The microsecond of the date */ - (uint32_t)microsecond; /** - * \return The seconds of the date + * \return The second of the date */ - (uint8_t)second; /** * \return The minute of the date @@ -203,17 +202,17 @@ /** * \param date Another date * \return The earlier date of the two dates */ -- (OFDate*)earlierDate: (OFDate*)date; +- (OFDate*)earlierDate: (OFDate*)otherDate; /** * \param date Another date * \return The later date of the two dates */ -- (OFDate*)laterDate: (OFDate*)date; +- (OFDate*)laterDate: (OFDate*)otherDate; /** * \return The seconds since 1970-01-01T00:00:00Z */ - (int64_t)timeIntervalSince1970; @@ -224,30 +223,30 @@ - (uint32_t)microsecondsOfTimeIntervalSince1970; /** * \return The seconds the receiver is after the date. */ -- (int64_t)timeIntervalSinceDate: (OFDate*)date; +- (int64_t)timeIntervalSinceDate: (OFDate*)otherDate; /** * \return The microseconds part of the seconds the receiver is after the date */ -- (uint32_t)microsecondsOfTimeIntervalSinceDate: (OFDate*)date; +- (uint32_t)microsecondsOfTimeIntervalSinceDate: (OFDate*)otherDate; /** * Returns a new date with the specified time interval added. * - * \param sec The seconds after the date + * \param seconds The seconds after the date * \return A new, autoreleased OFDate */ -- (OFDate*)dateByAddingTimeInterval: (int64_t)sec; +- (OFDate*)dateByAddingTimeInterval: (int64_t)seconds; /** * Returns a new date with the specified time interval added. * - * \param sec The seconds after the date - * \param usec The microseconds after the date + * \param seconds The seconds after the date + * \param microseconds The microseconds after the date * \return A new, autoreleased OFDate */ -- (OFDate*)dateByAddingTimeInterval: (int64_t)sec - withMicroseconds: (uint32_t)usec; +- (OFDate*)dateByAddingTimeInterval: (int64_t)seconds + withMicroseconds: (uint32_t)microseconds; @end Index: src/OFDate.m ================================================================== --- src/OFDate.m +++ src/OFDate.m @@ -38,55 +38,55 @@ static OFMutex *mutex; #endif #ifdef HAVE_GMTIME_R # define GMTIME_RET(field) \ - time_t sec_ = (time_t)sec; \ + time_t seconds_ = (time_t)seconds; \ struct tm tm; \ \ - if (sec != sec_) \ + if (seconds != seconds_) \ @throw [OFOutOfRangeException newWithClass: isa]; \ \ - if (gmtime_r(&sec_, &tm) == NULL) \ + if (gmtime_r(&seconds_, &tm) == NULL) \ @throw [OFOutOfRangeException newWithClass: isa]; \ \ return tm.field; # define LOCALTIME_RET(field) \ - time_t sec_ = (time_t)sec; \ + time_t seconds_ = (time_t)seconds; \ struct tm tm; \ \ - if (sec != sec_) \ + if (seconds != seconds_) \ @throw [OFOutOfRangeException newWithClass: isa]; \ \ - if (localtime_r(&sec_, &tm) == NULL) \ + if (localtime_r(&seconds_, &tm) == NULL) \ @throw [OFOutOfRangeException newWithClass: isa]; \ \ return tm.field; #else # ifdef OF_THREADS # define GMTIME_RET(field) \ - time_t sec_ = (time_t)sec; \ + time_t seconds_ = (time_t)seconds; \ struct tm *tm; \ \ - if (sec != sec_) \ + if (seconds != seconds_) \ @throw [OFOutOfRangeException newWithClass: isa]; \ \ [mutex lock]; \ \ @try { \ - if ((tm = gmtime(&sec_)) == NULL) \ + if ((tm = gmtime(&seconds_)) == NULL) \ @throw [OFOutOfRangeException newWithClass: isa]; \ \ return tm->field; \ } @finally { \ [mutex unlock]; \ } # define LOCALTIME_RET(field) \ - time_t sec_ = (time_t)sec; \ + time_t seconds_ = (time_t)seconds; \ struct tm *tm; \ \ - if (sec != sec_) \ + if (seconds != seconds_) \ @throw [OFOutOfRangeException newWithClass: isa]; \ \ [mutex lock]; \ \ @try { \ @@ -97,28 +97,28 @@ } @finally { \ [mutex unlock]; \ } # else # define GMTIME_RET(field) \ - time_t sec_ = (time_t)sec; \ + time_t seconds_ = (time_t)seconds; \ struct tm *tm; \ \ - if (sec != sec_) \ + if (seconds != seconds_) \ @throw [OFOutOfRangeException newWithClass: isa]; \ \ - if ((tm = gmtime(&sec_)) == NULL) \ + if ((tm = gmtime(&seconds_)) == NULL) \ @throw [OFOutOfRangeException newWithClass: isa]; \ \ return tm->field; # define LOCALTIME_RET(field) \ - time_t sec_ = (time_t)sec; \ + time_t seconds_ = (time_t)seconds; \ struct tm *tm; \ \ - if (sec != sec_) \ + if (seconds != seconds_) \ @throw [OFOutOfRangeException newWithClass: isa]; \ \ - if ((tm = localtime(&sec_)) == NULL) \ + if ((tm = localtime(&seconds_)) == NULL) \ @throw [OFOutOfRangeException newWithClass: isa]; \ \ return tm->field; # endif #endif @@ -136,32 +136,36 @@ + date { return [[[self alloc] init] autorelease]; } -+ dateWithTimeIntervalSince1970: (int64_t)sec -{ - return [[[self alloc] initWithTimeIntervalSince1970: sec] autorelease]; -} - -+ dateWithTimeIntervalSince1970: (int64_t)sec - microseconds: (uint32_t)usec -{ - return [[[self alloc] initWithTimeIntervalSince1970: sec - microseconds: usec] autorelease]; -} - -+ dateWithTimeIntervalSinceNow: (int64_t)sec -{ - return [[[self alloc] initWithTimeIntervalSinceNow: sec] autorelease]; -} - -+ dateWithTimeIntervalSinceNow: (int64_t)sec - microseconds: (uint32_t)usec -{ - return [[[self alloc] initWithTimeIntervalSinceNow: sec - microseconds: usec] autorelease]; ++ dateWithTimeIntervalSince1970: (int64_t)seconds +{ + return [[[self alloc] + initWithTimeIntervalSince1970: seconds] autorelease]; +} + ++ dateWithTimeIntervalSince1970: (int64_t)seconds + microseconds: (uint32_t)microseconds +{ + return [[[self alloc] + initWithTimeIntervalSince1970: seconds + microseconds: microseconds] autorelease]; +} + ++ dateWithTimeIntervalSinceNow: (int64_t)seconds +{ + return [[[self alloc] + initWithTimeIntervalSinceNow: seconds] autorelease]; +} + ++ dateWithTimeIntervalSinceNow: (int64_t)seconds + microseconds: (uint32_t)microseconds +{ + return [[[self alloc] + initWithTimeIntervalSinceNow: seconds + microseconds: microseconds] autorelease]; } + distantFuture { if (sizeof(time_t) == sizeof(int64_t)) @@ -197,54 +201,58 @@ return [self initWithTimeIntervalSince1970: t.tv_sec microseconds: (uint32_t)t.tv_usec]; } -- initWithTimeIntervalSince1970: (int64_t)sec_ +- initWithTimeIntervalSince1970: (int64_t)seconds_ { - return [self initWithTimeIntervalSince1970: sec_ + return [self initWithTimeIntervalSince1970: seconds_ microseconds: 0]; } -- initWithTimeIntervalSince1970: (int64_t)sec_ - microseconds: (uint32_t)usec_ +- initWithTimeIntervalSince1970: (int64_t)seconds_ + microseconds: (uint32_t)microseconds_ { self = [super init]; - sec = sec_; - usec = usec_; + seconds = seconds_; + microseconds = microseconds_; return self; } -- initWithTimeIntervalSinceNow: (int64_t)sec_ +- initWithTimeIntervalSinceNow: (int64_t)seconds_ { - return [self initWithTimeIntervalSinceNow: sec_ + return [self initWithTimeIntervalSinceNow: seconds_ microseconds: 0]; } -- initWithTimeIntervalSinceNow: (int64_t)sec_ - microseconds: (uint32_t)usec_ +- initWithTimeIntervalSinceNow: (int64_t)seconds_ + microseconds: (uint32_t)microseconds_ { self = [self init]; - sec += sec_; - usec += usec_; + seconds += seconds_; + microseconds += microseconds_; - while (usec > 999999) { - usec -= 10000000; - sec++; - } + seconds += microseconds / 1000000; + microseconds %= 1000000; return self; } - (BOOL)isEqual: (id)obj { + OFDate *otherDate; + if (![obj isKindOfClass: [OFDate class]]) return NO; - if (((OFDate*)obj)->sec != sec || ((OFDate*)obj)->usec != usec) + + otherDate = (OFDate*)obj; + + if (otherDate->seconds != seconds || + otherDate->microseconds != microseconds) return NO; return YES; } @@ -253,22 +261,26 @@ return [self retain]; } - (of_comparison_result_t)compare: (id)obj { + OFDate *otherDate; + if (![obj isKindOfClass: [OFDate class]]) @throw [OFInvalidArgumentException newWithClass: isa selector: _cmd]; - if (sec < ((OFDate*)obj)->sec) + otherDate = (OFDate*)obj; + + if (seconds < otherDate->seconds) return OF_ORDERED_ASCENDING; - if (sec > ((OFDate*)obj)->sec) + if (seconds > otherDate->seconds) return OF_ORDERED_DESCENDING; - if (usec < ((OFDate*)obj)->usec) + if (microseconds < otherDate->microseconds) return OF_ORDERED_ASCENDING; - if (usec > ((OFDate*)obj)->usec) + if (microseconds > otherDate->microseconds) return OF_ORDERED_DESCENDING; return OF_ORDERED_SAME; } @@ -277,11 +289,11 @@ return [self dateStringWithFormat: @"%Y-%m-%dT%H:%M:%SZ"]; } - (uint32_t)microsecond { - return usec; + return microseconds; } - (uint8_t)second { GMTIME_RET(tm_sec) @@ -348,29 +360,29 @@ } - (OFString*)dateStringWithFormat: (OFString*)fmt { OFString *ret; - time_t sec_ = (time_t)sec; + time_t seconds_ = (time_t)seconds; struct tm tm; char *buf; - if (sec != sec_) + if (seconds != seconds_) @throw [OFOutOfRangeException newWithClass: isa]; #ifdef HAVE_GMTIME_R - if (gmtime_r(&sec_, &tm) == NULL) + if (gmtime_r(&seconds_, &tm) == NULL) @throw [OFOutOfRangeException newWithClass: isa]; #else # ifdef OF_THREADS [mutex lock]; @try { # endif struct tm *tmp; - if ((tmp = gmtime(&sec_)) == NULL) + if ((tmp = gmtime(&seconds_)) == NULL) @throw [OFOutOfRangeException newWithClass: isa]; tm = *tmp; # ifdef OF_THREADS } @finally { @@ -394,29 +406,29 @@ } - (OFString*)localDateStringWithFormat: (OFString*)fmt { OFString *ret; - time_t sec_ = (time_t)sec; + time_t seconds_ = (time_t)seconds; struct tm tm; char *buf; - if (sec != sec_) + if (seconds != seconds_) @throw [OFOutOfRangeException newWithClass: isa]; #ifdef HAVE_LOCALTIME_R - if (localtime_r(&sec_, &tm) == NULL) + if (localtime_r(&seconds_, &tm) == NULL) @throw [OFOutOfRangeException newWithClass: isa]; #else # ifdef OF_THREADS [mutex lock]; @try { # endif struct tm *tmp; - if ((tmp = localtime(&sec_)) == NULL) + if ((tmp = localtime(&seconds_)) == NULL) @throw [OFOutOfRangeException newWithClass: isa]; tm = *tmp; # ifdef OF_THREADS } @finally { @@ -437,83 +449,78 @@ } return ret; } -- (OFDate*)earlierDate: (OFDate*)date +- (OFDate*)earlierDate: (OFDate*)otherDate { - if ([self compare: date] == OF_ORDERED_DESCENDING) - return [[date retain] autorelease]; + if ([self compare: otherDate] == OF_ORDERED_DESCENDING) + return [[otherDate retain] autorelease]; return [[self retain] autorelease]; } -- (OFDate*)laterDate: (OFDate*)date +- (OFDate*)laterDate: (OFDate*)otherDate { - if ([self compare: date] == OF_ORDERED_ASCENDING) - return [[date retain] autorelease]; + if ([self compare: otherDate] == OF_ORDERED_ASCENDING) + return [[otherDate retain] autorelease]; return [[self retain] autorelease]; } - (int64_t)timeIntervalSince1970 { - return sec; + return seconds; } - (uint32_t)microsecondsOfTimeIntervalSince1970 { - return usec; -} - -- (int64_t)timeIntervalSinceDate: (OFDate*)date -{ - int64_t sec_ = sec - date->sec; - int32_t usec_ = (int32_t)usec - date->usec; - - while (usec_ > 999999) { - usec_ -= 1000000; - sec_++; - } - - while (usec_ < 0) { - usec_ += 1000000; - sec_--; - } - - return sec_; -} - -- (uint32_t)microsecondsOfTimeIntervalSinceDate: (OFDate*)date -{ - int32_t usec_ = (int32_t)usec - date->usec; - - while (usec_ > 999999) - usec_ -= 1000000; - - while (usec_ < 0) - usec_ += 1000000; - - return usec_; + return microseconds; +} + +- (int64_t)timeIntervalSinceDate: (OFDate*)otherDate +{ + int64_t seconds_ = seconds - otherDate->seconds; + int32_t microseconds_ = (int32_t)microseconds - otherDate->microseconds; + + seconds_ += microseconds_ / 1000000; + microseconds_ %= 1000000; + + while (microseconds_ < 0) { + microseconds_ += 1000000; + seconds_--; + } + + return seconds_; +} + +- (uint32_t)microsecondsOfTimeIntervalSinceDate: (OFDate*)otherDate +{ + int32_t microseconds_ = (int32_t)microseconds - otherDate->microseconds; + + microseconds_ %= 1000000; + + while (microseconds_ < 0) + microseconds_ += 1000000; + + return microseconds_; } - (OFDate*)dateByAddingTimeInterval: (int64_t)sec_ { return [self dateByAddingTimeInterval: sec_ withMicroseconds: 0]; } -- (OFDate*)dateByAddingTimeInterval: (int64_t)sec_ - withMicroseconds: (uint32_t)usec_ -{ - sec_ += sec; - usec_ += usec; - - while (usec_ > 999999) { - usec_ -= 1000000; - sec_++; - } - - return [OFDate dateWithTimeIntervalSince1970: sec_ - microseconds: usec_]; +- (OFDate*)dateByAddingTimeInterval: (int64_t)seconds_ + withMicroseconds: (uint32_t)microseconds_ +{ + seconds_ += seconds; + microseconds_ += microseconds; + + seconds_ += microseconds_ / 1000000; + microseconds_ %= 1000000; + + return [OFDate dateWithTimeIntervalSince1970: seconds_ + microseconds: microseconds_]; } @end Index: tests/OFDateTests.m ================================================================== --- tests/OFDateTests.m +++ tests/OFDateTests.m @@ -32,12 +32,12 @@ TEST(@"+[dateWithTimeIntervalSince1970:]", (d1 = [OFDate dateWithTimeIntervalSince1970: 0])) TEST(@"+[dateWithTimeIntervalSince1970:microseconds:]", - (d2 = [OFDate dateWithTimeIntervalSince1970: 3600 * 25 + 5 - microseconds: 1])) + (d2 = [d1 dateByAddingTimeInterval: 3600 * 25 + 5 + withMicroseconds: 1])) TEST(@"-[description]", [[d1 description] isEqual: @"1970-01-01T00:00:00Z"] && [[d2 description] isEqual: @"1970-01-02T01:00:05Z"]) @@ -46,11 +46,11 @@ ![d1 isEqual: [OFDate dateWithTimeIntervalSince1970: 0 microseconds: 1]]) TEST(@"-[compare:]", [d1 compare: d2] == OF_ORDERED_ASCENDING) - TEST(@"-[seconds]", [d1 second] == 0 && [d2 second] == 5) + TEST(@"-[second]", [d1 second] == 0 && [d2 second] == 5) TEST(@"-[microsecond]", [d1 microsecond] == 0 && [d2 microsecond] == 1) TEST(@"-[minute]", [d1 minute] == 0 && [d2 minute] == 0)