Called when the filter has been changed
546196
def _reset(self):
        
        with self._lock:
            # Start listening to services with the new filter
            self.stop()
            self.start()

            for svc_ref in self.get_bindings():
                # Check if the current reference matches the filter
                if not self.requirement.filter.matches(
                    svc_ref.get_properties()
                ):
                    # Not the case: emulate a service departure
                    # The instance life cycle will be updated as well
                    self.on_service_departure(svc_ref)
1369422
public void setFilter(Filter filter)
    {
        if (this.filter == null)
        {
            this.filter = new FilterList();
        }
        if (filter != null)
        {
            this.filter.addFilter(filter);
        }
    }
164412
function () {
			this.writeDebug('checkFilters');
			for(var key in this.settings.taxonomyFilters) {

				if (this.settings.taxonomyFilters.hasOwnProperty(key)) {
					// Find the existing checked boxes for each checkbox filter
					this._existingCheckedFilters(key);

					// Find the existing selected value for each select filter
					this._existingSelectedFilters(key);

					// Find the existing value for each radio button filter
					this._existingRadioFilters(key);
				}
			}
		}
715233
def do_changed(self, subcmd, opts, component):
        

        releases = get_released_versions(component)
        latest = releases[0]

        filter_dir = components.comp_names[component].path

        latest_tag = '-'.join(latest)
        data = get_changed_since_tag(latest_tag, filter_dir)

        if len(data) > 0:
            print(data)
1008122
function () {
                var _this = this;
                /** @type {?} */
                var data = { filter: this.selectedFilter };
                /** @type {?} */
                var bottomSheetRef = this.bottomSheet.open(NgxFilterMenuComponent, {
                    data: data
                });
                bottomSheetRef.afterDismissed().subscribe(function () {
                    _this.selectedFilter = data.filter;
                    _this.applyFilter(true);
                });
            }
604004
protected void doPreview(final boolean isUpdateFilter) {
        loadingBox.show();
        previewTable.show(dataSetDef,
                          dataSetDef.getColumns(),
                          new DataSetEditorListener(isUpdateFilter));
    }
1153921
function handleCurrentFileChange(e, newFile, newPaneId, oldFile) {
        if (newFile) {
            if (_mrofList.length === 0) {
                _initRecentFilesList();
            }

	        _addToMROFList(newFile, newPaneId);
        }
    }
697091
function filesChanged(fileList) {
        if (FindUtils.isNodeSearchDisabled() || !fileList || fileList.length === 0) {
            return;
        }
        var updateObject = {
            "fileList": fileList
        };
        if (searchModel.filter) {
            updateObject.filesInSearchScope = FileFilters.getPathsMatchingFilter(searchModel.filter, fileList);
            _searchScopeChanged();
        }
        searchDomain.exec("filesChanged", updateObject);
    }
337075
@Override
    protected void onFilteredApplicationEvent(ApplicationEvent event) {
        if (this.eventLogger.isInfoEnabled()) {
            this.eventLogger.info(event.toString());
        }
    }
248538
public void setFilters(Filter[] filters) {
        if (filters != null && filters.length > 0
                && this.filters != null && this.filters.length > 0) {
            Filter[] oldFilters = this.filters;
            this.filters = new Filter[oldFilters.length + filters.length];
            System.arraycopy(oldFilters, 0, this.filters, 0, oldFilters.length);
            System.arraycopy(filters, 0, this.filters, oldFilters.length, filters.length);
        } else {
            this.filters = filters;
        }
    }
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();
            }
        }
    }
205182
public void afterAfter(Filter filter) {
        addFilter(HttpMethod.afterafter, FilterImpl.create(SparkUtils.ALL_PATHS, filter));
    }
717936
public void onSelectFilterFunction() {
        int selectedIdx = view.getSelectedFunctionIndex();
        if (selectedIdx >= 0) {
            CoreFunctionFilter coreFilter = getCoreFilter();
            CoreFunctionType functionType = getAvailableFunctions(coreFilter).get(selectedIdx);

            ColumnType columnType = metadata.getColumnType(coreFilter.getColumnId());
            List params = FilterFactory.createParameters(columnType, functionType);
            coreFilter.setType(functionType);
            coreFilter.setParameters(params);

            initFilterSelector();
            fireFilterChanged();

            if (!initFilterConfig().isEmpty()) {
                view.showFilterConfig();
            }
        }
    }
897326
def _on_change(self):
        """"""
        if callable(self.__callback):
            self.__callback((self._family, self._size, self._bold, self._italic, self._underline, self._overstrike))
511851
@Override
    public void stateChanged(ChangeEvent e) {
        log.debug("getting new collector");
        collector = (CorrectedResultCollector) createTestElement();
        if (collector instanceof CorrectedResultCollector) {
            setUpFiltering((CorrectedResultCollector) collector);
        }
        collector.loadExistingFile();
    }
430710
protected void notifyListeners(IQueryFilter<T> filter) {
        for (IQueryFilterChanged<T> listener : listeners) {
            listener.onFilterChanged(filter);
        }
    }
980486
boolean handleFilters(Map<String, Object> filters) {
		Validate.notNull(filters, "Filters required");
		boolean changed = false;

		// clear non active filters and remove them from lastFilters
		for (Object filterKey : CollectionUtils.subtract(lastFilters.keySet(),
				filters.keySet())) {
			BeanProperty.clearBeanProperty(adaptee, (String) filterKey);
			lastFilters.remove(filterKey);
			changed = true;
		}

		// set changed active filters
		for (Entry<String, Object> entry : filters.entrySet()) {
			if (!lastFilters.containsKey(entry.getKey())
					|| !entry.getValue()
							.equals(lastFilters.get(entry.getKey()))) {
				BeanProperty.setBeanProperty(adaptee, entry.getKey(),
						entry.getValue());
				lastFilters.put(entry.getKey(), entry.getValue());
				changed = true;
			}
		}

		return changed;
	}