Extended maintenance of Ruby versions 1.8.7 and 1.9.2 ended on July 31, 2014. Read more

In Files

  • time.c

Time

Time is an abstraction of dates and times. Time is stored internally as the number of seconds and microseconds since the epoch, January 1, 1970 00:00 UTC. On some operating systems, this offset is allowed to be negative. Also see the library modules Date and ParseDate. The Time class treats GMT (Greenwich Mean Time) and UTC (Coordinated Universal Time)[Yes, UTC really does stand for Coordinated Universal Time. There was a committee involved.] as equivalent. GMT is the older way of referring to these baseline times but persists in the names of calls on Posix systems.

All times are stored with some number of microseconds. Be aware of this fact when comparing times with each other—times that are apparently equal when displayed may be different when compared.

Public Class Methods

_load(string) => time click to toggle source

Unmarshal a dumped Time object.

 
               static VALUE
time_load(klass, str)
    VALUE klass, str;
{
    VALUE time = time_s_alloc(klass);

    if (FL_TEST(str, FL_EXIVAR)) {
        rb_copy_generic_ivar(time, str);
        FL_SET(time, FL_EXIVAR);
    }
    time_mload(time, str);
    return time;
}
            
at( aTime ) => time click to toggle source
at( seconds [, microseconds] ) => time

Creates a new time object with the value given by aTime, or the given number of seconds (and optional microseconds) from epoch. A non-portable feature allows the offset to be negative on some systems.

Time.at(0)            #=> Wed Dec 31 18:00:00 CST 1969
Time.at(946702800)    #=> Fri Dec 31 23:00:00 CST 1999
Time.at(-284061600)   #=> Sat Dec 31 00:00:00 CST 1960
 
               static VALUE
time_s_at(argc, argv, klass)
    int argc;
    VALUE *argv;
    VALUE klass;
{
    struct timeval tv;
    VALUE time, t;

    if (rb_scan_args(argc, argv, "11", &time, &t) == 2) {
        tv.tv_sec = NUM2LONG(time);
        tv.tv_usec = NUM2LONG(t);
    }
    else {
        tv = rb_time_timeval(time);
    }
    t = time_new_internal(klass, tv.tv_sec, tv.tv_usec);
    if (TYPE(time) == T_DATA && RDATA(time)->dfree == time_free) {
        struct time_object *tobj, *tobj2;

        GetTimeval(time, tobj);
        GetTimeval(t, tobj2);
        tobj2->gmt = tobj->gmt;
    }
    return t;
}
            
