Class: Time

Inherits:
Object show all
Defined in:
lib/cosmos/core_ext/time.rb,
lib/cosmos/io/json_rpc.rb

Overview

This file contains the COSMOS specific additions to the Ruby Time class

Time is expressed in many different ways and with many different epochs. This file supports the following formats:

Julian Date (jd or julian)
Modified Julian Date (mjd)
yds (year, day, and seconds of day)
mdy (year, month, day, hour, minute, second, us of second)
ccsds (day, ms, us from Jan 1, 1958 midnight)
time (a ruby time object with unix epoch Jan 1, 1970 midnight)
sec (seconds since an arbitrary epoch)

Constant Summary collapse

JULIAN_DAYS_PER_CENTURY =

There are 365.25 days per year because of leap years. In the Gregorian calendar some centuries have 36524 days because of the divide by 400 rule while others have 36525 days. The Julian century is DEFINED as having 36525 days.

36525.0
JULIAN_DATE_OF_JULIAN_EPOCH =

-4713/01/01 Noon

0.0
JULIAN_DATE_OF_MJD_EPOCH =

1858/11/17 Midnight

2400000.5
JULIAN_DATE_OF_GPS_EPOCH =

1980/01/06 Midnight

2444244.5
JULIAN_DATE_OF_J2000_EPOCH =

2000/01/01 Noon

2451545.0
JULIAN_DATE_OF_CCSDS_EPOCH =

1958/01/01 Midnight

2436204.5
DATE_TIME_MJD_EPOCH = 
DateTime.new(1858, 11, 17)
USEC_PER_MSEC = 
1000
MSEC_PER_SECOND = 
1000
SEC_PER_MINUTE = 
60
MINUTES_PER_HOUR = 
60
HOURS_PER_DAY = 
24
NSEC_PER_SECOND = 
1_000_000_000
USEC_PER_SECOND = 
USEC_PER_MSEC * MSEC_PER_SECOND
MSEC_PER_MINUTE = 
60 * MSEC_PER_SECOND
MSEC_PER_HOUR = 
60 * MSEC_PER_MINUTE
MSEC_PER_DAY = 
HOURS_PER_DAY * MSEC_PER_HOUR
SEC_PER_HOUR = 
SEC_PER_MINUTE * MINUTES_PER_HOUR
SEC_PER_DAY = 
HOURS_PER_DAY * SEC_PER_HOUR
USEC_PER_DAY = 
USEC_PER_SECOND * SEC_PER_DAY
MINUTES_PER_DAY = 
MINUTES_PER_HOUR * HOURS_PER_DAY
USEC_PER_MSEC_FLOAT = 
USEC_PER_MSEC.to_f
MSEC_PER_SECOND_FLOAT = 
MSEC_PER_SECOND.to_f
SEC_PER_MINUTE_FLOAT = 
SEC_PER_MINUTE.to_f
MINUTES_PER_HOUR_FLOAT = 
MINUTES_PER_HOUR.to_f
HOURS_PER_DAY_FLOAT = 
HOURS_PER_DAY.to_f
USEC_PER_SECOND_FLOAT = 
USEC_PER_SECOND.to_f
MSEC_PER_MINUTE_FLOAT = 
MSEC_PER_MINUTE.to_f
MSEC_PER_HOUR_FLOAT = 
MSEC_PER_HOUR.to_f
MSEC_PER_DAY_FLOAT = 
MSEC_PER_DAY.to_f
SEC_PER_HOUR_FLOAT = 
SEC_PER_HOUR.to_f
SEC_PER_DAY_FLOAT = 
SEC_PER_DAY.to_f
USEC_PER_DAY_FLOAT = 
USEC_PER_DAY.to_f
MINUTES_PER_DAY_FLOAT = 
MINUTES_PER_DAY.to_f
LeapYearMonthDays =

The number of days in each month during a leap year

