matchAll == true:
(p LIKE w_1  AND  p LIKE w_2  AND ... AND  p LIKE w_m)

matchAll == false:
(p LIKE w_1  OR   p LIKE w_2  OR  ... OR   p LIKE w_m)
486217
private void _buildTextMatchBinding(
                    final TextMatchBinding binding,
                    final StringBuilder stmt,
                    final List<Object> params
                    )
    {
        int  size = binding.getText().size();

        if (size == 1) {
            String  pattern = _WILDCARD_ + binding.getText().iterator().next() + _WILDCARD_;
            LikeBinding  like = new LikeBinding( binding.getProperty(), pattern );
            _buildLikeBinding( like, stmt, params );
        } else if (size > 1) {
            LogicalBinding  logic = null;
            if (binding.isMatchAll()) {
                logic = new AndBinding();
            } else {
                logic = new OrBinding();
            }
            String  prop = binding.getProperty();
            for (String  w : binding.getText()) {
                String  pattern = _WILDCARD_ + w + _WILDCARD_;
                LikeBinding  like = new LikeBinding( prop, pattern );
                logic.addElement( like );
            }
            _buildLogicalBinding( logic, stmt, params );
        } else {
            // size < 1
            throw new IllegalArgumentException( "no text in TextMatchBinding" );
        }
    }
1168069
public boolean matchMidClauses(char[] chars, int start, int length) 
  {
    return pattern.matchMiddle(chars, start, start+length);

  }
1015568
def slice_match(sub, counter):
    

    if sub.start is not None and counter < sub.start:
        return False
    if sub.stop is not None and counter >= sub.stop:
        raise StopIteration
    if sub.step is not None:
        if sub.start is None:
            if counter % sub.step != 0:
                return False
        else:
            if (counter - sub.start) % sub.step != 0:
                return False
    return True
1351442
function matchArgs(one,two) {
  var match = false;
  if (one === two) {
    match = true;
  } else if (lib.type.isArray(one) || lib.type.isObject(one)) {
    try {
      lib.assert.deepEqual(one,two);
      match = true;
    } catch(e) {
    }
  } else {
    try {
      lib.assert.strictEqual(one,two);
      match = true;
    } catch(e) {
    }
  }
  return match;
}
1305642
function (set1, set2) {
				
		if (set1 instanceof Array === false ||
			set2 instanceof Array === false)
			return false;
		
		// return true if at least one match is found
		for (var i=0; i < set1.length; i++) {
			for (var j=0; j < set2.length; j++) {
				if (set1[i] === set2[j]) {
                    //console.log("matched group/permission: " + set1[i]);
					return true;
                }
            }
        }
		return false;
	}
767865
public static boolean matches(String pattern, String value) {
        Pattern p = Pattern.compile(pattern);
        Matcher m = p.matcher(value);
        return m.matches();
    }
209076
def match_regex_list(patterns, string):
    """"""

    for p in patterns:

        if re.findall(p, string):
            return True

    return False
1176415
def match_sp_sep(first, second):
    
    if isinstance(first, list):
        one = [set(v.split(" ")) for v in first]
    else:
        one = [{v} for v in first.split(" ")]

    if isinstance(second, list):
        other = [set(v.split(" ")) for v in second]
    else:
        other = [{v} for v in second.split(" ")]

    # all values in one must appear in other
    if any(rt not in other for rt in one):
        return False
    return True
1217914
def is_match(self, match):
        
        result = False
        if self == match:
            result = True
        elif isinstance(match, str) and fnmatchcase(self.name, match):
            result = True  # Found by instance or name
        return result
713856
function boolMatch(s, matchers) {
    var i, matcher, down = s.toLowerCase();
    matchers = [].concat(matchers);
    for (i = 0; i < matchers.length; i += 1) {
      matcher = matchers[i];
      if (!matcher) continue;
      if (matcher.test && matcher.test(s)) return true;
      if (matcher.toLowerCase() === down) return true;
    }
  }
1258072
function matches(str, match) {
    if (Array.isArray(match)) {
        var l = match.length;
        for( var s=0; s < l; s++) {
            if ( mm(str,match[s])) {
                return true;
            }
        }
        return false;
    }
    return match.test(str);
}
104957
public static boolean matches(Pattern patternMatcher, Object... elements)
    {
        if (patternMatcher == null) {
            return true;
        }

        for (Object element : elements) {
            if (matches(patternMatcher, element)) {
                return true;
            }
        }

        return false;
    }
414142
def matchall(r, s, flags=0):
    
    try:
        return [m.group(0) for m in matchiter(r, s, flags)]
    except ValueError:
        return None
1152819
protected static boolean matches( String text , String pattern , boolean ignoreCase )
    {
        if (text == null)
            return false;
        if (pattern.length() == 0)
            return text.length() == 0;
        
        int textPos = 0;
        boolean startWithAny = false;
        StringTokenizer st = new StringTokenizer(pattern,"*?",true);
        while (st.hasMoreTokens())
        {
            String subPattern = st.nextToken();
            
            if (subPattern.equals("*"))
            {
                startWithAny = true;
            }
            else
            if (subPattern.equals("?"))
            {
                if (textPos < text.length())
                    textPos++;
                else
                    return false;
            }
            else
            {
                if (startWithAny)
                {
                    textPos = indexOf(text,subPattern,textPos,ignoreCase);
                    if (textPos == -1) return false;
                    startWithAny = false;
                }
                else
                {
                    if (!startsWith(text,subPattern,textPos,ignoreCase))
                        return false;
                }
                textPos += subPattern.length();
            }
        }
        
        // Remaining text
        if (textPos < text.length())
            if (!startWithAny)
                return false;
        
        return true;
    }
147523
private boolean match(char []a, int aOff, int aLength, char []b)
  {
    int bLength = b.length;

    if (aLength != bLength)
      return false;

    for (int i = aLength - 1; i >= 0; i--) {
      char chA = a[aOff + i];
      char chB = b[i];

      if (chA != chB && chA + 'a' - 'A' != chB) {
        return false;
      }
    }

    return true;
  }
112756
def matches_pattern(self, other):
        """"""
        ismatch = False
        if isinstance(other, Userdata):
            for key in self._userdata:
                if self._userdata[key] is None or other[key] is None:
                    ismatch = True
                elif self._userdata[key] == other[key]:
                    ismatch = True
                else:
                    ismatch = False
                    break
        return ismatch
972713
public static boolean match(WildcardPattern[] patterns, String value) {
    for (WildcardPattern pattern : patterns) {
      if (pattern.match(value)) {
        return true;
      }
    }
    return false;
  }