gm( year [, month, day, hour, min, sec, usec] ) => time click to toggle source
gm( sec, min, hour, day, month, year, wday, yday, isdst, tz

Creates a time based on given values, interpreted as UTC (GMT). The year must be specified. Other values default to the minimum value for that field (and may be nil or omitted). Months may be specified by numbers from 1 to 12, or by the three-letter English month names. Hours are specified on a 24-hour clock (0..23). Raises an ArgumentError if any values are out of range. Will also accept ten arguments in the order output by Time#to_a.

Time.utc(2000,"jan",1,20,15,1)  #=> Sat Jan 01 20:15:01 UTC 2000
Time.gm(2000,"jan",1,20,15,1)   #=> Sat Jan 01 20:15:01 UTC 2000
 
               static VALUE
time_s_mkutc(argc, argv, klass)
    int argc;
    VALUE *argv;
    VALUE klass;
{
    return time_utc_or_local(argc, argv, Qtrue, klass);
}
            
local( year [, month, day, hour, min, sec, usec] ) => time click to toggle source
local( sec, min, hour, day, month, year, wday, yday, isdst,

Same as Time::gm, but interprets the values in the local time zone.

Time.local(2000,"jan",1,20,15,1)   #=> Sat Jan 01 20:15:01 CST 2000
 
               static VALUE
time_s_mktime(argc, argv, klass)
    int argc;
    VALUE *argv;
    VALUE klass;
{
    return time_utc_or_local(argc, argv, Qfalse, klass);
}
            
mktime( year, month, day, hour, min, sec, usec ) => time click to toggle source

Same as Time::gm, but interprets the values in the local time zone.

Time.local(2000,"jan",1,20,15,1)   #=> Sat Jan 01 20:15:01 CST 2000
 
               static VALUE
time_s_mktime(argc, argv, klass)
    int argc;
    VALUE *argv;
    VALUE klass;
{
    return time_utc_or_local(argc, argv, Qfalse, klass);
}
            
new → time click to toggle source

Synonym for Time.new. Returns a Time object initialized tot he current system time.

Returns a Time object initialized to the current system time. Note: The object created will be created using the resolution available on your system clock, and so may include fractional seconds.

a = Time.new      #=> Wed Apr 09 08:56:03 CDT 2003
b = Time.new      #=> Wed Apr 09 08:56:03 CDT 2003
a == b            #=> false
"%.6f" % a.to_f   #=> "1049896563.230740"
"%.6f" % b.to_f   #=> "1049896563.231466"
 
               static VALUE
time_init(time)
    VALUE time;
{
    struct time_object *tobj;

    time_modify(time);
    GetTimeval(time, tobj);
    tobj->tm_got=0;
    tobj->tv.tv_sec = 0;
    tobj->tv.tv_usec = 0;
    if (gettimeofday(&tobj->tv, 0) < 0) {
        rb_sys_fail("gettimeofday");
    }

    return time;
}
            
new → time click to toggle source

Synonym for Time.new. Returns a Time object initialized tot he current system time.

Returns a Time object initialized to the current system time. Note: The object created will be created using the resolution available on your system clock, and so may include fractional seconds.

a = Time.new      #=> Wed Apr 09 08:56:03 CDT 2003
b = Time.new      #=> Wed Apr 09 08:56:03 CDT 2003
a == b            #=> false
"%.6f" % a.to_f   #=> "1049896563.230740"
"%.6f" % b.to_f   #=> "1049896563.231466"
times => struct_tms click to toggle source

Deprecated in favor of Process::times

 
               static VALUE
time_s_times(obj)
    VALUE obj;
{
    rb_warn("obsolete method Time::times; use Process::times");
    return rb_proc_times(obj);
}
            
utc( year [, month, day, hour, min, sec, usec] ) => time click to toggle source
utc( sec, min, hour, day, month, year, wday, yday, isdst, tz

Creates a time based on given values, interpreted as UTC (GMT). The year must be specified. Other values default to the minimum value for that field (and may be nil or omitted). Months may be specified by numbers from 1 to 12, or by the three-letter English month names. Hours are specified on a 24-hour clock (0..23). Raises an ArgumentError if any values are out of range. Will also accept ten arguments in the order output by Time#to_a.

Time.utc(2000,"jan",1,20,15,1)  #=> Sat Jan 01 20:15:01 UTC 2000
Time.gm(2000,"jan",1,20,15,1)   #=> Sat Jan 01 20:15:01 UTC 2000
 
               static VALUE
time_s_mkutc(argc, argv, klass)
    int argc;
    VALUE *argv;
    VALUE klass;
{
    return time_utc_or_local(argc, argv, Qtrue, klass);
}
            

Public Instance Methods

time + numeric => time click to toggle source

Addition—Adds some number of seconds (possibly fractional) to time and returns that value as a new time.

t = Time.now         #=> Wed Apr 09 08:56:03 CDT 2003
t + (60 * 60 * 24)   #=> Thu Apr 10 08:56:03 CDT 2003
 
               static VALUE
time_plus(time1, time2)
    VALUE time1, time2;
{
    struct time_object *tobj;
    GetTimeval(time1, tobj);

    if (TYPE(time2) == T_DATA && RDATA(time2)->dfree == time_free) {
        rb_raise(rb_eTypeError, "time + time?");
    }
    return time_add(tobj, time2, 1);
}
            
time - other_time => float click to toggle source
time - numeric => time

Difference—Returns a new time that represents the difference between two times, or subtracts the given number of seconds in numeric from time.

t = Time.now       #=> Wed Apr 09 08:56:03 CDT 2003
t2 = t + 2592000   #=> Fri May 09 08:56:03 CDT 2003
t2 - t             #=> 2592000.0
t2 - 2592000       #=> Wed Apr 09 08:56:03 CDT 2003
 
               static VALUE
time_minus(time1, time2)
    VALUE time1, time2;
{
    struct time_object *tobj;

    GetTimeval(time1, tobj);
    if (TYPE(time2) == T_DATA && RDATA(time2)->dfree == time_free) {
        struct time_object *tobj2;
        double f;

        GetTimeval(time2, tobj2);
        f = (double)tobj->tv.tv_sec - (double)tobj2->tv.tv_sec;
        f += ((double)tobj->tv.tv_usec - (double)tobj2->tv.tv_usec)*1e-6;
        /* XXX: should check float overflow on 64bit time_t platforms */

        return rb_float_new(f);
    }
    return time_add(tobj, time2, -1);
}
            
time <=> other_time => -1, 0, +1 click to toggle source
time <=> numeric => -1, 0, +1

Comparison—Compares time with other_time or with numeric, which is the number of seconds (possibly fractional) since epoch.

t = Time.now       #=> Wed Apr 09 08:56:03 CDT 2003
t2 = t + 2592000   #=> Fri May 09 08:56:03 CDT 2003
t <=> t2           #=> -1
t2 <=> t           #=> 1
t <=> t            #=> 0
 
               static VALUE
time_cmp(time1, time2)
    VALUE time1, time2;
{
    struct time_object *tobj1, *tobj2;

    GetTimeval(time1, tobj1);
    if (TYPE(time2) == T_DATA && RDATA(time2)->dfree == time_free) {
        GetTimeval(time2, tobj2);
        if (tobj1->tv.tv_sec == tobj2->tv.tv_sec) {
            if (tobj1->tv.tv_usec == tobj2->tv.tv_usec) return INT2FIX(0);
            if (tobj1->tv.tv_usec > tobj2->tv.tv_usec) return INT2FIX(1);
            return INT2FIX(-1);
        }
        if (tobj1->tv.tv_sec > tobj2->tv.tv_sec) return INT2FIX(1);
        return INT2FIX(-1);
    }

    return Qnil;
}
            
_dump => string click to toggle source

Dump time for marshaling.

 
               static VALUE
time_dump(argc, argv, time)
    int argc;
    VALUE *argv;
    VALUE time;
{
    VALUE str;

    rb_scan_args(argc, argv, "01", 0);
    str = time_mdump(time); 
    if (FL_TEST(time, FL_EXIVAR)) {
        rb_copy_generic_ivar(str, time);
        FL_SET(str, FL_EXIVAR);
    }

    return str;
}
            
asctime => string click to toggle source

Returns a canonical string representation of time.

Time.now.asctime   #=> "Wed Apr  9 08:56:03 2003"
 
               static VALUE
time_asctime(time)
    VALUE time;
{
    struct time_object *tobj;
    char *s;

    GetTimeval(time, tobj);
    if (tobj->tm_got == 0) {
        time_get_tm(time, tobj->gmt);
    }
    s = asctime(&tobj->tm);
    if (s[24] == '\n') s[24] = '\0';

    return rb_str_new2(s);
}
            
ctime => string click to toggle source

Returns a canonical string representation of time.

Time.now.asctime   #=> "Wed Apr  9 08:56:03 2003"
 
               static VALUE
time_asctime(time)
    VALUE time;
{
    struct time_object *tobj;
    char *s;

    GetTimeval(time, tobj);
    if (tobj->tm_got == 0) {
        time_get_tm(time, tobj->gmt);
    }
    s = asctime(&tobj->tm);
    if (s[24] == '\n') s[24] = '\0';

    return rb_str_new2(s);
}
            
day => fixnum click to toggle source

Returns the day of the month (1..n) for time.

t = Time.now   #=> Wed Apr 09 08:56:03 CDT 2003
t.day          #=> 9
t.mday         #=> 9
 
               static VALUE
time_mday(time)
    VALUE time;
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    if (tobj->tm_got == 0) {
        time_get_tm(time, tobj->gmt);
    }
    return INT2FIX(tobj->tm.tm_mday);
}
            
dst? => true or false click to toggle source

Returns true if time occurs during Daylight Saving Time in its time zone.

Time.local(2000, 7, 1).isdst   #=> true
Time.local(2000, 1, 1).isdst   #=> false
Time.local(2000, 7, 1).dst?    #=> true
Time.local(2000, 1, 1).dst?    #=> false
 
               static VALUE
time_isdst(time)
    VALUE time;
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    if (tobj->tm_got == 0) {
        time_get_tm(time, tobj->gmt);
    }
    return tobj->tm.tm_isdst?Qtrue:Qfalse;
}
            
eql?(other_time) click to toggle source

Return true if time and other_time are both Time objects with the same seconds and fractional seconds.

 
               static VALUE
time_eql(time1, time2)
    VALUE time1, time2;
{
    struct time_object *tobj1, *tobj2;

    GetTimeval(time1, tobj1);
    if (TYPE(time2) == T_DATA && RDATA(time2)->dfree == time_free) {
        GetTimeval(time2, tobj2);
        if (tobj1->tv.tv_sec == tobj2->tv.tv_sec) {
            if (tobj1->tv.tv_usec == tobj2->tv.tv_usec) return Qtrue;
        }
    }
    return Qfalse;
}
            
getgm => new_time click to toggle source

Returns a new new_time object representing time in UTC.

t = Time.local(2000,1,1,20,15,1)   #=> Sat Jan 01 20:15:01 CST 2000
t.gmt?                             #=> false
y = t.getgm                        #=> Sun Jan 02 02:15:01 UTC 2000
y.gmt?                             #=> true
t == y                             #=> true
 
               static VALUE
time_getgmtime(time)
    VALUE time;
{
    return time_gmtime(time_dup(time));
}
            
getlocal => new_time click to toggle source

Returns a new new_time object representing time in local time (using the local time zone in effect for this process).

t = Time.gm(2000,1,1,20,15,1)   #=> Sat Jan 01 20:15:01 UTC 2000
t.gmt?                          #=> true
l = t.getlocal                  #=> Sat Jan 01 14:15:01 CST 2000
l.gmt?                          #=> false
t == l                          #=> true
 
               static VALUE
time_getlocaltime(time)
    VALUE time;
{
    return time_localtime(time_dup(time));
}
            
getutc => new_time click to toggle source

Returns a new new_time object representing time in UTC.

t = Time.local(2000,1,1,20,15,1)   #=> Sat Jan 01 20:15:01 CST 2000
t.gmt?                             #=> false
y = t.getgm                        #=> Sun Jan 02 02:15:01 UTC 2000
y.gmt?                             #=> true
t == y                             #=> true
 
               static VALUE
time_getgmtime(time)
    VALUE time;
{
    return time_gmtime(time_dup(time));
}
            
gmt? => true or false click to toggle source

Returns true if time represents a time in UTC (GMT).

t = Time.now                        #=> Wed Apr 09 08:56:04 CDT 2003
t.utc?                              #=> false
t = Time.gm(2000,"jan",1,20,15,1)   #=> Sat Jan 01 20:15:01 UTC 2000
t.utc?                              #=> true

t = Time.now                        #=> Wed Apr 09 08:56:03 CDT 2003
t.gmt?                              #=> false
t = Time.gm(2000,1,1,20,15,1)       #=> Sat Jan 01 20:15:01 UTC 2000
t.gmt?                              #=> true
 
               static VALUE
time_utc_p(time)
    VALUE time;
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    if (tobj->gmt) return Qtrue;
    return Qfalse;
}
            
