Test if set sourceBitSet is contained in  set targetBitSet.
@param  sourceBitSet  a bitSet
@param  targetBitSet  a bitSet
@return    true if  sourceBitSet is contained in  targetBitSet
323619
private boolean isContainedIn(BitSet sourceBitSet, BitSet targetBitSet) {
        boolean result = false;

        if (sourceBitSet.isEmpty()) {
            return true;
        }

        BitSet setA = (BitSet) sourceBitSet.clone();
        setA.and(targetBitSet);

        if (setA.equals(sourceBitSet)) {
            result = true;
        }

        return result;
    }
1295502
public boolean containsSameLinksAs(Iterable<Link> links) {

		Links other = Links.of(links);

		return this.links.size() != other.links.size() ? false : this.links.containsAll(other.links);
	}
530016
public static boolean contains(String target, String... containWith) {
		return contains(target, Arrays.asList(containWith));
	}
819752
public boolean contains(IntBitRelation sub) {
        int i;

        if (line.length != sub.line.length) {
            return false;
        }

        for (i = 0; i < line.length; i++) {
            if (line[i] == null) {
                if (sub.line[i] != null) {
                    return false;
                }
            } else {
                if ((sub.line[i] != null) &&
                    !line[i].containsAll(sub.line[i])) {
                    return false;
                }
            }
        }
        return true;
    }
886071
private function doSetBinaryBitsetLeInt($bitset): void
    {
        $len = \strlen($bitset);
        $int = 0;
        for ($i = 0; $i < $len; ++$i) {
            $ord = \ord($bitset[$i]);

            if ($ord && $i > \PHP_INT_SIZE - 1) {
                throw new InvalidArgumentException('out-of-range bits detected');
            }

            $int |= $ord << (8 * $i);
        }

        if ($int & (~0 << $this->enumerationCount)) {
            throw new InvalidArgumentException('out-of-range bits detected');
        }

        $this->bitset = $int;
    }
291648
void addSourceTargetSet(UnicodeSet filter, UnicodeSet sourceSet, UnicodeSet targetSet, UnicodeSet revisiting) {
        int limit = anteContextLength + keyLength;
        UnicodeSet tempSource = new UnicodeSet();
        UnicodeSet temp = new UnicodeSet();

        // We need to walk through the pattern.
        // Iff some of the characters at ALL of the the positions are matched by the filter, then we add temp to toUnionTo
        for (int i=anteContextLength; i<limit; ) {
            int ch = UTF16.charAt(pattern, i);
            i += UTF16.getCharCount(ch);
            UnicodeMatcher matcher = data.lookupMatcher(ch);
            if (matcher == null) {
                if (!filter.contains(ch)) {
                    return;
                }
                tempSource.add(ch);
            } else {
                try {
                    if (!filter.containsSome((UnicodeSet) matcher)) {
                        return;
                    }
                    matcher.addMatchSetTo(tempSource);
                } catch (ClassCastException e) { // if the matcher is not a UnicodeSet
                    temp.clear();
                    matcher.addMatchSetTo(temp);
                    if (!filter.containsSome(temp)) {
                        return;
                    }
                    tempSource.addAll(temp);
                }
            }
        }
        // if we made our way through the gauntlet, add to source/target
        sourceSet.addAll(tempSource);
        output.addReplacementSetTo(targetSet);
    }
4233
public boolean containsPropertySet(Class<? extends Annotation> propertySet)
    {
        if (_annotElem.isAnnotationPresent(propertySet))
            return true;

        //
        // Call up to superclass for delegation
        //
        return super.containsPropertySet(propertySet);
    }
96324
def issuperset(self, other):
        """"""
        self._binary_sanity_check(other)
        return set.issuperset(self, other)
970277
public boolean contains(QualifiedName name) {
		Name unit = name.getUnit();
		// Get information associated with this unit
		SymbolTable.Group group = symbolTable.get(unit);
		return group != null && group.isValid(name.getName());
	}
751518
public static function isAnyBitSet( int $target, int $flag ) : bool
    {
        return self::isBitSet( $target, $flag, self::BITTEST_MODE_ANY );
    }
75108
public boolean contains(ImmutableRoaringBitmap subset) {
    if(subset.getCardinality() > getCardinality()) {
      return false;
    }
    final int length1 = this.highLowContainer.size();
    final int length2 = subset.highLowContainer.size();
    int pos1 = 0, pos2 = 0;
    while (pos1 < length1 && pos2 < length2) {
      final short s1 = this.highLowContainer.getKeyAtIndex(pos1);
      final short s2 = subset.highLowContainer.getKeyAtIndex(pos2);
      if (s1 == s2) {
        MappeableContainer c1 = this.highLowContainer.getContainerAtIndex(pos1);
        MappeableContainer c2 = subset.highLowContainer.getContainerAtIndex(pos2);
        if(!c1.contains(c2)) {
          return false;
        }
        ++pos1;
        ++pos2;
      } else if (compareUnsigned(s1, s2) > 0) {
        return false;
      } else {
        pos1 = subset.highLowContainer.advanceUntil(s2, pos1);
      }
    }
    return pos2 == length2;
  }
591637
public static BitSet getBitSet(IAtomContainer atomContainer) {
        BitSet bitSet;
        int size = atomContainer.getBondCount();

        if (size != 0) {
            bitSet = new BitSet(size);
            for (int i = 0; i < size; i++) {
                bitSet.set(i);
            }
        } else {
            bitSet = new BitSet();
        }

        return bitSet;
    }
999235
protected boolean setContainsGeneralTerm(Set<String> set, String term)
	{
		for (String s : set)
		{
			if (s.contains(term)) return true;
		}
		return false;
	}
678806
public static function isBitSet( int $target, int $flag, int $mode ) : bool
    {
        switch($mode){
        case self::BITTEST_MODE_ALL:
            return ($target & $flag) === $flag;
            break;
        case self::BITTEST_MODE_ANY:
            return ($target & $flag) != 0;
        }

        return false;
    }
1280030
public static boolean checkMultipleBitSet(int flags) {
    boolean set = false;
    while (flags != 0) {
      if ((flags & 0x01) != 0) {
        if (set) { return false; }
        else { set = true; }
      }
      flags = flags >> 1;
    }
    return false;
  }
1200753
@Override
    public NavigableSet<E> subSet(E fromElement, boolean fromInclusive, E toElement, boolean toInclusive)
    {
        int low = lowIndexOf(fromElement, fromInclusive);
        int high = highIndexOf(toElement, toInclusive);
        return new BinarySet(comparator, list.subList(low, high+1), false);
    }
1249530
public boolean isSubset(IntArray subset)
  {
    int []subData = subset._data;
    
    for (int i = subset._size - 1; i >= 0; i--) {
      if (! contains(subData[i]))
        return false;
    }

    return true;
  }