Class: Time

Inherits:
Object show all
Defined in:
lib/source/ruby.rb

Overview

Time

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Time

call-seq:

Time.new -> time
Time.now -> time

Returns a Time object initialized to the current system time. The object created will include fractional seconds to the thousandths place.

t1 = Time.new   #=> Tue Sep 23 2008 22:10:22 GMT-0400 (EDT)
t2 = Time.new   #=> Tue Sep 23 2008 22:10:22 GMT-0400 (EDT)
t1 == t2        #=> false
t1.to_f         #=> 1222222222.989
t2.to_f         #=> 1222222222.991



6350
6351
6352
 
# File 'lib/source/ruby.rb', line 6350

def initialize
  `this.__value__=new(Date)`
end

Class Method Details

.at(seconds, milliseconds) ⇒ Object

call-seq:

Time.at(a_time)                   -> time
Time.at(seconds [, microseconds]) -> time

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

Time.at(0)            #=> Wed Dec 31 1969 19:00:00 GMT-0500 (EST)
Time.at(946702800)    #=> Sat Jan 01 2000 00:00:00 GMT-0500 (EST)
Time.at(-284061600)   #=> Sat Dec 31 1960 01:00:00 GMT-0500 (EST)



6314
6315
6316
6317
6318
 
# File 'lib/source/ruby.rb', line 6314

def self.at(seconds,milliseconds)
  `var t=c$Time.m$new()`
  `t.__value__=typeof(seconds)=='number'?new(Date)(seconds*1000+(milliseconds||0)):seconds.__value__`
  return `t`
end

.now ⇒ Object

call-seq:

Time.new -> time
Time.now -> time

Returns a Time object initialized to the current system time. The object created will include fractional seconds to the thousandths place.

t1 = Time.now   #=> Tue Sep 23 2008 22:10:22 GMT-0400 (EDT)
t2 = Time.now   #=> Tue Sep 23 2008 22:10:22 GMT-0400 (EDT)
t1 == t2        #=> false
t1.to_f         #=> 1222222222.989
t2.to_f         #=> 1222222222.991



6333
6334
6335
 
# File 'lib/source/ruby.rb', line 6333

def self.now
  Time.new
end

Instance Method Details

#+(numeric) ⇒ Object

call-seq:

time + numeric -> time

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

t = Time.now         #=> Tue Sep 23 2008 22:10:22 GMT-0400 (EDT)
t + (60 * 60 * 24)   #=> Wed Sep 24 2008 22:10:22 GMT-0400 (EDT)



6363
6364
6365
6366
6367
 
# File 'lib/source/ruby.rb', line 6363

def +(numeric)
  `var t=c$Time.m$new()`
  `t.__value__=new(Date)(numeric*1000+this.__value__.valueOf())`
  return `t`
end

#-(time) ⇒ Object

call-seq:

time - other   -> float
time - numeric -> time

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

t = Time.now       #=> Tue Sep 23 2008 22:10:22 GMT-0400 (EDT)
t2 = t + 2592000   #=> Thu Oct 23 2008 22:10:22 GMT-0400 (EDT)
t2 - t             #=> 2592000.0
t2 - 2592000       #=> Tue Sep 23 2008 22:10:22 GMT-0400 (EDT)



6382
6383
6384
 
# File 'lib/source/ruby.rb', line 6382

def -(time)
  `typeof(time)=='number'?new(Date)(this.__value__.valueOf()-(time*1000)):(this.__value__.valueOf()-time.__value__.valueOf())/1000`
end

#<=>(time) ⇒ Object

call-seq:

time <=> other   -> -1, 0, 1
time <=> numeric -> -1, 0, 1

Comparison – compares time with other or with numeric, which is the number of seconds (possibly fractional) since epoch.

t1 = Time.now       #=> Tue Sep 23 2008 22:10:22 GMT-0400 (EDT)
t2 = t1 + 2592000   #=> Thu Oct 23 2008 22:10:22 GMT-0400 (EDT)
t1 <=> t2           #=> -1
t2 <=> t1           #=> 1
t1 <=> t1           #=> 0