gmt_offset => fixnum click to toggle source

Returns the offset in seconds between the timezone of time and UTC.

t = Time.gm(2000,1,1,20,15,1)   #=> Sat Jan 01 20:15:01 UTC 2000
t.gmt_offset                    #=> 0
l = t.getlocal                  #=> Sat Jan 01 14:15:01 CST 2000
l.gmt_offset                    #=> -21600
 
               static VALUE
time_utc_offset(time)
    VALUE time;
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    if (tobj->tm_got == 0) {
        time_get_tm(time, tobj->gmt);
    }

    if (tobj->gmt == 1) {
        return INT2FIX(0);
    }
    else {
#if defined(HAVE_STRUCT_TM_TM_GMTOFF)
        return INT2NUM(tobj->tm.tm_gmtoff);
#else
        struct tm *u, *l;
        time_t t;
        long off;
        l = &tobj->tm;
        t = tobj->tv.tv_sec;
        u = gmtime(&t);
        if (!u)
            rb_raise(rb_eArgError, "gmtime error");
        if (l->tm_year != u->tm_year)
            off = l->tm_year < u->tm_year ? -1 : 1;
        else if (l->tm_mon != u->tm_mon)
            off = l->tm_mon < u->tm_mon ? -1 : 1;
        else if (l->tm_mday != u->tm_mday)
            off = l->tm_mday < u->tm_mday ? -1 : 1;
        else
            off = 0;
        off = off * 24 + l->tm_hour - u->tm_hour;
        off = off * 60 + l->tm_min - u->tm_min;
        off = off * 60 + l->tm_sec - u->tm_sec;
        return LONG2FIX(off);
#endif
    }
}
            
