Update the filter according to the new properties

        :return: True if the filter changed, else False
        :raise ValueError: The filter is invalid
357268
def update_filter(self):
        
        # Consider the filter invalid
        self.valid_filter = False

        try:
            # Format the new filter
            filter_str = self._original_filter.format(
                **self._component_context.properties
            )
        except KeyError as ex:
            # An entry is missing: abandon
            logging.warning("Missing filter value: %s", ex)
            raise ValueError("Missing filter value")

        try:
            # Parse the new LDAP filter
            new_filter = ldapfilter.get_ldap_filter(filter_str)
        except (TypeError, ValueError) as ex:
            logging.warning("Error parsing filter: %s", ex)
            raise ValueError("Error parsing filter")

        # The filter is valid
        self.valid_filter = True

        # Compare to the "old" one
        if new_filter != self.requirement.filter:
            # Replace the requirement filter
            self.requirement.filter = new_filter
            return True

        # Same filter
        return False
1139032
private void updateWarnings() {
		boolean oldWarnings = hasWarnings;
		hasWarnings = false;
		if (validationResults.getHasWarnings()) {
			hasWarnings = true;
		}
		else {
			Iterator childIter = children.iterator();
			while (childIter.hasNext()) {
				ValidationResultsModel childModel = (ValidationResultsModel) childIter.next();
				if (childModel.getHasWarnings()) {
					hasWarnings = true;
					break;
				}
			}
		}
		firePropertyChange(HAS_WARNINGS_PROPERTY, oldWarnings, hasWarnings);
	}
977228
def update_filter_dict(d, user, status):
    
    if user is not None:
        if not user.id:
            return None
        d['user'] = user
    if status is not None:
        d['status'] = status
666052
protected function propertyHasChanged()
    {
        foreach ($this->dbFields as $field => $value) {
            if (isset($this->fields[$field]) && ($this->fields[$field] != $value)) {
                return true;
            }
        }

        return false;
    }
568804
public void filterUpdate(DataSetFilter filter) {
        if (displayerSettings.isFilterEnabled()) {

            DataSetFilter oldFilter = currentFilter;
            this.currentFilter = filter;

            // Notify to those interested parties the selection event.
            if (displayerSettings.isFilterNotificationEnabled()) {
                for (DisplayerListener listener : listenerList) {
                    listener.onFilterUpdate(this, oldFilter, filter);
                }
            }
            // Drill-down support
            if (displayerSettings.isFilterSelfApplyEnabled()) {
                dataSetHandler.unfilter(oldFilter);
                dataSetHandler.filter(filter);
                redraw();
            }
        }
    }
1234032
def update_hidden_property(self, name, old_value, new_value):
        # type: (str, Any, Any) -> None
        
        with self._lock:
            self.__safe_handlers_callback(
                "on_hidden_property_change", name, old_value, new_value
            )
758444
def apply_filter(self):
    ''''''
    self._ensure_modification_is_safe()

    if len(self.query.filters) > 0:
      self._iterable = Filter.filter(self.query.filters, self._iterable)
1045552
def update(cls):
        
        ifaddrs = getifaddrs()
        # Create new interfaces
        for ifname in ifaddrs.keys():
            if filter(ifname.startswith, cls.NAME_FILTER):
                cls.objects.get_or_create(name=ifname)

        # Delete no longer existing ones
        cls.objects.exclude(name__in=ifaddrs.keys()).delete()
664728
async def check_filters(filters: typing.Iterable[FilterObj], args):
    
    data = {}
    if filters is not None:
        for filter_ in filters:
            f = await execute_filter(filter_, args)
            if not f:
                raise FilterNotPassed()
            elif isinstance(f, dict):
                data.update(f)
    return data
707057
@Override
    public boolean updateContext(IQueryContext context) {
        boolean result = false;
        
        for (IQueryFilter<T> filter : filters) {
            result |= filter.updateContext(context);
        }
        
        return result;
    }
895946
def update_with(self, **query):
        
        for k, v in self._filter_attrs(query).items():
            setattr(self, k, v)
        return self.save()
1203467
def update(self, *args, **kwargs):
        

        dict.update(self, *args, **kwargs)
        self.__dict__.update(*args, **kwargs)
675047
def update(self, key, value):
        
        if not isinstance(value, dict):
            raise BadValueError(
                'The value {} is incorrect.'
                ' Values should be strings'.format(value))
        if key in self.data:
            v = self.get(key)
            v.update(value)
        else:
            v = value
        self.set(key, v)
374596
def changed(self, *fields):
        
        S = super(Value, self).changed
        for fld in fields or (None,): # no args tests for any change
            if S(fld):
                return True
        return False
1120100
protected void dirtyUpdated() {
		boolean dirty = isDirty();
		if (hasChanged(oldDirty, dirty)) {
			oldDirty = dirty;
			firePropertyChange(DIRTY_PROPERTY, !dirty, dirty);
		}
	}
830762
def update_filter(self, filter_id, body, params=None):
        
        for param in (filter_id, body):
            if param in SKIP_IN_PATH:
                raise ValueError("Empty value passed for a required argument.")
        return self.transport.perform_request(
            "POST",
            _make_path("_ml", "filters", filter_id, "_update"),
            params=params,
            body=body,
        )
852852
def update_filter(self, *args, **kwargs):
        
        forbidden_statuses = []
        if not self.loaded_checkb.isChecked():
            forbidden_statuses.append(reftrack.Reftrack.LOADED)
        if not self.unloaded_checkb.isChecked():
            forbidden_statuses.append(reftrack.Reftrack.UNLOADED)
        if not self.imported_checkb.isChecked():
            forbidden_statuses.append(reftrack.Reftrack.IMPORTED)
        if not self.empty_checkb.isChecked():
            forbidden_statuses.append(None)
        self.proxy.set_forbidden_statuses(forbidden_statuses)

        forbidden_types = []
        for typ, cb in self.typecbmap.items():
            if not cb.isChecked():
                forbidden_types.append(typ)
        self.proxy.set_forbidden_types(forbidden_types)

        forbidden_uptodate = []
        if not self.old_checkb.isChecked():
            forbidden_uptodate.append(False)
        if not self.newest_checkb.isChecked():
            forbidden_uptodate.append(True)
        self.proxy.set_forbidden_uptodate(forbidden_uptodate)

        forbidden_alien = [] if self.alien_checkb.isChecked() else [True]
        self.proxy.set_forbidden_alien(forbidden_alien)

        self.proxy.setFilterWildcard(self.search_le.text())