<p>matches.</p>

@param cells a {@link com.greenpepper.Example} object.
@return a boolean.
335906
public boolean matches(Example cells)
    {
        for (int i = 0; i < cells.remainings(); ++i)
        {
            Example cell = cells.at( i );

            if (i < headers.length)
            {
                ExpectedColumn column = (ExpectedColumn) headers[i];
                String message = column.header();

                if (HeaderForm.parse(message).isExpected()) continue;
                if (StringUtil.isBlank( contentOf( cell ) )) {
                    if (column.getClass() == ExpectedColumn.class) continue;

                    try
                    {
                        column.setCheck(fixture.check(column.header()));
                        final Statistics statistics = column.doCell(cell, false);

                        if (statistics.indicatesFailure())
                        {
                            return false;
                        }
                    }
                    catch (Exception e)
                    {
                        return false;
                    }
                } else { // Check for equality
                    try
                    {
                        Call call = new Call( fixture.check( column.header() ) );
                        Expectation expectation = ShouldBe.literal( contentOf( cell ) );

                        Object result = call.execute();
                        if (!expectation.meets( result ))
                        {
                            return false;
                        }
                    }
                    catch (Exception e)
                    {
                        return false;
                    }
                }


            }
        }

        return true;
    }
890795
public static boolean matchesAny(String str, List<String> regexes) {
        return matchesAny(str, regexes, true);
    }
272857
public boolean matches(String path, MatchingStrategy matchingStrategy) {
    return path!=null && matchingStrategy.matches(clause, path);
  }
953390
public void containsCell(Cell<?, ?, ?> cell) {
    checkNotNull(cell);
    checkNoNeedToDisplayBothValues("cellSet()").that(actual().cellSet()).contains(cell);
  }
866369
public boolean matches(String string) {		
		Matcher matcher = pattern.matcher(string);
		boolean result = matcher.matches();
		return result;		
	}
551564
public static Collection<Row> getRowsFromsCells(Collection<Cells> cellsCol) {
        Collection<Row> result = new ArrayList<>();
        for (Cells cells : cellsCol) {
            result.add(getRowFromCells(cells));
        }
        return result;
    }
632211
public static final boolean matchTypeMap(Map<String, Class<?>> m1, Map<String, Class<?>> m2) {
        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();

        if (isTraceOn && tc.isEntryEnabled())
            Tr.entry(tc, "matchTypeMap", new Object[] { m1, m2 });

        boolean match = false;

        if (m1 == m2)
            match = true;
        else if (m1 != null && m1.equals(m2))
            match = true;
        if (isTraceOn && tc.isEntryEnabled())
            Tr.exit(tc, "matchTypeMap", match);
        return match;
    }
1248887
public <A> void match(Map<A,? extends Collection<I>> samples, BiConsumer<T, A> consumer)
    {
        Map<A,Collection<I>> m = new HashMap<>(samples);
        boolean cont = true;
        while (cont)
        {
            cont = false;
            Iterator<Entry<A, Collection<I>>> iterator = m.entrySet().iterator();
            while (iterator.hasNext())
            {
                Entry<A, Collection<I>> e = iterator.next();
                T match = match(e.getValue());
                if (match != null)
                {
                    consumer.accept(match, e.getKey());
                    cont = true;
                    iterator.remove();
                }
            }
        }
    }
312899
public static Cell matchCell(Row row, int colIndex, String searchKey) {
        val cell = row.getCell(colIndex);
        if (cell == null) return null;

        val value = getCellStringValue(cell);
        if (StringUtils.contains(value, searchKey)) return cell;

        return null;
    }
1089124
protected static boolean match(Object ref, Object test) {
    if(ref == null) {
      return false;
    }
    // Cheap and fast, may hold for class labels!
    if(ref == test) {
      return true;
    }
    if(ref instanceof LabelList && test instanceof LabelList) {
      final LabelList lref = (LabelList) ref;
      final LabelList ltest = (LabelList) test;
      final int s1 = lref.size(), s2 = ltest.size();
      if(s1 == 0 || s2 == 0) {
        return false;
      }
      for(int i = 0; i < s1; i++) {
        String l1 = lref.get(i);
        if(l1 == null) {
          continue;
        }
        for(int j = 0; j < s2; j++) {
          if(l1.equals(ltest.get(j))) {
            return true;
          }
        }
      }
    }
    // Fallback to equality, e.g. on class labels
    return ref.equals(test);
  }
439859
@Override
    public boolean matches(IAtom atom) {
        // h counts should be set before match throw runtime exception?
        if (atom.getImplicitHydrogenCount() == null)
            return false;
        return atom.getImplicitHydrogenCount() == hcount;
    }
79222
public void acceptCell(C cell) {
        cell.reset();
        if(cell.isReusable()) {
            pool.add(cell);
        } else {
            cell.dispose();
        }
    }
933130
public static List<String> contentAsList( Iterable<Example> cells )
    {
        return new ArrayList<String>( Arrays.asList( content( cells ) ) );
    }
1070240
public Match match(List<String> desired, int threshold) {
    return matchImpl(parse(desired), threshold);
  }
93359
public List<Match> matches(List<String> desired, int threshold) {
    return matchesImpl(parse(desired), threshold);
  }
707725
public static boolean overlaps(List<ByteBuffer> minColumnNames1, List<ByteBuffer> maxColumnNames1, List<ByteBuffer> minColumnNames2, List<ByteBuffer> maxColumnNames2, CellNameType comparator)
    {
        if (minColumnNames1.isEmpty() || maxColumnNames1.isEmpty() || minColumnNames2.isEmpty() || maxColumnNames2.isEmpty())
            return true;

        return !(compare(maxColumnNames1, minColumnNames2, comparator) < 0 || compare(minColumnNames1, maxColumnNames2, comparator) > 0);
    }
1245712
public static boolean matches(Collection<Filter> filters, Extension extension)
    {
        if (filters != null) {
            for (Filter filter : filters) {
                if (!matches(filter, extension)) {
                    return false;
                }
            }
        }

        return true;
    }