Class: Time

Inherits:

Object

Object
Time

show all

Includes:: Comparable

Defined in:: time.c

Class Method Summary collapse

._load(string) ⇒ Time

Unmarshal a dumped Time object.
.at ⇒ Object

Creates a new time object with the value given by aTime, or the given number of seconds (and optional microseconds) from epoch.
.gm ⇒ Object

Time.gm( year [, month, day, hour, min, sec, usec] ) => time Time.gm( sec, min, hour, day, month, year, wday, yday, isdst, tz ) => time.
.local ⇒ Object

Time.mktime( year, month, day, hour, min, sec, usec ) => time.
.mktime ⇒ Object

Time.mktime( year, month, day, hour, min, sec, usec ) => time.
.now ⇒ Object

Synonym for Time.new.
.times ⇒ Object

Deprecated in favor of Process::times.
.utc ⇒ Object

Time.gm( year [, month, day, hour, min, sec, usec] ) => time Time.gm( sec, min, hour, day, month, year, wday, yday, isdst, tz ) => time.

Instance Method Summary collapse

#+(numeric) ⇒ Time

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

Difference---Returns a new time that represents the difference between two times, or subtracts the given number of seconds in numeric from time.
#<=> ⇒ Object

Comparison---Compares time with other_time or with numeric, which is the number of seconds (possibly fractional) since epoch.
#_dump ⇒ String

Dump time for marshaling.
#asctime ⇒ Object

Returns a canonical string representation of time.
#ctime ⇒ Object

Returns a canonical string representation of time.
#day ⇒ Object

Returns the day of the month (1..n) for time.
#dst? ⇒ Object

Returns true if time occurs during Daylight Saving Time in its time zone.
#eql?(other_time) ⇒ Object

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

Returns a new new_time object representing time in UTC.
#getlocal ⇒ Time

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

Returns a new new_time object representing time in UTC.
#gmt? ⇒ Object

Returns true if time represents a time in UTC (GMT).
#gmt_offset ⇒ Object

Returns the offset in seconds between the timezone of time and UTC.
#gmtime ⇒ Object

Converts time to UTC (GMT), modifying the receiver.
#gmtoff ⇒ Object

Returns the offset in seconds between the timezone of time and UTC.
#hash ⇒ Fixnum

Return a hash code for this time object.
#hour ⇒ Fixnum

Returns the hour of the day (0..23) for time.
#initialize ⇒ Object constructor

Synonym for Time.new.
#initialize_copy ⇒ Object

:nodoc:.
#inspect ⇒ Object

Returns a string representing time.
#isdst ⇒ Object

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

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

undocumented.
#marshal_load ⇒ Object

undocumented.
#mday ⇒ Object

Returns the day of the month (1..n) for time.
#min ⇒ Fixnum

Returns the minute of the hour (0..59) for time.
#mon ⇒ Object

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

Returns the month of the year (1..12) for time.
#sec ⇒ Fixnum

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.
#strftime(string) ⇒ String

Formats time according to the directives in the given format string.
#succ ⇒ Time

Return a new time object, one second later than time.
#to_a ⇒ Array

Returns a ten-element array of values for time: sec, min, hour, day, month, year, wday, yday, isdst, zone ].
#to_f ⇒ Float

Returns the value of time as a floating point number of seconds since epoch.
#to_i ⇒ Object

Returns the value of time as an integer number of seconds since epoch.
#to_s ⇒ Object

Returns a string representing time.
#tv_sec ⇒ Object

Returns the value of time as an integer number of seconds since epoch.
#tv_usec ⇒ Object

Returns just the number of microseconds for time.
#usec ⇒ Object

Returns just the number of microseconds for time.
#utc ⇒ Object

Converts time to UTC (GMT), modifying the receiver.
#utc? ⇒ Object

Returns true if time represents a time in UTC (GMT).
#utc_offset ⇒ Object

Returns the offset in seconds between the timezone of time and UTC.
#wday ⇒ Fixnum

Returns an integer representing the day of the week, 0..6, with Sunday == 0.
#yday ⇒ Fixnum

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

Returns the year for time (including the century).
#zone ⇒ String

Returns the name of the time zone used for time.

Methods included from Comparable

#<, #<=, #==, #>, #>=, #between?

Constructor Details

#initialize ⇒ `Object`

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

call-seq:

Time.new -> 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"

