Match against +Fear::Right+

 @param conditions [<#==>]
 @return [Fear::EitherPatternMatch]
175078
def right(*conditions, &effect)
      branch = Fear.case(Fear::Right, &RIGHT_EXTRACTOR).and_then(Fear.case(*conditions, &effect))
      or_else(branch)
    end
772626
def condition_fulfilled?(model, condition, options)
      case condition
      when Symbol
        result = model.send(condition)
      when Proc
        result = call_proc(condition, model, options)
      end
      !!result
    end
427629
public Condition<S, D> or(Condition<S, D> condition) {
    Assert.notNull(condition, "condition");
    return Conditions.or(this, condition);
  }
910618
def match_any(self, match):
        
        match_key = '_id'
        param = '$exists'
        if match:
            flag = 'true'
        else:
            flag = 'false'
        if match_key in self._query_terms:
            self._query_terms[match_key][param] = flag
        else:
            self._query_terms[match_key] = {param: flag}
1353607
def _match_lhs(cp, rules):
    """"""
    rule_matches = []
    for rule in rules:
        reactant_pattern = rule.rule_expression.reactant_pattern
        for rule_cp in reactant_pattern.complex_patterns:
            if _cp_embeds_into(rule_cp, cp):
                rule_matches.append(rule)
                break
    return rule_matches
1372337
def matches?(query)
      return true if query.nil? || query.respond_to?(:empty?) && query.empty?

      case query
      when Symbol
        query.to_s == id.to_s
      when Element
        query == self
      when Regexp
        to_s.match(query)
      when /^\/(.+)\/$/
        to_s.match(Regexp.new($1))
      when /@(\*|\w+)(?:\[([^\]]*)\])?/
        query.scan(/(!)?@(\*|\w+)(?:\[([^\]]*)\])?/).any? do |non, type, condition|
          if (non ? !has_type?(type) : has_type?(type))
            if condition.nil? || condition.empty?
              true
            else
              condition.to_s.split(/\s*\|\|\s*/).any? do |conditions|
                meets_all? conditions.split(/\s*(?:,|&&)\s*/)
              end
            end
          end
        end
      else
        id.to_s == query
      end
    end
593964
def overlaps_with(self, othermatch, strict=False):
        '''
        
        '''
        one = self.matches_entry(othermatch, strict)
        if strict:
            return one
        return one and othermatch.matches_entry(self, strict)
126325
def match!(message)
      params = {}
      args = []
      @conditions.each do |condition|
        if result = condition.match(message)
          params.merge!(result[0])
          args += result[1]
        else
          return nil
        end
      end
      { :block => @block, :klass => @klass, :params => params, :args => args }
    end
888462
def token(cls: Type[ConditionType], left: Any, op: Optional[Any] = None,
              right: Optional[Any] = None) -> ConditionType:
        
        condition = cls()
        condition.left = left
        if op:
            condition.op = op
        if right:
            condition.right = right
        return condition
2733
def match_records(records)
      conditions = self.conditions
      records.select { |record| conditions.matches?(record) }
    end
215383
def matches_conditions?(object, query)
        query[:guard] == false ||
        Array(if_condition).all? {|condition| evaluate_method(object, condition)} &&
        !Array(unless_condition).any? {|condition| evaluate_method(object, condition)}
      end
1151436
def match_pattern(expr_or_pattern: object, expr: object) -> MatchDict:
    
    try:  # first try expr_or_pattern as a Pattern
        return expr_or_pattern.match(expr)
    except AttributeError:  # expr_or_pattern is an expr, not a Pattern
        if expr_or_pattern == expr:
            return MatchDict()  # success
        else:
            res = MatchDict()
            res.success = False
            res.reason = "Expressions '%s' and '%s' are not the same" % (
                          repr(expr_or_pattern), repr(expr))
            return res
230474
def match(self, *args):
        """"""

        self.fall = self.fall or not args
        self.fall = self.fall or (self.value in args)

        return self.fall
1194253
def match?
      match = false
      @instance.current_node.recursive_children do |child_node|
        match = match || (child_node && child_node.match?(@rules))
      end
      !match
    end
556537
def match(self, cond, node):
        

        op, args = cond

        # 条件匹配
        if op == 'and':
            for arg in args:
                if not self.match(arg, node):
                    return False
            return True

        if op == 'or':
            for arg in args:
                if self.match(arg, node):
                    return True
            return False

        # 属性匹配
        comparator = self.comparators.get(op)
        if comparator:
            attribute, value = args
            targetValue = node.getAttr(attribute)
            return comparator.compare(targetValue, value)

        raise NoSuchComparatorException(op, 'poco.sdk.DefaultMatcher')
1298370
def fnmatches(entry, *pattern_list):
    

    for pattern in pattern_list:
        if pattern and fnmatch(entry, pattern):
            return True
    return False
1168107
private static boolean matchesPatternList(final String str, final List<Pattern> patterns) {
        if (patterns != null) {
            for (final Pattern pattern : patterns) {
                if (pattern.matcher(str).matches()) {
                    return true;
                }
            }
        }
        return false;
    }