Drops rules from the queue of the rules that still need to be
            evaluated for the currently processed field.
            If no arguments are given, the whole queue is emptied.
770950
def _drop_remaining_rules(self, *rules):
        
        if rules:
            for rule in rules:
                try:
                    self._remaining_rules.remove(rule)
                except ValueError:
                    pass
        else:
            self._remaining_rules = []
1202012
def clear(self):
        
        self._lock = None
        self._ipopo_instance = None
        self._context = None
        self.requirement = None
        self._value = None
        self._field = None
658363
public void clear()
    {
        _version++;
        if (_version>1000)
        {
            _version=0;
            for (int i=_fields.size();i-->0;)
            {
                Field field=(Field)_fields.get(i);
                if (field!=null)
                    field.clear();
            }
        }
    }
314818
public void clear() {
    this.posLiterals = new HashMap<>();
    this.negLiterals = new HashMap<>();
    this.generatedVariables = new HashSet<>();
    this.nots = new HashMap<>();
    this.implications = new HashMap<>();
    this.equivalences = new HashMap<>();
    this.ands2 = new HashMap<>();
    this.ands3 = new HashMap<>();
    this.ands4 = new HashMap<>();
    this.andsN = new HashMap<>();
    this.ors2 = new HashMap<>();
    this.ors3 = new HashMap<>();
    this.ors4 = new HashMap<>();
    this.orsN = new HashMap<>();
    this.pbConstraints = new HashMap<>();
    this.ccCounter = 0;
    this.pbCounter = 0;
    this.cnfCounter = 0;
  }
1331327
public void clear() {
        modCount++;
        for (int i = 0; i < size; i++)
            queue[i] = null;
        size = 0;
    }
316227
public void clear() {
		names.clear();
		values = null;
		valueType.clear();
		args.clear();
		whereArgs.clear();
		compiledStatement = null;
		compiledStatementBindIndex = 1;

	}
437908
public void empty() {
		searchButton.setDisabled(true);
		resetButton.setDisabled(true);
		for (AttributeCriterionPane criterionPane : criterionPanes) {
			criterionStack.removeMember(criterionPane);
		}
		criterionPanes.clear();
		for (HLayout criterionPane : buttonPanes) {
			buttonStack.removeMember(criterionPane);
		}
		buttonPanes.clear();
		for (HandlerRegistration handlerRegistration : addHandlers) {
			handlerRegistration.removeHandler();
		}
		addHandlers.clear();
		for (HandlerRegistration handlerRegistration : removeHandlers) {
			handlerRegistration.removeHandler();
		}
		removeHandlers.clear();
		addEmptyRow(0);
	}
475417
def cleanup(self):
        
        for dict in (self.rule2func, self.rules, self.rule2name):
            for i in list(dict.keys()):
                dict[i] = None
        for i in dir(self):
            setattr(self, i, None)
396509
def _clear_empty_values(args):
    '''
    
    '''
    result = {}
    for param in args:
        if args[param] is not None:
            result[param] = args[param]
    return result
1331585
protected void removeEmptyResourceFields() {

        Set<Component> componentsToRemove = new HashSet<Component>();
        int count = 0;
        Component lastElement = null;

        for (Component c : m_resources) {
            if (c instanceof CmsRemovableFormRow<?>) {
                count++;
                AbstractField<?> field = (AbstractField<?>)((CmsRemovableFormRow)c).getInput();
                String value = (String)(field.getValue());
                if (value.isEmpty()) {
                    componentsToRemove.add(c);
                    lastElement = c;
                }
            }
        }

        //if all fields are empty -> keep one of them to attach validator to
        if (componentsToRemove.size() == count) {
            componentsToRemove.remove(lastElement);
        }

        if (count == 0) {
            addResource("");
        }

        for (Component c : componentsToRemove) {
            m_resources.removeComponent(c);
            m_componentsToValidate.remove(c);
        }
    }
118759
public void clearSavedFields() {
    append = null;
    tokenToName = new LinkedHashMap<String, Navigation>();
    nameToToken = new LinkedHashMap<String, Navigation>();
    remainingMappings = new ArrayList<Navigation>();
  }
779142
public function reset_rule() {
        $this->raw_set('ruleoutcome', static::OUTCOME_NONE);
        $this->raw_set('ruletype', null);
        $this->raw_set('ruleconfig', null);
    }
418109
public void clear() {
        this.attributes.clear();
        this.queryParameters = null;
        this.inReader = null;
        this.streamActive = false;
        this.inStream = null;
        this.encoding = null;
        this.sessionData = null;
        this.strippedURI = null;
        this.srvContext = null;
        this.srvPath = null;
        this.pathInfo = null;
        this.pathInfoComputed = false;
        this.filters = null;
    }
183475
def clearReqVars(self):
        
        self.errorMsg = None
        self.payload = None
        self.url = None
        self.resp = None
        self.res = None
        self.method = None
        self.printErrors = None
988871
def remove_rule(self, name):
        
        self._rule_attrs.remove(name)
        delattr(self, name)
954429
def _apply_rules_no_recurse(expr, rules):
    """"""
    try:
        # `rules` is an OrderedDict key => (pattern, replacement)
        items = rules.items()
    except AttributeError:
        # `rules` is a list of (pattern, replacement) tuples
        items = enumerate(rules)
    for key, (pat, replacement) in items:
        matched = pat.match(expr)
        if matched:
            try:
                return replacement(**matched)
            except CannotSimplify:
                pass
    return expr
752403
private function dropObsoleteRoutines(): void
  {
    // Make a lookup table from routine name to source.
    $lookup = [];
    foreach ($this->sources as $source)
    {
      $lookup[$source['routine_name']] = $source;
    }

    // Drop all routines not longer in sources.
    foreach ($this->rdbmsOldMetadata as $old_routine)
    {
      if (!isset($lookup[$old_routine['routine_name']]))
      {
        $this->io->logInfo('Dropping %s <dbo>%s</dbo>',
                           strtolower($old_routine['routine_type']),
                           $old_routine['routine_name']);

        DataLayer::dropRoutine($old_routine['routine_type'], $old_routine['routine_name']);
      }
    }
  }