# File 'time.c'

/*
 *  Document-method: now
 *
 *  Synonym for <code>Time.new</code>. Returns a +Time+ object
 *  initialized tot he current system time.
 *
 *  call-seq:
 *     Time.new -> time
 *  
 *  Returns a <code>Time</code> object initialized to the current system
 *  time. <b>Note:</b> 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;
}

Class Method Details

._load(string) ⇒ `Time`

Unmarshal a dumped Time object.

Returns:

(Time)

# File 'time.c'

/*
 * call-seq:
 *   Time._load(string)   => time
 *
 * 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` .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

Overloads:

.at(aTime) ⇒ Time
Returns:
- (Time)
.at(seconds[, microseconds]) ⇒ Time
Returns:
- (Time)

# File 'time.c'

/*
 *  call-seq:
 *     Time.at( aTime ) => time
 *     Time.at( seconds [, microseconds] ) => time
 *  
 *  Creates a new time object with the value given by <i>aTime</i>, or
 *  the given number of <i>seconds</i> (and optional
 *  <i>microseconds</i>) 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;
}

.utc(year[, month, day, hour, min, sec, usec]) ⇒ `Time` .utc(sec, min, hour, day, month, year, wday, yday, isdst, tz) ⇒ `Object`

Time.gm( year [, month, day, hour, min, sec, usec] ) => time

Time.gm( sec, min, hour, day, month, year, wday, yday, isdst, tz
) => time

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

Overloads:

.utc(year[, month, day, hour, min, sec, usec]) ⇒ Time
Returns:
- (Time)

# File 'time.c'

/*
 *  call-seq:
 *     Time.utc( year [, month, day, hour, min, sec, usec] ) => time
 *     Time.utc( sec, min, hour, day, month, year, wday, yday, isdst, tz
 *     ) => time
 *     Time.gm( year [, month, day, hour, min, sec, usec] ) => time
 *     Time.gm( sec, min, hour, day, month, year, wday, yday, isdst, tz
 *     ) => time
 *     
 *  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 <code>nil</code> 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 <code>ArgumentError</code> if any values are out of range. Will
 *  also accept ten arguments in the order output by
 *  <code>Time#to_a</code>.
 *
 *     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` .local(sec, min, hour, day, month, year, wday, yday, isdst) ⇒ `Object`

Time.mktime( year, month, day, hour, min, sec, usec ) => time

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

Overloads:

.local(year[, month, day, hour, min, sec, usec]) ⇒ Time
Returns:
- (Time)

# File 'time.c'

/*
 *  call-seq:
 *     Time.local( year [, month, day, hour, min, sec, usec] ) => time
 *     Time.local( sec, min, hour, day, month, year, wday, yday, isdst,
 *     tz ) => time
 *     Time.mktime( year, month, day, hour, min, sec, usec )   => time
 *  
 *  Same as <code>Time::gm</code>, 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);
}

.local(year[, month, day, hour, min, sec, usec]) ⇒ `Time` .local(sec, min, hour, day, month, year, wday, yday, isdst) ⇒ `Object`

Time.mktime( year, month, day, hour, min, sec, usec ) => time

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

Overloads:

.local(year[, month, day, hour, min, sec, usec]) ⇒ Time
Returns:
- (Time)

# File 'time.c'

/*
 *  call-seq:
 *     Time.local( year [, month, day, hour, min, sec, usec] ) => time
 *     Time.local( sec, min, hour, day, month, year, wday, yday, isdst,
 *     tz ) => time
 *     Time.mktime( year, month, day, hour, min, sec, usec )   => time
 *  
 *  Same as <code>Time::gm</code>, 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);
}

.now ⇒ `Object`

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

call-seq:

Time.new -> time

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 ⇒ `Object`

Deprecated in favor of Process::times

# File 'time.c'

/*
 *  call-seq:
 *     Time.times => struct_tms
 *  
 *  Deprecated in favor of <code>Process::times</code>
 */

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` .utc(sec, min, hour, day, month, year, wday, yday, isdst, tz) ⇒ `Object`

Time.gm( year [, month, day, hour, min, sec, usec] ) => time

Time.gm( sec, min, hour, day, month, year, wday, yday, isdst, tz
) => time

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

Overloads:

.utc(year[, month, day, hour, min, sec, usec]) ⇒ Time
Returns:
- (Time)

# File 'time.c'

/*
 *  call-seq:
 *     Time.utc( year [, month, day, hour, min, sec, usec] ) => time
 *     Time.utc( sec, min, hour, day, month, year, wday, yday, isdst, tz
 *     ) => time
 *     Time.gm( year [, month, day, hour, min, sec, usec] ) => time
 *     Time.gm( sec, min, hour, day, month, year, wday, yday, isdst, tz
 *     ) => time
 *     
 *  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 <code>nil</code> 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 <code>ArgumentError</code> if any values are out of range. Will
 *  also accept ten arguments in the order output by
 *  <code>Time#to_a</code>.
 *
 *     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);
}

Instance Method Details

#+(numeric) ⇒ `Time`

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

Returns:

(Time)

# File 'time.c'

/*
 *  call-seq:
 *     time + numeric => time
 *  
 *  Addition---Adds some number of seconds (possibly fractional) to
 *  <i>time</i> 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);
}

#-(other_time) ⇒ `Float` #-(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

Overloads:

#-(other_time) ⇒ Float
Returns:
- (Float)
#-(numeric) ⇒ Time
Returns:
- (Time)

# File 'time.c'

/*
 *  call-seq:
 *     time - other_time => float
 *     time - numeric    => time
 *  
 *  Difference---Returns a new time that represents the difference
 *  between two times, or subtracts the given number of seconds in
 *  <i>numeric</i> from <i>time</i>.
 *     
 *     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);
}

#<=>(other_time) ⇒ `-1`, ... #<=>(numeric) ⇒ `-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

