Check whether RDN is semantically equal to other.

@param RDN $other Object to compare to
@return bool
492393
public function equals(RDN $other): bool
    {
        // if attribute count doesn't match
        if (count($this) != count($other)) {
            return false;
        }
        $attribs1 = $this->_attribs;
        $attribs2 = $other->_attribs;
        // if there's multiple attributes, sort using SET OF rules
        if (count($attribs1) > 1) {
            $attribs1 = self::fromASN1($this->toASN1())->_attribs;
            $attribs2 = self::fromASN1($other->toASN1())->_attribs;
        }
        for ($i = count($attribs1) - 1; $i >= 0; --$i) {
            $tv1 = $attribs1[$i];
            $tv2 = $attribs2[$i];
            if (!$tv1->equals($tv2)) {
                return false;
            }
        }
        return true;
    }
395958
public function compareTo($other)
    {
        if ($other === null) {
            return false;
        }
        if (!($other instanceof VariableNode)) {
            return false;
        }

        return $this->getName() == $other->getName();
    }
575091
public function compareTo($other)
    {
        if ($other === null) {
            return false;
        }
        if (!($other instanceof ExpressionNode)) {
            return false;
        }

        if ($this->getOperator() != $other->getOperator()) return false;

        $thisLeft = $this->getLeft();
        $otherLeft = $other->getLeft();
        $thisRight = $this->getRight();
        $otherRight = $other->getRight();

        if ($thisLeft === null) {
            return $otherLeft === null && $thisRight->compareTo($otherRight);
        }

        if ($thisRight === null) {
            return $otherRight=== null && $thisLeft->compareTo($otherLeft);
        }

        return $thisLeft->compareTo($otherLeft) && $thisRight->compareTo($otherRight);
    }
1361640
public function isEqual(EnumSet $other): bool
    {
        return $this->enumeration === $other->enumeration
            && $this->bitset === $other->bitset;
    }
2295
def is_superdomain(self, other):
        

        (nr, o, nl) = self.fullcompare(other)
        if nr == NAMERELN_SUPERDOMAIN or nr == NAMERELN_EQUAL:
            return True
        return False
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;
    }
822440
public function isEqual($other)
    {
        return !($other instanceof self) ?
            false :
            ($this->id === $other->id && $this->customerId === $other->customerId);
    }
777276
public function shallowEquals(Atomic $other)
    {
        return strtolower($this->getKey()) === strtolower($other->getKey())
            && !($other instanceof ObjectLike && $this instanceof ObjectLike);
    }
1026977
public function equals(GeneralName $other): bool
    {
        if ($this->_tag != $other->_tag) {
            return false;
        }
        if ($this->_choiceASN1()->toDER() != $other->_choiceASN1()->toDER()) {
            return false;
        }
        return true;
    }
695094
public function greaterThan( $other )
	{
		return $this->namespaceURI && $other->namespaceURI == null ||
		$this->namespaceURI && $other->namespaceURI && $this->namespaceURI > $other->namespaceURI ||
		$this->namespaceURI == $other->namespaceURI && $this->localName > $other->localName;
	}
809238
public function isSameValueAs(Locale $other)
    {
        return
            $this->languageCode == $other->languageCode &&
            $this->countryCode == $other->countryCode
        ;
    }
339645
public function logicalAnd(self $other){
		
		$l = \max(array($this->count(), $other->count()));
		$new = new static();
		
		for($i = 0; $i < $l; ++$i){
			$new[$i] = isset($this[$i], $other[$i])
					? ($this[$i] && $other[$i])
					: false;
		}
		
		return $new;
		
	}
1247828
public function equals(LatLngBounds $other)
    {
        if (!$this->getNorthEast()->equals($other->getNorthEast())) {
            return false;
        }

        return $this->getSouthWest()->equals($other->getSouthWest());
    }
1080597
public function compareTo($other)
    {
        if ($other === null) {
            return false;
        }
        if (!($other instanceof SubExpressionNode)) {
            return false;
        }

        return $this->getValue() == $other->getValue();
    }
1251089
final public function equals($other)
    {
        if ($other instanceof $this) {
            if ($other === $this) {
                return true;
            }
            $other = $other->toArray();
        } elseif (!is_array($other)) {
            return false;
        }
        
        $me = $this->toArray();
    
        if (count($me) !== count($other)) {
            return false;
        }
    
        foreach ($me as $key => $value) {
            if (!array_key_exists($key, $other) || $value !== $other[$key]) {
                return false;
            }
        }
        
        return true;
    }
144829
public function equal($other, $delta = .0)
    {
        $this->isNumeric();

        if (0 === $delta) {
            return parent::equal($other);
        }

        return $this->doCheck(function ($value) use ($other, $delta) {
            $this->throwExceptionIfFalse(
                $this->isBetween($value - $other, -$delta, $delta),
                'Value %s is not equal to %s (±%s)', $value, $other, $delta
            );
        });
    }
364705
public function equals ($other)
	{
		ensure('Argument', $other, 'is_a_string', __CLASS__, __METHOD__);

		if ($other instanceof self) {
			return $other->to_s() === $this->string;
		}

		return $other === $this->string;
	}