Returns whether this LocalDateRange is equal to the given one.

@param LocalDateRange $that The range to compare to.

@return bool True if this range equals the given one, false otherwise.
192388
public function isEqualTo(LocalDateRange $that) : bool
    {
        return $this->startDate->isEqualTo($that->startDate)
            && $this->endDate->isEqualTo($that->endDate);
    }
1403
@SuppressWarnings("ObjectEquality")
    @Override
    public int compareTo(Slice that)
    {
        if (this == that) {
            return 0;
        }
        return compareTo(0, size, that, 0, that.size);
    }
1269133
public function equalsTo(Object $object)
    {
        if (!$this->sameTypeAs($object)) {
            throw new NotMatchTypeException($this);
        }

        return
            $this->year() === $object->year() &&
            $this->month() === $object->month() &&
            $this->day() === $object->day();
    }
1080597
public function compareTo($other)
    {
        if ($other === null) {
            return false;
        }
        if (!($other instanceof SubExpressionNode)) {
            return false;
        }

        return $this->getValue() == $other->getValue();
    }
381585
public static function isSameDate(DateTimeInterface $first, DateTimeInterface $second): bool
	{
		if ($first->getTimezone()->getName() !== $second->getTimezone()->getName()) {
			throw new InvalidArgumentException(
				sprintf(
					'You cannot compare times from two different timezones (%s, %s) for same date.'
					. ' Date is not always same at a time in different locations.',
					$first->getTimezone()->getName(),
					$second->getTimezone()->getName()
				)
			);
		}

		return $first->format('Y-m-d') === $second->format('Y-m-d');
	}
1076263
public function equals(self $other) : bool
    {
        return
            $this->wrapped->y     == $other->wrapped->y &&
            $this->wrapped->m     == $other->wrapped->m &&
            $this->wrapped->d     == $other->wrapped->d &&
            $this->wrapped->h     == $other->wrapped->h &&
            $this->wrapped->i     == $other->wrapped->i &&
            $this->wrapped->s     == $other->wrapped->s &&
            $this->wrapped->days  == $other->wrapped->days &&
            $this->microseconds   == $other->microseconds;
    }
22931
public static function compare($date1, $date2): int
    {
        $d1 = static::create($date1);
        $d2 = static::create($date2);

        return ($d1 > $d2) ? static::DATETIME_GREATER : (($d1 < $d2) ? static::DATETIME_LESS : static::DATETIME_EQUAL);
    }
472918
public static function equals(TimeSlot $a, TimeSlot $b) {

        // Compare the start dates.
        if (false === DateTimeHelper::equals($a->getStartDate(), $b->getStartDate())) {
            return false;
        }

        // Compare the end dates.
        if (false === DateTimeHelper::equals($a->getEndDate(), $b->getEndDate())) {
            return false;
        }

        // Compare the time slots count.
        if (count($a->getTimeSlots()) !== count($b->getTimeSlots())) {
            return false;
        }

        // Handle each time slot.
        for ($i = count($a->getTimeSlots()) - 1; 0 <= $i; --$i) {
            if (false === static::equals($a->getTimeSlots()[$i], $b->getTimeSlots()[$i])) {
                return false;
            }
        }

        //
        return true;
    }
842250
public function equals($compare): bool
    {
        if ($compare instanceof self) {
            return ($this->timestamp() === $compare->timestamp());
        }

        return false;
    }
138538
public boolean isInRange(@Nullable CalendarDay minDate, @Nullable CalendarDay maxDate) {
    return !(minDate != null && minDate.isAfter(this)) &&
        !(maxDate != null && maxDate.isBefore(this));
  }
388004
public function compareTo(Year $that) : int
    {
        if ($this->year > $that->year) {
            return 1;
        }

        if ($this->year < $that->year) {
            return -1;
        }

        return 0;
    }
571817
public function equalsTo(Object $object)
    {
        if (!$this->sameTypeAs($object)) {
            throw new NotMatchTypeException($this);
        }

        return $this->date()->equalsTo($object->date()) && $this->time()->equalsTo($object->time());
    }
53845
public function equals(ColumnDefaultValue $other)
    {
        if ($this->getType() != $other->getType()) {
            return false;
        }
        if ($this == $other) {
            return true;
        }
        // special case for current timestamp
        $equivalents = array('CURRENT_TIMESTAMP', 'NOW()');
        if (in_array(strtoupper($this->getValue()), $equivalents) && in_array(strtoupper($other->getValue()), $equivalents)) {
            return true;
        }

        return false; // Can't help, they are different
    }
71261
private static function compare(DateTimeRange $a, DateTimeRange $b)
	{
		if (!$a->interval->equals($b->interval))
		{
			throw new \InvalidArgumentException('Intervals of ranges are not equal.');
		}

		if ($a->equals($b))
		{
			return 0;
		}

		if ($a->start()->isAfter($b->start()))
		{
			return 1;
		}

		if ($a->start()->isBefore($b->start()) || $a->end()->isBefore($b->end()))
		{
			return -1;
		}

		return 1;
	}
916200
public function contains(DatePeriodDateTime $comparison, bool $equal = true) : bool
    {
        if ($equal) {
            return $comparison->gte($this) && $comparison->getEndDate()->lte($this->endDate);
        } else {
            return $comparison->gt($this) && $comparison->getEndDate()->lt($this->endDate);
        }
    }
317822
public function isGreaterThan(Decimal $that) : bool
    {
        $this->scaleValues($this, $that, $a, $b);

        return $a > $b;
    }
128868
public function Equals($obj)
	{
		if ( ! $obj instanceof NotationValue )
		{
			return false;
		}

		/**
		 * @var NotationValue $other
		 */
		$other = $obj;
		return $this->LocalName == $other->LocalName && $this->NamespaceUri == $other->NamespaceUri;

	}