Overloads:

#<=>(other_time) ⇒ -1, ...
Returns:
- (-1, 0, +1)
#<=>(numeric) ⇒ -1, ...
Returns:
- (-1, 0, +1)

# File 'time.c'

/*
 *  call-seq:
 *     time <=> other_time => -1, 0, +1 
 *     time <=> numeric    => -1, 0, +1
 *  
 *  Comparison---Compares <i>time</i> with <i>other_time</i> or with
 *  <i>numeric</i>, 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`

Dump time for marshaling.

Returns:

(String)

# File 'time.c'

/*
 * call-seq:
 *   time._dump   => string
 *
 * 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` #ctime ⇒ `String`

Returns a canonical string representation of time.

Time.now.asctime   #=> "Wed Apr  9 08:56:03 2003"

Overloads:

#asctime ⇒ String
Returns:
- (String)
#ctime ⇒ String
Returns:
- (String)

# File 'time.c'

/*
 *  call-seq:
 *     time.asctime => string
 *     time.ctime   => string
 *  
 *  Returns a canonical string representation of <i>time</i>.
 *     
 *     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);
}

#asctime ⇒ `String` #ctime ⇒ `String`

Returns a canonical string representation of time.

Time.now.asctime   #=> "Wed Apr  9 08:56:03 2003"

Overloads:

#asctime ⇒ String
Returns:
- (String)
#ctime ⇒ String
Returns:
- (String)

# File 'time.c'

/*
 *  call-seq:
 *     time.asctime => string
 *     time.ctime   => string
 *  
 *  Returns a canonical string representation of <i>time</i>.
 *     
 *     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` #mday ⇒ `Fixnum`

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

Overloads:

#day ⇒ Fixnum
Returns:
- (Fixnum)
#mday ⇒ Fixnum
Returns:
- (Fixnum)

# File 'time.c'

/*
 *  call-seq:
 *     time.day  => fixnum
 *     time.mday => fixnum
 *  
 *  Returns the day of the month (1..n) for <i>time</i>.
 *     
 *     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);
}

#isdst ⇒ `Boolean` #dst? ⇒ `Boolean`

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

Overloads:

#isdst ⇒ Boolean
Returns:
- (Boolean)
#dst? ⇒ Boolean
Returns:
- (Boolean)

# File 'time.c'

/*
 *  call-seq:
 *     time.isdst => true or false
 *     time.dst?  => true or false
 *  
 *  Returns <code>true</code> if <i>time</i> 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) ⇒ `Object`

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

# File 'time.c'

/*
 * call-seq:
 *  time.eql?(other_time)
 *
 * Return <code>true</code> if <i>time</i> and <i>other_time</i> are
 * both <code>Time</code> 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 ⇒ `Time` #getutc ⇒ `Time`

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

Overloads:

#getgm ⇒ Time
Returns:
- (Time)
#getutc ⇒ Time
Returns:
- (Time)

# File 'time.c'

/*
 *  call-seq:
 *     time.getgm  => new_time
 *     time.getutc => new_time
 *  
 *  Returns a new <code>new_time</code> object representing <i>time</i> 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 ⇒ `Time`

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

Returns:

(Time)

# File 'time.c'

/*
 *  call-seq:
 *     time.getlocal => new_time
 *  
 *  Returns a new <code>new_time</code> object representing <i>time</i> 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));
}

#getgm ⇒ `Time` #getutc ⇒ `Time`

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

Overloads:

#getgm ⇒ Time
Returns:
- (Time)
#getutc ⇒ Time
Returns:
- (Time)

# File 'time.c'

/*
 *  call-seq:
 *     time.getgm  => new_time
 *     time.getutc => new_time
 *  
 *  Returns a new <code>new_time</code> object representing <i>time</i> 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));
}

#utc? ⇒ `Boolean` #gmt? ⇒ `Boolean`

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

Overloads:

#utc? ⇒ Boolean
Returns:
- (Boolean)
#gmt? ⇒ Boolean
Returns:
- (Boolean)

# File 'time.c'

/*
 *  call-seq:
 *     time.utc? => true or false
 *     time.gmt? => true or false
 *  
 *  Returns <code>true</code> if <i>time</i> 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` #gmtoff ⇒ `Fixnum` #utc_offset ⇒ `Fixnum`

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

Overloads:

#gmt_offset ⇒ Fixnum
Returns:
- (Fixnum)
#gmtoff ⇒ Fixnum
Returns:
- (Fixnum)
#utc_offset ⇒ Fixnum
Returns:
- (Fixnum)

# File 'time.c'

/*
 *  call-seq:
 *     time.gmt_offset => fixnum
 *     time.gmtoff     => fixnum
 *     time.utc_offset => fixnum
 *  
 *  Returns the offset in seconds between the timezone of <i>time</i>
 *  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` #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

Overloads:

#gmtime ⇒ Time
Returns:
- (Time)
#utc ⇒ Time
Returns:
- (Time)

# File 'time.c'

/*
 *  call-seq:
 *     time.gmtime    => time
 *     time.utc       => time
 *  
 *  Converts <i>time</i> 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;
}

#gmt_offset ⇒ `Fixnum` #gmtoff ⇒ `Fixnum` #utc_offset ⇒ `Fixnum`

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

Overloads:

#gmt_offset ⇒ Fixnum
Returns:
- (Fixnum)
#gmtoff ⇒ Fixnum
Returns:
- (Fixnum)
#utc_offset ⇒ Fixnum
Returns:
- (Fixnum)

# File 'time.c'

/*
 *  call-seq:
 *     time.gmt_offset => fixnum
 *     time.gmtoff     => fixnum
 *     time.utc_offset => fixnum
 *  
 *  Returns the offset in seconds between the timezone of <i>time</i>
 *  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`

Return a hash code for this time object.

Returns:

(Fixnum)

# File 'time.c'

/*
 * call-seq:
 *   time.hash   => fixnum
 *
 * 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`

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

t = Time.now   #=> Wed Apr 09 08:56:03 CDT 2003
t.hour         #=> 8

Returns:

(Fixnum)

# File 'time.c'

/*
 *  call-seq:
 *     time.hour => fixnum
 *  
 *  Returns the hour of the day (0..23) for <i>time</i>.
 *     
 *     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);
}

#initialize_copy ⇒ `Object`

:nodoc:

# File 'time.c'

/* :nodoc: */
static VALUE
time_init_copy(copy, time)
    VALUE copy, time;
{
    struct time_object *tobj, *tcopy;

    if (copy == time) return copy;
    time_modify(copy);
    if (TYPE(time) != T_DATA || RDATA(time)->dfree != time_free) {
    rb_raise(rb_eTypeError, "wrong argument type");
    }
    GetTimeval(time, tobj);
    GetTimeval(copy, tcopy);
    MEMCPY(tcopy, tobj, struct time_object, 1);

    return copy;
}

