Class: TimeRange

Inherits:
Range
  • Object
show all
Defined in:
lib/time_range.rb

Overview

> 172798.0

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(rbegin, rend) ⇒ TimeRange

Returns a new instance of TimeRange.

Raises:

  • (WrongTimeRangeError) 


61
62
63
64
65
 
# File 'lib/time_range.rb', line 61

def initialize(rbegin, rend)
  raise WrongTimeRangeError, WRONG_ARG unless (rbegin.is_a?(Time) && rend.is_a?(Time))
  rbegin, rend = rend, rbegin if rbegin > rend
  orig_init(rbegin, rend)
end

Class Method Details

.for_date(date) ⇒ Object 



113
114
115
 
# File 'lib/time_range.rb', line 113

def self.for_date(date)
  TimeRange.new(date.to_time, (date + 1).to_time - 1)
end

.intersection(*tranges) ⇒ Object 



117
118
119
120
121
122
123
124
125
126
127
128
129
130
 
# File 'lib/time_range.rb', line 117

def self.intersection(*tranges)
  return tranges if tranges.is_a?(TimeRange)
  tranges = tranges.flatten.sort!{|a,b| a.begin <=> b.begin}
  return tranges.first if (tranges.count == 1)
  first, second = tranges[0], tranges[1]
  if(tranges.count == 2)
    return nil unless first.intersects?(second)
    tbegin = [first.begin, second.begin].max
    tend =   [first.end, second.end].min
    return TimeRange.new(tbegin, tend)
  elsif tranges.count > 2
    return intersection([intersection(first, second), tranges[2..-1] ].flatten) if first.intersects?(second)
  end
end

.sum_length(tranges) ⇒ Object 



149
150
151
152
153
154
155
 
# File 'lib/time_range.rb', line 149

def self.sum_length(tranges)
  result = 0.0
  tranges.each do |range|
    result += range.length
  end
  result
end

.union(*tranges) ⇒ Object 



132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
 
# File 'lib/time_range.rb', line 132

def self.union(*tranges)
  return tranges if tranges.is_a?(TimeRange) && tranges.begin != tranges.end
  tranges = tranges.flatten.sort{|a,b| a.begin <=> b.begin}.select{|trange| trange.begin != trange.end}
  return tranges.first if (tranges.count == 1)
  first, second = tranges[0], tranges[1]
  if(tranges.count == 2)
    return [first, second] unless first.intersects?(second)
    tbegin = [first.begin, second.begin].min
    tend =   [first.end, second.end].max
    return TimeRange.new(tbegin, tend)
  elsif tranges.count > 2
    return [ first, union(tranges[1..-1])].flatten unless first.intersects?(second)
    result = union([ union(first, second), tranges[2..-1]])
    return result.is_a?(Array) ? result.flatten : result
  end
end

Instance Method Details

#fully_include?(time_rage) ⇒ Boolean

Returns:

  • (Boolean) 


86
87
88
 
# File 'lib/time_range.rb', line 86

def fully_include?(time_rage)
  self.include?(time_rage.begin) && self.include?(time_rage.end)
end

#include?(time) ⇒ Boolean

Returns:

  • (Boolean) 


76
77
78
79
80
81
82
83
84
 
# File 'lib/time_range.rb', line 76

def include?(time)
  if time.is_a?(Time)
    self.begin <= time && self.end >= time
  elsif time.is_a?(Date)
    self.begin.to_date <= time && self.end.to_date >= time
  else
    raise WrongTimeRangeError, WRONG_ARG 
  end
end

#intersection(range) ⇒ Object 



72
73
74
 
# File 'lib/time_range.rb', line 72

def intersection(range)
  TimeRange.intersection(self, range)
end

#intersects?(range) ⇒ Boolean

Returns:

  • (Boolean) 


67
68
69
70
 
# File 'lib/time_range.rb', line 67

def intersects?(range)
  (self.begin >= range.begin &&  self.begin <= range.end) || (self.end >= range.begin &&  self.end <= range.end) ||
    (range.begin >= self.begin &&  range.begin  <= self.end) || (range.end >= self.begin &&  range.end <= self.end)
end

#length ⇒ Object 



90
91
92
 
# File 'lib/time_range.rb', line 90

def length
  self.end - self.begin
end

#orig_init ⇒ Object 



60
 
# File 'lib/time_range.rb', line 60

alias_method :orig_init, :initialize

#subtract(*ranges) ⇒ Object 



94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
 
# File 'lib/time_range.rb', line 94

def subtract(*ranges)
  ranges = ranges.flatten.sort{|a, b| a.begin <=> b.begin}
  return self if ranges.empty?
  result = []
  ranges.each do |range|
    subtraction = self.intersection(TimeRange.new(self.begin, range.begin) ) if range.eql?(ranges.first)
    result << subtraction if subtraction

    if range.eql?(ranges.last)
      subtraction = self.intersection(TimeRange.new(range.end, self.end ) )
      result << subtraction if subtraction
    else
      subtraction = self.intersection(TimeRange.new(range.end, ranges[ranges.index(range) + 1].begin ))
      result << subtraction if subtraction
    end
  end
  TimeRange.union(result)
end