/* (non-Javadoc)
@see org.opoo.press.Converter#matches(org.opoo.press.Source)
768407
@Override
    public boolean matches(Source src) {
        String name = src.getOrigin().getName().toLowerCase();
        if (FilenameUtils.isExtension(name, "textile")) {
            return true;
        }
        return false;
    }
1226430
@Override
    public final MatchResult matches(final List<String> lines) {
        for (int i = 0; i < lines.size(); i++) {
            if (matches(i + 1, lines.get(i))) return new MatchResult(true, this, i);
        }
        return NO_MATCH;
    }
41802
@Override
	public boolean satisfies(Match match, int... ind)
	{
		for (MappedConst mc : con)
		{
			if (mc.satisfies(match, ind)) return true;
		}
		return false;
	}
644316
private static boolean matches(String matchHeader, String toMatch) {
        String[] matchValues = matchHeader.split("\\s*,\\s*");
        Arrays.sort(matchValues);
        return Arrays.binarySearch(matchValues, toMatch) > -1
                || Arrays.binarySearch(matchValues, "*") > -1;
    }
660829
public <U extends T> OngoingMatchingC0<T, U> when(MatchesExact<U> o) {
    List<Matcher<Object>> matchers = Lists.of(ArgumentMatchers.eq(o.t));
    return new OngoingMatchingC0<>(
        this, new DecomposableMatchBuilder0<>(matchers, new IdentityFieldExtractor<U>()).build());
  }
343498
public static boolean containsIgnoreCase(final String source, final String target) {

    if (source != null && target != null) {
      return indexOfIgnoreCase(source, target) != INDEX_OF_NOT_FOUND;
    } else {
      return false;
    }
  }
870819
public boolean isMatchHint(String strKeyArea, Object objKeyData)
    {
        if (m_mapHints != null)
            if (objKeyData.equals(m_mapHints.get(strKeyArea)))
                return true;    // Match;
        return false;   // No match
    }
871069
public boolean matches(String target, int start, int end) {
		return this.matches(target, start, end, (Match) null);
	}
157138
public boolean matches(Archive source) {
        if (includePattern != null) {
            return source.reader().entries().stream()
                    .map(name -> name.replace('/', '.'))
                    .filter(name -> !name.equals("module-info.class"))
                    .anyMatch(this::matches);
        }
        return hasTargetFilter();
    }
1108826
public char match(ISense source, ISense target) throws MatcherLibraryException {
        char result = IMappingElement.IDK;
        try {
            String tExtendedGloss = getExtendedGloss(target, 1, IMappingElement.LESS_GENERAL);
            List<String> sourceLemmas = source.getLemmas();
            //variations of this matcher
            //StringTokenizer stSource = new StringTokenizer(tExtendedGloss, " ,.\"'();");
            String lemmaT;
            int counter = 0;
            for (String sourceLemma : sourceLemmas) {
                StringTokenizer stTarget = new StringTokenizer(tExtendedGloss, " ,.\"'();");
                if (!meaninglessWords.contains(sourceLemma))
                    while (stTarget.hasMoreTokens()) {
                        lemmaT = stTarget.nextToken();
                        if (!meaninglessWords.contains(lemmaT)) {
                            if (sourceLemma.equalsIgnoreCase(lemmaT)) {
                                counter++;
                            }
                        }
                    }
            }
            if (counter > threshold) {
                result = IMappingElement.EQUIVALENCE;
            }
        } catch (LinguisticOracleException e) {
            final String errMessage = e.getClass().getSimpleName() + ": " + e.getMessage();
            log.error(errMessage, e);
            throw new MatcherLibraryException(errMessage, e);
        }
        return result;
    }
668583
public T match(CharSequence text, boolean matchPrefix)
    {
        if (root == null)
        {
            throw new IllegalStateException("not compiled");
        }
        int length = text.length();
        for (int ii=0;ii<length;ii++)
        {
            switch (match(text.charAt(ii)))
            {
                case Error:
                    return null;
                case Ok:
                    if (matchPrefix)
                    {
                        T uniqueMatch = state.getUniqueMatch();
                        if (uniqueMatch != null)
                        {
                            state = root;
                            return uniqueMatch;
                        }
                    }
                    break;
                case Match:
                    return getMatched();
            }
        }
        return null;
    }
724599
private boolean containsNumericMatcher(String matcherExpression) {
        for (String numericMatcher : numericMatchers) {
            if (matcherExpression.contains(numericMatcher)) {
                return true;
            }
        }

        return false;
    }
308991
public static boolean matches(Class<? extends Annotation> anno, String consName) {
		return VALIDATORS.get(anno).equals(consName);
	}
664614
public char nodeMatch(IContextMapping<IAtomicConceptOfLabel> acolMapping,
                          Map<INode, ArrayList<IAtomicConceptOfLabel>> nmtAcols,
                          Map<String, IAtomicConceptOfLabel> sourceACoLs,
                          Map<String, IAtomicConceptOfLabel> targetACoLs,
                          INode sourceNode, INode targetNode) throws NodeMatcherException {
        throw new NodeMatcherException("Unsupported operation");
    }
1289509
public ExpressionBuilder matches(final SubordinateTrigger trigger, final String compare) {
		BooleanExpression exp = new CompareExpression(CompareType.MATCH, trigger, compare);
		appendExpression(exp);

		return this;
	}
1319054
protected final boolean anyMatches(ConditionContext context,
			AnnotatedTypeMetadata metadata, Condition... conditions) {
		for (Condition condition : conditions) {
			if (matches(context, metadata, condition)) {
				return true;
			}
		}
		return false;
	}
829202
private boolean containsIgnoreCase(List<String> stringlist, String match) {
		for (String s : stringlist) {
			if (s.equalsIgnoreCase(match)) {
				return true;
			}
		}
		return false;
	}