openHAB

Class: OpenHAB::Core::Types::DateTimeType

Inherits:
Object
  • Object
show all
Includes:
Command, State
Defined in:
lib/openhab/core/types/date_time_type.rb

Overview

DateTimeType uses a ZonedDateTime internally.

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Type

#==

Constructor Details

#initialize(value = nil) ⇒ DateTimeType

Create a new instance of DateTimeType

Parameters:



82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
 
# File 'lib/openhab/core/types/date_time_type.rb', line 82

def initialize(value = nil)
  if value.respond_to?(:to_zoned_date_time)
    super(value.to_zoned_date_time)
    return
  elsif value.respond_to?(:to_time)
    super(value.to_time.to_zoned_date_time)
    return
  elsif value.respond_to?(:to_str)
    # strings respond_do?(:to_d), but we want to avoid that conversion
    super(value.to_str)
    return
  elsif value.respond_to?(:to_d)
    super(Time.at(value.to_d).to_zoned_date_time)
    return
  end

  super
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(method, *args, &block) ⇒ Object

Forward missing methods to the ZonedDateTime object or a ruby Time object representing the same instant



208
209
210
211
212
213
 
# File 'lib/openhab/core/types/date_time_type.rb', line 208

def method_missing(method, *args, &block)
  return zoned_date_time.send(method, *args, &block) if zoned_date_time.respond_to?(method)
  return to_time.send(method, *args, &block) if ::Time.instance_methods.include?(method.to_sym)

  super
end

Class Method Details

.parse(time_string) ⇒ DateTimeType

Parses a String representing a time into a OpenHAB::Core::Types::DateTimeType. First tries to parse it using Java's parser, then falls back to the Ruby Time.parse.

Parameters:

  • time_string (String)

Returns:



43
44
45
46
47
48
49
50
51
52
53
 
# File 'lib/openhab/core/types/date_time_type.rb', line 43

def parse(time_string)
  time_string = "#{time_string}Z" if TIME_ONLY_REGEX.match?(time_string)
  DateTimeType.new(time_string)
rescue java.lang.StringIndexOutOfBoundsException, java.lang.IllegalArgumentException => e
  # Try Ruby's Time.parse if DateTimeType parser fails
  begin
    DateTimeType.new(::Time.parse(time_string).to_zoned_date_time)
  rescue ArgumentError
    raise ArgumentError, e.message
  end
end

Instance Method Details

#+(other) ⇒ DateTimeType

Add other to self

Parameters:

Returns:



220
221
222
223
224
225
226
227
228
229
230
 
# File 'lib/openhab/core/types/date_time_type.rb', line 220

def +(other)
  if other.is_a?(Duration)
    DateTimeType.new(zoned_date_time.plus(other))
  elsif other.respond_to?(:to_d)
    DateTimeType.new(zoned_date_time.plus_nanos((other.to_d * 1_000_000_000).to_i))
  elsif other.respond_to?(:coerce) && (lhs, rhs = other.coerce(to_d))
    lhs + rhs
  else
    raise TypeError, "\#{other.class} can't be coerced into \#{self.class}"
  end
end

#-(other) ⇒ DateTimeType, Duration

Subtract other from self

if other is a Duration-like object, the result is a new OpenHAB::Core::Types::DateTimeType of duration seconds earlier in time.

if other is a DateTime-like object, the result is a Duration representing how long between the two instants in time.

Parameters:

Returns:



243
244
245
246
247
248
249
250
251
252
253
254
255
 
# File 'lib/openhab/core/types/date_time_type.rb', line 243

def -(other)
  if other.is_a?(Duration)
    DateTimeType.new(zoned_date_time.minus(other))
  elsif other.respond_to?(:to_time)
    to_time - other.to_time
  elsif other.respond_to?(:to_d)
    DateTimeType.new(zoned_date_time.minus_nanos((other.to_d * 1_000_000_000).to_i))
  elsif other.respond_to?(:coerce) && (lhs, rhs = other.coerce(to_d))
    lhs - rhs
  else
    raise TypeError, "\#{other.class} can't be coerced into \#{self.class}"
  end