6399
6400
6401
6402
6403
6404
6405
 
# File 'lib/source/ruby.rb', line 6399

def <=>(time)
  `var v=this.__value__.valueOf(),ms=typeof(time)=='number'?time*1000:time.__value__.valueOf()`
  `if(v<ms){return -1;}`
  `if(v==ms){return 0;}`
  `if(v>ms){return 1;}`
  return nil
end

#day ⇒ Object

call-seq:

time.day  -> integer
time.mday -> integer

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

t = Time.now    #=> Tue Sep 23 2008 22:10:22 GMT-0400 (EDT)
t.day           #=> 23



6416
6417
6418
 
# File 'lib/source/ruby.rb', line 6416

def day
  `this.__value__.getDate()`
end

#dst? ⇒ Boolean

FIX: Incomplete

Returns:

  • (Boolean) 


6421
6422
 
# File 'lib/source/ruby.rb', line 6421

def dst?
end

#eql?(time) ⇒ Boolean

call-seq:

time.eql?(other) -> true or false

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

Returns:

  • (Boolean) 


6430
6431
6432
6433
 
# File 'lib/source/ruby.rb', line 6430

def eql?(time)
  `if(time.constructor!=c$Time){return false;}`
  `this.__value__.valueOf()==time.__value__.valueOf()`
end

#getgm ⇒ Object

FIX: Incomplete



6436
6437
 
# File 'lib/source/ruby.rb', line 6436

def getgm
end

#getlocal ⇒ Object

FIX: Incomplete



6440
6441
 
# File 'lib/source/ruby.rb', line 6440

def getlocal
end

#getutc ⇒ Object

FIX: Incomplete



6444
6445
 
# File 'lib/source/ruby.rb', line 6444

def getutc
end

#gmt? ⇒ Boolean

FIX: Incomplete

Returns:

  • (Boolean) 


6448
6449
 
# File 'lib/source/ruby.rb', line 6448

def gmt?
end

#gmt_offset ⇒ Object

call-seq:

time.gmt_offset -> integer
time.gmtoff     -> integer
time.utc_offset -> integer

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

t = Time.now    #=> Tue Sep 23 2008 22:10:22 GMT-0400 (EDT)
t.gmt_offset    #=> -14400



6461
6462
6463
 
# File 'lib/source/ruby.rb', line 6461

def gmt_offset
  `this.__value__.getTimezoneOffset() * -60`
end

#gmtime ⇒ Object

FIX: Incomplete



6466
6467
 
# File 'lib/source/ruby.rb', line 6466

def gmtime
end

#gmtoff ⇒ Object

call-seq:

time.gmt_offset -> integer
time.gmtoff     -> integer
time.utc_offset -> integer

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

t = Time.now    #=> Tue Sep 23 2008 22:10:22 GMT-0400 (EDT)
t.gmtoff        #=> -14400



6479
6480
6481
 
# File 'lib/source/ruby.rb', line 6479

def gmtoff
  `this.__value__.getTimezoneOffset() * -60`
end

#hash ⇒ Object

:nodoc:



6483
6484
6485
 
# File 'lib/source/ruby.rb', line 6483

def hash # :nodoc:
  `'t_'+this.__value__.valueOf()/1000`
end

#hour ⇒ Object

call-seq:

time.hour -> integer

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

t = Time.now   #=> Tue Sep 23 2008 22:10:22 GMT-0400 (EDT)
t.hour         #=> 22



6495
6496
6497
 
# File 'lib/source/ruby.rb', line 6495

def hour
  `this.__value__.getHours()`
end

#inspect ⇒ Object

call-seq:

time.inspect -> string
time.to_s    -> string

Returns a string representing time.

Time.now.inspect    #=> "Tue Sep 23 2008 22:10:22 GMT-0400 (EDT)"



