Determine whether the given constrainer is equal to this object.

@param  \Silber\Bouncer\Constraints\Constrainer  $constrainer
@return bool
428976
public function equals(Constrainer $constrainer)
    {
        if (! $constrainer instanceof static) {
            return false;
        }

        if ($this->constraints->count() != $constrainer->constraints->count()) {
            return false;
        }

        foreach ($this->constraints as $index => $constraint) {
            if (! $constrainer->constraints[$index]->equals($constraint)) {
                return false;
            }
        }

        return true;
    }
138595
public function check(EiEntry $eiEntry): bool {
		if (empty($this->eiEntryConstraints)) return true;
		
		foreach ($this->eiEntryConstraints as $eiEntryConstraint) {
			if ($eiEntryConstraint->check($eiEntry)) {
				if (!$this->useAnd) return true;
			} else {
				if ($this->useAnd) return false;
			}
		}
		
		return $this->useAnd;
	}
427188
public function validate($value, Constraint $constraint)
    {
        $block = $constraint->block;
        if ($block instanceof BlockInterface && true === $block->isTransverse() && !empty($value)) {
            $blockCode = $this->repository->findOneTransverseBlockByCode($value, $block->getLanguage(), $block->getSiteId());
            if (null !== $blockCode && $blockCode->getId() !== $block->getId()) {
                $this->context->buildViolation($constraint->message)
                    ->atPath('code')
                    ->addViolation();
            }
        }

    }
876437
private function validateConstraints(array $constraints): bool
    {
        foreach ($constraints as $constraint) {
            if (!$constraint instanceof Closure && !$constraint instanceof Constraint) {
                return false;
            }
        }

        return true;
    }
164480
public function Equals( $obj )
	{
		/**
		 * @var SequenceType $dest
		 */
		$dest = $obj;
		if ( ! is_null( $obj ) )
		{
			return $this->TypeCode == $dest->TypeCode &&
				$this->SchemaElement == $dest->SchemaElement &&
				$this->SchemaAttribute == $dest->SchemaAttribute &&
				$this->SchemaType == $dest->SchemaType &&
				$this->Cardinality == $dest->Cardinality;
		}
		return false;
	}
291134
public function equals($obj)
    {
        if (gettype($obj) === 'object' && $obj instanceof self) {
            return $obj->getFirst() === $this->getFirst() && $obj->getSecond() === $this->getSecond();
        }

        return false;
    }
48029
public static function equal($object, $value = null): bool
    {
        if (!Any::isLine($object)) {
            return false;
        }

        return $object === $value;
    }
830246
public function __isset($property)
    {
        if (isset(static::$getterMap[static::class][$property])) {
            return true;
        }
        return $this->constraints->__isset($property);
    }
479061
protected function _getConstraintClass($type)
    {
        $class = null;
        foreach ($this->_constraintExpressions as $className => $exp) {
            if (preg_match("/{$exp}/i", $type)) {
                $class = $className;
                break;
            }
        }
        return $class;
    }
306232
public function equals($other)
    {
        if (!($other instanceof self)) {
            $other = new BigInt($other);
        }
        return ($this->compare($other) === 0);
    }
24480
public function isEqualTo(UserInterface $user)
    {
        if ($user->getRoles() !== $this->getRoles()) {
            return false;
        }

        if ($this->username !== $user->getUsername()) {
            return false;
        }

        if ($this->id !== $user->getId()) {
            return false;
        }

        return true;
    }
882234
public function equals(Module $obj)
    {
        if (get_called_class() !== get_class($obj)) {
            return false;
        }

        /** @var Module $this */
        return $this->getValue() === $obj->getValue();
    }
1009392
public function visitMinimumPropertiesConstraint(ObjectValue\MinimumPropertiesConstraint $constraint)
    {
        $value = $this->currentValue();
        if (
            !$value instanceof Value\ObjectValue ||
            $value->count() >= $constraint->minimum()
        ) {
            return $this->createResult();
        }

        return $this->createSingleIssueResult($constraint);
    }
727724
public function equals(ObjectInterface $user)
    {
        if($user instanceof UserInterface)
        {
            if($user->getEmail() == $this->getEmail())
            {
                if($user->getPassword() == $this->getPassword()) {
                    return true;
                }
            }
        }

        return false;
    }
35477
protected function checkType(ExpressionContract $expression)
    {
        if (!$expression instanceof ConstraintContract) {
            throw new InvalidArgumentException("ConstraintGroup works only with Constraint not " . Type::of($expression));
        }

        return $expression;
    }
959705
public function Equals( $obj )
	{
		if ( ! $obj instanceof GYearMonthValue )
		{
			return false;
		}

		/**
		 * @var DateTimeValueBase $other
		 */
		$other = $obj;
		return $this->ToString( null ) == $other->ToString( null );
	}
1133732
public function equals(Rule $rule)
    {
        if ($this->ruleHash !== $rule->ruleHash) {
            return false;
        }

        if (count($this->literals) != count($rule->literals)) {
            return false;
        }

        for ($i = 0, $n = count($this->literals); $i < $n; $i++) {
            if ($this->literals[$i] !== $rule->literals[$i]) {
                return false;
            }
        }

        return true;
    }