gmtime => time click to toggle source

Converts time to UTC (GMT), modifying the receiver.

t = Time.now   #=> Wed Apr 09 08:56:03 CDT 2003
t.gmt?         #=> false
t.gmtime       #=> Wed Apr 09 13:56:03 UTC 2003
t.gmt?         #=> true

t = Time.now   #=> Wed Apr 09 08:56:04 CDT 2003
t.utc?         #=> false
t.utc          #=> Wed Apr 09 13:56:04 UTC 2003
t.utc?         #=> true
 
               static VALUE
time_gmtime(time)
    VALUE time;
{
    struct time_object *tobj;
    struct tm *tm_tmp;
    time_t t;

    GetTimeval(time, tobj);
    if (tobj->gmt) {
        if (tobj->tm_got)
            return time;
    }
    else {
        time_modify(time);
    }
    t = tobj->tv.tv_sec;
    tm_tmp = gmtime(&t);
    if (!tm_tmp)
        rb_raise(rb_eArgError, "gmtime error");
    tobj->tm = *tm_tmp;
    tobj->tm_got = 1;
    tobj->gmt = 1;
    return time;
}
            
gmtoff => fixnum click to toggle source

Returns the offset in seconds between the timezone of time and UTC.

t = Time.gm(2000,1,1,20,15,1)   #=> Sat Jan 01 20:15:01 UTC 2000
t.gmt_offset                    #=> 0
l = t.getlocal                  #=> Sat Jan 01 14:15:01 CST 2000
l.gmt_offset                    #=> -21600
 
               static VALUE
time_utc_offset(time)
    VALUE time;
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    if (tobj->tm_got == 0) {
        time_get_tm(time, tobj->gmt);
    }

    if (tobj->gmt == 1) {
        return INT2FIX(0);
    }
    else {
#if defined(HAVE_STRUCT_TM_TM_GMTOFF)
        return INT2NUM(tobj->tm.tm_gmtoff);
#else
        struct tm *u, *l;
        time_t t;
        long off;
        l = &tobj->tm;
        t = tobj->tv.tv_sec;
        u = gmtime(&t);
        if (!u)
            rb_raise(rb_eArgError, "gmtime error");
        if (l->tm_year != u->tm_year)
            off = l->tm_year < u->tm_year ? -1 : 1;
        else if (l->tm_mon != u->tm_mon)
            off = l->tm_mon < u->tm_mon ? -1 : 1;
        else if (l->tm_mday != u->tm_mday)
            off = l->tm_mday < u->tm_mday ? -1 : 1;
        else
            off = 0;
        off = off * 24 + l->tm_hour - u->tm_hour;
        off = off * 60 + l->tm_min - u->tm_min;
        off = off * 60 + l->tm_sec - u->tm_sec;
        return LONG2FIX(off);
#endif
    }
}
            
hash => fixnum click to toggle source

Return a hash code for this time object.

 
               static VALUE
time_hash(time)
    VALUE time;
{
    struct time_object *tobj;
    long hash;

    GetTimeval(time, tobj);
    hash = tobj->tv.tv_sec ^ tobj->tv.tv_usec;
    return LONG2FIX(hash);
}
            
hour => fixnum click to toggle source

Returns the hour of the day (0..23) for time.

t = Time.now   #=> Wed Apr 09 08:56:03 CDT 2003
t.hour         #=> 8
 
               static VALUE
time_hour(time)
    VALUE time;
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    if (tobj->tm_got == 0) {
        time_get_tm(time, tobj->gmt);
    }
    return INT2FIX(tobj->tm.tm_hour);
}
            
inspect => string click to toggle source

Returns a string representing time. Equivalent to calling Time#strftime with a format string of “%a %b %d %H:%M:%S %Z %Y”.

Time.now.to_s   #=> "Wed Apr 09 08:56:04 CDT 2003"
 
               static VALUE