6507
6508
6509
 
# File 'lib/source/ruby.rb', line 6507

def inspect
  `$q(''+this)`
end

#isdst ⇒ Object

FIX: Incomplete



6512
6513
 
# File 'lib/source/ruby.rb', line 6512

def isdst
end

#localtime ⇒ Object

FIX: Incomplete



6516
6517
 
# File 'lib/source/ruby.rb', line 6516

def localtime
end

#mday ⇒ Object

call-seq:

time.day  -> integer
time.mday -> integer

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

t = Time.now    #=> Tue Sep 23 2008 22:10:22 GMT-0400 (EDT)
t.mday          #=> 23



6528
6529
6530
 
# File 'lib/source/ruby.rb', line 6528

def mday
  `this.__value__.getDate()`
end

#min ⇒ Object

call-seq:

time.min -> integer

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

t = Time.now    #=> Tue Sep 23 2008 22:10:22 GMT-0400 (EDT)
t.min           #=> 10



6540
6541
6542
 
# File 'lib/source/ruby.rb', line 6540

def min
  `this.__value__.getMinutes()`
end

#mon ⇒ Object

call-seq:

time.mon   -> integer
time.month -> integer

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

t = Time.now    #=> Tue Sep 23 2008 22:10:22 GMT-0400 (EDT)
t.mon           #=> 9



6553
6554
6555
 
# File 'lib/source/ruby.rb', line 6553

def mon
  `this.__value__.getMonth()`
end

#month ⇒ Object

call-seq:

time.mon   -> integer
time.month -> integer

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

t = Time.now    #=> Tue Sep 23 2008 22:10:22 GMT-0400 (EDT)
t.month         #=> 9



6566
6567
6568
 
# File 'lib/source/ruby.rb', line 6566

def month
  `this.__value__.getMonth()`
end

#sec ⇒ Object

call-seq:

time.sec -> integer

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

t = Time.now    #=> Tue Sep 23 2008 22:10:22 GMT-0400 (EDT)
t.sec           #=> 22



6578
6579
6580
 
# File 'lib/source/ruby.rb', line 6578

def sec
  `this.__value__.getSeconds()`
end

#strftime ⇒ Object

FIX: Incomplete



6583
6584
 
# File 'lib/source/ruby.rb', line 6583

def strftime
end

#succ ⇒ Object

call-seq:

time.succ -> new_time

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



6591
6592
6593
6594
6595
 
# File 'lib/source/ruby.rb', line 6591

def succ
  `var t=c$Time.m$new()`
  `t.__value__=new(Date)(1000+this.__value__.valueOf())`
  return `t`
end

#to_a ⇒ Object

call-seq:

time.to_a -> array

Returns a ten-element array of values for time: [ sec, min, hour, day, month, year, wday, yday, isdst, zone ]<tt/>. The ten elements can be passed directly to <tt>Time::utc or Time::local to create a new Time.

t = Time.now    #=> Tue Sep 23 2008 22:10:22 GMT-0400 (EDT)
t.to_a          #=> [22, 10, 22, 23, 9, 2008, 2, 267, true, "EDT"]

FIX: Incomplete



6609
6610
6611
 
# File 'lib/source/ruby.rb', line 6609

def to_a
  []
end

#to_f ⇒ Object

call-seq:

time.to_f -> numeric

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

t = Time.now    #=> Tue Sep 23 2008 22:10:22 GMT-0400 (EDT)
t.to_f          #=> 1222222222.989



6622
6623
6624
 
# File 'lib/source/ruby.rb', line 6622

def to_f
  `this.__value__.valueOf()/1000`
end

#to_i ⇒ Object

call-seq:

time.to_i -> integer

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

t = Time.now    #=> Tue Sep 23 2008 22:10:22 GMT-0400 (EDT)
t.to_i          #=> 1222222222



6634
6635
6636
 
# File 'lib/source/ruby.rb', line 6634

def to_i
  `parseInt(this.__value__.valueOf()/1000)`