[31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
CommonYearMonthDays =

The number of days in each month during a year (not a leap year)

[31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
@@use_utc =

Class variable that allows us to globally select whether to use UTC or local time.

false

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.ccsds2julian(day, ms, us) ⇒ Float

Returns The CCSDS date converted to a julian date.

Parameters:

  • day (Float) —

    CCSDS day

  • ms (Integer) —

    CCSDS milliseconds

  • us (Integer) —

    CCSDS microseconds

Returns:

  • (Float) —

    The CCSDS date converted to a julian date



382
383
384
 
# File 'lib/cosmos/core_ext/time.rb', line 382

def self.ccsds2julian(day, ms, us)
  (day + JULIAN_DATE_OF_CCSDS_EPOCH) + ((ms.to_f + (us / 1000.0)) / MSEC_PER_DAY_FLOAT)
end

.ccsds2mdy(day, ms, us) ⇒ Array<Year, Month, Day, Hour, Minute, Second, Microsecond>

Convert a CCSDS Date to mdy format Note that an array is returned rather than a Time object because Time objects cannot represent all possible CCSDS dates

Parameters:

  • day (Float) —

    CCSDS day

  • ms (Integer) —

    CCSDS milliseconds

  • us (Integer) —

    CCSDS microseconds

Returns:

  • (Array<Year, Month, Day, Hour, Minute, Second, Microsecond>) —

    CCSDS date converted to an array of values



345
346
347
348
349
350
351
352
353
354
355
356
 
# File 'lib/cosmos/core_ext/time.rb', line 345

def self.ccsds2mdy(day, ms, us)
  jdate = day + JULIAN_DATE_OF_CCSDS_EPOCH
  year, month, day, hour, minute, second, _ = julian2mdy(jdate)
  hour = (ms / MSEC_PER_HOUR).to_i
  temp = ms - (hour * MSEC_PER_HOUR)
  minute = (temp / MSEC_PER_MINUTE).to_i
  temp -= minute * MSEC_PER_MINUTE
  second = temp / MSEC_PER_SECOND
  temp -= second * MSEC_PER_SECOND
  us = us + (temp * USEC_PER_MSEC)
  return [year, month, day, hour, minute, second, us]
end

.ccsds2sec(day, ms, us, sec_epoch_jd = JULIAN_DATE_OF_CCSDS_EPOCH) ⇒ Float

Returns The number of seconds from the given epoch to the given CCSDS day, milliseconds, and microseconds.

Parameters:

  • day (Float) —

    CCSDS day

  • ms (Integer) —

    CCSDS milliseconds

  • us (Integer) —

    CCSDS microseconds

  • sec_epoch_jd (Float) (defaults to: JULIAN_DATE_OF_CCSDS_EPOCH) —

    Epoch to convert seconds from as a julian date

Returns:

  • (Float) —

    The number of seconds from the given epoch to the given CCSDS day, milliseconds, and microseconds.



406
407
408
 
# File 'lib/cosmos/core_ext/time.rb', line 406

def self.ccsds2sec(day, ms, us, sec_epoch_jd = JULIAN_DATE_OF_CCSDS_EPOCH)
  (self.ccsds2julian(day, ms, us) - sec_epoch_jd) * SEC_PER_DAY_FLOAT
end

.days_from_j2000(time) ⇒ Float

Returns Number of julian days since Jan 1, 2000 at noon.

Parameters:

Returns:

  • (Float) —

    Number of julian days since Jan 1, 2000 at noon



271
272
273
 
# File 'lib/cosmos/core_ext/time.rb', line 271

def self.days_from_j2000(time)
  time.to_julian - JULIAN_DATE_OF_J2000_EPOCH
end

.format_seconds(seconds) ⇒ String

Returns Seconds formatted as a human readable string with days, hours, minutes, and seconds.

Parameters:

  • seconds (Numeric) —

    Total number of seconds

Returns:

  • (String) —

    Seconds formatted as a human readable string with days, hours, minutes, and seconds.



110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
 
# File 'lib/cosmos/core_ext/time.rb', line 110

def self.format_seconds(seconds)
  result = ""
  mm, ss = seconds.divmod(60)
  hh, mm = mm.divmod(60)
  dd, hh = hh.divmod(24)
  if dd != 0
    if dd == 1
      result << "%d day, " % dd
    else
      result << "%d days, " % dd
    end
  end
  if hh != 0
    if hh == 1
      result << "%d hour, " % hh
    else
      result << "%d hours, " % hh
    end
  end
  if mm != 0
    if mm == 1
      result << "%d minute, " % mm
    else
      result << "%d minutes, " % mm
    end
  end
  if ss > 0
    result << "%.2f seconds" % ss
  else
    result = result[0..-3]
  end
  result
end

.from_nsec_from_epoch(nsec_from_epoch) ⇒ Object 



501
502
503
504
505
506
507
 
# File 'lib/cosmos/core_ext/time.rb', line 501

def self.from_nsec_from_epoch(nsec_from_epoch)
  return nil if nsec_from_epoch.nil?

  seconds = nsec_from_epoch / NSEC_PER_SECOND
  nanoseconds = nsec_from_epoch % NSEC_PER_SECOND
  Time.at(seconds, nanoseconds, :nsec)
end

.init_epoch_delta(epoch) ⇒ Float

Ruby time objects cannot handle times before the Unix Epoch. Calculate a delta (in seconds) to be used when real epochs are before the Unix Epoch. Each received timestamp will be adjusted by this delta so a ruby time object can be used to parse the time.

Parameters:

  • epoch (String) —

    epoch is a string in the following format: "yyyy/mm/dd hh:mm:ss"

Returns:

  • (Float) —

    unix_epohc_delta



471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
 
# File 'lib/cosmos/core_ext/time.rb', line 471

def self.init_epoch_delta(epoch)
  # UnixEpoch - Jan 1, 1970 00:00:00
  unix_epoch = DateTime.new(1970, 1, 1, 0, 0, 0)

  split_epoch = epoch.split
  epoch_date = split_epoch[0].split("/")
  epoch_time = split_epoch[1].split(":")

  if epoch_date[0].to_i < 1970 then
    # Calculate delta between epoch and unix epoch
    real_epoch = DateTime.new(epoch_date[0].to_i, epoch_date[1].to_i, epoch_date[2].to_i, epoch_time[0].to_i, epoch_time[1].to_i, epoch_time[2].to_i)
    day_delta = (unix_epoch - real_epoch).to_i
    unix_epoch_delta = day_delta * 86400
    if real_epoch.hour != 0 or real_epoch.min != 0 or real_epoch.sec != 0
      hour_delta = 23 - real_epoch.hour
      min_delta = 59 - real_epoch.min
      sec_delta = 60 - real_epoch.sec
      unix_epoch_delta += ((hour_delta * 3600) + (min_delta * 60) + sec_delta)
    end
  else
    unix_epoch_delta = 0
  end

  unix_epoch_delta
end

.julian2ccsds(jdate) ⇒ Array<day, ms, us>

Returns Julian converted to CCSDS.

Parameters:

  • jdate (Float) —

    julian date

Returns:

  • (Array<day, ms, us>) —

    Julian converted to CCSDS



388
389
390
391
392
393
394
395
396
397
398
 
# File 'lib/cosmos/core_ext/time.rb', line 388

def self.julian2ccsds(jdate)
  day = jdate - JULIAN_DATE_OF_CCSDS_EPOCH
  fraction = day % 1.0
  day = day.to_i
  ms  = fraction * MSEC_PER_DAY_FLOAT
  fraction = ms % 1.0
  ms = ms.to_i
  us = fraction * USEC_PER_MSEC
  us = us.to_i
  return [day, ms, us]
end

.julian2mdy(jdate) ⇒ Array<Year, Month, Day, Hour, Minute, Second, Microsecond>

Convert a Julian Date to mdy format Note that an array is returned rather than a Time object because Time objects cannot represent all possible Julian dates

Parameters:

  • jdate (Float) —

    Julian date

Returns:

  • (Array<Year, Month, Day, Hour, Minute, Second, Microsecond>) —

    Julian date converted to an array of values



287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
 
# File 'lib/cosmos/core_ext/time.rb', line 287

def self.julian2mdy(jdate)
  z = (jdate + 0.5).to_i
  w = ((z - 1867216.25) / 36524.25).to_i
  x = w / 4
  a = z + 1 + w - x
  b = a + 1524
  c = ((b - 122.1) / 365.25).to_i
  d = (365.25 * c).to_i
  e = ((b - d) / 30.6001).to_i
  f = (30.6001 * e).to_i

  day = b - d - f
  if e > 13
    month = e - 13
  else
    month = e - 1
  end
  if month > 2
    year = c - 4716
  else
    year = c - 4715
  end

  fraction = jdate - jdate.to_i

  if fraction >= 0.5
    hour = (fraction - 0.5) * 24.0
  else
    hour = (fraction * 24.0) + 12.0
  end

  fraction = hour - hour.to_i
  hour = hour.to_i

  minute = fraction * 60.0

  fraction = minute - minute.to_i
  minute = minute.to_i

  second = fraction * 60.0

  fraction = second - second.to_i
  second = second.to_i

  us = fraction * 1000000.0
  us = us.to_i

  return [year, month, day, hour, minute, second, us]
end

.julian_centuries_since_j2000(time) ⇒ Float

Returns Number of julian centuries since Jan 1, 2000 at noon.

Parameters:

Returns:

  • (Float) —

    Number of julian centuries since Jan 1, 2000 at noon



277
278
279
 
# File 'lib/cosmos/core_ext/time.rb', line 277

def self.julian_centuries_since_j2000(time)
  self.days_from_j2000(time) / JULIAN_DAYS_PER_CENTURY
end

.leap_year?(year) ⇒ Boolean

Returns Whether the year is a leap year.

Parameters:

  • year (Integer)

Returns:

  • (Boolean) —

    Whether the year is a leap year



210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
 
# File 'lib/cosmos/core_ext/time.rb', line 210

def self.leap_year?(year)
  return_value = false

  if (year % 4) == 0
    return_value = true

    if (year % 100) == 0
      return_value = false

      if (year % 400) == 0
        return_value = true
      end
    end
  end

  return return_value
end

.mdy2ccsds(year, month, day, hour, minute, second, us) ⇒ Array<day, ms, us>

Convert from mdy format to CCSDS Date Note that an array is used rather than a Time object because Time objects cannot represent all possible CCSDS dates

Parameters:

  • year (Integer)
  • month (Integer)
  • day (Integer)
  • hour (Integer)
  • minute (Integer)
  • second (Integer)
  • us (Integer)

Returns:

  • (Array<day, ms, us>) —

    MDY converted to CCSDS



370
371
372
373
374
375
376
 
# File 'lib/cosmos/core_ext/time.rb', line 370

def self.mdy2ccsds(year, month, day, hour, minute, second, us)
  ms  = (hour * MSEC_PER_HOUR) + (minute * MSEC_PER_MINUTE) + (second * MSEC_PER_SECOND) + (us / USEC_PER_MSEC)
  us  = us % USEC_PER_MSEC
  jd  = Time.mdy2julian(year, month, day, 0, 0, 0, 0)
  day = (jd - JULIAN_DATE_OF_CCSDS_EPOCH).round
  return [day, ms, us]
end

.mdy2julian(year, month = 1, day = 1, hour = 0, minute = 0, second = 0, us = 0) ⇒ Float

Convert the given year, month, day, hour, minute, second, and us into a Julian date. Julian dates are the number of days (plus fractional days) since Jan 1, 4713 BC at noon.

Parameters:

  • year (Integer)
  • month (Integer) (defaults to: 1)
  • day (Integer) (defaults to: 1)
  • hour (Integer) (defaults to: 0)
  • minute (Integer) (defaults to: 0)
  • second (Integer) (defaults to: 0)
  • us (Integer) (defaults to: 0)

Returns:

  • (Float) —

    The given time as a Julian date



166
167
168
169
170
 
# File 'lib/cosmos/core_ext/time.rb', line 166

def self.mdy2julian(year, month = 1, day = 1, hour = 0, minute = 0, second = 0, us = 0)
  # Note DateTime does not support fractions of seconds
  date_time = DateTime.new(year, month, day, hour, minute, second)
  (date_time - DATE_TIME_MJD_EPOCH).to_f + JULIAN_DATE_OF_MJD_EPOCH + us / USEC_PER_DAY_FLOAT
end

.mdy2mjd(year, month = 1, day = 1, hour = 0, minute = 0, second = 0, us = 0) ⇒ Time

Convert the given year, month, day, hour, minute, second, and us into a Modified Julian date. Modified Julian dates have an Epoch of Nov 17, 1858 at midnight.

Parameters:

  • year (Integer)
  • month (Integer) (defaults to: 1)
  • day (Integer) (defaults to: 1)
  • hour (Integer) (defaults to: 0)
  • minute (Integer) (defaults to: 0)
  • second (Integer) (defaults to: 0)
  • us (Integer) (defaults to: 0)

Returns:

  • (Time) —

    The given time as a Julian date



190
191
192
 
# File 'lib/cosmos/core_ext/time.rb', line 190

def self.mdy2mjd(year, month = 1, day = 1, hour = 0, minute = 0, second = 0, us = 0)
  return Time.mdy2julian(year, month, day, hour, minute, second, us) - JULIAN_DATE_OF_MJD_EPOCH
end

.sec2ccsds(sec, sec_epoch_jd = JULIAN_DATE_OF_CCSDS_EPOCH) ⇒ Array<day, ms, us>

Returns CCSDS date.

Parameters:

  • sec (Float) —

    Number of seconds to convert

  • sec_epoch_jd (Float) (defaults to: JULIAN_DATE_OF_CCSDS_EPOCH) —

    Epoch of seconds value

Returns:

  • (Array<day, ms, us>) —

    CCSDS date



413
414
415
 
# File 'lib/cosmos/core_ext/time.rb', line 413

def self.sec2ccsds(sec, sec_epoch_jd = JULIAN_DATE_OF_CCSDS_EPOCH)
  self.julian2ccsds((sec / SEC_PER_DAY_FLOAT) + sec_epoch_jd)
end

.total_seconds(hour, minute, second, us) ⇒ Float

Returns The number of seconds represented by the hours, minutes, seconds and microseconds.

Parameters:

  • hour (Integer)
  • minute (Integer)
  • second (Integer)
  • us (Integer)

Returns:

  • (Float) —

    The number of seconds represented by the hours, minutes, seconds and microseconds



239
240
241
 
# File 'lib/cosmos/core_ext/time.rb', line 239

def self.total_seconds(hour, minute, second, us)
  (hour * SEC_PER_HOUR_FLOAT) + (minute * SEC_PER_MINUTE_FLOAT) + second + (us / USEC_PER_SECOND_FLOAT)
end

.use_local ⇒ Object

Set up the Time class so that a call to the sys method will set the Time object being operated upon to be a local time.



93
94
95
 
# File 'lib/cosmos/core_ext/time.rb', line 93

def self.use_local
  @@use_utc = false
end

.use_utc ⇒ Object

Set up the Time class so that a call to the sys method will set the Time object being operated upon to be a UTC time.



87
88
89
 
# File 'lib/cosmos/core_ext/time.rb', line 87

def self.use_utc
  @@use_utc = true
end

.yds(year, day_of_year, sec_of_day) ⇒ Object

Create a new time object given year, day of year (1-366), and seconds of day

Parameters:

  • year (Integer)
  • day_of_year (Integer) —

    (1-366)

  • sec_of_day (Integer) 


204
205
206
 
# File 'lib/cosmos/core_ext/time.rb', line 204

def self.yds(year, day_of_year, sec_of_day)
  return Time.utc(*yds2mdy(year, day_of_year, sec_of_day))
end

.yds2julian(year, day, sec) ⇒ Float

Returns Year, day, seconds converted to the Julian date.

Parameters:

  • year (Integer) —

    Year

  • day (Integer) —

    Day of the year

  • sec (Integer) —

    Seconds in the day

Returns:

  • (Float) —

    Year, day, seconds converted to the Julian date



461
462
463
464
 
# File 'lib/cosmos/core_ext/time.rb', line 461

def self.yds2julian(year, day, sec)
  year, month, day, hour, min, seconds, usec = self.yds2mdy(year, day, sec)
  Time.mdy2julian(year, month, day, hour, min, seconds, usec)
end

.yds2mdy(year, day, sec) ⇒ Array

Returns [year, month, day, hour, minute, second, usec].

Parameters:

  • year (Integer) —

    Year

  • day (Integer) —

    Day of the year

  • sec (Float) —

    Seconds in the day

Returns:

  • (Array) —
    year, month, day, hour, minute, second, usec


421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
 
# File 'lib/cosmos/core_ext/time.rb', line 421

def self.yds2mdy(year, day, sec)
  # Convert day of year (1-366) to day of month (1-31)
  if self.leap_year?(year)
    array = Time::LeapYearMonthDays
  else
    array = Time::CommonYearMonthDays
  end

  month = 1
  array.each do |days|
    if (day - days) >= 1
      day   -= days
      month += 1
    else
      break
    end
  end

  # Calculate hour of day (0-23)
  hour = (sec / SEC_PER_HOUR).to_i
  sec -= (hour * SEC_PER_HOUR).to_f

  # Calculate minute of hour (0-59)
  min  = (sec / SEC_PER_MINUTE).to_i
  sec -= (min * SEC_PER_MINUTE).to_f

  # Calculate second of minute (0-60)
  seconds = sec.to_i
  sec -= seconds.to_f

  # Calculate useconds of second (0-999999)
  usec = (sec * 1000000.0).to_i

  return [year, month, day, hour, min, seconds, usec]
end

Instance Method Details

#as_json(options = nil) ⇒ Object

:nodoc:



116
117
118
 
# File 'lib/cosmos/io/json_rpc.rb', line 116

def as_json(options = nil) #:nodoc:
  to_json(options).remove_quotes
end

#formatted(include_year = true, fractional_digits = 3, include_utc_offset = false) ⇒ String

Returns Date formatted as YYYY/MM/DD HH:MM:SS.US UTC_OFFSET.

Returns:

  • (String) —

    Date formatted as YYYY/MM/DD HH:MM:SS.US UTC_OFFSET



249
250
251
252
253
254
255
256
257
258
259
260
261
262
 
# File 'lib/cosmos/core_ext/time.rb', line 249

def formatted(include_year = true, fractional_digits = 3, include_utc_offset = false)
  str =  ""
  str << "%Y/%m/%d " if include_year
  str << "%H:%M:%S"
  str << ".%#{fractional_digits}N" if fractional_digits > 0
  if include_utc_offset
    if self.utc?
      str << " UTC"
    else
      str << " %z"
    end
  end
  self.strftime(str)
end

#leap_year? ⇒ Boolean

Returns Whether the year is a leap year.

Returns:

  • (Boolean) —

    Whether the year is a leap year



229
230
231
 
# File 'lib/cosmos/core_ext/time.rb', line 229

def leap_year?
  Time.leap_year?(self.year)
end

#seconds_of_day ⇒ Float

Returns The number of seconds in the day (0-86399.99).

Returns:

  • (Float) —

    The number of seconds in the day (0-86399.99)



244
245
246
 
# File 'lib/cosmos/core_ext/time.rb', line 244

def seconds_of_day
  Time.total_seconds(self.hour, self.min, self.sec, self.usec)
end

#sys ⇒ Object

Set the Time object to be either a UTC or local time depending on the use_utc flag.



99
100
101
102
103
104
105
 
# File 'lib/cosmos/core_ext/time.rb', line 99

def sys
  if @@use_utc
    self.utc
  else
    self.localtime
  end
end

#to_julian ⇒ Float Also known as: to_jd

Returns The Time converted to a julian date.

Returns:

  • (Float) —

    The Time converted to a julian date



173
174
175
 
# File 'lib/cosmos/core_ext/time.rb', line 173

def to_julian
  return Time.mdy2julian(self.year, self.month, self.day, self.hour, self.min, self.sec, self.usec)
end

#to_mjd ⇒ Object

Convert a time object to the modified julian date



195
196
197
 
# File 'lib/cosmos/core_ext/time.rb', line 195

def to_mjd
  return Time.mdy2mjd(self.year, self.month, self.day, self.hour, self.min, self.sec, self.usec)
end

#to_nsec_from_epoch ⇒ Object 



497
498
499
 
# File 'lib/cosmos/core_ext/time.rb', line 497

def to_nsec_from_epoch
  (self.tv_sec * NSEC_PER_SECOND) + self.tv_nsec
end

#to_timestamp ⇒ String

Returns Date formatted as YYYYMMDDHHmmSSNNNNNNNNN.

Returns:

  • (String) —

    Date formatted as YYYYMMDDHHmmSSNNNNNNNNN



265
266
267
 
# File 'lib/cosmos/core_ext/time.rb', line 265

def to_timestamp
  self.strftime("%Y%m%d%H%M%S%N")
end