removeFilteredPolicy removes rules based on field filters from the current policy.
344479
boolean removeFilteredPolicy(String sec, String ptype, int fieldIndex, String... fieldValues) {
        boolean ruleRemoved = model.removeFilteredPolicy(sec, ptype, fieldIndex, fieldValues);
        if (!ruleRemoved) {
            return false;
        }

        if (adapter != null && autoSave) {
            try {
                adapter.removeFilteredPolicy(sec, ptype, fieldIndex, fieldValues);
            } catch (Error e) {
                if (!e.getMessage().equals("not implemented")) {
                    throw e;
                }
            }

            if (watcher != null) {
                // error intentionally ignored
                watcher.update();
            }
        }

        return true;
    }
141048
public void removeFilterModel(final FilterModel model) {
		if (model.getUrlPatterns() != null) {
			try {
				deassociateBundle(model.getContextModel().getVirtualHosts(), model.getContextModel().getBundle());
				filterLock.writeLock().lock();
				for (String virtualHost:resolveVirtualHosts(model)) {
					for (String urlPattern : model.getUrlPatterns()) {
							String fullPath = getFullPath(model.getContextModel(), urlPattern);
							Set<UrlPattern> urlSet = filterUrlPatterns.get(virtualHost).get(fullPath);
							UrlPattern toDelete = null;
							for (UrlPattern pattern : urlSet) {
									FilterModel filterModel = (FilterModel) pattern.getModel();
									Class<?> filter = filterModel.getFilterClass();
									Class<?> matchFilter = model.getFilterClass();
									if (filter != null && filter.equals(matchFilter)) {
											toDelete = pattern;
											break;
									}
							}
							urlSet.remove(toDelete);
					}
				}
			} finally {
				filterLock.writeLock().unlock();
			}
		}
	}
159557
def delete_dscp_marking_rule(self, rule, policy):
        """"""
        return self.delete(self.qos_dscp_marking_rule_path %
                           (policy, rule))
673183
func (a *Adapter) RemoveFilteredPolicy(sec string, ptype string, fieldIndex int, fieldValues ...string) error {
	return errors.New("not implemented")
}
1147548
def remove_file_filters(self, file_filters):
        
        self.file_filters = util.remove_from_list(self.file_filters,
                                                  file_filters)
442319
def delete_policy(self, scaling_group, policy):
        
        uri = "/%s/%s/policies/%s" % (self.uri_base,
                utils.get_id(scaling_group), utils.get_id(policy))
        resp, resp_body = self.api.method_delete(uri)
1037055
public final function removeRule($field, $rule = null) {
		if ($rule == null) {
			unset($this->rules[ $field ]);
		} else {
			$idx = $this->ruleKeys[ $field ][ $rule ];
			unset($this->rules[ $field ][ $idx ]);
		}
	}
79381
public void removeFilter(AbstractLogFilter<E> filter) {
                Validate.notNull(filter);
                filters.remove(filter);
                uptodate = false;
                filter.deleteObserver(this);
        }
920515
def firewall_policy_remove_rule(self, firewall_policy, body=None):
        """"""
        return self.put(self.firewall_policy_remove_path % (firewall_policy),
                        body=body)
903046
public OperationFuture<List<AntiAffinityPolicy>> delete(AntiAffinityPolicyFilter filter) {
        List<AntiAffinityPolicy> policyRefs = getRefsFromFilter(filter);
        return delete(policyRefs.toArray(new AntiAffinityPolicy[policyRefs.size()]));
    }
325104
function(){
		var i = filters.length,
		    x = 0,
		    urlObj = url.parse(this.url, parseQueryString=false);

		while (x < i) {
			if(filters[x].domain === urlObj.hostname){
				for (var y = 0; y < filters[x].hCardBlockList.length; y++) {
					delete this.representativehCard.properties[filters[x].hCardBlockList[y]];
				}
			}
			x++;
		}
	}
1156984
public function removeIDFilterIfNeeded()
    {
        if (!$this->useIdFilter && !$this->idFilterRemoved) {
            $this->removeDefaultIDFilter();

            $this->layout->removeDefaultIDFilter();

            $this->idFilterRemoved = true;
        }
    }
903632
func (e *Enforcer) RemoveFilteredGroupingPolicySafe(fieldIndex int, fieldValues ...string) (result bool, err error) {
	defer func() {
		if r := recover(); r != nil {
			err = fmt.Errorf("%v", r)
			result = false
		}
	}()

	result = e.RemoveFilteredGroupingPolicy(fieldIndex, fieldValues...)
	err = nil
	return
}
747375
func (e *Enforcer) RemoveFilteredNamedGroupingPolicy(ptype string, fieldIndex int, fieldValues ...string) bool {
	ruleRemoved := e.removeFilteredPolicy("g", ptype, fieldIndex, fieldValues...)

	if e.autoBuildRoleLinks {
		e.BuildRoleLinks()
	}
	return ruleRemoved
}
1374020
def remove(self, (s, p, o), context=None):
        
        named_graph = _get_named_graph(context)
        query_sets = _get_query_sets_for_object(o)

        filter_parameters = dict()
        if named_graph is not None:
            filter_parameters['context_id'] = named_graph.id
        if s:
            filter_parameters['subject'] = s
        if p:
            filter_parameters['predicate'] = p
        if o:
            filter_parameters['object'] = o

        query_sets = [qs.filter(**filter_parameters) for qs in query_sets]  # pylint: disable=W0142

        for qs in query_sets:
            qs.delete()
561593
public void clear() {
        ruleMap.clear();
        ruleConversionMap.clear();
        absentTypes.clear();
        checkedTypes.clear();
        checkedRules.clear();
        fruitlessRules.clear();
    }
178293
public function removePolicy($sec, $ptype, array $rule)
    {
        foreach ($this->model[$sec][$ptype]->policy as $i => $r) {
            if (empty(array_diff($rule, $r))) {
                array_splice($this->model[$sec][$ptype]->policy, $i, 1);

                return true;
            }
        }

        return false;
    }