time_to_s(time)
    VALUE time;
{
    struct time_object *tobj;
    char buf[128];
    int len;

    GetTimeval(time, tobj);
    if (tobj->tm_got == 0) {
        time_get_tm(time, tobj->gmt);
    }
    if (tobj->gmt == 1) {
        len = strftime(buf, 128, "%a %b %d %H:%M:%S UTC %Y", &tobj->tm);
    }
    else {
        time_t off;
        char buf2[32];
        char sign = '+';
#if defined(HAVE_STRUCT_TM_TM_GMTOFF)
        off = tobj->tm.tm_gmtoff;
#else
        VALUE tmp = time_utc_offset(time);
        off = NUM2INT(tmp);
#endif
        if (off < 0) {
            sign = '-';
            off = -off;
        }
        sprintf(buf2, "%%a %%b %%d %%H:%%M:%%S %c%02d%02d %%Y",
                sign, (int)(off/3600), (int)(off%3600/60));
        len = strftime(buf, 128, buf2, &tobj->tm);
    }
    return rb_str_new(buf, len);
}
            
isdst => true or false click to toggle source

Returns true if time occurs during Daylight Saving Time in its time zone.

Time.local(2000, 7, 1).isdst   #=> true
Time.local(2000, 1, 1).isdst   #=> false
Time.local(2000, 7, 1).dst?    #=> true
Time.local(2000, 1, 1).dst?    #=> false
 
               static VALUE
time_isdst(time)
    VALUE time;
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    if (tobj->tm_got == 0) {
        time_get_tm(time, tobj->gmt);
    }
    return tobj->tm.tm_isdst?Qtrue:Qfalse;
}
            
localtime => time click to toggle source

Converts time to local time (using the local time zone in effect for this process) modifying the receiver.

t = Time.gm(2000, "jan", 1, 20, 15, 1)
t.gmt?        #=> true
t.localtime   #=> Sat Jan 01 14:15:01 CST 2000
t.gmt?        #=> false
 
               static VALUE
time_localtime(time)
    VALUE time;
{
    struct time_object *tobj;
    struct tm *tm_tmp;
    time_t t;

    GetTimeval(time, tobj);
    if (!tobj->gmt) {
        if (tobj->tm_got)
            return time;
    }
    else {
        time_modify(time);
    }
    t = tobj->tv.tv_sec;
    tm_tmp = localtime(&t);
    if (!tm_tmp)
        rb_raise(rb_eArgError, "localtime error");
    tobj->tm = *tm_tmp;
    tobj->tm_got = 1;
    tobj->gmt = 0;
    return time;
}
            
marshal_dump() click to toggle source

undocumented

 
               static VALUE
time_mdump(time)
    VALUE time;
{
    struct time_object *tobj;
    struct tm *tm;
    unsigned long p, s;
    char buf[8];
    time_t t;
    int i;

    GetTimeval(time, tobj);

    t = tobj->tv.tv_sec;
    tm = gmtime(&t);

    if ((tm->tm_year & 0xffff) != tm->tm_year)
        rb_raise(rb_eArgError, "year too big to marshal");

    p = 0x1UL        << 31 | /*  1 */
        tobj->gmt    << 30 | /*  1 */
        tm->tm_year  << 14 | /* 16 */
        tm->tm_mon   << 10 | /*  4 */
        tm->tm_mday  <<  5 | /*  5 */
        tm->tm_hour;         /*  5 */
    s = tm->tm_min   << 26 | /*  6 */
        tm->tm_sec   << 20 | /*  6 */
        tobj->tv.tv_usec;    /* 20 */

    for (i=0; i<4; i++) {
        buf[i] = p & 0xff;
        p = RSHIFT(p, 8);
    }
    for (i=4; i<8; i++) {
        buf[i] = s & 0xff;
        s = RSHIFT(s, 8);
    }

    return rb_str_new(buf, 8);
}
            
marshal_load(p1) click to toggle source

undocumented

 
               static VALUE
time_mload(time, str)
    VALUE time, str;
{
    struct time_object *tobj;
    unsigned long p, s;
    time_t sec, usec;
    unsigned char *buf;
    struct tm tm;
    int i, gmt;

    time_modify(time);
    StringValue(str);
    buf = (unsigned char *)RSTRING(str)->ptr;
    if (RSTRING(str)->len != 8) {
        rb_raise(rb_eTypeError, "marshaled time format differ");
    }

    p = s = 0;
    for (i=0; i<4; i++) {
        p |= buf[i]<<(8*i);
    }
    for (i=4; i<8; i++) {
        s |= buf[i]<<(8*(i-4));
    }

    if ((p & (1UL<<31)) == 0) {
        sec = p;
        usec = s;
    }
    else {
        p &= ~(1UL<<31);
        gmt        = (p >> 30) & 0x1;
        tm.tm_year = (p >> 14) & 0xffff;
        tm.tm_mon  = (p >> 10) & 0xf;
        tm.tm_mday = (p >>  5) & 0x1f;
        tm.tm_hour =  p        & 0x1f;
        tm.tm_min  = (s >> 26) & 0x3f;
        tm.tm_sec  = (s >> 20) & 0x3f;
        tm.tm_isdst = 0;

        sec = make_time_t(&tm, Qtrue);
        usec = (time_t)(s & 0xfffff);
    }
    time_overflow_p(&sec, &usec);

    GetTimeval(time, tobj);
    tobj->tm_got = 0;
    tobj->gmt = gmt;
    tobj->tv.tv_sec = sec;
    tobj->tv.tv_usec = usec;
    return time;
}
            
mday => fixnum click to toggle source

Returns the day of the month (1..n) for time.

t = Time.now   #=> Wed Apr 09 08:56:03 CDT 2003
t.day          #=> 9
t.mday         #=> 9
 
               static VALUE
