Ruby » Ruby master

static struct tm *localtime_with_gmtoff_zone(const time_t *t, struct tm *result, long *gmtoff, const char **zone);

/*

* http://use.perl.org/articles/08/02/07/197204.shtml

*

* http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=522949

*

* #!/usr/bin/ruby

VALUE timev;

int y, wday;

if (lt(vtm_utc->year, INT2FIX(1916))) {

VALUE off = INT2FIX(0);

int isdst = 0;

return off;

}

vtm2 = *vtm_utc;

/*

* Document-method: now

*

* initialized to the current system time.

*/

* Time.new -> time

* Time.new(year, month=nil, day=nil, hour=nil, min=nil, sec=nil, utc_offset=nil) -> time

*

*

*

* 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.

*

* a = Time.new #=> 2007-11-19 07:50:02 -0600

* b = Time.new #=> 2007-11-19 07:50:02 -0600

* Time.at(seconds_with_frac) -> time

* Time.at(seconds, microseconds_with_frac) -> time

*

* non-portable feature allows the offset to be negative on some systems.

*

* If a numeric argument is given, the result is in local 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

*

* year must be specified. Other values default to the minimum value

* 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

*

* 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

* 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

*

* local time zone.

*

* Time.local(2000,"jan",1,20,15,1) #=> 2000-01-01 20:15:01 -0600

* time.to_i -> int

* time.tv_sec -> int

*

* since the Epoch.

*

* t = Time.now

* call-seq:

* time.to_f -> float

*

* seconds since the Epoch.

*

* t = Time.now

* t.to_i #=> 1270968744

*

* Note that IEEE 754 double is not accurate enough to represent

*/

static VALUE

* call-seq:

* time.to_r -> a_rational

*

* since the Epoch.

*

* t = Time.now

* p t.to_r #=> (1270968792716287611/1000000000)

*

* This methods is intended to be used to get an accurate value

*/

static VALUE

* time.usec -> int

* time.tv_usec -> int

*

*

* t = Time.now #=> 2007-11-19 08:03:26 -0600

* "%10.6f" % t.to_f #=> "1195481006.775195"

* time.nsec -> int

* time.tv_nsec -> int

*

*

* t = Time.now #=> 2007-11-17 15:18:03 +0900

* "%10.9f" % t.to_f #=> "1195280283.536151409"

* t.nsec #=> 536151406

*

* IEEE 754 double is not accurate enough to represent

*/

static VALUE

* call-seq:

* time.subsec -> number

*

*

*

* t = Time.now #=> 2009-03-26 22:33:12 +0900

* "%10.9f" % t.to_f #=> "1238074392.940563917"

* t.subsec #=> (94056401/100000000)

*

* IEEE 754 double is not accurate enough to represent

*/

static VALUE

* call-seq:

* time <=> other_time -> -1, 0, +1 or nil

*

*

* t = Time.now #=> 2007-11-19 08:12:12 -0600

* t2 = t + 2592000 #=> 2007-12-19 08:12:12 -0600

* call-seq:

* time.eql?(other_time)

*

*/

static VALUE

* time.utc? -> true or false

* time.gmt? -> true or false

*

*

* t = Time.now #=> 2007-11-19 08:15:23 -0600

* t.utc? #=> false

* call-seq:

* time.hash -> fixnum

*

*/

static VALUE

* time.localtime -> time

* time.localtime(utc_offset) -> time

*

* effect for this process) modifying the receiver.

*

* If _utc_offset_ is given, it is used instead of the local time.

* time.gmtime -> time

* time.utc -> time

*

*

* t = Time.now #=> 2007-11-19 08:18:31 -0600

* t.gmt? #=> false

* time.getlocal -> new_time

* time.getlocal(utc_offset) -> new_time

*

* 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.

* time.getgm -> new_time

* time.getutc -> new_time

*

*

* t = Time.local(2000,1,1,20,15,1) #=> 2000-01-01 20:15:01 -0600

* t.gmt? #=> false

* time.asctime -> string

* time.ctime -> string

*

*

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

*/

* time.inspect -> string

* time.to_s -> string

*

*

*/

static VALUE

* time + numeric -> time

*

* Addition---Adds some number of seconds (possibly fractional) to

*

* t = Time.now #=> 2007-11-19 08:22:21 -0600

* t + (60 * 60 * 24) #=> 2007-11-20 08:22:21 -0600

* time - other_time -> float

* time - numeric -> time

*

*

* t = Time.now #=> 2007-11-19 08:23:10 -0600

* t2 = t + 2592000 #=> 2007-12-19 08:23:10 -0600

* call-seq:

* time.succ -> new_time

*

* Time#succ is obsolete since 1.9.2 for time is not a discrete value.

*

* t = Time.now #=> 2007-11-19 08:23:57 -0600

* t.succ #=> 2007-11-19 08:23:58 -0600

*/

VALUE

* time.round([ndigits]) -> new_time

*

* Rounds sub seconds to a given precision in decimal digits (0 digits by default).

* _ndigits_ should be zero or positive integer.

*

* require 'time'

* call-seq:

* time.sec -> fixnum

*

*

*

* t = Time.now #=> 2007-11-19 08:25:02 -0600

* t.sec #=> 2

* call-seq:

* time.min -> fixnum

*

*

* t = Time.now #=> 2007-11-19 08:25:51 -0600

* t.min #=> 25

* call-seq:

* time.hour -> fixnum

*

*

* t = Time.now #=> 2007-11-19 08:26:20 -0600

* t.hour #=> 8

* time.day -> fixnum

* time.mday -> fixnum

*

*

* t = Time.now #=> 2007-11-19 08:27:03 -0600

* t.day #=> 19

* time.mon -> fixnum

* time.month -> fixnum

