Test if an interval is after another.
@param that interval
@return true if that interval (upper endpoint) is before this (lower
endpoint)
@see #before(org.nmdp.ngs.fca.Interval)
345379
public boolean after(final Interval<C> that) {
        if(this.hasNone() || that.hasNone()) {
            return false;
        }
        return that.before(this);
    }
633064
public boolean intersectsWith(Range other) {
        return !other.isEmpty() && !this.isEmpty() &&
                (this.contains(other.lower) || other.contains(this.lower)
                        || (other.upper > upper && other.lower < lower));
    }
123021
def within(self, other: "Interval", inclusive: bool = True) -> bool:
        
        if not other:
            return False
        if inclusive:
            return self.start >= other.start and self.end <= other.end
        else:
            return self.start > other.start and self.end < other.end
1351626
public final boolean adjacent(final DateRange range) {
        boolean adjacent = false;
        if (rangeStart.equals(range.getRangeEnd())) {
            adjacent = true;
        } else if (rangeEnd.equals(range.getRangeStart())) {
            adjacent = true;
        }
        return adjacent;
    }
761082
@Override
	public int compareTo(Object arg0) {
		if (arg0 instanceof SimpleInterval) {
			SimpleInterval that = (SimpleInterval)arg0;
			return intervalName.compareTo(that.getIntervalName());
		}
		return 0;
	}
882000
public boolean contains(ChronoInterval<T> interval) {

        for (ChronoInterval<T> i : this.intervals) {
            if (i.equals(interval)) {
                return true;
            }
        }

        return false;

    }
1137718
public boolean isNewerThan(SetElement other) {
    if (other == null) {
      return true;
    }
    return this.timestamp.isNewerThan(other.timestamp);
  }
1129016
public boolean isNewerThan(Value other) {
    if (other == null) {
      return true;
    }
    return this.timestamp.isNewerThan(other.timestamp);
  }
429123
def later_than(after, before):
    
    if isinstance(after, str):
        after = str_to_time(after)
    elif isinstance(after, int):
        after = time.gmtime(after)

    if isinstance(before, str):
        before = str_to_time(before)
    elif isinstance(before, int):
        before = time.gmtime(before)

    return after >= before
1073963
public boolean before (final TimeOfDay timeOfDay)
  {
    if (timeOfDay.m_nHour > m_nHour)
      return true;
    if (timeOfDay.m_nHour < m_nHour)
      return false;

    if (timeOfDay.m_nMinute > m_nMinute)
      return true;
    if (timeOfDay.m_nMinute < m_nMinute)
      return false;

    if (timeOfDay.m_nSecond > m_nSecond)
      return true;
    if (timeOfDay.m_nSecond < m_nSecond)
      return false;

    return false; // must be equal...
  }
1070933
private boolean containsInterval(Interval i) {
        if (i != null) {
            return directedGraph.contains(i.getStart())
                    && directedGraph.contains(i.getFinish());
        } else {
            return false;
        }
    }
521391
private int compareEnds(Interval<T> other){
		if (end == null && other.end == null)
			return 0;
		if (end == null)
			return 1;
		if (other.end == null)
			return -1;
		int compare = end.compareTo(other.end);
		if (compare != 0)
			return compare;
		if (isEndInclusive ^ other.isEndInclusive)
			return isEndInclusive ? 1 : -1;
		return 0;
	}
431674
public boolean isBefore(final T element) {
        if (element == null) {
            return false;
        }

        return upperEndpoint.includes(element) == false;
    }
470076
public boolean isDisjunct() {

        for (int i = 0, n = this.intervals.size() - 1; i < n; i++) {
            ChronoInterval<T> current = this.intervals.get(i);
            ChronoInterval<T> next = this.intervals.get(i + 1);
            if (current.getEnd().isInfinite() || next.getStart().isInfinite()) {
                return false;
            } else if (current.getEnd().isOpen()) {
                if (this.isAfter(current.getEnd().getTemporal(), next.getStart().getTemporal())) {
                    return false;
                }
            } else if (!this.isBefore(current.getEnd().getTemporal(), next.getStart().getTemporal())) {
                return false;
            }
        }

        return true;

    }
1322414
def is_entailed_by(self, other):
        
        other = IntervalCell.coerce(other)
        return other.low >= self.low and other.high <= self.high
1052653
public int compareIntervalOrder(Interval<E> other)
  {
    int flags = getRelationFlags(other);
    if (checkFlagExclusiveSet(flags, REL_FLAGS_INTERVAL_BEFORE, REL_FLAGS_INTERVAL_UNKNOWN)) {
      return -1;
    } else if (checkFlagExclusiveSet(flags, REL_FLAGS_INTERVAL_AFTER, REL_FLAGS_INTERVAL_UNKNOWN)) {
      return 1;
    } else {
      return 0;
    }
  }
342519
public static boolean valueChanged(Enum<?> before, Enum<?> after) {
        if (before == null && after == null) {
            return false;
        }
        if (after == null) {
            return false;
        }
        if (before == null && after != null) {
            return true;
        }
        return !(before == after);
    }