#inspect ⇒ `String` #to_s ⇒ `String`

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"

Overloads:

#inspect ⇒ String
Returns:
- (String)
#to_s ⇒ String
Returns:
- (String)

# File 'time.c'

/*
 *  call-seq:
 *     time.inspect => string
 *     time.to_s    => string
 *  
 *  Returns a string representing <i>time</i>. Equivalent to calling
 *  <code>Time#strftime</code> with a format string of ``<code>%a</code>
 *  <code>%b</code> <code>%d</code> <code>%H:%M:%S</code>
 *  <code>%Z</code> <code>%Y</code>''.
 *     
 *     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 ⇒ `Boolean` #dst? ⇒ `Boolean`

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

Overloads:

#isdst ⇒ Boolean
Returns:
- (Boolean)
#dst? ⇒ Boolean
Returns:
- (Boolean)

# File 'time.c'

/*
 *  call-seq:
 *     time.isdst => true or false
 *     time.dst?  => true or false
 *  
 *  Returns <code>true</code> if <i>time</i> 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`

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

Returns:

(Time)

# File 'time.c'

/*
 *  call-seq:
 *     time.localtime => time
 *  
 *  Converts <i>time</i> 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 ⇒ `Object`

undocumented

# File 'time.c'

/*
 * 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 ⇒ `Object`

undocumented

# File 'time.c'

/*
 * 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;
}

#day ⇒ `Fixnum` #mday ⇒ `Fixnum`

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

Overloads:

#day ⇒ Fixnum
Returns:
- (Fixnum)
#mday ⇒ Fixnum
Returns:
- (Fixnum)

# File 'time.c'

/*
 *  call-seq:
 *     time.day  => fixnum
 *     time.mday => fixnum
 *  
 *  Returns the day of the month (1..n) for <i>time</i>.
 *     
 *     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`

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

t = Time.now   #=> Wed Apr 09 08:56:03 CDT 2003
t.min          #=> 56

Returns:

(Fixnum)

# File 'time.c'

/*
 *  call-seq:
 *     time.min => fixnum
 *  
 *  Returns the minute of the hour (0..59) for <i>time</i>.
 *     
 *     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` #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

Overloads:

#mon ⇒ Fixnum
Returns:
- (Fixnum)
#month ⇒ Fixnum
Returns:
- (Fixnum)

# File 'time.c'

/*
 *  call-seq:
 *     time.mon   => fixnum
 *     time.month => fixnum
 *  
 *  Returns the month of the year (1..12) for <i>time</i>.
 *     
 *     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);
}

#mon ⇒ `Fixnum` #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

Overloads:

#mon ⇒ Fixnum
Returns:
- (Fixnum)
#month ⇒ Fixnum
Returns:
- (Fixnum)

# File 'time.c'

/*
 *  call-seq:
 *     time.mon   => fixnum
 *     time.month => fixnum
 *  
 *  Returns the month of the year (1..12) for <i>time</i>.
 *     
 *     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`

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

Returns:

(Fixnum)

# File 'time.c'

/*
 *  call-seq:
 *     time.sec => fixnum
 *  
 *  Returns the second of the minute (0..60)<em>[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.]</em> for <i>time</i>.
 *     
 *     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`

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:

%a - The abbreviated weekday name (``Sun'')
%A - The  full  weekday  name (``Sunday'')
%b - The abbreviated month name (``Jan'')
%B - The  full  month  name (``January'')
%c - The preferred local date and time representation
%d - Day of the month (01..31)
%H - Hour of the day, 24-hour clock (00..23)
%I - Hour of the day, 12-hour clock (01..12)
%j - Day of the year (001..366)
%m - Month of the year (01..12)
%M - Minute of the hour (00..59)
%p - Meridian indicator (``AM''  or  ``PM'')
%S - Second of the minute (00..60)
%U - 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
%X - Preferred representation for the time alone, no date
%y - Year without a century (00..99)
%Y - Year with century
%Z - Time zone name
%% - 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"

Returns:

(String)

# File 'time.c'

/*
 *  call-seq:
 *     time.strftime( string ) => string
 *  
 *  Formats <i>time</i> 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:
 *    %a - The abbreviated weekday name (``Sun'')
 *    %A - The  full  weekday  name (``Sunday'')
 *    %b - The abbreviated month name (``Jan'')
 *    %B - The  full  month  name (``January'')
 *    %c - The preferred local date and time representation
 *    %d - Day of the month (01..31)
 *    %H - Hour of the day, 24-hour clock (00..23)
 *    %I - Hour of the day, 12-hour clock (01..12)
 *    %j - Day of the year (001..366)
 *    %m - Month of the year (01..12)
 *    %M - Minute of the hour (00..59)
 *    %p - Meridian indicator (``AM''  or  ``PM'')
 *    %S - Second of the minute (00..60)
 *    %U - 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
 *    %X - Preferred representation for the time alone, no date
 *    %y - Year without a century (00..99)
 *    %Y - Year with century
 *    %Z - Time zone name
 *    %% - 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 ⇒ `Time`

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

Returns:

(Time)

# File 'time.c'

/*
 * call-seq:
 *   time.succ   => new_time
 *
 * Return a new time object, one second later than <code>time</code>.
 */

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`

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"]

Returns:

(Array)

# File 'time.c'

/*
 *  call-seq:
 *     time.to_a => array
 *  
 *  Returns a ten-element <i>array</i> of values for <i>time</i>:
 *  {<code>[ sec, min, hour, day, month, year, wday, yday, isdst, zone
 *  ]</code>}. See the individual methods for an explanation of the
 *  valid ranges of each value. The ten elements can be passed directly
 *  to <code>Time::utc</code> or <code>Time::local</code> to create a
 *  new <code>Time</code>.
 *     
 *     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`

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

