Test whether one QName equals another

@param QName $other
@return boolean
179954
public function equals( $other )
	{
		try
		{
			return $this->qnameValueHash == $other->qnameValueHash ||
				( $this->localName == $other->localName && $this->namespaceURI == $other->namespaceURI );
		}
		catch( \Exception $ex )
		{
			return false;
		}
	}
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);
    }
736506
public function fieldLessThanOrEqualAnother(string $fieldName, string $otherFieldName)
    {
        $this->validateFieldsExist(__METHOD__, $fieldName, $otherFieldName);

        return $this->validate(new FieldLessThanOrEqualAnotherValidator($this->fields[$fieldName], $this->fields[$otherFieldName]));
    }
11494
public function compareTo($other): bool {
        if(!($other instanceof $this)) {
            return FALSE;
        }
        if($this->getHost() !== $other->getHost()) {
            return FALSE;
        }
        if($this->getPort() !== $other->getPort()) {
            return FALSE;
        }
        return TRUE;
    }
1201244
public function equals($compare)
    {
        if ($compare instanceof self) {
            return ($compare->className == $this->className && $compare->propertyName == $this->propertyName);
        }
        
        return false;
    }
1098083
public function fieldGreaterThanOrEqualAnother(string $fieldName, string $otherFieldName)
    {
        $this->validateFieldsExist(__METHOD__, $fieldName, $otherFieldName);

        return $this->validate(new FieldGreaterThanOrEqualAnotherValidator($this->fields[$fieldName], $this->fields[$otherFieldName]));
    }
1146335
public function equal($other, $trim = false)
    {
        $this->isString();

        if (false === $trim) {
            return parent::equal($other);
        }

        return $this->doCheck(function ($value) use ($other) {
            $this->throwExceptionIfFalse(
                trim($value) === trim($other),
                'Value %s is not equal to %s', $value, $other
            );
        });
    }
782833
private function queueExists($queueName)
    {
        try {
            $this->resolveUrl($queueName);

            return true;
        } catch (\InvalidArgumentException $exception) {
            return false;
        } catch (SqsException $exception) {
            if ($previousException = $exception->getPrevious()) {
                switch ($previousException->getCode()) {
                    case self::AWS_SQS_EXCEPTION_BAD_REQUEST:
                    case self::AWS_SQS_EXCEPTION_NOT_FOUND:
                        return false;
                }
            }

            throw $exception;
        }
    }
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;
    }
809238
public function isSameValueAs(Locale $other)
    {
        return
            $this->languageCode == $other->languageCode &&
            $this->countryCode == $other->countryCode
        ;
    }
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;
	}
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;
    }
39716
public function equals($anotherPath) {
		$anotherPath = $anotherPath instanceof Path ? $anotherPath : new Path($anotherPath);

		if ($this->isStream() ^ $anotherPath->isStream()) {
			return false;
		}

		if ($this->isStream() && $anotherPath->isStream()) {
			return $this->toString() === $anotherPath->toString();
		}

		return realpath($this->pathname->toString()) == realpath($anotherPath->toString());
	}
936689
private static function compareQNames($a, $b) {
		$a_index = array_search($a, self::$attributes_order);
		$b_index = array_search($b, self::$attributes_order);

		if ($a_index !== false && $b_index !== false) {
			return $a_index - $b_index;
		}
		if ($a_index === false && $b_index === false) {
			return strcmp($a, $b);
		}
		return ($a_index === false) ? 1 : -1;
	}
1330110
public function isSame(Index $other, $renamedColumns = null)
    {
        if ($renamedColumns) {
            $columns = [];
            foreach ($this->columns as $col) {
                $columns[] = isset($renamedColumns[$col]) ? $renamedColumns[$col]->name : $col;
            }
        } else {
            $columns = $this->columns;
        }
        if ($columns != $other->columns) {
            return false;
        }
        if ($this->name == self::PRIMARY || $other->name == self::PRIMARY) {
            return $this->name == $other->name;
        } else {
            return $this->type == $other->type;
        }
    }
287303
public function strictEqual($other)
    {
        $this->doCheck(function ($value) use ($other) {
            $this->throwExceptionIfFalse(
                $value === $other,
                'Value "%s" is not the same as "%s"', $value, $other
            );
        });

        return $this;
    }
35708
public function equals($compare)
    {
        if ($compare instanceof self) {
            return ($compare->className === $this->className && $compare->methodName === $this->methodName);
        }
        
        return false;
    }