Determine if this schedule conflicts with another schedule
 @param [IceCube::Schedule] other_schedule - The schedule to compare to
 @param [Time] closing_time - the last time to consider
 @return [Boolean] whether or not the schedules conflict at all
344531
def conflicts_with?(other_schedule, closing_time = nil)
      closing_time = TimeUtil.ensure_time(closing_time)
      unless terminating? || other_schedule.terminating? || closing_time
        raise ArgumentError, "One or both schedules must be terminating to use #conflicts_with?"
      end
      # Pick the terminating schedule, and other schedule
      # No need to reverse if terminating? or there is a closing time
      terminating_schedule = self
      unless terminating? || closing_time
        terminating_schedule, other_schedule = other_schedule, terminating_schedule
      end
      # Go through each occurrence of the terminating schedule and determine
      # if the other occurs at that time
      #
      last_time = nil
      terminating_schedule.each_occurrence do |time|
        if closing_time && time > closing_time
          last_time = closing_time
          break
        end
        last_time = time
        return true if other_schedule.occurring_at?(time)
      end
      # Due to durations, we need to walk up to the end time, and verify in the
      # other direction
      if last_time
        last_time += terminating_schedule.duration
        other_schedule.each_occurrence do |time|
          break if time > last_time
          return true if terminating_schedule.occurring_at?(time)
        end
      end
      # No conflict, return false
      false
    end
1268586
function icaltime_compare(other) {
      var a = this.toUnixTime();
      var b = other.toUnixTime();

      if (a > b) return 1;
      if (b > a) return -1;
      return 0;
    }
198533
public final boolean overlaps(@NotNull final DayOpeningHours other) {
        Contract.requireArgNotNull("other", other);
        return hourRanges.overlaps(other.hourRanges);
    }
787917
def Intersect(self, other):
        
        if isinstance(other, Range):
            max_low = self.low if (self.low >= other.low) else other.low
            min_high = self.high if (self.high <= other.high) else other.high

            if max_low <= min_high:
                return True

        return False
950383
def can_pull(self, initial, scheduled):
        
        if not initial and self.config.is_valid_schedule():
            # if the config has a valid schedule, return True if this is a scheduled run
            return scheduled
        return True
1214114
def occurs_between?(begin_time, closing_time, options = {})
      enumerate_occurrences(begin_time, closing_time, options).next
      true
    rescue StopIteration
      false
    end
1328498
def equals(self, other):
        
        if self.is_(other):
            return True

        if not isinstance(other, ABCIndexClass):
            return False
        elif not isinstance(other, type(self)):
            try:
                other = type(self)(other)
            except Exception:
                return False

        if not is_dtype_equal(self.dtype, other.dtype):
            # have different timezone
            return False

        elif is_period_dtype(self):
            if not is_period_dtype(other):
                return False
            if self.freq != other.freq:
                return False

        return np.array_equal(self.asi8, other.asi8)
342014
public boolean schedulePolling() {
        if(isDisabled())    return false;
        SCMTrigger scmt = getTrigger(SCMTrigger.class);
        if(scmt==null)      return false;
        scmt.run();
        return true;
    }
719307
def min_time_next
      tn = DEVS::INFINITY
      if (obj = @scheduler.peek)
        tn = obj.time_next
      end
      tn
    end
522319
def overlapping(self, other):
        """"""
        return (
            other.start in self.ref_range) or (
            self.start in other.ref_range)
70282
def _HasId(self, schedule, entity_id):
    
    try:
      self._GetById(schedule, entity_id)
      has = True
    except KeyError:
      has = False
    return has
1270492
public boolean isIntersectingNE(Envelope2D other) {
		return ((xmin <= other.xmin) ? xmax >= other.xmin : other.xmax >= xmin)
				&& // check that x projections overlap
				((ymin <= other.ymin) ? ymax >= other.ymin : other.ymax >= ymin); // check
																					// that
																					// y
																					// projections
																					// overlap
	}
168663
def has_intersection(self, other):
        
        return bool(lib.SDL_HasIntersection(self._ptr, other._ptr))
659779
function icaltime_compare(other) {
      var a = this.toSeconds();
      var b = other.toSeconds();
      return (a > b) - (b > a);
    }
1148867
def intersection(other)
      raise(ISO8601::Errors::IntervalError, "The intervals are disjoint") \
        if disjoint?(other) && other.disjoint?(self)

      return self if subset?(other)
      return other if other.subset?(self)

      a, b = sort_pair(self, other)
      self.class.from_datetimes(b.first, a.last)
    end
134976
def independent_from(self, other):
        
        if self is other:
            return False
        return not self.orders_after(other) and not other.orders_after(self)
1082832
def update(time)
            @last_scheduled = @reactor.now

            parsed_time = Scheduler.parse_in(time, :quiet)
            if parsed_time.nil?
                # Parse at will throw an error if time is invalid
                parsed_time = Scheduler.parse_at(time) - @scheduler.time_diff
            else
                parsed_time += @last_scheduled
            end

            @next_scheduled = parsed_time
            @scheduler.reschedule(self)
        end