time_mday(time)
    VALUE time;
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    if (tobj->tm_got == 0) {
        time_get_tm(time, tobj->gmt);
    }
    return INT2FIX(tobj->tm.tm_mday);
}
            
min => fixnum click to toggle source

Returns the minute of the hour (0..59) for time.

t = Time.now   #=> Wed Apr 09 08:56:03 CDT 2003
t.min          #=> 56
 
               static VALUE
time_min(time)
    VALUE time;
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    if (tobj->tm_got == 0) {
        time_get_tm(time, tobj->gmt);
    }
    return INT2FIX(tobj->tm.tm_min);
}
            
mon => fixnum click to toggle source
month => fixnum

Returns the month of the year (1..12) for time.

t = Time.now   #=> Wed Apr 09 08:56:03 CDT 2003
t.mon          #=> 4
t.month        #=> 4
 
               static VALUE
time_mon(time)
    VALUE time;
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    if (tobj->tm_got == 0) {
        time_get_tm(time, tobj->gmt);
    }
    return INT2FIX(tobj->tm.tm_mon+1);
}
            
month => fixnum click to toggle source

Returns the month of the year (1..12) for time.

t = Time.now   #=> Wed Apr 09 08:56:03 CDT 2003
t.mon          #=> 4
t.month        #=> 4
 
               static VALUE
time_mon(time)
    VALUE time;
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    if (tobj->tm_got == 0) {
        time_get_tm(time, tobj->gmt);
    }
    return INT2FIX(tobj->tm.tm_mon+1);
}
            
sec => fixnum click to toggle source

Returns the second of the minute (0..60)[Yes, seconds really can range from zero to 60. This allows the system to inject leap seconds every now and then to correct for the fact that years are not really a convenient number of hours long.] for time.

t = Time.now   #=> Wed Apr 09 08:56:04 CDT 2003
t.sec          #=> 4
 
               static VALUE
time_sec(time)
    VALUE time;
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    if (tobj->tm_got == 0) {
        time_get_tm(time, tobj->gmt);
    }
    return INT2FIX(tobj->tm.tm_sec);
}
            
strftime( string ) => string click to toggle source

Formats time according to the directives in the given format string. Any text not listed as a directive will be passed through to the output string.

Format meaning:

% - The abbreviated weekday name (%x`Sun'')
% - The  full  weekday  name (%x`Sunday'')
% - The abbreviated month name (%x`Jan'')
% - The  full  month  name (%x`January'')
% - The preferred local date and time representation
% - Day of the month (01..31)
% - Hour of the day, 24-hour clock (00..23)
% - Hour of the day, 12-hour clock (01..12)
% - Day of the year (001..366)
% - Month of the year (01..12)
% - Minute of the hour (00..59)
% - Meridian indicator (%x`AM''  or  %x`PM'')
% - Second of the minute (00..60)
% - Week  number  of the current year,
        starting with the first Sunday as the first
        day of the first week (00..53)
%W- Week  number  of the current year,
        starting with the first Monday as the first
        day of the first week (00..53)
%w- Day of the week (Sunday is 0, 0..6)
%x- Preferred representation for the date alone, no time
% - Preferred representation for the time alone, no date
% - Year without a century (00..99)
% - Year with century
% - Time zone name
%Q - Literal ``%'' character

 t = Time.now
 t.strftime("Printed on %m/%d/%Y")   #=> "Printed on 04/09/2003"
 t.strftime("at %I:%M%p")            #=> "at 08:56AM"
 
               static VALUE
time_strftime(time, format)
    VALUE time, format;
{
    struct time_object *tobj;
    char buffer[SMALLBUF], *buf = buffer;
    const char *fmt;
    long len;
    VALUE str;

    GetTimeval(time, tobj);
    if (tobj->tm_got == 0) {
        time_get_tm(time, tobj->gmt);
    }
    StringValue(format);
    format = rb_str_new4(format);
    fmt = RSTRING(format)->ptr;
    len = RSTRING(format)->len;
    if (len == 0) {
        rb_warning("strftime called with empty format string");
    }
    else if (strlen(fmt) < len) {
        /* Ruby string may contain \0's. */
        const char *p = fmt, *pe = fmt + len;

        str = rb_str_new(0, 0);
        while (p < pe) {
            len = rb_strftime(&buf, p, &tobj->tm);
            rb_str_cat(str, buf, len);
            p += strlen(p);
            if (buf != buffer) {
                free(buf);
                buf = buffer;
            }
            for (fmt = p; p < pe && !*p; ++p);
            if (p > fmt) rb_str_cat(str, fmt, p - fmt);
        }
        return str;
    }
    else {
        len = rb_strftime(&buf, RSTRING(format)->ptr, &tobj->tm);
    }
    str = rb_str_new(buf, len);
    if (buf != buffer) free(buf);
    return str;
}
            
succ => new_time click to toggle source

Return a new time object, one second later than time.

 
               static VALUE
time_succ(time)
    VALUE time;
{
    struct time_object *tobj;
    int gmt;

    GetTimeval(time, tobj);
    gmt = tobj->gmt;
    time = rb_time_new(tobj->tv.tv_sec + 1, tobj->tv.tv_usec);
    GetTimeval(time, tobj);
    tobj->gmt = gmt;
    return time;
}
            
to_a => array click to toggle source

Returns a ten-element array of values for time: {[ sec, min, hour, day, month, year, wday, yday, isdst, zone ]}. See the individual methods for an explanation of the valid ranges of each value. The ten elements can be passed directly to Time::utc or Time::local to create a new Time.