end

#to_s ⇒ Object

call-seq:

time.inspect -> string
time.to_s    -> string

Returns a string representing time.

Time.now.to_s   #=> "Tue Sep 23 2008 22:10:22 GMT-0400 (EDT)"



6646
6647
6648
 
# File 'lib/source/ruby.rb', line 6646

def to_s
  `$q(''+this.__value__)`
end

#tv_sec ⇒ Object

call-seq:

time.to_i -> integer

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

t = Time.now    #=> Tue Sep 23 2008 22:10:22 GMT-0400 (EDT)
t.tv_sec        #=> 1222222222



6658
6659
6660
 
# File 'lib/source/ruby.rb', line 6658

def tv_sec
  `parseInt(this.__value__.valueOf()/1000)`
end

#tv_usec ⇒ Object

call-seq:

time.tv_usec -> integer
time.usec    -> integer

Returns just the number of microseconds for time.

t = Time.now    #=> Tue Sep 23 2008 22:10:22 GMT-0400 (EDT)
t.to_f          #=> 1222222222.989
t.tv_usec       #=> 989000



6672
6673
6674
 
# File 'lib/source/ruby.rb', line 6672

def tv_usec
  `parseInt(this.__value__.valueOf()/1000)`
end

#usec ⇒ Object

call-seq:

time.tv_usec -> integer
time.usec    -> integer

Returns just the number of microseconds for time.

t = Time.now    #=> Tue Sep 23 2008 22:10:22 GMT-0400 (EDT)
t.to_f          #=> 1222222222.989
t.usec          #=> 989000



6686
6687
6688
6689
 
# File 'lib/source/ruby.rb', line 6686

def usec
  `var v = this.__value__.valueOf()`
  `(v*1000)-parseInt(v/1000)*1000000`
end

#utc ⇒ Object

FIX: Incomplete



6692
6693
 
# File 'lib/source/ruby.rb', line 6692

def utc
end

#utc? ⇒ Boolean

FIX: Incomplete

Returns:

  • (Boolean) 


6696
6697
 
# File 'lib/source/ruby.rb', line 6696

def utc?
end

#utc_offset ⇒ Object

call-seq:

time.gmt_offset -> integer
time.gmtoff     -> integer
time.utc_offset -> integer

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

t = Time.now    #=> Tue Sep 23 2008 22:10:22 GMT-0400 (EDT)
t.utc_offset    #=> -14400



6709
6710
6711
 
# File 'lib/source/ruby.rb', line 6709

def utc_offset
  `this.__value__.getTimezoneOffset() * -60`
end

#wday ⇒ Object

call-seq:

time.wday -> integer

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

t = Time.now    #=> Tue Sep 23 2008 22:10:22 GMT-0400 (EDT)
t.wday          #=> 2



6721
6722
6723
 
# File 'lib/source/ruby.rb', line 6721

def wday
  `this.__value__.getDay()`
end

#yday ⇒ Object

call-seq:

time.yday -> integer

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

t = Time.now    #=> Tue Sep 23 2008 22:10:22 GMT-0400 (EDT)
t.yday          #=> 267



6733
6734
6735
6736
 
# File 'lib/source/ruby.rb', line 6733

def yday
  `var d2=new Date(),d1=new Date(new Date(new Date().setFullYear(d2.getFullYear(),0,0)).setHours(0,0,0,0))`
  `parseInt((d2-d1)/1000/60/60/24)`
end

#year ⇒ Object

call-seq:

time.year -> integer

Returns the four-digit year for time.

t = Time.now    #=> Tue Sep 23 2008 22:10:22 GMT-0400 (EDT)
t.year          #=> 2008



6746
6747
6748
 
# File 'lib/source/ruby.rb', line 6746

def year
  `this.__value__.getFullYear()`
end

#zone ⇒ Object

FIX: Incomplete



6751
6752
 
# File 'lib/source/ruby.rb', line 6751

def zone
end