Remove a {@link RuleWrapper} from the list.

@param remRule the {@link Rule} to remove.
197949
public void removeRule( RuleWrapper remRule ) {
        Rule rule = remRule.getRule();
        featureTypeStyle.rules().remove(rule);
        rulesWrapperList.remove(remRule);
    }
324643
public void unbind(ValidationObject validationObject)
    {
        Integer id = System.identityHashCode(validationObject);
    	m_unbinding.add(id);
        List<ProposedValue> proposedValues = new ArrayList<ProposedValue>();
    	ProxyObject proxyObject = getSession().getProxyObject(validationObject);
    	for (ProxyField proxyField: proxyObject.getFieldMap().values())
    	{
    		if (!proxyField.isDerived())
    		{
    			// Figure out if this property contains a list or a known object type
    			// we want to ignore those and only reset primitive objects (long, String etc)
    			Class<?> clazz = proxyField.getPropertyMetadata().getGetMethod().getReturnType();
       			if (clazz.isAssignableFrom(List.class))
    			{
    				continue;
    			}
       			if (getSession().getValidationEngine().getClassMetadata(clazz) != null)
    			{
    				continue;
    			}
    			RuleProxyField ruleProxyField = getRuleProxyField(proxyField);
    			if (ruleProxyField.isDifferent(proxyField.getInitialValue()))
    			{
    				ProposedValue pv = new ProposedValue(ruleProxyField,proxyField.getInitialValue());
    				proposedValues.add(pv);
    			}
    		}    		
    	}
        setValues(proposedValues);
        m_boundObjects.remove(id);
    	m_unbinding.remove(id);
        List<String> kill = new ArrayList<String>();
        for (Map.Entry<String, RuleContext> entry: m_ruleContextsMap.entrySet())
        {
        	if (entry.getValue().getValidationObject() == validationObject)
        	{
        		kill.add(entry.getKey());
        	}
        }

        for (String key: kill)
        {
        	RuleContext rc = m_ruleContextsMap.remove(key);
        	rc.reset();
        }
    }