now = Time.now   #=> Wed Apr 09 08:56:04 CDT 2003
t = now.to_a     #=> [4, 56, 8, 9, 4, 2003, 3, 99, true, "CDT"]
 
               static VALUE
time_to_a(time)
    VALUE time;
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    if (tobj->tm_got == 0) {
        time_get_tm(time, tobj->gmt);
    }
    return rb_ary_new3(10,
                    INT2FIX(tobj->tm.tm_sec),
                    INT2FIX(tobj->tm.tm_min),
                    INT2FIX(tobj->tm.tm_hour),
                    INT2FIX(tobj->tm.tm_mday),
                    INT2FIX(tobj->tm.tm_mon+1),
                    LONG2NUM((long)tobj->tm.tm_year+1900),
                    INT2FIX(tobj->tm.tm_wday),
                    INT2FIX(tobj->tm.tm_yday+1),
                    tobj->tm.tm_isdst?Qtrue:Qfalse,
                    time_zone(time));
}
            
to_f => float click to toggle source

Returns the value of time as a floating point number of seconds since epoch.

t = Time.now
"%10.5f" % t.to_f   #=> "1049896564.13654"
t.to_i              #=> 1049896564
 
               static VALUE
time_to_f(time)
    VALUE time;
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    return rb_float_new((double)tobj->tv.tv_sec+(double)tobj->tv.tv_usec/1e6);
}
            
to_i => int click to toggle source

Returns the value of time as an integer number of seconds since epoch.

t = Time.now
"%10.5f" % t.to_f   #=> "1049896564.17839"
t.to_i              #=> 1049896564
 
               static VALUE
time_to_i(time)
    VALUE time;
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    return LONG2NUM(tobj->tv.tv_sec);
}
            
to_s => string click to toggle source

Returns a string representing time. Equivalent to calling Time#strftime with a format string of “%a %b %d %H:%M:%S %Z %Y”.

Time.now.to_s   #=> "Wed Apr 09 08:56:04 CDT 2003"
 
               static VALUE
time_to_s(time)
    VALUE time;
{
    struct time_object *tobj;
    char buf[128];
    int len;

    GetTimeval(time, tobj);
    if (tobj->tm_got == 0) {
        time_get_tm(time, tobj->gmt);
    }
    if (tobj->gmt == 1) {
        len = strftime(buf, 128, "%a %b %d %H:%M:%S UTC %Y", &tobj->tm);
    }
    else {
        time_t off;
        char buf2[32];
        char sign = '+';
#if defined(HAVE_STRUCT_TM_TM_GMTOFF)
        off = tobj->tm.tm_gmtoff;
#else
        VALUE tmp = time_utc_offset(time);
        off = NUM2INT(tmp);
#endif
        if (off < 0) {
            sign = '-';
            off = -off;
        }
        sprintf(buf2, "%%a %%b %%d %%H:%%M:%%S %c%02d%02d %%Y",
                sign, (int)(off/3600), (int)(off%3600/60));
        len = strftime(buf, 128, buf2, &tobj->tm);
    }
    return rb_str_new(buf, len);
}
            
tv_sec => int click to toggle source

Returns the value of time as an integer number of seconds since epoch.

t = Time.now
"%10.5f" % t.to_f   #=> "1049896564.17839"
t.to_i              #=> 1049896564
 
               static VALUE
time_to_i(time)
    VALUE time;
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    return LONG2NUM(tobj->tv.tv_sec);
}
            
tv_usec => int click to toggle source

Returns just the number of microseconds for time.

t = Time.now        #=> Wed Apr 09 08:56:04 CDT 2003
"%10.6f" % t.to_f   #=> "1049896564.259970"
t.usec              #=> 259970
 
               static VALUE
time_usec(time)
    VALUE time;
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    return LONG2NUM(tobj->tv.tv_usec);
}
            
usec => int click to toggle source

Returns just the number of microseconds for time.

t = Time.now        #=> Wed Apr 09 08:56:04 CDT 2003
"%10.6f" % t.to_f   #=> "1049896564.259970"
t.usec              #=> 259970
 
               static VALUE
time_usec(time)
    VALUE time;
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    return LONG2NUM(tobj->tv.tv_usec);
}
            
gmtime => time click to toggle source
utc => time

Converts time to UTC (GMT), modifying the receiver.

t = Time.now   #=> Wed Apr 09 08:56:03 CDT 2003
t.gmt?         #=> false
t.gmtime       #=> Wed Apr 09 13:56:03 UTC 2003
t.gmt?         #=> true

t = Time.now   #=> Wed Apr 09 08:56:04 CDT 2003
t.utc?         #=> false
t.utc          #=> Wed Apr 09 13:56:04 UTC 2003
t.utc?         #=> true
 
               static VALUE
time_gmtime(time)
    VALUE time;
{
    struct time_object *tobj;
    struct tm *tm_tmp;
    time_t t;

    GetTimeval(time, tobj);
    if (tobj->gmt) {
        if (tobj->tm_got)
            return time;
    }
    else {
        time_modify(time);
    }
    t = tobj->tv.tv_sec;
    tm_tmp = gmtime(&t);
    if (!tm_tmp)
        rb_raise(rb_eArgError, "gmtime error");
    tobj->tm = *tm_tmp;
    tobj->tm_got = 1;
    tobj->gmt = 1;
    return time;
}
            
