Check if this EnumSet is a superset of other
@param EnumSet $other
@return bool
492422
public function isSuperset(EnumSet $other): bool
    {
        return $this->enumeration === $other->enumeration
            && ($this->bitset | $other->bitset) === $this->bitset;
    }
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;
    }
295201
public function equals($other, $parts=['scheme', 'user', 'host', 'path'])
    {
        $other = $other instanceof UrlContract ? $other : new static($other);
        $parts = (array)$parts;

        foreach ($parts as $part) {
            if ($part == 'path') {
                continue;
            }
            if ($this->$part != $other->$part) {
                return false;
            }
        }

        if (!in_array('path', $parts)) {
            return true;
        }

        return $this->path->equals($other->path);
    }
1361640
public function isEqual(EnumSet $other): bool
    {
        return $this->enumeration === $other->enumeration
            && $this->bitset === $other->bitset;
    }
68663
def is_entailed_by(self, other):
        
        if not set(self.include.keys()).issubset(set(other.include.keys())):
            return False
        if not self.exclude.isuperset(other.exclude):
            return False
        if not self.prototype.is_entailed_by(other.prototype):
            return False
        return True
911854
public function equals(Target $other): bool
    {
        if ($this->_type != $other->_type) {
            return false;
        }
        if ($this->toASN1()->toDER() != $other->toASN1()->toDER()) {
            return false;
        }
        return true;
    }
1016033
function (other) {
        assertNotNull(other);

        var c = collectionCount(other);

        if (c !== -1) {
            // if other is the empty set then this is a superset
            if (c === 0) {
                return true;
            }

            else if (areEqualityComparersEqual(this, other)) {
                if (c > this.count()) {
                    return false;
                }
            }
        }

        return containsAllElements(this, other);
    }
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;
	}
1053036
protected function matches($other)
    {
        foreach ($this->constraints as $key => $constraint) {
            if (! array_key_exists($key, $other)) {
                return false;
            }

            if (! $constraint->evaluate($other[$key], '', true)) {
                return false;
            }
        }

        if ($this->isStrict and array_diff_key($other, $this->constraints)) {
            return false;
        }

        return true;
    }
990934
public function compareTo($other)
    {
        if ($other === null) {
            return false;
        }
        if (!($other instanceof ConstantNode)) {
            return false;
        }

        return $this->getName() == $other->getName();
    }
400579
public <T> boolean containsAny(Set<T> set, Collection<T> other) {
        for (T t : other) {
            if (set.contains(t)) {
                return true;
            }
        }
        return false;
    }
1371041
private function hasSameColumnLengths(self $other) : bool
    {
        $filter = static function (?int $length) : bool {
            return $length !== null;
        };

        return array_filter($this->options['lengths'] ?? [], $filter)
            === array_filter($other->options['lengths'] ?? [], $filter);
    }
927570
public function lessThanOrEqual( $other )
	{
		return $this->namespaceURI == null && $other->namespaceURI ||
		$this->namespaceURI && $other->namespaceURI && $this->namespaceURI < $other->namespaceURI ||
		$this->namespaceURI == $other->namespaceURI && $this->localName <= $other->localName;
	}
354216
public boolean properSupersetOf(org.odmg.DSet otherSet)
    {
        return (otherSet.size() > 0 && otherSet.size() < this.size() && this.supersetOf(otherSet));
    }
63461
public function equals(Type $other)
    {
        $result = $other->isAssignableFrom($this) && $this->isAssignableFrom($other);
        $result2 = $this->getName() === $other->getName();
        
        //Are there any types which do not have the same name, but are assignable to each other?
        //(United types are sorted by their names)
        if ($result !== $result2)
            throw new \Exception("This should not happen - please report a bug!");
        
        return $result;
    }
1199040
public boolean containsAll(final LongHashSet other) {
        final LongIterator iterator = other.iterator();
        while (iterator.hasNext()) {
            if (!contains(iterator.nextValue())) {
                return false;
            }
        }
        return true;
    }