A mixin inline never it self.

@param rule the rule
@return true, if the mixin is currently formatting
502465
boolean containsRule( Rule rule ) {
        for( int i = state.stackIdx - 1; i >= 0; i-- ) {
            if( rule == state.stack.get( i ).mixin ) {
                return true;
            }
        }
        return false;
    }
1001137
public String gaRuleIdentifyer(final AbstractRule rule) {
    final String plainName = RuleNames.getRuleNames(rule).getUniqueRuleName(rule);
    return this.toJavaIdentifier(plainName, true);
  }
488942
private static function isRule($rule) {

		if(false === is_string($rule)) {
			return trigger_error(sprintf('Argument 1 passed to %s() must be of the type string, "%s" given', __METHOD__, gettype($rule)), E_USER_ERROR);
		}

		$class = static :: getRuleClass($rule);

		return true === class_exists($class);
	}
132106
public MultipleRuleContext<DPO, RI, RO> check(Collection<Rule<RI, RO>> rules) {
        if (rules != null) {
            addedRules.addAll(rules);
        }

        // Stay in the same context and re-use the same instance because no type has changed
        return this;
    }
678829
function hasParentRule(rule) {
  if (!rule.parent) {
    return false
  }

  if (rule.parent.type === 'rule') {
    return true
  }

  return hasParentRule(rule.parent)
}
148196
private boolean hasRuleSet(CssAtRule atRule, CssTokenIterator iter)
  {
    int debugIndex;
    if (debug)
    {
      checkArgument(iter.last.getChar() == '{');
      debugIndex = iter.index();
    }
    List<CssToken> list = iter.list;
    for (int i = iter.index() + 1; i < list.size(); i++)
    {
      CssToken tk = list.get(i);
      if (MATCH_OPENBRACE.apply(tk))
      {
        return true;
      }
      else if (MATCH_SEMI_CLOSEBRACE.apply(tk))
      {
        return false;
      }
    }
    if (debug)
    {
      checkState(iter.last.getChar() == '{');
      checkState(iter.index() == debugIndex);
    }
    return false;
  }
366405
public static boolean validate(
		BiMap<Character, ObfuscationOperationRule<Character, Character>> rules)
	{
		Set<Character> keySet = rules.keySet();
		for (Entry<Character, ObfuscationOperationRule<Character, Character>> entry : rules
			.entrySet())
		{
			ObfuscationOperationRule<Character, Character> value = entry.getValue();
			Character operatedCharacter = Operation.operate(value.getCharacter(),
				value.getOperation());
			if (keySet.contains(operatedCharacter))
			{
				return false;
			}
		}
		return true;
	}
267851
private function isRule($rule) {

		if(false === is_string($rule)) {
			return false;
		}

		$class = $this -> getRuleClass($rule);

		return true === class_exists($class);
	}
849124
protected function isNested($rule)
    {
        if (isset($rule->rules) && is_array($rule->rules) && count($rule->rules) > 0) {
            return true;
        }

        return false;
    }
498837
public static String prettyPrintRule(Rule rule)
    {
        StringBuilder result = new StringBuilder();
        if (rule instanceof Context)
        {
            final Context context = (Context) rule;
            RuleProvider provider = (RuleProvider) context.get(RuleMetadataType.RULE_PROVIDER);

            if (provider != null && provider.getMetadata() != null)
            {
                result.append(provider.getMetadata().getPhase().getSimpleName()).append(" - ");
                result.append(provider.getMetadata().getID()).append(" - ");
            }

            if (rule.getId() != null)
                result.append(rule.getId());
        }

        return result.toString();
    }
926260
function filterValidRule(rule) {
  return (rule.hasOwnProperty('match')&&typeof rule.match === "object")
  && (rule.hasOwnProperty('use') && (
    typeof rule.use === "object"
    || typeof rule.use === "function"
  ))
  && (
    (rule.match.hasOwnProperty('request'))
    || (rule.match.hasOwnProperty('base'))
  )
}
57246
public final void ruleDisjunction() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalXtext.g:633:2: ( ( ( rule__Disjunction__Group__0 ) ) )
            // InternalXtext.g:634:2: ( ( rule__Disjunction__Group__0 ) )
            {
            // InternalXtext.g:634:2: ( ( rule__Disjunction__Group__0 ) )
            // InternalXtext.g:635:3: ( rule__Disjunction__Group__0 )
            {
             before(grammarAccess.getDisjunctionAccess().getGroup()); 
            // InternalXtext.g:636:3: ( rule__Disjunction__Group__0 )
            // InternalXtext.g:636:4: rule__Disjunction__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__Disjunction__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getDisjunctionAccess().getGroup()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
1216707
public final void ruleXExpression() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalXbase.g:71:2: ( ( ruleXAssignment ) )
            // InternalXbase.g:72:2: ( ruleXAssignment )
            {
            // InternalXbase.g:72:2: ( ruleXAssignment )
            // InternalXbase.g:73:3: ruleXAssignment
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getXExpressionAccess().getXAssignmentParserRuleCall()); 
            }
            pushFollow(FOLLOW_2);
            ruleXAssignment();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getXExpressionAccess().getXAssignmentParserRuleCall()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
805672
private boolean isDependent(String style) {
		if (!style.trim().startsWith("<")) {
			return false;
		}
		Pattern p = Pattern.compile("rel\\s*=\\s*\"\\s*independent-parent\\s*\"");
		Matcher m = p.matcher(style);
		return m.find();
	}
149066
public static PolygonSymbolizer polygonSymbolizerFromRule( Rule rule ) {
        List<Symbolizer> symbolizers = rule.symbolizers();
        PolygonSymbolizer polygonSymbolizer = null;
        for( Symbolizer symbolizer : symbolizers ) {
            if (symbolizer instanceof PolygonSymbolizer) {
                polygonSymbolizer = (PolygonSymbolizer) symbolizer;
                break;
            }
        }
        if (polygonSymbolizer == null) {
            throw new IllegalArgumentException();
        }
        return polygonSymbolizer;
    }
1189281
def rule=(rule)
      validator = EnumAttributeValidator.new('String', ["INCLUDE", "EXCLUDE"])
      unless validator.valid?(rule)
        fail ArgumentError, "invalid value for 'rule', must be one of #{validator.allowable_values}."
      end
      @rule = rule
    end
1299473
function isValidExtendedRule(rule) {
    return ( typeof rule       === 'object' &&
             typeof rule.url   === 'string' &&
             ( typeof rule.delay === 'number' ||
               typeof rule.delay === 'string' ) &&
             typeof rule.rewrite === 'string'
           );
}