Apply `fullmatch`.
768754
def fullmatch(self, string, *args, **kwargs):
        """"""

        return self._pattern.fullmatch(string, *args, **kwargs)
275718
def ismatch(self, s):
        
        if self._ismatchfun(s) and self._compiled_pattern.match(s):
            return True
        return False
1337453
private Match matchImpl(List<Entry> desiredLocales, int threshold) {
    int bestDistance = MAX_DISTANCE;
    Entry bestMatch = null;
    for (Entry desired : desiredLocales) {
      List<String> exact = exactMatch.get(desired.locale);
      if (exact != null) {
        return new Match(exact.get(0), 0);
      }
      for (Entry supported : supportedLocales) {
        int distance = DISTANCE_TABLE.distance(desired.locale, supported.locale, threshold);
        if (distance < bestDistance) {
          bestDistance = distance;
          bestMatch = supported;
        }
      }
    }
    return bestMatch == null 
        ? new Match(firstEntry.bundleId, MAX_DISTANCE)
        : new Match(bestMatch.bundleId, bestDistance);
  }
573759
def apply(self, search, field, value):
        """"""
        # We assume that the field in question has a "raw" counterpart.
        return search.query('match', **{'{}.raw'.format(field): value})
645864
def apply(self, collection, ops, **kwargs):
        """"""
        validator = lambda obj: all(op(obj, val) for (op, val) in ops)  # noqa
        return [o for o in collection if validator(o)]
508391
def match(self, category, pattern):
        """"""

        return fnmatch.fnmatch(category, pattern, flags=self.FNMATCH_FLAGS)
1347149
function matchImmediate(el, match) {
        var matched = 1, startEl = el, relativeOp, startMatch = match;
        do {
            matched &= singleMatch(el, match);
            if (matched) {
                // advance
                match = match && match.prev;
                if (!match) {
                    return true;
                }
                relativeOp = relativeExpr[match.nextCombinator];
                el = dir(el, relativeOp.dir);
                if (!relativeOp.immediate) {
                    return {
                        // advance for non-immediate
                        el: el,
                        match: match
                    };
                }
            } else {
                relativeOp = relativeExpr[match.nextCombinator];
                if (relativeOp.immediate) {
                    // retreat but advance startEl
                    return {
                        el: dir(startEl, relativeExpr[startMatch.nextCombinator].dir),
                        match: startMatch
                    };
                } else {
                    // advance (before immediate match + jump unmatched)
                    return {
                        el: el && dir(el, relativeOp.dir),
                        match: match
                    };
                }
            }
        } while (el);    // only occur when match immediate
        // only occur when match immediate
        return {
            el: dir(startEl, relativeExpr[startMatch.nextCombinator].dir),
            match: startMatch
        };
    }
742820
void setMatcher(ContentMatcher m)
  {

    if (tc.isEntryEnabled())
      tc.entry(
        this,cclass,
        "setMatcher",
        "matcher: " + m + ", hasContent: " + new Boolean(hasContent));

    wildMatchers.add(m);
    this.hasContent |= m.hasTests();

    if (tc.isEntryEnabled())
      tc.exit(this,cclass, "setMatcher");
  }
709382
def match_handle(loc, tokens):
    """"""
    if len(tokens) == 4:
        matches, match_type, item, stmts = tokens
        cond = None
    elif len(tokens) == 5:
        matches, match_type, item, cond, stmts = tokens
    else:
        raise CoconutInternalException("invalid match statement tokens", tokens)

    if match_type == "in":
        invert = False
    elif match_type == "not in":
        invert = True
    else:
        raise CoconutInternalException("invalid match type", match_type)

    matching = Matcher(loc, match_check_var)
    matching.match(matches, match_to_var)
    if cond:
        matching.add_guard(cond)
    return (
        match_to_var + " = " + item + "\n"
        + matching.build(stmts, invert=invert)
    )
217679
private function buildMatcher()
    {
        $this->matchers = [];
        foreach ($this->option as $key => $value) {
            $this->matchers[$key] = $this->buildOneMatcher($key, $value);
        }
    }
545454
def match(self, files):
        """"""
        if not files:
            return set()

        if (self.matched_inherit.all_files()
                or self.matched_and_subdir.all_files()
                or self.matched_no_subdir.all_files()):
            # Optimization: one of the matched patterns matches everything
            # So simply return it
            return set(files)

        unmatched = set(files)
        matched = set()
        for pattern_set in self._matching_pattern_sets():
            pattern_set.match_files(matched, unmatched)
            if not unmatched:
                # Optimization: If we have matched all files already
                # simply return at this point - nothing else to do
                break

        return matched
191534
def _ParseMatchGrp(self, key, val):
    """"""
    if key in self._match_keywords:
      self._ParseEntry(key, val)
1281901
private boolean doesMatchFullName(String firstName, String fullName){
        boolean matching = false;
        if(firstName != null && !firstName.isEmpty() && fullName != null && !fullName.isEmpty()){
            String firstFromCMDB;
            String[] array = fullName.split(" ");

            firstName = firstName.toLowerCase();
            firstFromCMDB = array[0];
            firstFromCMDB = firstFromCMDB.toLowerCase();
            if(firstFromCMDB.length() < firstName.length()){
                if(firstName.indexOf(firstFromCMDB) != -1){
                    matching = true;
                }
            }else if (firstFromCMDB.indexOf(firstName) != -1){
                matching = true;
            }
        }
        return matching;
    }
936849
def match(self, selector, index):
        """"""

        pseudo = None
        m = self.re_pseudo_name.match(selector, index)
        if m:
            name = util.lower(css_unescape(m.group('name')))
            pattern = self.patterns.get(name)
            if pattern:
                pseudo = pattern.match(selector, index)
                if pseudo:
                    self.matched_name = pattern

        return pseudo
940420
public static P<String> fullTextMatch(String configuration, boolean plain, final String value){
		return new P<>(new FullText(configuration,null,plain),value);
	}
1023786
def apply(self, model):
        """"""
        model.medium = {row.exchange: row.uptake
                        for row in self.data.itertuples(index=False)}
36719
def match(self, *args):
        """"""
        if self.fall or not args:
            return True
        elif self.value in args: # changed for v1.5, see below
            self.fall = True
            return True
        else:
            return False