end

#<=>(other) ⇒ Integer?

Comparison

Parameters:

  • other (Object) —

    object to compare to

Returns:

  • (Integer, nil) —

    -1, 0, +1 depending on whether other is less than, equal to, or greater than self

    nil is returned if the two values are incomparable.



122
123
124
125
126
127
128
129
130
131
132
133
 
# File 'lib/openhab/core/types/date_time_type.rb', line 122

def <=>(other)
  logger.trace("(#{self.class}) #{self} <=> #{other} (#{other.class})")
  if other.is_a?(self.class)
    zoned_date_time <=> other.zoned_date_time
  elsif other.respond_to?(:to_time)
    to_time <=> other.to_time
  elsif other.respond_to?(:coerce)
    return nil unless (lhs, rhs = other.coerce(self))

    lhs <=> rhs
  end
end

#coerce(other) ⇒ [DateTimeType, DateTimeType]?

Type Coercion

Coerce object to a DateTimeType

Parameters:

  • other (Time) —

    object to coerce to a DateTimeType

Returns:



144
145
146
147
148
149
 
# File 'lib/openhab/core/types/date_time_type.rb', line 144

def coerce(other)
  logger.trace("Coercing #{self} as a request from #{other.class}")
  return [other, zoned_date_time] if other.respond_to?(:to_zoned_date_time)

  [DateTimeType.new(other), self] if other.respond_to?(:to_time)
end

#eql?(other) ⇒ true, false

Check equality without type conversion

Returns:

  • (true, false) —

    if the same value is represented, without type conversion



106
107
108
109
110
 
# File 'lib/openhab/core/types/date_time_type.rb', line 106

def eql?(other)
  return false unless other.instance_of?(self.class)

  zoned_date_time.compare_to(other.zoned_date_time).zero?
end

#to_f ⇒ Float

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

Returns:

  • (Float) —

    Number of seconds since the Epoch, with nanosecond presicion



156
157
158
 
# File 'lib/openhab/core/types/date_time_type.rb', line 156

def to_f
  zoned_date_time.to_epoch_second + (zoned_date_time.nano / 1_000_000_000)
end

#to_zoned_date_time(context = nil) ⇒ ZonedTimeTime

Parameters:

  • context (ZonedDateTime, nil) (defaults to: nil) —

    A ZonedDateTime used to fill in missing fields during conversion. Not used in this class.

Returns:

  • (ZonedTimeTime) 


60
61
62
 
# File 'lib/openhab/core/types/date_time_type.rb', line 60

def to_zoned_date_time(context = nil) # rubocop:disable Lint/UnusedMethodArgument
  zoned_date_time
end

#utc? ⇒ true, false

Returns true if time represents a time in UTC (GMT)

Returns:

  • (true, false) —

    true if utc_offset == 0, false otherwise



174
175
176
 
# File 'lib/openhab/core/types/date_time_type.rb', line 174

def utc?
  utc_offset.zero?
end

#utc_offset ⇒ Integer

The offset in seconds from UTC

Returns:

  • (Integer) —

    The offset from UTC, in seconds



165
166
167
 
# File 'lib/openhab/core/types/date_time_type.rb', line 165

def utc_offset
  zoned_date_time.offset.total_seconds
end

#wday ⇒ Integer

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

Returns:



183
184
185
 
# File 'lib/openhab/core/types/date_time_type.rb', line 183

def wday
  zoned_date_time.day_of_week.value % 7
end

#zone ⇒ String

The timezone

Returns:

  • (String) —

    The timezone in [+-]hh:mm(:ss) format (Z for UTC)



192
193
194
 
# File 'lib/openhab/core/types/date_time_type.rb', line 192

def zone
  zoned_date_time.zone.id
end