149174
public final void entryRuleAbstractRule() throws RecognitionException {
        try {
            // InternalXtext.g:104:1: ( ruleAbstractRule EOF )
            // InternalXtext.g:105:1: ruleAbstractRule EOF
            {
             before(grammarAccess.getAbstractRuleRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            ruleAbstractRule();

            state._fsp--;

             after(grammarAccess.getAbstractRuleRule()); 
            match(input,EOF,FollowSets000.FOLLOW_2); 

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
1312790
public final void ruleEnumRule() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalXtext.g:1408:2: ( ( ( rule__EnumRule__Group__0 ) ) )
            // InternalXtext.g:1409:2: ( ( rule__EnumRule__Group__0 ) )
            {
            // InternalXtext.g:1409:2: ( ( rule__EnumRule__Group__0 ) )
            // InternalXtext.g:1410:3: ( rule__EnumRule__Group__0 )
            {
             before(grammarAccess.getEnumRuleAccess().getGroup()); 
            // InternalXtext.g:1411:3: ( rule__EnumRule__Group__0 )
            // InternalXtext.g:1411:4: rule__EnumRule__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__EnumRule__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getEnumRuleAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

        }
        return ;
    }
955933
public static void unregisterURLRewriter( ServletRequest request, URLRewriter rewriter )
    {
        if ( rewriter == null ) { return; }

        ArrayList/*< URLRewriter >*/ rewriters = getRewriters( request );

        if ( rewriters == null )
        {
            return;
        }
        else
        {
            rewriters.remove( rewriter );

            if ( rewriters.size() == 0 )
            {
                request.removeAttribute( URL_REWRITERS_KEY );
            }
        }
    }
988871
def remove_rule(self, name):
        
        self._rule_attrs.remove(name)
        delattr(self, name)
26710
@Override
	public void clearCache(CPRule cpRule) {
		entityCache.removeResult(CPRuleModelImpl.ENTITY_CACHE_ENABLED,
			CPRuleImpl.class, cpRule.getPrimaryKey());

		finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
		finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
	}
76059
public static LineSymbolizer lineSymbolizerFromRule( Rule rule ) {
        List<Symbolizer> symbolizers = rule.symbolizers();
        LineSymbolizer lineSymbolizer = null;
        for( Symbolizer symbolizer : symbolizers ) {
            if (symbolizer instanceof LineSymbolizer) {
                lineSymbolizer = (LineSymbolizer) symbolizer;
                break;
            }
        }
        if (lineSymbolizer == null) {
            throw new IllegalArgumentException();
        }
        return lineSymbolizer;
    }
1059468
public void addRule(String nonterminal, List<String> rhs)
    {
        addRule(null, nonterminal, "", false, rhs);
    }
664400
public void resolveBeanClass(ItemRule itemRule) throws IllegalRuleException {
        Iterator<Token[]> it = ItemRule.tokenIterator(itemRule);
        if (it != null) {
            while (it.hasNext()) {
                Token[] tokens = it.next();
                if (tokens != null) {
                    for (Token token : tokens) {
                        resolveBeanClass(token);
                    }
                }
            }
        }
    }
371627
public void setRules(java.util.Collection<RuleSummary> rules) {
        if (rules == null) {
            this.rules = null;
            return;
        }

        this.rules = new java.util.ArrayList<RuleSummary>(rules);
    }
803215
public RuleWrapper getFirstRule() {
        if (featureTypeStylesWrapperList.size() > 0) {
            FeatureTypeStyleWrapper featureTypeStyleWrapper = featureTypeStylesWrapperList.get(0);
            List<RuleWrapper> rulesWrapperList = featureTypeStyleWrapper.getRulesWrapperList();
            if (rulesWrapperList.size() > 0) {
                RuleWrapper ruleWrapper = rulesWrapperList.get(0);
                return ruleWrapper;
            }
        }
        return null;
    }
159312
@Indexable(type = IndexableType.DELETE)
	@Override
	public CPRuleAssetCategoryRel deleteCPRuleAssetCategoryRel(
		CPRuleAssetCategoryRel cpRuleAssetCategoryRel) {
		return cpRuleAssetCategoryRelPersistence.remove(cpRuleAssetCategoryRel);
	}
488916
public final void ruleAbstractRule() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalXtext.g:116:2: ( ( ( rule__AbstractRule__Alternatives ) ) )
            // InternalXtext.g:117:2: ( ( rule__AbstractRule__Alternatives ) )
            {
            // InternalXtext.g:117:2: ( ( rule__AbstractRule__Alternatives ) )
            // InternalXtext.g:118:3: ( rule__AbstractRule__Alternatives )
            {
             before(grammarAccess.getAbstractRuleAccess().getAlternatives()); 
            // InternalXtext.g:119:3: ( rule__AbstractRule__Alternatives )
            // InternalXtext.g:119:4: rule__AbstractRule__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__AbstractRule__Alternatives();

            state._fsp--;


            }

             after(grammarAccess.getAbstractRuleAccess().getAlternatives()); 

            }


            }

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

            	restoreStackSize(stackSize);

        }
        return ;
    }
186075
protected static <E extends LogRecordHandler> boolean removeHandler(Class<E> toRemove) {
    boolean rtn = false;
    Iterator<LogRecordHandler> iter = handlers.iterator();
    while(iter.hasNext()){
      if(iter.next().getClass().equals(toRemove)){
        rtn = true;
        iter.remove();
      }
    }
    return rtn;
  }
766503
public void removeChunkedMessageWrapper(long wrapperId)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "removeChunkedMessageWrapper", Long.valueOf(wrapperId));
        inProgressMessages.remove(Long.valueOf(wrapperId));
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "removeChunkedMessageWrapper");
    }
1122027
public NeedleRule withOuter(final MethodRule rule) {
        if (rule instanceof InjectionProvider) {
            addInjectionProvider((InjectionProvider<?>) rule);
        }
        methodRuleChain.add(0, rule);
        return this;
    }