utc? => true or false click to toggle source

Returns true if time represents a time in UTC (GMT).

t = Time.now                        #=> Wed Apr 09 08:56:04 CDT 2003
t.utc?                              #=> false
t = Time.gm(2000,"jan",1,20,15,1)   #=> Sat Jan 01 20:15:01 UTC 2000
t.utc?                              #=> true

t = Time.now                        #=> Wed Apr 09 08:56:03 CDT 2003
t.gmt?                              #=> false
t = Time.gm(2000,1,1,20,15,1)       #=> Sat Jan 01 20:15:01 UTC 2000
t.gmt?                              #=> true
 
               static VALUE
time_utc_p(time)
    VALUE time;
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    if (tobj->gmt) return Qtrue;
    return Qfalse;
}
            
utc_offset => fixnum click to toggle source

Returns the offset in seconds between the timezone of time and UTC.

t = Time.gm(2000,1,1,20,15,1)   #=> Sat Jan 01 20:15:01 UTC 2000
t.gmt_offset                    #=> 0
l = t.getlocal                  #=> Sat Jan 01 14:15:01 CST 2000
l.gmt_offset                    #=> -21600
 
               static VALUE
time_utc_offset(time)
    VALUE time;
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    if (tobj->tm_got == 0) {
        time_get_tm(time, tobj->gmt);
    }

    if (tobj->gmt == 1) {
        return INT2FIX(0);
    }
    else {
#if defined(HAVE_STRUCT_TM_TM_GMTOFF)
        return INT2NUM(tobj->tm.tm_gmtoff);
#else
        struct tm *u, *l;
        time_t t;
        long off;
        l = &tobj->tm;
        t = tobj->tv.tv_sec;
        u = gmtime(&t);
        if (!u)
            rb_raise(rb_eArgError, "gmtime error");
        if (l->tm_year != u->tm_year)
            off = l->tm_year < u->tm_year ? -1 : 1;
        else if (l->tm_mon != u->tm_mon)
            off = l->tm_mon < u->tm_mon ? -1 : 1;
        else if (l->tm_mday != u->tm_mday)
            off = l->tm_mday < u->tm_mday ? -1 : 1;
        else
            off = 0;
        off = off * 24 + l->tm_hour - u->tm_hour;
        off = off * 60 + l->tm_min - u->tm_min;
        off = off * 60 + l->tm_sec - u->tm_sec;
        return LONG2FIX(off);
#endif
    }
}
            
wday => fixnum click to toggle source

Returns an integer representing the day of the week, 0..6, with Sunday == 0.

t = Time.now   #=> Wed Apr 09 08:56:04 CDT 2003
t.wday         #=> 3
 
               static VALUE
time_wday(time)
    VALUE time;
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    if (tobj->tm_got == 0) {
        time_get_tm(time, tobj->gmt);
    }
    return INT2FIX(tobj->tm.tm_wday);
}
            
yday => fixnum click to toggle source

Returns an integer representing the day of the year, 1..366.

t = Time.now   #=> Wed Apr 09 08:56:04 CDT 2003
t.yday         #=> 99
 
               static VALUE
time_yday(time)
    VALUE time;
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    if (tobj->tm_got == 0) {
        time_get_tm(time, tobj->gmt);
    }
    return INT2FIX(tobj->tm.tm_yday+1);
}
            
year => fixnum click to toggle source

Returns the year for time (including the century).

t = Time.now   #=> Wed Apr 09 08:56:04 CDT 2003
t.year         #=> 2003
 
               static VALUE
time_year(time)
    VALUE time;
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    if (tobj->tm_got == 0) {
        time_get_tm(time, tobj->gmt);
    }
    return LONG2NUM((long)tobj->tm.tm_year+1900);
}
            
zone => string click to toggle source

Returns the name of the time zone used for time. As of Ruby 1.8, returns “UTC” rather than “GMT” for UTC times.

t = Time.gm(2000, "jan", 1, 20, 15, 1)
t.zone   #=> "UTC"
t = Time.local(2000, "jan", 1, 20, 15, 1)
t.zone   #=> "CST"
 
               static VALUE
time_zone(time)
    VALUE time;
{
    struct time_object *tobj;
#if !defined(HAVE_TM_ZONE) && (!defined(HAVE_TZNAME) || !defined(HAVE_DAYLIGHT))
    char buf[64];
    int len;
#endif
    
    GetTimeval(time, tobj);
    if (tobj->tm_got == 0) {
        time_get_tm(time, tobj->gmt);
    }

    if (tobj->gmt == 1) {
        return rb_str_new2("UTC");
    }
#if defined(HAVE_TM_ZONE)
    return rb_str_new2(tobj->tm.tm_zone);
#elif defined(HAVE_TZNAME) && defined(HAVE_DAYLIGHT)
    return rb_str_new2(tzname[daylight && tobj->tm.tm_isdst]);
#else
    len = strftime(buf, 64, "%Z", &tobj->tm);
    return rb_str_new(buf, len);
#endif
}
            

Commenting is here to help enhance the documentation. For example, code samples, or clarification of the documentation.

If you have questions about Ruby or the documentation, please post to one of the Ruby mailing lists. You will get better, faster, help that way.

If you wish to post a correction of the docs, please do so, but also file bug report so that it can be corrected for the next release. Thank you.

If you want to help improve the Ruby documentation, please visit Documenting-ruby.org.

blog comments powered by Disqus