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



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

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)



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

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



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

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)



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

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)



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

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



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

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



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

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

#dst? ⇒ Boolean

FIX: Incomplete

Returns:

  • (Boolean) 


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

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) 


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

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

#getgm ⇒ Object

FIX: Incomplete



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

def getgm
end

#getlocal ⇒ Object

FIX: Incomplete



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

def getlocal
end

#getutc ⇒ Object

FIX: Incomplete



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

def getutc
end

#gmt? ⇒ Boolean

FIX: Incomplete

Returns:

  • (Boolean) 


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

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



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

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

#gmtime ⇒ Object

FIX: Incomplete



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

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



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

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

#hash ⇒ Object

:nodoc:



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

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



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

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



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

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

#isdst ⇒ Object

FIX: Incomplete



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

def isdst
end

#localtime ⇒ Object

FIX: Incomplete



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

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



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

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



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

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



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

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



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

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



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

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

#strftime ⇒ Object

FIX: Incomplete



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

def strftime
end

#succ ⇒ Object

call-seq:

time.succ -> new_time

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



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

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



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

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



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

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



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

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



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

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



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

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



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

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



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

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

#utc ⇒ Object

FIX: Incomplete



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

def utc
end

#utc? ⇒ Boolean

FIX: Incomplete

Returns:

  • (Boolean) 


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

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



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

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



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

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



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

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



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

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

#zone ⇒ Object

FIX: Incomplete



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

def zone
end