*

*

* t = Time.now #=> 2007-11-19 08:27:30 -0600

* t.mon #=> 11

* call-seq:

* time.year -> fixnum

*

*

* t = Time.now #=> 2007-11-19 08:27:51 -0600

* t.year #=> 2007

* call-seq:

* time.sunday? -> true or false

*

*

* t = Time.local(1990, 4, 1) #=> 1990-04-01 00:00:00 -0600

* t.sunday? #=> true

* call-seq:

* time.monday? -> true or false

*

*

* t = Time.local(2003, 8, 4) #=> 2003-08-04 00:00:00 -0500

* p t.monday? #=> true

* call-seq:

* time.tuesday? -> true or false

*

*

* t = Time.local(1991, 2, 19) #=> 1991-02-19 00:00:00 -0600

* p t.tuesday? #=> true

* call-seq:

* time.wednesday? -> true or false

*

*

* t = Time.local(1993, 2, 24) #=> 1993-02-24 00:00:00 -0600

* p t.wednesday? #=> true

* call-seq:

* time.thursday? -> true or false

*

*

* t = Time.local(1995, 12, 21) #=> 1995-12-21 00:00:00 -0600

* p t.thursday? #=> true

* call-seq:

* time.friday? -> true or false

*

*

* t = Time.local(1987, 12, 18) #=> 1987-12-18 00:00:00 -0600

* t.friday? #=> true

* call-seq:

* time.saturday? -> true or false

*

*

* t = Time.local(2006, 6, 10) #=> 2006-06-10 00:00:00 -0500

* t.saturday? #=> true

* time.isdst -> true or false

* time.dst? -> true or false

*

* Saving Time in its time zone.

*

* # CST6CDT:

* call-seq:

* time.zone -> string

*

* 1.8, returns ``UTC'' rather than ``GMT'' for UTC times.

*

* t = Time.gm(2000, "jan", 1, 20, 15, 1)

* time.gmtoff -> fixnum

* time.utc_offset -> fixnum

*

* and UTC.

*

* t = Time.gm(2000,1,1,20,15,1) #=> 2000-01-01 20:15:01 UTC

* call-seq:

* time.to_a -> array

*

* valid ranges of each value. The ten elements can be passed directly

*

* t = Time.now #=> 2007-11-19 08:36:01 -0600

* now = t.to_a #=> [1, 36, 8, 19, 11, 2007, 1, 323, false, "CST"]

* call-seq:

* time.strftime( string ) -> string

*

* Any text not listed as a directive will be passed through to the

* output string.

*

* The directive consists of a percent (%) character,

* zero or more flags, optional minimum field width,

* optional modifier and a conversion specifier

*

* %<flags><width><modifier><conversion>

*

* Flags:

*

* The minimum field width specifies the minimum width.

*

* They are ignored.

*

* Format directives:

* Date (Year, Month, Day):

* %Y - Year with century (can be negative, 4 digits at least)

* -0001, 0000, 1995, 2009, 14292, etc.

* %y - year % 100 (00..99)

*

* %m - Month of the year, zero-padded (01..12)

* %z - Time zone as hour and minute offset from UTC (e.g. +0900)

* %:z - hour and minute offset from UTC with a colon (e.g. +09:00)

* %::z - hour, minute and second offset from UTC (e.g. +09:00:00)

*

* Weekday:

* %A - The full weekday name (``Sunday'')

* %w - Day of the week (Sunday is 0, 0..6)

*

* ISO 8601 week-based year and week number:

* The days in the year before the first week are in the last week of

* the previous year.

* %G - The week-based year

* %V - Week number of the week-based year (01..53)

*

* Week number:

*

* Seconds since the Epoch:

* %s - Number of seconds since 1970-01-01 00:00:00 UTC.

* %T - 24-hour time (%H:%M:%S)

*

* This method is similar to strftime() function defined in ISO C and POSIX.

* systems such as C.

*

* %z is recommended over %Z.

* %Z doesn't identify the timezone.

* For example, "CST" is used at America/Chicago (-06:00),

* America/Havana (-05:00), Asia/Harbin (+08:00), Australia/Darwin (+09:30)

* and Australia/Adelaide (+10:30).

* For example, it may generate a non ASCII string on Japanese Windows.

* i.e. the result can be different to "JST".

* So the numeric time zone offset, %z, is recommended.

* call-seq:

* Time._load(string) -> time

*

*/

static VALUE

/*

* 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

* (Greenwich Mean Time) and UTC (Coordinated Universal Time) as equivalent.

* GMT is the older way of referring to these baseline times but persists in

* the names of calls on POSIX systems.

* with each other -- times that are apparently equal when displayed may be

* different when compared.

*

* The integer is a number of nanoseconds since the _Epoch_ which can

* represent 1823-11-12 to 2116-02-20.

*

* = Examples

*

*

* == Creating a new Time instance

*

* you want to construct a time this way you must pass at least a year. If you

* at 00:00:00 with the current system timezone. Here are some examples:

*

* Time.new(2002) #=> 2002-01-01 00:00:00 -0500

* Time.new(2002, 10, 31) #=> 2002-10-31 00:00:00 -0500

* Time.new(2002, 10, 31, 2, 2, 2, "+02:00") #=> 2002-10-31 02:02:02 -0200

*

*

* seconds (or fraction of seconds) since the {Unix

* Epoch}[http://en.wikipedia.org/wiki/Unix_time].

*

*

* == Working with an instance of Time

*

* will work on the assumption that you have done the following:

*

* t = Time.new(1993, 02, 24, 12, 0, 0, "+09:00")

*

* t + (60*60*24*365) #=> 1994-02-24 12:00:00 +0900

*

*

* t.to_i #=> 730522800

*