Class: Time
Overview
Time is an abstraction of dates and times. Time is stored internally as the number of seconds with fraction since the Epoch, January 1, 1970 00:00 UTC. Also see the library modules Date. 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 may have fraction. Be aware of this fact when comparing times with each other---times that are apparently equal when displayed may be different when compared.
Class Method Summary collapse
-
._load(string) ⇒ Time
Unmarshal a dumped
Timeobject. -
.at ⇒ Object
Creates a new time object with the value given by time, the given number of seconds_with_frac, or seconds and microseconds_with_frac from the Epoch.
-
.gm ⇒ Object
Creates a time based on given values, interpreted as UTC (GMT).
-
.local ⇒ Object
Same as
Time::gm, but interprets the values in the local time zone. -
.mktime ⇒ Object
Same as
Time::gm, but interprets the values in the local time zone. -
.now ⇒ Object
Synonym for
Time.new. -
.utc ⇒ Object
Creates a time based on given values, interpreted as UTC (GMT).
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.
-
#<=>(other_time) ⇒ -1, ...
Comparison---Compares time with other_time.
-
#_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
trueif time occurs during Daylight Saving Time in its time zone. -
#eql?(other_time) ⇒ Object
Return
trueif time and other_time are bothTimeobjects with the same seconds and fractional seconds. -
#friday? ⇒ Boolean
Returns
trueif time represents Friday. -
#getgm ⇒ Object
Returns a new
new_timeobject representing time in UTC. -
#getlocal ⇒ Object
Returns a new
new_timeobject representing time in local time (using the local time zone in effect for this process). -
#getutc ⇒ Object
Returns a new
new_timeobject representing time in UTC. -
#gmt? ⇒ Object
Returns
trueif 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
Returns a
Timeobject. -
#initialize_copy ⇒ Object
:nodoc:.
-
#inspect ⇒ Object
Returns a string representing time.
-
#isdst ⇒ Object
Returns
trueif time occurs during Daylight Saving Time in its time zone. -
#localtime ⇒ Object
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.
-
#monday? ⇒ Boolean
Returns
trueif time represents Monday. -
#month ⇒ Object
Returns the month of the year (1..12) for time.
-
#nsec ⇒ Object
Returns just the number of nanoseconds for time.
-
#round([ndigits]) ⇒ Time
Rounds sub seconds to a given precision in decimal digits (0 digits by default).
-
#saturday? ⇒ Boolean
Returns
trueif time represents Saturday. -
#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.
-
#subsec ⇒ Numeric
Returns just the fraction for time.
- #succ ⇒ Object
-
#sunday? ⇒ Boolean
Returns
trueif time represents Sunday. -
#thursday? ⇒ Boolean
Returns
trueif time represents Thursday. -
#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 the Epoch.
-
#to_i ⇒ Object
Returns the value of time as an integer number of seconds since the Epoch.
-
#to_r ⇒ Object
Returns the value of time as a rational number of seconds since the Epoch.
-
#to_s ⇒ Object
Returns a string representing time.
-
#tuesday? ⇒ Boolean
Returns
trueif time represents Tuesday. -
#tv_nsec ⇒ Object
Returns just the number of nanoseconds for time.
-
#tv_sec ⇒ Object
Returns the value of time as an integer number of seconds since the 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
trueif 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.
-
#wednesday? ⇒ Boolean
Returns
trueif time represents Wednesday. -
#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
#new ⇒ Time #new(year, month = nil, day = nil, hour = nil, min = nil, sec = nil, utc_offset = nil) ⇒ Time
Returns a Time object.
It is initialized to the current system time if no argument. Note: The object created will be created using the resolution available on your system clock, and so may include fractional seconds.
If one or more arguments specified, the time is initialized to the specified time. sec may have fraction if it is a rational.
utc_offset is the offset from UTC. It is a string such as ???+09:00??? or a number of seconds such as 32400.
a = Time.new #=> 2007-11-19 07:50:02 -0600
b = Time.new #=> 2007-11-19 07:50:02 -0600
a == b #=> false
"%.6f" % a.to_f #=> "1195480202.282373"
"%.6f" % b.to_f #=> "1195480202.283415"
Time.new(2008,6,21, 13,30,0, "+09:00") #=> 2008-06-21 13:30:00 +0900
# A trip for RubyConf 2007
t1 = Time.new(2007,11,1,15,25,0, "+09:00") # JST (Narita)
t2 = Time.new(2007,11,1,12, 5,0, "-05:00") # CDT (Minneapolis)
t3 = Time.new(2007,11,1,13,25,0, "-05:00") # CDT (Minneapolis)
t4 = Time.new(2007,11,1,16,53,0, "-04:00") # EDT (Charlotte)
t5 = Time.new(2007,11,5, 9,24,0, "-05:00") # EST (Charlotte)
t6 = Time.new(2007,11,5,11,21,0, "-05:00") # EST (Detroit)
t7 = Time.new(2007,11,5,13,45,0, "-05:00") # EST (Detroit)
t8 = Time.new(2007,11,6,17,10,0, "+09:00") # JST (Narita)
p((t2-t1)/3600.0) #=> 10.666666666666666
p((t4-t3)/3600.0) #=> 2.466666666666667
p((t6-t5)/3600.0) #=> 1.95
p((t8-t7)/3600.0) #=> 13.416666666666666
|
|
# File 'time.c'
/*
* call-seq:
* Time.new -> time
* Time.new(year, month=nil, day=nil, hour=nil, min=nil, sec=nil, utc_offset=nil) -> time
*
* Returns a <code>Time</code> object.
*
* It is initialized to the current system time if no argument.
* <b>Note:</b> The object created will be created using the
* resolution available on your system clock, and so may include
* fractional seconds.
*
* If one or more arguments specified, the time is initialized
* to the specified time.
* _sec_ may have fraction if it is a rational.
*
* _utc_offset_ is the offset from UTC.
* It is a string such as "+09:00" or a number of seconds such as 32400.
*
* a = Time.new #=> 2007-11-19 07:50:02 -0600
* b = Time.new #=> 2007-11-19 07:50:02 -0600
* a == b #=> false
* "%.6f" % a.to_f #=> "1195480202.282373"
* "%.6f" % b.to_f #=> "1195480202.283415"
*
* Time.new(2008,6,21, 13,30,0, "+09:00") #=> 2008-06-21 13:30:00 +0900
*
* # A trip for RubyConf 2007
* t1 = Time.new(2007,11,1,15,25,0, "+09:00") # JST (Narita)
* t2 = Time.new(2007,11,1,12, 5,0, "-05:00") # CDT (Minneapolis)
* t3 = Time.new(2007,11,1,13,25,0, "-05:00") # CDT (Minneapolis)
* t4 = Time.new(2007,11,1,16,53,0, "-04:00") # EDT (Charlotte)
* t5 = Time.new(2007,11,5, 9,24,0, "-05:00") # EST (Charlotte)
* t6 = Time.new(2007,11,5,11,21,0, "-05:00") # EST (Detroit)
* t7 = Time.new(2007,11,5,13,45,0, "-05:00") # EST (Detroit)
* t8 = Time.new(2007,11,6,17,10,0, "+09:00") # JST (Narita)
* p((t2-t1)/3600.0) #=> 10.666666666666666
* p((t4-t3)/3600.0) #=> 2.466666666666667
* p((t6-t5)/3600.0) #=> 1.95
* p((t8-t7)/3600.0) #=> 13.416666666666666
*
*/
static VALUE
time_init(int argc, VALUE *argv, VALUE time)
{
if (argc == 0)
return time_init_0(time);
else
return time_init_1(argc, argv, time);
}
|
Class Method Details
._load(string) ⇒ Time
Unmarshal a dumped Time object.
|
|
# File 'time.c'
/*
* call-seq:
* Time._load(string) -> time
*
* Unmarshal a dumped +Time+ object.
*/
static VALUE
time_load(VALUE klass, VALUE str)
{
VALUE time = time_s_alloc(klass);
time_mload(time, str);
return time;
}
|
.at(time) ⇒ Time .at(seconds_with_frac) ⇒ Time .at(seconds, microseconds_with_frac) ⇒ Time
Creates a new time object with the value given by time, the given number of seconds_with_frac, or seconds and microseconds_with_frac from the Epoch. seconds_with_frac and microseconds_with_frac can be Integer, Float, Rational, or other Numeric. non-portable feature allows the offset to be negative on some systems.
Time.at(0) #=> 1969-12-31 18:00:00 -0600
Time.at(Time.at(0)) #=> 1969-12-31 18:00:00 -0600
Time.at(946702800) #=> 1999-12-31 23:00:00 -0600
Time.at(-284061600) #=> 1960-12-31 00:00:00 -0600
Time.at(946684800.2).usec #=> 200000
Time.at(946684800, 123456.789).nsec #=> 123456789
|
|
# File 'time.c'
/*
* call-seq:
* Time.at(time) -> time
* Time.at(seconds_with_frac) -> time
* Time.at(seconds, microseconds_with_frac) -> time
*
* Creates a new time object with the value given by <i>time</i>,
* the given number of <i>seconds_with_frac</i>, or
* <i>seconds</i> and <i>microseconds_with_frac</i> from the Epoch.
* <i>seconds_with_frac</i> and <i>microseconds_with_frac</i>
* can be Integer, Float, Rational, or other Numeric.
* non-portable feature allows the offset to be negative on some systems.
*
* Time.at(0) #=> 1969-12-31 18:00:00 -0600
* Time.at(Time.at(0)) #=> 1969-12-31 18:00:00 -0600
* Time.at(946702800) #=> 1999-12-31 23:00:00 -0600
* Time.at(-284061600) #=> 1960-12-31 00:00:00 -0600
* Time.at(946684800.2).usec #=> 200000
* Time.at(946684800, 123456.789).nsec #=> 123456789
*/
static VALUE
time_s_at(int argc, VALUE *argv, VALUE klass)
{
VALUE time, t;
wideval_t timew;
if (rb_scan_args(argc, argv, "11", &time, &t) == 2) {
time = num_exact(time);
t = num_exact(t);
timew = wadd(rb_time_magnify(v2w(time)), wmulquoll(v2w(t), TIME_SCALE, 1000000));
t = time_new_timew(klass, timew);
}
else if (IsTimeval(time)) {
struct time_object *tobj, *tobj2;
GetTimeval(time, tobj);
t = time_new_timew(klass, tobj->timew);
GetTimeval(t, tobj2);
TIME_COPY_GMT(tobj2, tobj);
}
else {
timew = rb_time_magnify(v2w(num_exact(time)));
t = time_new_timew(klass, timew);
}
return t;
}
|
.utc(year) ⇒ Time .utc(year, month) ⇒ Time .utc(year, month, day) ⇒ Time .utc(year, month, day, hour) ⇒ Time .utc(year, month, day, hour, min) ⇒ Time .utc(year, month, day, hour, min, sec_with_frac) ⇒ Time .utc(year, month, day, hour, min, sec, usec_with_frac) ⇒ Time .utc(sec, min, hour, day, month, year, wday, yday, isdst, tz) ⇒ Time .gm(year) ⇒ Time .gm(year, month) ⇒ Time .gm(year, month, day) ⇒ Time .gm(year, month, day, hour) ⇒ Time .gm(year, month, day, hour, min) ⇒ Time .gm(year, month, day, hour, min, sec_with_frac) ⇒ Time .gm(year, month, day, hour, min, sec, usec_with_frac) ⇒ 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. sec_with_frac and usec_with_frac can have a fractional part.
Time.utc(2000,"jan",1,20,15,1) #=> 2000-01-01 20:15:01 UTC
Time.gm(2000,"jan",1,20,15,1) #=> 2000-01-01 20:15:01 UTC
|
|
# File 'time.c'
/*
* call-seq:
* Time.utc(year) -> time
* Time.utc(year, month) -> time
* Time.utc(year, month, day) -> time
* Time.utc(year, month, day, hour) -> time
* Time.utc(year, month, day, hour, min) -> time
* Time.utc(year, month, day, hour, min, sec_with_frac) -> time
* Time.utc(year, month, day, hour, min, sec, usec_with_frac) -> time
* Time.utc(sec, min, hour, day, month, year, wday, yday, isdst, tz) -> time
* Time.gm(year) -> time
* Time.gm(year, month) -> time
* Time.gm(year, month, day) -> time
* Time.gm(year, month, day, hour) -> time
* Time.gm(year, month, day, hour, min) -> time
* Time.gm(year, month, day, hour, min, sec_with_frac) -> time
* Time.gm(year, month, day, hour, min, sec, usec_with_frac) -> 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>.
* <i>sec_with_frac</i> and <i>usec_with_frac</i> can have a fractional part.
*
* Time.utc(2000,"jan",1,20,15,1) #=> 2000-01-01 20:15:01 UTC
* Time.gm(2000,"jan",1,20,15,1) #=> 2000-01-01 20:15:01 UTC
*/
static VALUE
time_s_mkutc(int argc, VALUE *argv, VALUE klass)
{
return time_utc_or_local(argc, argv, TRUE, klass);
}
|
.local(year) ⇒ Time .local(year, month) ⇒ Time .local(year, month, day) ⇒ Time .local(year, month, day, hour) ⇒ Time .local(year, month, day, hour, min) ⇒ Time .local(year, month, day, hour, min, sec_with_frac) ⇒ Time .local(year, month, day, hour, min, sec, usec_with_frac) ⇒ Time .local(sec, min, hour, day, month, year, wday, yday, isdst, tz) ⇒ Time .mktime(year) ⇒ Time .mktime(year, month) ⇒ Time .mktime(year, month, day) ⇒ Time .mktime(year, month, day, hour) ⇒ Time .mktime(year, month, day, hour, min) ⇒ Time .mktime(year, month, day, hour, min, sec_with_frac) ⇒ Time .mktime(year, month, day, hour, min, sec, usec_with_frac) ⇒ Time .mktime(sec, min, hour, day, month, year, wday, yday, isdst, tz) ⇒ Time
Same as Time::gm, but interprets the values in the local time zone.
Time.local(2000,"jan",1,20,15,1) #=> 2000-01-01 20:15:01 -0600
|
|
# File 'time.c'
/*
* call-seq:
* Time.local(year) -> time
* Time.local(year, month) -> time
* Time.local(year, month, day) -> time
* Time.local(year, month, day, hour) -> time
* Time.local(year, month, day, hour, min) -> time
* Time.local(year, month, day, hour, min, sec_with_frac) -> time
* Time.local(year, month, day, hour, min, sec, usec_with_frac) -> time
* Time.local(sec, min, hour, day, month, year, wday, yday, isdst, tz) -> time
* Time.mktime(year) -> time
* Time.mktime(year, month) -> time
* Time.mktime(year, month, day) -> time
* Time.mktime(year, month, day, hour) -> time
* Time.mktime(year, month, day, hour, min) -> time
* Time.mktime(year, month, day, hour, min, sec_with_frac) -> time
* Time.mktime(year, month, day, hour, min, sec, usec_with_frac) -> time
* Time.mktime(sec, min, hour, day, month, year, wday, yday, isdst, tz) -> time
*
* Same as <code>Time::gm</code>, but interprets the values in the
* local time zone.
*
* Time.local(2000,"jan",1,20,15,1) #=> 2000-01-01 20:15:01 -0600
*/
static VALUE
time_s_mktime(int argc, VALUE *argv, VALUE klass)
{
return time_utc_or_local(argc, argv, FALSE, klass);
}
|
.local(year) ⇒ Time .local(year, month) ⇒ Time .local(year, month, day) ⇒ Time .local(year, month, day, hour) ⇒ Time .local(year, month, day, hour, min) ⇒ Time .local(year, month, day, hour, min, sec_with_frac) ⇒ Time .local(year, month, day, hour, min, sec, usec_with_frac) ⇒ Time .local(sec, min, hour, day, month, year, wday, yday, isdst, tz) ⇒ Time .mktime(year) ⇒ Time .mktime(year, month) ⇒ Time .mktime(year, month, day) ⇒ Time .mktime(year, month, day, hour) ⇒ Time .mktime(year, month, day, hour, min) ⇒ Time .mktime(year, month, day, hour, min, sec_with_frac) ⇒ Time .mktime(year, month, day, hour, min, sec, usec_with_frac) ⇒ Time .mktime(sec, min, hour, day, month, year, wday, yday, isdst, tz) ⇒ Time
Same as Time::gm, but interprets the values in the local time zone.
Time.local(2000,"jan",1,20,15,1) #=> 2000-01-01 20:15:01 -0600
|
|
# File 'time.c'
/*
* call-seq:
* Time.local(year) -> time
* Time.local(year, month) -> time
* Time.local(year, month, day) -> time
* Time.local(year, month, day, hour) -> time
* Time.local(year, month, day, hour, min) -> time
* Time.local(year, month, day, hour, min, sec_with_frac) -> time
* Time.local(year, month, day, hour, min, sec, usec_with_frac) -> time
* Time.local(sec, min, hour, day, month, year, wday, yday, isdst, tz) -> time
* Time.mktime(year) -> time
* Time.mktime(year, month) -> time
* Time.mktime(year, month, day) -> time
* Time.mktime(year, month, day, hour) -> time
* Time.mktime(year, month, day, hour, min) -> time
* Time.mktime(year, month, day, hour, min, sec_with_frac) -> time
* Time.mktime(year, month, day, hour, min, sec, usec_with_frac) -> time
* Time.mktime(sec, min, hour, day, month, year, wday, yday, isdst, tz) -> time
*
* Same as <code>Time::gm</code>, but interprets the values in the
* local time zone.
*
* Time.local(2000,"jan",1,20,15,1) #=> 2000-01-01 20:15:01 -0600
*/
static VALUE
time_s_mktime(int argc, VALUE *argv, VALUE klass)
{
return time_utc_or_local(argc, argv, FALSE, klass);
}
|
.now ⇒ Object
Synonym for Time.new. Returns a Time object initialized to the current system time.
|
|
# File 'time.c'
/*
* call-seq:
* Time.now -> time
*
* Creates a new time object for the current time.
*
* Time.now #=> 2009-06-24 12:39:54 +0900
*/
static VALUE
time_s_now(VALUE klass)
{
return rb_class_new_instance(0, NULL, klass);
}
|
.utc(year) ⇒ Time .utc(year, month) ⇒ Time .utc(year, month, day) ⇒ Time .utc(year, month, day, hour) ⇒ Time .utc(year, month, day, hour, min) ⇒ Time .utc(year, month, day, hour, min, sec_with_frac) ⇒ Time .utc(year, month, day, hour, min, sec, usec_with_frac) ⇒ Time .utc(sec, min, hour, day, month, year, wday, yday, isdst, tz) ⇒ Time .gm(year) ⇒ Time .gm(year, month) ⇒ Time .gm(year, month, day) ⇒ Time .gm(year, month, day, hour) ⇒ Time .gm(year, month, day, hour, min) ⇒ Time .gm(year, month, day, hour, min, sec_with_frac) ⇒ Time .gm(year, month, day, hour, min, sec, usec_with_frac) ⇒ 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. sec_with_frac and usec_with_frac can have a fractional part.
Time.utc(2000,"jan",1,20,15,1) #=> 2000-01-01 20:15:01 UTC
Time.gm(2000,"jan",1,20,15,1) #=> 2000-01-01 20:15:01 UTC
|
|
# File 'time.c'
/*
* call-seq:
* Time.utc(year) -> time
* Time.utc(year, month) -> time
* Time.utc(year, month, day) -> time
* Time.utc(year, month, day, hour) -> time
* Time.utc(year, month, day, hour, min) -> time
* Time.utc(year, month, day, hour, min, sec_with_frac) -> time
* Time.utc(year, month, day, hour, min, sec, usec_with_frac) -> time
* Time.utc(sec, min, hour, day, month, year, wday, yday, isdst, tz) -> time
* Time.gm(year) -> time
* Time.gm(year, month) -> time
* Time.gm(year, month, day) -> time
* Time.gm(year, month, day, hour) -> time
* Time.gm(year, month, day, hour, min) -> time
* Time.gm(year, month, day, hour, min, sec_with_frac) -> time
* Time.gm(year, month, day, hour, min, sec, usec_with_frac) -> 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>.
* <i>sec_with_frac</i> and <i>usec_with_frac</i> can have a fractional part.
*
* Time.utc(2000,"jan",1,20,15,1) #=> 2000-01-01 20:15:01 UTC
* Time.gm(2000,"jan",1,20,15,1) #=> 2000-01-01 20:15:01 UTC
*/
static VALUE
time_s_mkutc(int argc, VALUE *argv, VALUE klass)
{
return time_utc_or_local(argc, argv, TRUE, 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 #=> 2007-11-19 08:22:21 -0600
t + (60 * 60 * 24) #=> 2007-11-20 08:22:21 -0600
|
|
# 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 #=> 2007-11-19 08:22:21 -0600
* t + (60 * 60 * 24) #=> 2007-11-20 08:22:21 -0600
*/
static VALUE
time_plus(VALUE time1, VALUE time2)
{
struct time_object *tobj;
GetTimeval(time1, tobj);
if (IsTimeval(time2)) {
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 #=> 2007-11-19 08:23:10 -0600
t2 = t + 2592000 #=> 2007-12-19 08:23:10 -0600
t2 - t #=> 2592000.0
t2 - 2592000 #=> 2007-11-19 08:23:10 -0600
|
|
# 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 #=> 2007-11-19 08:23:10 -0600
* t2 = t + 2592000 #=> 2007-12-19 08:23:10 -0600
* t2 - t #=> 2592000.0
* t2 - 2592000 #=> 2007-11-19 08:23:10 -0600
*/
static VALUE
time_minus(VALUE time1, VALUE time2)
{
struct time_object *tobj;
GetTimeval(time1, tobj);
if (IsTimeval(time2)) {
struct time_object *tobj2;
GetTimeval(time2, tobj2);
return rb_Float(rb_time_unmagnify_to_float(wsub(tobj->timew, tobj2->timew)));
}
return time_add(tobj, time2, -1);
}
|
#<=>(other_time) ⇒ -1, ...
Comparison---Compares time with other_time.
t = Time.now #=> 2007-11-19 08:12:12 -0600
t2 = t + 2592000 #=> 2007-12-19 08:12:12 -0600
t <=> t2 #=> -1
t2 <=> t #=> 1
t = Time.now #=> 2007-11-19 08:13:38 -0600
t2 = t + 0.1 #=> 2007-11-19 08:13:38 -0600
t.nsec #=> 98222999
t2.nsec #=> 198222999
t <=> t2 #=> -1
t2 <=> t #=> 1
t <=> t #=> 0
|
|
# File 'time.c'
/*
* call-seq:
* time <=> other_time -> -1, 0, +1 or nil
*
* Comparison---Compares <i>time</i> with <i>other_time</i>.
*
* t = Time.now #=> 2007-11-19 08:12:12 -0600
* t2 = t + 2592000 #=> 2007-12-19 08:12:12 -0600
* t <=> t2 #=> -1
* t2 <=> t #=> 1
*
* t = Time.now #=> 2007-11-19 08:13:38 -0600
* t2 = t + 0.1 #=> 2007-11-19 08:13:38 -0600
* t.nsec #=> 98222999
* t2.nsec #=> 198222999
* t <=> t2 #=> -1
* t2 <=> t #=> 1
* t <=> t #=> 0
*/
static VALUE
time_cmp(VALUE time1, VALUE time2)
{
struct time_object *tobj1, *tobj2;
int n;
GetTimeval(time1, tobj1);
if (IsTimeval(time2)) {
GetTimeval(time2, tobj2);
n = wcmp(tobj1->timew, tobj2->timew);
}
else {
VALUE tmp;
tmp = rb_funcall(time2, rb_intern("<=>"), 1, time1);
if (NIL_P(tmp)) return Qnil;
n = -rb_cmpint(tmp, time1, time2);
}
if (n == 0) return INT2FIX(0);
if (n > 0) return INT2FIX(1);
return INT2FIX(-1);
}
|
#_dump ⇒ String
Dump time for marshaling.
|
|
# File 'time.c'
/*
* call-seq:
* time._dump -> string
*
* Dump _time_ for marshaling.
*/
static VALUE
time_dump(int argc, VALUE *argv, VALUE time)
{
VALUE str;
rb_scan_args(argc, argv, "01", 0);
str = time_mdump(time);
return str;
}
|
#asctime ⇒ String #ctime ⇒ String
Returns a canonical string representation of time.
Time.now.asctime #=> "Wed Apr 9 08:56:03 2003"
|
|
# 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(VALUE time)
{
struct time_object *tobj;
GetTimeval(time, tobj);
return strftimev("%a %b %e %T %Y", time);
}
|
#asctime ⇒ String #ctime ⇒ String
Returns a canonical string representation of time.
Time.now.asctime #=> "Wed Apr 9 08:56:03 2003"
|
|
# 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(VALUE time)
{
struct time_object *tobj;
GetTimeval(time, tobj);
return strftimev("%a %b %e %T %Y", time);
}
|
#day ⇒ Fixnum #mday ⇒ Fixnum
Returns the day of the month (1..n) for time.
t = Time.now #=> 2007-11-19 08:27:03 -0600
t.day #=> 19
t.mday #=> 19
|
|
# 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 #=> 2007-11-19 08:27:03 -0600
* t.day #=> 19
* t.mday #=> 19
*/
static VALUE
time_mday(VALUE time)
{
struct time_object *tobj;
GetTimeval(time, tobj);
MAKE_TM(time, tobj);
return INT2FIX(tobj->vtm.mday);
}
|
#isdst ⇒ Boolean #dst? ⇒ Boolean
Returns true if time occurs during Daylight Saving Time in its time zone.
# CST6CDT:
Time.local(2000, 1, 1).zone #=> "CST"
Time.local(2000, 1, 1).isdst #=> false
Time.local(2000, 1, 1).dst? #=> false
Time.local(2000, 7, 1).zone #=> "CDT"
Time.local(2000, 7, 1).isdst #=> true
Time.local(2000, 7, 1).dst? #=> true
# Asia/Tokyo:
Time.local(2000, 1, 1).zone #=> "JST"
Time.local(2000, 1, 1).isdst #=> false
Time.local(2000, 1, 1).dst? #=> false
Time.local(2000, 7, 1).zone #=> "JST"
Time.local(2000, 7, 1).isdst #=> false
Time.local(2000, 7, 1).dst? #=> false
|
|
# 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.
*
* # CST6CDT:
* Time.local(2000, 1, 1).zone #=> "CST"
* Time.local(2000, 1, 1).isdst #=> false
* Time.local(2000, 1, 1).dst? #=> false
* Time.local(2000, 7, 1).zone #=> "CDT"
* Time.local(2000, 7, 1).isdst #=> true
* Time.local(2000, 7, 1).dst? #=> true
*
* # Asia/Tokyo:
* Time.local(2000, 1, 1).zone #=> "JST"
* Time.local(2000, 1, 1).isdst #=> false
* Time.local(2000, 1, 1).dst? #=> false
* Time.local(2000, 7, 1).zone #=> "JST"
* Time.local(2000, 7, 1).isdst #=> false
* Time.local(2000, 7, 1).dst? #=> false
*/
static VALUE
time_isdst(VALUE time)
{
struct time_object *tobj;
GetTimeval(time, tobj);
MAKE_TM(time, tobj);
return tobj->vtm.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(VALUE time1, VALUE time2)
{
struct time_object *tobj1, *tobj2;
GetTimeval(time1, tobj1);
if (IsTimeval(time2)) {
GetTimeval(time2, tobj2);
return rb_equal(w2v(tobj1->timew), w2v(tobj2->timew));
}
return Qfalse;
}
|
#friday? ⇒ Boolean
Returns true if time represents Friday.
t = Time.local(1987, 12, 18) #=> 1987-12-18 00:00:00 -0600
t.friday? #=> true
|
|
# File 'time.c'
/*
* call-seq:
* time.friday? -> true or false
*
* Returns <code>true</code> if <i>time</i> represents Friday.
*
* t = Time.local(1987, 12, 18) #=> 1987-12-18 00:00:00 -0600
* t.friday? #=> true
*/
static VALUE
time_friday(VALUE time)
{
wday_p(5);
}
|
#getgm ⇒ Time #getutc ⇒ Time
Returns a new new_time object representing time in UTC.
t = Time.local(2000,1,1,20,15,1) #=> 2000-01-01 20:15:01 -0600
t.gmt? #=> false
y = t.getgm #=> 2000-01-02 02:15:01 UTC
y.gmt? #=> true
t == y #=> true
|
|
# 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) #=> 2000-01-01 20:15:01 -0600
* t.gmt? #=> false
* y = t.getgm #=> 2000-01-02 02:15:01 UTC
* y.gmt? #=> true
* t == y #=> true
*/
static VALUE
time_getgmtime(VALUE time)
{
return time_gmtime(time_dup(time));
}
|
#getlocal ⇒ Time #getlocal(utc_offset) ⇒ Time
Returns a new new_time object representing time in local time (using the local time zone in effect for this process).
If utc_offset is given, it is used instead of the local time.
t = Time.utc(2000,1,1,20,15,1) #=> 2000-01-01 20:15:01 UTC
t.utc? #=> true
l = t.getlocal #=> 2000-01-01 14:15:01 -0600
l.utc? #=> false
t == l #=> true
j = t.getlocal("+09:00") #=> 2000-01-02 05:15:01 +0900
j.utc? #=> false
t == j #=> true
|
|
# File 'time.c'
/*
* call-seq:
* time.getlocal -> new_time
* time.getlocal(utc_offset) -> 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).
*
* If _utc_offset_ is given, it is used instead of the local time.
*
* t = Time.utc(2000,1,1,20,15,1) #=> 2000-01-01 20:15:01 UTC
* t.utc? #=> true
*
* l = t.getlocal #=> 2000-01-01 14:15:01 -0600
* l.utc? #=> false
* t == l #=> true
*
* j = t.getlocal("+09:00") #=> 2000-01-02 05:15:01 +0900
* j.utc? #=> false
* t == j #=> true
*/
static VALUE
time_getlocaltime(int argc, VALUE *argv, VALUE time)
{
VALUE off;
rb_scan_args(argc, argv, "01", &off);
if (!NIL_P(off)) {
off = utc_offset_arg(off);
validate_utc_offset(off);
time = time_dup(time);
time_set_utc_offset(time, off);
return time_fixoff(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) #=> 2000-01-01 20:15:01 -0600
t.gmt? #=> false
y = t.getgm #=> 2000-01-02 02:15:01 UTC
y.gmt? #=> true
t == y #=> true
|
|
# 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) #=> 2000-01-01 20:15:01 -0600
* t.gmt? #=> false
* y = t.getgm #=> 2000-01-02 02:15:01 UTC
* y.gmt? #=> true
* t == y #=> true
*/
static VALUE
time_getgmtime(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 #=> 2007-11-19 08:15:23 -0600
t.utc? #=> false
t = Time.gm(2000,"jan",1,20,15,1) #=> 2000-01-01 20:15:01 UTC
t.utc? #=> true
t = Time.now #=> 2007-11-19 08:16:03 -0600
t.gmt? #=> false
t = Time.gm(2000,1,1,20,15,1) #=> 2000-01-01 20:15:01 UTC
t.gmt? #=> true
|
|
# 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 #=> 2007-11-19 08:15:23 -0600
* t.utc? #=> false
* t = Time.gm(2000,"jan",1,20,15,1) #=> 2000-01-01 20:15:01 UTC
* t.utc? #=> true
*
* t = Time.now #=> 2007-11-19 08:16:03 -0600
* t.gmt? #=> false
* t = Time.gm(2000,1,1,20,15,1) #=> 2000-01-01 20:15:01 UTC
* t.gmt? #=> true
*/
static VALUE
time_utc_p(VALUE time)
{
struct time_object *tobj;
GetTimeval(time, tobj);
if (TIME_UTC_P(tobj)) 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) #=> 2000-01-01 20:15:01 UTC
t.gmt_offset #=> 0
l = t.getlocal #=> 2000-01-01 14:15:01 -0600
l.gmt_offset #=> -21600
|
|
# 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) #=> 2000-01-01 20:15:01 UTC
* t.gmt_offset #=> 0
* l = t.getlocal #=> 2000-01-01 14:15:01 -0600
* l.gmt_offset #=> -21600
*/
static VALUE
time_utc_offset(VALUE time)
{
struct time_object *tobj;
GetTimeval(time, tobj);
MAKE_TM(time, tobj);
if (TIME_UTC_P(tobj)) {
return INT2FIX(0);
}
else {
return tobj->vtm.utc_offset;
}
}
|
#gmtime ⇒ Time #utc ⇒ Time
Converts time to UTC (GMT), modifying the receiver.
t = Time.now #=> 2007-11-19 08:18:31 -0600
t.gmt? #=> false
t.gmtime #=> 2007-11-19 14:18:31 UTC
t.gmt? #=> true
t = Time.now #=> 2007-11-19 08:18:51 -0600
t.utc? #=> false
t.utc #=> 2007-11-19 14:18:51 UTC
t.utc? #=> true
|
|
# File 'time.c'
/*
* call-seq:
* time.gmtime -> time
* time.utc -> time
*
* Converts <i>time</i> to UTC (GMT), modifying the receiver.
*
* t = Time.now #=> 2007-11-19 08:18:31 -0600
* t.gmt? #=> false
* t.gmtime #=> 2007-11-19 14:18:31 UTC
* t.gmt? #=> true
*
* t = Time.now #=> 2007-11-19 08:18:51 -0600
* t.utc? #=> false
* t.utc #=> 2007-11-19 14:18:51 UTC
* t.utc? #=> true
*/
static VALUE
time_gmtime(VALUE time)
{
struct time_object *tobj;
struct vtm vtm;
GetTimeval(time, tobj);
if (TIME_UTC_P(tobj)) {
if (tobj->tm_got)
return time;
}
else {
time_modify(time);
}
if (!gmtimew(tobj->timew, &vtm))
rb_raise(rb_eArgError, "gmtime error");
tobj->vtm = vtm;
tobj->tm_got = 1;
TIME_SET_UTC(tobj);
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) #=> 2000-01-01 20:15:01 UTC
t.gmt_offset #=> 0
l = t.getlocal #=> 2000-01-01 14:15:01 -0600
l.gmt_offset #=> -21600
|
|
# 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) #=> 2000-01-01 20:15:01 UTC
* t.gmt_offset #=> 0
* l = t.getlocal #=> 2000-01-01 14:15:01 -0600
* l.gmt_offset #=> -21600
*/
static VALUE
time_utc_offset(VALUE time)
{
struct time_object *tobj;
GetTimeval(time, tobj);
MAKE_TM(time, tobj);
if (TIME_UTC_P(tobj)) {
return INT2FIX(0);
}
else {
return tobj->vtm.utc_offset;
}
}
|
#hash ⇒ Fixnum
Return a hash code for this time object.
|
|
# File 'time.c'
/*
* call-seq:
* time.hash -> fixnum
*
* Return a hash code for this time object.
*/
static VALUE
time_hash(VALUE time)
{
struct time_object *tobj;
GetTimeval(time, tobj);
return rb_hash(w2v(tobj->timew));
}
|
#hour ⇒ Fixnum
Returns the hour of the day (0..23) for time.
t = Time.now #=> 2007-11-19 08:26:20 -0600
t.hour #=> 8
|
|
# File 'time.c'
/*
* call-seq:
* time.hour -> fixnum
*
* Returns the hour of the day (0..23) for <i>time</i>.
*
* t = Time.now #=> 2007-11-19 08:26:20 -0600
* t.hour #=> 8
*/
static VALUE
time_hour(VALUE time)
{
struct time_object *tobj;
GetTimeval(time, tobj);
MAKE_TM(time, tobj);
return INT2FIX(tobj->vtm.hour);
}
|
#initialize_copy ⇒ Object
:nodoc:
|
|
# File 'time.c'
/* :nodoc: */
static VALUE
time_init_copy(VALUE copy, VALUE time)
{
struct time_object *tobj, *tcopy;
if (copy == time) return copy;
time_modify(copy);
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 "%Y-%m-%d %H:%M:%S %z" for a local time and "%Y-%m-%d %H:%M:%S UTC" for a UTC time.
Time.now.to_s #=> "2007-10-05 16:09:51 +0900"
Time.now.utc.to_s #=> "2007-10-05 07:09:51 UTC"
|
|
# 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>%Y-%m-%d</code> <code>%H:%M:%S</code> <code>%z</code>''
* for a local time and
* ``<code>%Y-%m-%d</code> <code>%H:%M:%S</code> <code>UTC</code>''
* for a UTC time.
*
* Time.now.to_s #=> "2007-10-05 16:09:51 +0900"
* Time.now.utc.to_s #=> "2007-10-05 07:09:51 UTC"
*/
static VALUE
time_to_s(VALUE time)
{
struct time_object *tobj;
GetTimeval(time, tobj);
if (TIME_UTC_P(tobj))
return strftimev("%Y-%m-%d %H:%M:%S UTC", time);
else
return strftimev("%Y-%m-%d %H:%M:%S %z", time);
}
|
#isdst ⇒ Boolean #dst? ⇒ Boolean
Returns true if time occurs during Daylight Saving Time in its time zone.
# CST6CDT:
Time.local(2000, 1, 1).zone #=> "CST"
Time.local(2000, 1, 1).isdst #=> false
Time.local(2000, 1, 1).dst? #=> false
Time.local(2000, 7, 1).zone #=> "CDT"
Time.local(2000, 7, 1).isdst #=> true
Time.local(2000, 7, 1).dst? #=> true
# Asia/Tokyo:
Time.local(2000, 1, 1).zone #=> "JST"
Time.local(2000, 1, 1).isdst #=> false
Time.local(2000, 1, 1).dst? #=> false
Time.local(2000, 7, 1).zone #=> "JST"
Time.local(2000, 7, 1).isdst #=> false
Time.local(2000, 7, 1).dst? #=> false
|
|
# 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.
*
* # CST6CDT:
* Time.local(2000, 1, 1).zone #=> "CST"
* Time.local(2000, 1, 1).isdst #=> false
* Time.local(2000, 1, 1).dst? #=> false
* Time.local(2000, 7, 1).zone #=> "CDT"
* Time.local(2000, 7, 1).isdst #=> true
* Time.local(2000, 7, 1).dst? #=> true
*
* # Asia/Tokyo:
* Time.local(2000, 1, 1).zone #=> "JST"
* Time.local(2000, 1, 1).isdst #=> false
* Time.local(2000, 1, 1).dst? #=> false
* Time.local(2000, 7, 1).zone #=> "JST"
* Time.local(2000, 7, 1).isdst #=> false
* Time.local(2000, 7, 1).dst? #=> false
*/
static VALUE
time_isdst(VALUE time)
{
struct time_object *tobj;
GetTimeval(time, tobj);
MAKE_TM(time, tobj);
return tobj->vtm.isdst ? Qtrue : Qfalse;
}
|
#localtime ⇒ Time #localtime(utc_offset) ⇒ Time
Converts time to local time (using the local time zone in effect for this process) modifying the receiver.
If utc_offset is given, it is used instead of the local time.
t = Time.utc(2000, "jan", 1, 20, 15, 1) #=> 2000-01-01 20:15:01 UTC
t.utc? #=> true
t.localtime #=> 2000-01-01 14:15:01 -0600
t.utc? #=> false
t.localtime("+09:00") #=> 2000-01-02 05:15:01 +0900
t.utc? #=> false
|
|
# File 'time.c'
/*
* call-seq:
* time.localtime -> time
* time.localtime(utc_offset) -> time
*
* Converts <i>time</i> to local time (using the local time zone in
* effect for this process) modifying the receiver.
*
* If _utc_offset_ is given, it is used instead of the local time.
*
* t = Time.utc(2000, "jan", 1, 20, 15, 1) #=> 2000-01-01 20:15:01 UTC
* t.utc? #=> true
*
* t.localtime #=> 2000-01-01 14:15:01 -0600
* t.utc? #=> false
*
* t.localtime("+09:00") #=> 2000-01-02 05:15:01 +0900
* t.utc? #=> false
*/
static VALUE
time_localtime_m(int argc, VALUE *argv, VALUE time)
{
VALUE off;
rb_scan_args(argc, argv, "01", &off);
if (!NIL_P(off)) {
off = utc_offset_arg(off);
validate_utc_offset(off);
time_set_utc_offset(time, off);
return time_fixoff(time);
}
return time_localtime(time);
}
|
#marshal_dump ⇒ Object
undocumented
|
|
# File 'time.c'
/*
* undocumented
*/
static VALUE
time_mdump(VALUE time)
{
struct time_object *tobj;
unsigned long p, s;
char buf[8];
int i;
VALUE str;
struct vtm vtm;
long year;
long usec, nsec;
VALUE subsecx, nano, subnano, v;
GetTimeval(time, tobj);
gmtimew(tobj->timew, &vtm);
if (FIXNUM_P(vtm.year)) {
year = FIX2LONG(vtm.year);
if (year < 1900 || 1900+0xffff < year)
rb_raise(rb_eArgError, "year too big to marshal: %ld UTC", year);
}
else {
rb_raise(rb_eArgError, "year too big to marshal");
}
subsecx = vtm.subsecx;
nano = mulquo(subsecx, INT2FIX(1000000000), INT2FIX(TIME_SCALE));
divmodv(nano, INT2FIX(1), &v, &subnano);
nsec = FIX2LONG(v);
usec = nsec / 1000;
nsec = nsec % 1000;
nano = add(LONG2FIX(nsec), subnano);
p = 0x1UL << 31 | /* 1 */
TIME_UTC_P(tobj) << 30 | /* 1 */
(year-1900) << 14 | /* 16 */
(vtm.mon-1) << 10 | /* 4 */
vtm.mday << 5 | /* 5 */
vtm.hour; /* 5 */
s = vtm.min << 26 | /* 6 */
vtm.sec << 20 | /* 6 */
usec; /* 20 */
for (i=0; i<4; i++) {
buf[i] = (unsigned char)p;
p = RSHIFT(p, 8);
}
for (i=4; i<8; i++) {
buf[i] = (unsigned char)s;
s = RSHIFT(s, 8);
}
str = rb_str_new(buf, 8);
rb_copy_generic_ivar(str, time);
if (!rb_equal(nano, INT2FIX(0))) {
if (TYPE(nano) == T_RATIONAL) {
rb_ivar_set(str, id_nano_num, RRATIONAL(nano)->num);
rb_ivar_set(str, id_nano_den, RRATIONAL(nano)->den);
}
else {
rb_ivar_set(str, id_nano_num, nano);
rb_ivar_set(str, id_nano_den, INT2FIX(1));
}
}
if (nsec) { /* submicro is only for Ruby 1.9.1 compatibility */
/*
* submicro is formatted in fixed-point packed BCD (without sign).
* It represent digits under microsecond.
* For nanosecond resolution, 3 digits (2 bytes) are used.
* However it can be longer.
* Extra digits are ignored for loading.
*/
char buf[2];
int len = (int)sizeof(buf);
buf[1] = (char)((nsec % 10) << 4);
nsec /= 10;
buf[0] = (char)(nsec % 10);
nsec /= 10;
buf[0] |= (char)((nsec % 10) << 4);
if (buf[1] == 0)
len = 1;
rb_ivar_set(str, id_submicro, rb_str_new(buf, len));
}
if (!TIME_UTC_P(tobj)) {
VALUE off = time_utc_offset(time), div, mod;
divmodv(off, INT2FIX(1), &div, &mod);
if (rb_equal(mod, INT2FIX(0)))
off = rb_Integer(div);
rb_ivar_set(str, id_offset, off);
}
return str;
}
|
#marshal_load ⇒ Object
undocumented
|
|
# File 'time.c'
/*
* undocumented
*/
static VALUE
time_mload(VALUE time, VALUE str)
{
struct time_object *tobj;
unsigned long p, s;
time_t sec;
long usec;
unsigned char *buf;
struct vtm vtm;
int i, gmt;
long nsec;
VALUE submicro, nano_num, nano_den, offset;
wideval_t timew;
time_modify(time);
nano_num = rb_attr_get(str, id_nano_num);
if (nano_num != Qnil) {
st_delete(rb_generic_ivar_table(str), (st_data_t*)&id_nano_num, 0);
}
nano_den = rb_attr_get(str, id_nano_den);
if (nano_den != Qnil) {
st_delete(rb_generic_ivar_table(str), (st_data_t*)&id_nano_den, 0);
}
submicro = rb_attr_get(str, id_submicro);
if (submicro != Qnil) {
st_delete(rb_generic_ivar_table(str), (st_data_t*)&id_submicro, 0);
}
offset = rb_attr_get(str, id_offset);
if (offset != Qnil) {
validate_utc_offset(offset);
st_delete(rb_generic_ivar_table(str), (st_data_t*)&id_offset, 0);
}
rb_copy_generic_ivar(time, str);
StringValue(str);
buf = (unsigned char *)RSTRING_PTR(str);
if (RSTRING_LEN(str) != 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) {
gmt = 0;
offset = Qnil;
sec = p;
usec = s;
nsec = usec * 1000;
timew = wadd(rb_time_magnify(TIMET2WV(sec)), wmulquoll(WINT2FIXWV(usec), TIME_SCALE, 1000000));
}
else {
p &= ~(1UL<<31);
gmt = (int)((p >> 30) & 0x1);
vtm.year = INT2FIX(((int)(p >> 14) & 0xffff) + 1900);
vtm.mon = ((int)(p >> 10) & 0xf) + 1;
vtm.mday = (int)(p >> 5) & 0x1f;
vtm.hour = (int) p & 0x1f;
vtm.min = (int)(s >> 26) & 0x3f;
vtm.sec = (int)(s >> 20) & 0x3f;
vtm.utc_offset = INT2FIX(0);
vtm.yday = vtm.wday = 0;
vtm.isdst = 0;
vtm.zone = "";
usec = (long)(s & 0xfffff);
nsec = usec * 1000;
vtm.subsecx = mulquo(LONG2FIX(nsec), INT2FIX(TIME_SCALE), LONG2FIX(1000000000));
if (nano_num != Qnil) {
VALUE nano = quo(num_exact(nano_num), num_exact(nano_den));
vtm.subsecx = add(vtm.subsecx, mulquo(nano, INT2FIX(TIME_SCALE), LONG2FIX(1000000000)));
}
else if (submicro != Qnil) { /* for Ruby 1.9.1 compatibility */
unsigned char *ptr;
long len;
int digit;
ptr = (unsigned char*)StringValuePtr(submicro);
len = RSTRING_LEN(submicro);
nsec = 0;
if (0 < len) {
if (10 <= (digit = ptr[0] >> 4)) goto end_submicro;
nsec += digit * 100;
if (10 <= (digit = ptr[0] & 0xf)) goto end_submicro;
nsec += digit * 10;
}
if (1 < len) {
if (10 <= (digit = ptr[1] >> 4)) goto end_submicro;
nsec += digit;
}
vtm.subsecx = add(vtm.subsecx, mulquo(LONG2FIX(nsec), INT2FIX(TIME_SCALE), LONG2FIX(1000000000)));
end_submicro: ;
}
timew = timegmw(&vtm);
}
GetTimeval(time, tobj);
tobj->tm_got = 0;
tobj->timew = timew;
if (gmt) {
TIME_SET_UTC(tobj);
}
else if (!NIL_P(offset)) {
time_set_utc_offset(time, offset);
time_fixoff(time);
}
return time;
}
|
#day ⇒ Fixnum #mday ⇒ Fixnum
Returns the day of the month (1..n) for time.
t = Time.now #=> 2007-11-19 08:27:03 -0600
t.day #=> 19
t.mday #=> 19
|
|
# 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 #=> 2007-11-19 08:27:03 -0600
* t.day #=> 19
* t.mday #=> 19
*/
static VALUE
time_mday(VALUE time)
{
struct time_object *tobj;
GetTimeval(time, tobj);
MAKE_TM(time, tobj);
return INT2FIX(tobj->vtm.mday);
}
|
#min ⇒ Fixnum
Returns the minute of the hour (0..59) for time.
t = Time.now #=> 2007-11-19 08:25:51 -0600
t.min #=> 25
|
|
# File 'time.c'
/*
* call-seq:
* time.min -> fixnum
*
* Returns the minute of the hour (0..59) for <i>time</i>.
*
* t = Time.now #=> 2007-11-19 08:25:51 -0600
* t.min #=> 25
*/
static VALUE
time_min(VALUE time)
{
struct time_object *tobj;
GetTimeval(time, tobj);
MAKE_TM(time, tobj);
return INT2FIX(tobj->vtm.min);
}
|
#mon ⇒ Fixnum #month ⇒ Fixnum
Returns the month of the year (1..12) for time.
t = Time.now #=> 2007-11-19 08:27:30 -0600
t.mon #=> 11
t.month #=> 11
|
|
# 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 #=> 2007-11-19 08:27:30 -0600
* t.mon #=> 11
* t.month #=> 11
*/
static VALUE
time_mon(VALUE time)
{
struct time_object *tobj;
GetTimeval(time, tobj);
MAKE_TM(time, tobj);
return INT2FIX(tobj->vtm.mon);
}
|
#monday? ⇒ Boolean
Returns true if time represents Monday.
t = Time.local(2003, 8, 4) #=> 2003-08-04 00:00:00 -0500
p t.monday? #=> true
|
|
# File 'time.c'
/*
* call-seq:
* time.monday? -> true or false
*
* Returns <code>true</code> if <i>time</i> represents Monday.
*
* t = Time.local(2003, 8, 4) #=> 2003-08-04 00:00:00 -0500
* p t.monday? #=> true
*/
static VALUE
time_monday(VALUE time)
{
wday_p(1);
}
|
#mon ⇒ Fixnum #month ⇒ Fixnum
Returns the month of the year (1..12) for time.
t = Time.now #=> 2007-11-19 08:27:30 -0600
t.mon #=> 11
t.month #=> 11
|
|
# 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 #=> 2007-11-19 08:27:30 -0600
* t.mon #=> 11
* t.month #=> 11
*/
static VALUE
time_mon(VALUE time)
{
struct time_object *tobj;
GetTimeval(time, tobj);
MAKE_TM(time, tobj);
return INT2FIX(tobj->vtm.mon);
}
|
#nsec ⇒ Integer #tv_nsec ⇒ Integer
Returns just the number of nanoseconds for time.
t = Time.now #=> 2007-11-17 15:18:03 +0900
"%10.9f" % t.to_f #=> "1195280283.536151409"
t.nsec #=> 536151406
The lowest digit of to_f and nsec is different because IEEE 754 double is not accurate enough to represent nanoseconds from the Epoch. The accurate value is returned by nsec.
|
|
# File 'time.c'
/*
* call-seq:
* time.nsec -> int
* time.tv_nsec -> int
*
* Returns just the number of nanoseconds for <i>time</i>.
*
* t = Time.now #=> 2007-11-17 15:18:03 +0900
* "%10.9f" % t.to_f #=> "1195280283.536151409"
* t.nsec #=> 536151406
*
* The lowest digit of to_f and nsec is different because
* IEEE 754 double is not accurate enough to represent
* nanoseconds from the Epoch.
* The accurate value is returned by nsec.
*/
static VALUE
time_nsec(VALUE time)
{
struct time_object *tobj;
GetTimeval(time, tobj);
return rb_to_int(w2v(wmulquoll(wmod(tobj->timew, WINT2WV(TIME_SCALE)), 1000000000, TIME_SCALE)));
}
|
#round([ndigits]) ⇒ Time
Rounds sub seconds to a given precision in decimal digits (0 digits by default). It returns a new time object. ndigits should be zero or positive integer.
require 'time'
t = Time.utc(2010,3,30, 5,43,"25.123456789".to_r)
p t.iso8601(10) #=> "2010-03-30T05:43:25.1234567890Z"
p t.round.iso8601(10) #=> "2010-03-30T05:43:25.0000000000Z"
p t.round(0).iso8601(10) #=> "2010-03-30T05:43:25.0000000000Z"
p t.round(1).iso8601(10) #=> "2010-03-30T05:43:25.1000000000Z"
p t.round(2).iso8601(10) #=> "2010-03-30T05:43:25.1200000000Z"
p t.round(3).iso8601(10) #=> "2010-03-30T05:43:25.1230000000Z"
p t.round(4).iso8601(10) #=> "2010-03-30T05:43:25.1235000000Z"
p t.round(5).iso8601(10) #=> "2010-03-30T05:43:25.1234600000Z"
p t.round(6).iso8601(10) #=> "2010-03-30T05:43:25.1234570000Z"
p t.round(7).iso8601(10) #=> "2010-03-30T05:43:25.1234568000Z"
p t.round(8).iso8601(10) #=> "2010-03-30T05:43:25.1234567900Z"
p t.round(9).iso8601(10) #=> "2010-03-30T05:43:25.1234567890Z"
p t.round(10).iso8601(10) #=> "2010-03-30T05:43:25.1234567890Z"
t = Time.utc(1999,12,31, 23,59,59)
p((t + 0.4).round.iso8601(3)) #=> "1999-12-31T23:59:59.000Z"
p((t + 0.49).round.iso8601(3)) #=> "1999-12-31T23:59:59.000Z"
p((t + 0.5).round.iso8601(3)) #=> "2000-01-01T00:00:00.000Z"
p((t + 1.4).round.iso8601(3)) #=> "2000-01-01T00:00:00.000Z"
p((t + 1.49).round.iso8601(3)) #=> "2000-01-01T00:00:00.000Z"
p((t + 1.5).round.iso8601(3)) #=> "2000-01-01T00:00:01.000Z"
t = Time.utc(1999,12,31, 23,59,59)
p (t + 0.123456789).round(4).iso8601(6) #=> "1999-12-31T23:59:59.123500Z"
|
|
# File 'time.c'
/*
* call-seq:
* time.round([ndigits]) -> new_time
*
* Rounds sub seconds to a given precision in decimal digits (0 digits by default).
* It returns a new time object.
* _ndigits_ should be zero or positive integer.
*
* require 'time'
*
* t = Time.utc(2010,3,30, 5,43,"25.123456789".to_r)
* p t.iso8601(10) #=> "2010-03-30T05:43:25.1234567890Z"
* p t.round.iso8601(10) #=> "2010-03-30T05:43:25.0000000000Z"
* p t.round(0).iso8601(10) #=> "2010-03-30T05:43:25.0000000000Z"
* p t.round(1).iso8601(10) #=> "2010-03-30T05:43:25.1000000000Z"
* p t.round(2).iso8601(10) #=> "2010-03-30T05:43:25.1200000000Z"
* p t.round(3).iso8601(10) #=> "2010-03-30T05:43:25.1230000000Z"
* p t.round(4).iso8601(10) #=> "2010-03-30T05:43:25.1235000000Z"
* p t.round(5).iso8601(10) #=> "2010-03-30T05:43:25.1234600000Z"
* p t.round(6).iso8601(10) #=> "2010-03-30T05:43:25.1234570000Z"
* p t.round(7).iso8601(10) #=> "2010-03-30T05:43:25.1234568000Z"
* p t.round(8).iso8601(10) #=> "2010-03-30T05:43:25.1234567900Z"
* p t.round(9).iso8601(10) #=> "2010-03-30T05:43:25.1234567890Z"
* p t.round(10).iso8601(10) #=> "2010-03-30T05:43:25.1234567890Z"
*
* t = Time.utc(1999,12,31, 23,59,59)
* p((t + 0.4).round.iso8601(3)) #=> "1999-12-31T23:59:59.000Z"
* p((t + 0.49).round.iso8601(3)) #=> "1999-12-31T23:59:59.000Z"
* p((t + 0.5).round.iso8601(3)) #=> "2000-01-01T00:00:00.000Z"
* p((t + 1.4).round.iso8601(3)) #=> "2000-01-01T00:00:00.000Z"
* p((t + 1.49).round.iso8601(3)) #=> "2000-01-01T00:00:00.000Z"
* p((t + 1.5).round.iso8601(3)) #=> "2000-01-01T00:00:01.000Z"
*
* t = Time.utc(1999,12,31, 23,59,59)
* p (t + 0.123456789).round(4).iso8601(6) #=> "1999-12-31T23:59:59.123500Z"
*/
static VALUE
time_round(int argc, VALUE *argv, VALUE time)
{
VALUE ndigits, v, a, b, den;
long nd;
struct time_object *tobj;
rb_scan_args(argc, argv, "01", &ndigits);
if (NIL_P(ndigits))
ndigits = INT2FIX(0);
else
ndigits = rb_to_int(ndigits);
nd = NUM2LONG(ndigits);
if (nd < 0)
rb_raise(rb_eArgError, "negative ndigits given");
GetTimeval(time, tobj);
v = w2v(rb_time_unmagnify(tobj->timew));
a = INT2FIX(1);
b = INT2FIX(10);
while (0 < nd) {
if (nd & 1)
a = mul(a, b);
b = mul(b, b);
nd = nd >> 1;
}
den = quo(INT2FIX(1), a);
v = mod(v, den);
if (lt(v, quo(den, INT2FIX(2))))
return time_add(tobj, v, -1);
else
return time_add(tobj, sub(den, v), 1);
}
|
#saturday? ⇒ Boolean
Returns true if time represents Saturday.
t = Time.local(2006, 6, 10) #=> 2006-06-10 00:00:00 -0500
t.saturday? #=> true
|
|
# File 'time.c'
/*
* call-seq:
* time.saturday? -> true or false
*
* Returns <code>true</code> if <i>time</i> represents Saturday.
*
* t = Time.local(2006, 6, 10) #=> 2006-06-10 00:00:00 -0500
* t.saturday? #=> true
*/
static VALUE
time_saturday(VALUE time)
{
wday_p(6);
}
|
#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 #=> 2007-11-19 08:25:02 -0600
t.sec #=> 2
|
|
# 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 #=> 2007-11-19 08:25:02 -0600
* t.sec #=> 2
*/
static VALUE
time_sec(VALUE time)
{
struct time_object *tobj;
GetTimeval(time, tobj);
MAKE_TM(time, tobj);
return INT2FIX(tobj->vtm.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
%C - Century (20 in 2009)
%d - Day of the month (01..31)
%D - Date (%m/%d/%y)
%e - Day of the month, blank-padded ( 1..31)
%F - Equivalent to %Y-%m-%d (the ISO 8601 date format)
%h - Equivalent to %b
%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)
%k - hour, 24-hour clock, blank-padded ( 0..23)
%l - hour, 12-hour clock, blank-padded ( 0..12)
%L - Millisecond of the second (000..999)
%m - Month of the year (01..12)
%M - Minute of the hour (00..59)
%n - Newline (\n)
%N - Fractional seconds digits, default is 9 digits (nanosecond)
%3N millisecond (3 digits)
%6N microsecond (6 digits)
%9N nanosecond (9 digits)
%p - Meridian indicator (``AM'' or ``PM'')
%P - Meridian indicator (``am'' or ``pm'')
%r - time, 12-hour (same as %I:%M:%S %p)
%R - time, 24-hour (%H:%M)
%s - Number of seconds since 1970-01-01 00:00:00 UTC.
%S - Second of the minute (00..60)
%t - Tab character (\t)
%T - time, 24-hour (%H:%M:%S)
%u - Day of the week as a decimal, Monday being 1. (1..7)
%U - Week number of the current year,
starting with the first Sunday as the first
day of the first week (00..53)
%v - VMS date (%e-%b-%Y)
%V - Week number of year according to ISO 8601 (01..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 as hour offset from UTC (e.g. +0900)
%Z - Time zone name
%% - Literal ``%'' character
t = Time.now #=> 2007-11-19 08:37:48 -0600
t.strftime("Printed on %m/%d/%Y") #=> "Printed on 11/19/2007"
t.strftime("at %I:%M%p") #=> "at 08:37AM"
|
|
# 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
* %C - Century (20 in 2009)
* %d - Day of the month (01..31)
* %D - Date (%m/%d/%y)
* %e - Day of the month, blank-padded ( 1..31)
* %F - Equivalent to %Y-%m-%d (the ISO 8601 date format)
* %h - Equivalent to %b
* %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)
* %k - hour, 24-hour clock, blank-padded ( 0..23)
* %l - hour, 12-hour clock, blank-padded ( 0..12)
* %L - Millisecond of the second (000..999)
* %m - Month of the year (01..12)
* %M - Minute of the hour (00..59)
* %n - Newline (\n)
* %N - Fractional seconds digits, default is 9 digits (nanosecond)
* %3N millisecond (3 digits)
* %6N microsecond (6 digits)
* %9N nanosecond (9 digits)
* %p - Meridian indicator (``AM'' or ``PM'')
* %P - Meridian indicator (``am'' or ``pm'')
* %r - time, 12-hour (same as %I:%M:%S %p)
* %R - time, 24-hour (%H:%M)
* %s - Number of seconds since 1970-01-01 00:00:00 UTC.
* %S - Second of the minute (00..60)
* %t - Tab character (\t)
* %T - time, 24-hour (%H:%M:%S)
* %u - Day of the week as a decimal, Monday being 1. (1..7)
* %U - Week number of the current year,
* starting with the first Sunday as the first
* day of the first week (00..53)
* %v - VMS date (%e-%b-%Y)
* %V - Week number of year according to ISO 8601 (01..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 as hour offset from UTC (e.g. +0900)
* %Z - Time zone name
* %% - Literal ``%'' character
*
* t = Time.now #=> 2007-11-19 08:37:48 -0600
* t.strftime("Printed on %m/%d/%Y") #=> "Printed on 11/19/2007"
* t.strftime("at %I:%M%p") #=> "at 08:37AM"
*/
static VALUE
time_strftime(VALUE time, VALUE format)
{
void rb_enc_copy(VALUE, VALUE);
struct time_object *tobj;
char buffer[SMALLBUF], *buf = buffer;
const char *fmt;
long len;
VALUE str;
GetTimeval(time, tobj);
MAKE_TM(time, tobj);
StringValue(format);
if (!rb_enc_str_asciicompat_p(format)) {
rb_raise(rb_eArgError, "format should have ASCII compatible encoding");
}
format = rb_str_new4(format);
fmt = RSTRING_PTR(format);
len = RSTRING_LEN(format);
if (len == 0) {
rb_warning("strftime called with empty format string");
}
else if (memchr(fmt, '\0', 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_alloc(&buf, p, &tobj->vtm, tobj->timew, TIME_UTC_P(tobj));
rb_str_cat(str, buf, len);
p += strlen(p);
if (buf != buffer) {
xfree(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_alloc(&buf, RSTRING_PTR(format),
&tobj->vtm, tobj->timew, TIME_UTC_P(tobj));
}
str = rb_str_new(buf, len);
if (buf != buffer) xfree(buf);
rb_enc_copy(str, format);
return str;
}
|
#subsec ⇒ Numeric
Returns just the fraction for time.
The result is possibly rational.
t = Time.now #=> 2009-03-26 22:33:12 +0900
"%10.9f" % t.to_f #=> "1238074392.940563917"
t.subsec #=> (94056401/100000000)
The lowest digit of to_f and subsec is different because IEEE 754 double is not accurate enough to represent the rational. The accurate value is returned by subsec.
|
|
# File 'time.c'
/*
* call-seq:
* time.subsec -> number
*
* Returns just the fraction for <i>time</i>.
*
* The result is possibly rational.
*
* t = Time.now #=> 2009-03-26 22:33:12 +0900
* "%10.9f" % t.to_f #=> "1238074392.940563917"
* t.subsec #=> (94056401/100000000)
*
* The lowest digit of to_f and subsec is different because
* IEEE 754 double is not accurate enough to represent
* the rational.
* The accurate value is returned by subsec.
*/
static VALUE
time_subsec(VALUE time)
{
struct time_object *tobj;
GetTimeval(time, tobj);
return quo(w2v(wmod(tobj->timew, WINT2FIXWV(TIME_SCALE))), INT2FIX(TIME_SCALE));
}
|
#succ ⇒ Object
#sunday? ⇒ Boolean
Returns true if time represents Sunday.
t = Time.local(1990, 4, 1) #=> 1990-04-01 00:00:00 -0600
t.sunday? #=> true
|
|
# File 'time.c'
/*
* call-seq:
* time.sunday? -> true or false
*
* Returns <code>true</code> if <i>time</i> represents Sunday.
*
* t = Time.local(1990, 4, 1) #=> 1990-04-01 00:00:00 -0600
* t.sunday? #=> true
*/
static VALUE
time_sunday(VALUE time)
{
wday_p(0);
}
|
#thursday? ⇒ Boolean
Returns true if time represents Thursday.
t = Time.local(1995, 12, 21) #=> 1995-12-21 00:00:00 -0600
p t.thursday? #=> true
|
|
# File 'time.c'
/*
* call-seq:
* time.thursday? -> true or false
*
* Returns <code>true</code> if <i>time</i> represents Thursday.
*
* t = Time.local(1995, 12, 21) #=> 1995-12-21 00:00:00 -0600
* p t.thursday? #=> true
*/
static VALUE
time_thursday(VALUE time)
{
wday_p(4);
}
|
#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.
t = Time.now #=> 2007-11-19 08:36:01 -0600
now = t.to_a #=> [1, 36, 8, 19, 11, 2007, 1, 323, false, "CST"]
|
|
# 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>.
*
* t = Time.now #=> 2007-11-19 08:36:01 -0600
* now = t.to_a #=> [1, 36, 8, 19, 11, 2007, 1, 323, false, "CST"]
*/
static VALUE
time_to_a(VALUE time)
{
struct time_object *tobj;
GetTimeval(time, tobj);
MAKE_TM(time, tobj);
return rb_ary_new3(10,
INT2FIX(tobj->vtm.sec),
INT2FIX(tobj->vtm.min),
INT2FIX(tobj->vtm.hour),
INT2FIX(tobj->vtm.mday),
INT2FIX(tobj->vtm.mon),
tobj->vtm.year,
INT2FIX(tobj->vtm.wday),
INT2FIX(tobj->vtm.yday),
tobj->vtm.isdst?Qtrue:Qfalse,
time_zone(time));
}
|
#to_f ⇒ Float
Returns the value of time as a floating point number of seconds since the Epoch.
t = Time.now
"%10.5f" % t.to_f #=> "1270968744.77658"
t.to_i #=> 1270968744
Note that IEEE 754 double is not accurate enough to represent number of nanoseconds from the Epoch.
|
|
# File 'time.c'
/*
* call-seq:
* time.to_f -> float
*
* Returns the value of <i>time</i> as a floating point number of
* seconds since the Epoch.
*
* t = Time.now
* "%10.5f" % t.to_f #=> "1270968744.77658"
* t.to_i #=> 1270968744
*
* Note that IEEE 754 double is not accurate enough to represent
* number of nanoseconds from the Epoch.
*/
static VALUE
time_to_f(VALUE time)
{
struct time_object *tobj;
GetTimeval(time, tobj);
return rb_Float(rb_time_unmagnify_to_float(tobj->timew));
}
|
#to_i ⇒ Integer #tv_sec ⇒ Integer
Returns the value of time as an integer number of seconds since the Epoch.
t = Time.now
"%10.5f" % t.to_f #=> "1270968656.89607"
t.to_i #=> 1270968656
|
|
# 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 the Epoch.
*
* t = Time.now
* "%10.5f" % t.to_f #=> "1270968656.89607"
* t.to_i #=> 1270968656
*/
static VALUE
time_to_i(VALUE time)
{
struct time_object *tobj;
GetTimeval(time, tobj);
return w2v(wdiv(tobj->timew, WINT2FIXWV(TIME_SCALE)));
}
|
#to_r ⇒ Object
Returns the value of time as a rational number of seconds since the Epoch.
t = Time.now
p t.to_r #=> (1270968792716287611/1000000000)
This methods is intended to be used to get an accurate value representing nanoseconds from the Epoch. You can use this to convert time to another Epoch.
|
|
# File 'time.c'
/*
* call-seq:
* time.to_r -> a_rational
*
* Returns the value of <i>time</i> as a rational number of seconds
* since the Epoch.
*
* t = Time.now
* p t.to_r #=> (1270968792716287611/1000000000)
*
* This methods is intended to be used to get an accurate value
* representing nanoseconds from the Epoch. You can use this
* to convert time to another Epoch.
*/
static VALUE
time_to_r(VALUE time)
{
struct time_object *tobj;
VALUE v;
GetTimeval(time, tobj);
v = w2v(rb_time_unmagnify(tobj->timew));
if (TYPE(v) != T_RATIONAL) {
v = rb_Rational1(v);
}
return v;
}
|
#inspect ⇒ String #to_s ⇒ String
Returns a string representing time. Equivalent to calling Time#strftime with a format string of "%Y-%m-%d %H:%M:%S %z" for a local time and "%Y-%m-%d %H:%M:%S UTC" for a UTC time.
Time.now.to_s #=> "2007-10-05 16:09:51 +0900"
Time.now.utc.to_s #=> "2007-10-05 07:09:51 UTC"
|
|
# 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>%Y-%m-%d</code> <code>%H:%M:%S</code> <code>%z</code>''
* for a local time and
* ``<code>%Y-%m-%d</code> <code>%H:%M:%S</code> <code>UTC</code>''
* for a UTC time.
*
* Time.now.to_s #=> "2007-10-05 16:09:51 +0900"
* Time.now.utc.to_s #=> "2007-10-05 07:09:51 UTC"
*/
static VALUE
time_to_s(VALUE time)
{
struct time_object *tobj;
GetTimeval(time, tobj);
if (TIME_UTC_P(tobj))
return strftimev("%Y-%m-%d %H:%M:%S UTC", time);
else
return strftimev("%Y-%m-%d %H:%M:%S %z", time);
}
|
#tuesday? ⇒ Boolean
Returns true if time represents Tuesday.
t = Time.local(1991, 2, 19) #=> 1991-02-19 00:00:00 -0600
p t.tuesday? #=> true
|
|
# File 'time.c'
/*
* call-seq:
* time.tuesday? -> true or false
*
* Returns <code>true</code> if <i>time</i> represents Tuesday.
*
* t = Time.local(1991, 2, 19) #=> 1991-02-19 00:00:00 -0600
* p t.tuesday? #=> true
*/
static VALUE
time_tuesday(VALUE time)
{
wday_p(2);
}
|
#nsec ⇒ Integer #tv_nsec ⇒ Integer
Returns just the number of nanoseconds for time.
t = Time.now #=> 2007-11-17 15:18:03 +0900
"%10.9f" % t.to_f #=> "1195280283.536151409"
t.nsec #=> 536151406
The lowest digit of to_f and nsec is different because IEEE 754 double is not accurate enough to represent nanoseconds from the Epoch. The accurate value is returned by nsec.
|
|
# File 'time.c'
/*
* call-seq:
* time.nsec -> int
* time.tv_nsec -> int
*
* Returns just the number of nanoseconds for <i>time</i>.
*
* t = Time.now #=> 2007-11-17 15:18:03 +0900
* "%10.9f" % t.to_f #=> "1195280283.536151409"
* t.nsec #=> 536151406
*
* The lowest digit of to_f and nsec is different because
* IEEE 754 double is not accurate enough to represent
* nanoseconds from the Epoch.
* The accurate value is returned by nsec.
*/
static VALUE
time_nsec(VALUE time)
{
struct time_object *tobj;
GetTimeval(time, tobj);
return rb_to_int(w2v(wmulquoll(wmod(tobj->timew, WINT2WV(TIME_SCALE)), 1000000000, TIME_SCALE)));
}
|
#to_i ⇒ Integer #tv_sec ⇒ Integer
Returns the value of time as an integer number of seconds since the Epoch.
t = Time.now
"%10.5f" % t.to_f #=> "1270968656.89607"
t.to_i #=> 1270968656
|
|
# 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 the Epoch.
*
* t = Time.now
* "%10.5f" % t.to_f #=> "1270968656.89607"
* t.to_i #=> 1270968656
*/
static VALUE
time_to_i(VALUE time)
{
struct time_object *tobj;
GetTimeval(time, tobj);
return w2v(wdiv(tobj->timew, WINT2FIXWV(TIME_SCALE)));
}
|
#usec ⇒ Integer #tv_usec ⇒ Integer
Returns just the number of microseconds for time.
t = Time.now #=> 2007-11-19 08:03:26 -0600
"%10.6f" % t.to_f #=> "1195481006.775195"
t.usec #=> 775195
|
|
# 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 #=> 2007-11-19 08:03:26 -0600
* "%10.6f" % t.to_f #=> "1195481006.775195"
* t.usec #=> 775195
*/
static VALUE
time_usec(VALUE time)
{
struct time_object *tobj;
wideval_t w, q, r;
GetTimeval(time, tobj);
w = wmod(tobj->timew, WINT2WV(TIME_SCALE));
wmuldivmod(w, WINT2FIXWV(1000000), WINT2FIXWV(TIME_SCALE), &q, &r);
return rb_to_int(w2v(q));
}
|
#usec ⇒ Integer #tv_usec ⇒ Integer
Returns just the number of microseconds for time.
t = Time.now #=> 2007-11-19 08:03:26 -0600
"%10.6f" % t.to_f #=> "1195481006.775195"
t.usec #=> 775195
|
|
# 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 #=> 2007-11-19 08:03:26 -0600
* "%10.6f" % t.to_f #=> "1195481006.775195"
* t.usec #=> 775195
*/
static VALUE
time_usec(VALUE time)
{
struct time_object *tobj;
wideval_t w, q, r;
GetTimeval(time, tobj);
w = wmod(tobj->timew, WINT2WV(TIME_SCALE));
wmuldivmod(w, WINT2FIXWV(1000000), WINT2FIXWV(TIME_SCALE), &q, &r);
return rb_to_int(w2v(q));
}
|
#gmtime ⇒ Time #utc ⇒ Time
Converts time to UTC (GMT), modifying the receiver.
t = Time.now #=> 2007-11-19 08:18:31 -0600
t.gmt? #=> false
t.gmtime #=> 2007-11-19 14:18:31 UTC
t.gmt? #=> true
t = Time.now #=> 2007-11-19 08:18:51 -0600
t.utc? #=> false
t.utc #=> 2007-11-19 14:18:51 UTC
t.utc? #=> true
|
|
# File 'time.c'
/*
* call-seq:
* time.gmtime -> time
* time.utc -> time
*
* Converts <i>time</i> to UTC (GMT), modifying the receiver.
*
* t = Time.now #=> 2007-11-19 08:18:31 -0600
* t.gmt? #=> false
* t.gmtime #=> 2007-11-19 14:18:31 UTC
* t.gmt? #=> true
*
* t = Time.now #=> 2007-11-19 08:18:51 -0600
* t.utc? #=> false
* t.utc #=> 2007-11-19 14:18:51 UTC
* t.utc? #=> true
*/
static VALUE
time_gmtime(VALUE time)
{
struct time_object *tobj;
struct vtm vtm;
GetTimeval(time, tobj);
if (TIME_UTC_P(tobj)) {
if (tobj->tm_got)
return time;
}
else {
time_modify(time);
}
if (!gmtimew(tobj->timew, &vtm))
rb_raise(rb_eArgError, "gmtime error");
tobj->vtm = vtm;
tobj->tm_got = 1;
TIME_SET_UTC(tobj);
return time;
}
|
#utc? ⇒ Boolean #gmt? ⇒ Boolean
Returns true if time represents a time in UTC (GMT).
t = Time.now #=> 2007-11-19 08:15:23 -0600
t.utc? #=> false
t = Time.gm(2000,"jan",1,20,15,1) #=> 2000-01-01 20:15:01 UTC
t.utc? #=> true
t = Time.now #=> 2007-11-19 08:16:03 -0600
t.gmt? #=> false
t = Time.gm(2000,1,1,20,15,1) #=> 2000-01-01 20:15:01 UTC
t.gmt? #=> true
|
|
# 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 #=> 2007-11-19 08:15:23 -0600
* t.utc? #=> false
* t = Time.gm(2000,"jan",1,20,15,1) #=> 2000-01-01 20:15:01 UTC
* t.utc? #=> true
*
* t = Time.now #=> 2007-11-19 08:16:03 -0600
* t.gmt? #=> false
* t = Time.gm(2000,1,1,20,15,1) #=> 2000-01-01 20:15:01 UTC
* t.gmt? #=> true
*/
static VALUE
time_utc_p(VALUE time)
{
struct time_object *tobj;
GetTimeval(time, tobj);
if (TIME_UTC_P(tobj)) 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) #=> 2000-01-01 20:15:01 UTC
t.gmt_offset #=> 0
l = t.getlocal #=> 2000-01-01 14:15:01 -0600
l.gmt_offset #=> -21600
|
|
# 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) #=> 2000-01-01 20:15:01 UTC
* t.gmt_offset #=> 0
* l = t.getlocal #=> 2000-01-01 14:15:01 -0600
* l.gmt_offset #=> -21600
*/
static VALUE
time_utc_offset(VALUE time)
{
struct time_object *tobj;
GetTimeval(time, tobj);
MAKE_TM(time, tobj);
if (TIME_UTC_P(tobj)) {
return INT2FIX(0);
}
else {
return tobj->vtm.utc_offset;
}
}
|
#wday ⇒ Fixnum
Returns an integer representing the day of the week, 0..6, with Sunday == 0.
t = Time.now #=> 2007-11-20 02:35:35 -0600
t.wday #=> 2
t.sunday? #=> false
t.monday? #=> false
t.tuesday? #=> true
t.wednesday? #=> false
t.thursday? #=> false
t.friday? #=> false
t.saturday? #=> false
|
|
# 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 #=> 2007-11-20 02:35:35 -0600
* t.wday #=> 2
* t.sunday? #=> false
* t.monday? #=> false
* t.tuesday? #=> true
* t.wednesday? #=> false
* t.thursday? #=> false
* t.friday? #=> false
* t.saturday? #=> false
*/
static VALUE
time_wday(VALUE time)
{
struct time_object *tobj;
GetTimeval(time, tobj);
MAKE_TM(time, tobj);
return INT2FIX(tobj->vtm.wday);
}
|
#wednesday? ⇒ Boolean
Returns true if time represents Wednesday.
t = Time.local(1993, 2, 24) #=> 1993-02-24 00:00:00 -0600
p t.wednesday? #=> true
|
|
# File 'time.c'
/*
* call-seq:
* time.wednesday? -> true or false
*
* Returns <code>true</code> if <i>time</i> represents Wednesday.
*
* t = Time.local(1993, 2, 24) #=> 1993-02-24 00:00:00 -0600
* p t.wednesday? #=> true
*/
static VALUE
time_wednesday(VALUE time)
{
wday_p(3);
}
|
#yday ⇒ Fixnum
Returns an integer representing the day of the year, 1..366.
t = Time.now #=> 2007-11-19 08:32:31 -0600
t.yday #=> 323
|
|
# File 'time.c'
/*
* call-seq:
* time.yday -> fixnum
*
* Returns an integer representing the day of the year, 1..366.
*
* t = Time.now #=> 2007-11-19 08:32:31 -0600
* t.yday #=> 323
*/
static VALUE
time_yday(VALUE time)
{
struct time_object *tobj;
GetTimeval(time, tobj);
MAKE_TM(time, tobj);
return INT2FIX(tobj->vtm.yday);
}
|
#year ⇒ Fixnum
Returns the year for time (including the century).
t = Time.now #=> 2007-11-19 08:27:51 -0600
t.year #=> 2007
|
|
# File 'time.c'
/*
* call-seq:
* time.year -> fixnum
*
* Returns the year for <i>time</i> (including the century).
*
* t = Time.now #=> 2007-11-19 08:27:51 -0600
* t.year #=> 2007
*/
static VALUE
time_year(VALUE time)
{
struct time_object *tobj;
GetTimeval(time, tobj);
MAKE_TM(time, tobj);
return tobj->vtm.year;
}
|
#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"
|
|
# 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(VALUE time)
{
struct time_object *tobj;
GetTimeval(time, tobj);
MAKE_TM(time, tobj);
if (TIME_UTC_P(tobj)) {
return rb_str_new2("UTC");
}
if (tobj->vtm.zone == NULL)
return Qnil;
return rb_str_new2(tobj->vtm.zone);
}
|