Returns:

(Float)

# File 'time.c'

/*
 *  call-seq:
 *     time.to_f => float
 *  
 *  Returns the value of <i>time</i> 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 ⇒ `Integer` #tv_sec ⇒ `Integer`

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

Overloads:

#to_i ⇒ Integer
Returns:
- (Integer)
#tv_sec ⇒ Integer
Returns:
- (Integer)

# File 'time.c'

/*
 *  call-seq:
 *     time.to_i   => int
 *     time.tv_sec => int
 *  
 *  Returns the value of <i>time</i> 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);
}

#inspect ⇒ `String` #to_s ⇒ `String`

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"

Overloads:

#inspect ⇒ String
Returns:
- (String)
#to_s ⇒ String
Returns:
- (String)

# File 'time.c'

/*
 *  call-seq:
 *     time.inspect => string
 *     time.to_s    => string
 *  
 *  Returns a string representing <i>time</i>. Equivalent to calling
 *  <code>Time#strftime</code> with a format string of ``<code>%a</code>
 *  <code>%b</code> <code>%d</code> <code>%H:%M:%S</code>
 *  <code>%Z</code> <code>%Y</code>''.
 *     
 *     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);
}

#to_i ⇒ `Integer` #tv_sec ⇒ `Integer`

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

Overloads:

#to_i ⇒ Integer
Returns:
- (Integer)
#tv_sec ⇒ Integer
Returns:
- (Integer)

# File 'time.c'

/*
 *  call-seq:
 *     time.to_i   => int
 *     time.tv_sec => int
 *  
 *  Returns the value of <i>time</i> 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);
}

#usec ⇒ `Integer` #tv_usec ⇒ `Integer`

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

Overloads:

#usec ⇒ Integer
Returns:
- (Integer)
#tv_usec ⇒ Integer
Returns:
- (Integer)

# File 'time.c'

/*
 *  call-seq:
 *     time.usec    => int
 *     time.tv_usec => int
 *  
 *  Returns just the number of microseconds for <i>time</i>.
 *     
 *     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 ⇒ `Integer` #tv_usec ⇒ `Integer`

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

Overloads:

#usec ⇒ Integer
Returns:
- (Integer)
#tv_usec ⇒ Integer
Returns:
- (Integer)

# File 'time.c'

/*
 *  call-seq:
 *     time.usec    => int
 *     time.tv_usec => int
 *  
 *  Returns just the number of microseconds for <i>time</i>.
 *     
 *     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` #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

Overloads:

#gmtime ⇒ Time
Returns:
- (Time)
#utc ⇒ Time
Returns:
- (Time)

# File 'time.c'

/*
 *  call-seq:
 *     time.gmtime    => time
 *     time.utc       => time
 *  
 *  Converts <i>time</i> 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? ⇒ `Boolean` #gmt? ⇒ `Boolean`

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

Overloads:

#utc? ⇒ Boolean
Returns:
- (Boolean)
#gmt? ⇒ Boolean
Returns:
- (Boolean)

# File 'time.c'

/*
 *  call-seq:
 *     time.utc? => true or false
 *     time.gmt? => true or false
 *  
 *  Returns <code>true</code> if <i>time</i> 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` #gmtoff ⇒ `Fixnum` #utc_offset ⇒ `Fixnum`

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

Overloads:

#gmt_offset ⇒ Fixnum
Returns:
- (Fixnum)
#gmtoff ⇒ Fixnum
Returns:
- (Fixnum)
#utc_offset ⇒ Fixnum
Returns:
- (Fixnum)

# File 'time.c'

/*
 *  call-seq:
 *     time.gmt_offset => fixnum
 *     time.gmtoff     => fixnum
 *     time.utc_offset => fixnum
 *  
 *  Returns the offset in seconds between the timezone of <i>time</i>
 *  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`

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

Returns:

(Fixnum)

# File 'time.c'

/*
 *  call-seq:
 *     time.wday => fixnum
 *  
 *  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`

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

Returns:

(Fixnum)

# File 'time.c'

/*
 *  call-seq:
 *     time.yday => fixnum
 *  
 *  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`

Returns the year for time (including the century).

t = Time.now   #=> Wed Apr 09 08:56:04 CDT 2003
t.year         #=> 2003

Returns:

(Fixnum)

# File 'time.c'

/*
 *  call-seq:
 *     time.year => fixnum
 *  
 *  Returns the year for <i>time</i> (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`

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"

Returns:

(String)

# File 'time.c'

/*
 *  call-seq:
 *     time.zone => string
 *  
 *  Returns the name of the time zone used for <i>time</i>. 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
}

Class: Time

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Comparable

Constructor Details

#initialize ⇒ Object

Class Method Details

._load(string) ⇒ Time

.at(aTime) ⇒ Time .at(seconds[, microseconds]) ⇒ Time

.utc(year[, month, day, hour, min, sec, usec]) ⇒ Time .utc(sec, min, hour, day, month, year, wday, yday, isdst, tz) ⇒ Object

.local(year[, month, day, hour, min, sec, usec]) ⇒ Time .local(sec, min, hour, day, month, year, wday, yday, isdst) ⇒ Object

.local(year[, month, day, hour, min, sec, usec]) ⇒ Time .local(sec, min, hour, day, month, year, wday, yday, isdst) ⇒ Object

.now ⇒ Object

.times ⇒ Object

.utc(year[, month, day, hour, min, sec, usec]) ⇒ Time .utc(sec, min, hour, day, month, year, wday, yday, isdst, tz) ⇒ Object

Instance Method Details

#+(numeric) ⇒ Time

#-(other_time) ⇒ Float #-(numeric) ⇒ Time

#<=>(other_time) ⇒ -1, ... #<=>(numeric) ⇒ -1, ...

#_dump ⇒ String

#asctime ⇒ String #ctime ⇒ String

#asctime ⇒ String #ctime ⇒ String

#day ⇒ Fixnum #mday ⇒ Fixnum

#isdst ⇒ Boolean #dst? ⇒ Boolean

#eql?(other_time) ⇒ Object

#getgm ⇒ Time #getutc ⇒ Time

#getlocal ⇒ Time

#getgm ⇒ Time #getutc ⇒ Time

#utc? ⇒ Boolean #gmt? ⇒ Boolean

#gmt_offset ⇒ Fixnum #gmtoff ⇒ Fixnum #utc_offset ⇒ Fixnum

#gmtime ⇒ Time #utc ⇒ Time

#gmt_offset ⇒ Fixnum #gmtoff ⇒ Fixnum #utc_offset ⇒ Fixnum

#hash ⇒ Fixnum

#hour ⇒ Fixnum

#initialize_copy ⇒ Object

#inspect ⇒ String #to_s ⇒ String

#isdst ⇒ Boolean #dst? ⇒ Boolean

#localtime ⇒ Time

#marshal_dump ⇒ Object

#marshal_load ⇒ Object

#day ⇒ Fixnum #mday ⇒ Fixnum

#min ⇒ Fixnum

#mon ⇒ Fixnum #month ⇒ Fixnum

#mon ⇒ Fixnum #month ⇒ Fixnum

#sec ⇒ Fixnum

#strftime(string) ⇒ String

#succ ⇒ Time

#to_a ⇒ Array

#to_f ⇒ Float

#to_i ⇒ Integer #tv_sec ⇒ Integer

#inspect ⇒ String #to_s ⇒ String

#to_i ⇒ Integer #tv_sec ⇒ Integer

#usec ⇒ Integer #tv_usec ⇒ Integer

#usec ⇒ Integer #tv_usec ⇒ Integer

#gmtime ⇒ Time #utc ⇒ Time

#utc? ⇒ Boolean #gmt? ⇒ Boolean

#gmt_offset ⇒ Fixnum #gmtoff ⇒ Fixnum #utc_offset ⇒ Fixnum

#wday ⇒ Fixnum

#yday ⇒ Fixnum

#year ⇒ Fixnum

#zone ⇒ String

#initialize ⇒ `Object`

._load(string) ⇒ `Time`

.at(aTime) ⇒ `Time` .at(seconds[, microseconds]) ⇒ `Time`

.utc(year[, month, day, hour, min, sec, usec]) ⇒ `Time` .utc(sec, min, hour, day, month, year, wday, yday, isdst, tz) ⇒ `Object`

.local(year[, month, day, hour, min, sec, usec]) ⇒ `Time` .local(sec, min, hour, day, month, year, wday, yday, isdst) ⇒ `Object`

.local(year[, month, day, hour, min, sec, usec]) ⇒ `Time` .local(sec, min, hour, day, month, year, wday, yday, isdst) ⇒ `Object`

.now ⇒ `Object`

.times ⇒ `Object`

.utc(year[, month, day, hour, min, sec, usec]) ⇒ `Time` .utc(sec, min, hour, day, month, year, wday, yday, isdst, tz) ⇒ `Object`

#+(numeric) ⇒ `Time`

#-(other_time) ⇒ `Float` #-(numeric) ⇒ `Time`

#<=>(other_time) ⇒ `-1`, ... #<=>(numeric) ⇒ `-1`, ...

#_dump ⇒ `String`

#asctime ⇒ `String` #ctime ⇒ `String`

#asctime ⇒ `String` #ctime ⇒ `String`

#day ⇒ `Fixnum` #mday ⇒ `Fixnum`

#isdst ⇒ `Boolean` #dst? ⇒ `Boolean`

#eql?(other_time) ⇒ `Object`

#getgm ⇒ `Time` #getutc ⇒ `Time`

#getlocal ⇒ `Time`

#getgm ⇒ `Time` #getutc ⇒ `Time`

#utc? ⇒ `Boolean` #gmt? ⇒ `Boolean`

#gmt_offset ⇒ `Fixnum` #gmtoff ⇒ `Fixnum` #utc_offset ⇒ `Fixnum`

#gmtime ⇒ `Time` #utc ⇒ `Time`

#gmt_offset ⇒ `Fixnum` #gmtoff ⇒ `Fixnum` #utc_offset ⇒ `Fixnum`

#hash ⇒ `Fixnum`

#hour ⇒ `Fixnum`

#initialize_copy ⇒ `Object`

#inspect ⇒ `String` #to_s ⇒ `String`

#isdst ⇒ `Boolean` #dst? ⇒ `Boolean`

#localtime ⇒ `Time`

#marshal_dump ⇒ `Object`

#marshal_load ⇒ `Object`

#day ⇒ `Fixnum` #mday ⇒ `Fixnum`

#min ⇒ `Fixnum`

#mon ⇒ `Fixnum` #month ⇒ `Fixnum`

#mon ⇒ `Fixnum` #month ⇒ `Fixnum`

#sec ⇒ `Fixnum`

#strftime(string) ⇒ `String`

#succ ⇒ `Time`

#to_a ⇒ `Array`

#to_f ⇒ `Float`

#to_i ⇒ `Integer` #tv_sec ⇒ `Integer`

#inspect ⇒ `String` #to_s ⇒ `String`

#to_i ⇒ `Integer` #tv_sec ⇒ `Integer`

#usec ⇒ `Integer` #tv_usec ⇒ `Integer`

#usec ⇒ `Integer` #tv_usec ⇒ `Integer`

#gmtime ⇒ `Time` #utc ⇒ `Time`

#utc? ⇒ `Boolean` #gmt? ⇒ `Boolean`

#gmt_offset ⇒ `Fixnum` #gmtoff ⇒ `Fixnum` #utc_offset ⇒ `Fixnum`

#wday ⇒ `Fixnum`

#yday ⇒ `Fixnum`

#year ⇒ `Fixnum`

#zone ⇒ `String`