Returns all ranges for which {@link Range#contains(Comparable)} item is true, without
preserving multiplicity.
437124
@Override
  public Collection<Range<T>> rangesContaining(final T item) {
    final ImmutableSet.Builder<Range<T>> ret = ImmutableSet.builder();
    for (final Range<T> range : ranges) {
      if (range.contains(item)) {
        ret.add(range);
      }
    }
    return ret.build();
  }
332520
public static boolean contains (int[] list, int value)
    {
        int llength = list.length; // no optimizing bastards
        for (int i = 0; i < llength; i++) {
            if (list[i] == value) {
                return true;
            }
        }
        return false;
    }
140652
public boolean contains (Object value)
    {
        for (int ii = 0, nn = size(); ii < nn; ii++) {
            if (ObjectUtil.equals(value, _list[ii])) {
                return true;
            }
        }
        return false;
    }
362712
public boolean contains(final MediaType type) {
        boolean contains = false;
        for (final MediaType mine : this.list) {
            if (mine.matches(type)) {
                contains = true;
                break;
            }
        }
        return contains;
    }
490882
public static List<Range> union(List<Range> ranges){
        ranges = new ArrayList<Range>(ranges);
        Collections.sort(ranges, new Comparator<Range>(){
            @Override
            public int compare(Range r1, Range r2){
                return r1.min-r2.min;
            }
        });
        List<Range> union = new ArrayList<Range>();
        for(Range r: ranges){
            if(union.isEmpty())
                union.add(r);
            else
                CollectionUtil.addAll(union, union.remove(union.size() - 1).union(r));
        }
        return union;
    }
1004593
@Override
  public boolean intersects(IVersionRange yourRange)
  {
    for (IVersionRange range : ranges) {
      if (range.intersects(yourRange)) {
        return true;
      }
    }
    return false;
  }
496150
@Override
  public Collection<Range<T>> rangesContaining(final Range<T> queryRange) {
    final ImmutableSet.Builder<Range<T>> ret = ImmutableSet.builder();
    for (final Range<T> range : ranges) {
      if (range.encloses(queryRange)) {
        ret.add(range);
      }
    }
    return ret.build();
  }
13311
public boolean hasBoundaryMatches()
    {
        for (Transition<DFAState<T>> t : transitions.values())
        {
            CharRange range = t.getCondition();
            if (range.getFrom() < 0)
            {
                return true;
            }
        }
        return false;
    }
914715
public static <T extends Comparable<T>> RangeSet<T> unionRangeSets(final Iterable<RangeSet<T>> rangeSets)
  {
    final RangeSet<T> rangeSet = TreeRangeSet.create();
    for (RangeSet<T> set : rangeSets) {
      rangeSet.addAll(set);
    }
    return rangeSet;
  }
1236390
public static boolean contains(String target, List<String> containWith) {
		if (isNull(target)) {
			return false;
		}
		
		return matcher(target).contains(containWith);
	}
115485
public boolean containsAll(final IntHashSet other) {
        final IntIterator iterator = other.iterator();
        while (iterator.hasNext()) {
            if (!contains(iterator.nextValue())) {
                return false;
            }
        }
        return true;
    }
427855
def ContainsAll(self, *values):
    
    self._awql = self._CreateMultipleValuesCondition(values, 'CONTAINS_ALL')
    return self._query_builder
1336872
@Override
    public boolean contains(U unit) {

        for (Item<?> item : this.getTotalLength()) {
            if (item.getUnit().equals(unit)) {
                return (item.getAmount() > 0);
            }
        }

        return false;

    }
1150635
public static boolean isClosed(final Range<?> range) {
    return range.hasUpperBound() && BoundType.CLOSED.equals(range.upperBoundType())
        && range.hasLowerBound() && BoundType.CLOSED.equals(range.lowerBoundType());
  }
1337476
public static <T> boolean contains(T[] a, T o) {
    for (T item : a) {
      if (item.equals(o)) return true;
    }
    return false;
  }
879871
public boolean contains(LCMSDataSubset other) {

    // compare ms levels
    Set<Integer> msLvlsThis = getMsLvls();
    Set<Integer> msLvlsThat = other.getMsLvls();
    // if ms levels are null, this definitely matches any other subset
    // so we need to check msLevelsThis frist!
    if (msLvlsThis != null && msLvlsThat != null) {
      if (!msLvlsThis.containsAll(msLvlsThat)) {
        return false;
      }
    }

    // compare mz ranges
    List<DoubleRange> mzRangesThis = getMzRanges();
    List<DoubleRange> mzRangesThat = other.getMzRanges();
    if (mzRangesThis != null && mzRangesThat != null) {
      if (!mzRangesThis.containsAll(mzRangesThat)) {
        return false;
      }
    }

    // compare scan number ranges
    Integer scanNumLoThis = getScanNumLo();
    Integer scanNumLoThat = other.getScanNumLo();
    if (scanNumLoThis != null && scanNumLoThat != null) {
      if (scanNumLoThis > scanNumLoThat) {
        return false;
      }
    }
    Integer scanNumHiThis = getScanNumHi();
    Integer scanNumHiThat = other.getScanNumHi();
    if (scanNumHiThis != null && scanNumHiThat != null) {
      if (scanNumHiThis < scanNumHiThat) {
        return false;
      }
    }
    return true;
  }
116034
@Override
  public Collection<Range<T>> rangesOverlapping(final Range<T> queryRange) {
    final ImmutableSet.Builder<Range<T>> ret = ImmutableSet.builder();
    for (final Range<T> range : ranges) {
      if (range.isConnected(queryRange) && !range.intersection(queryRange).isEmpty()) {
        ret.add(range);
      }
    }
    return ret.build();
  }