Restores container filters to the ones previously saved via saveFilters().
173481
public void restoreFilters() {

        IndexedContainer container = (IndexedContainer)m_fileTable.getContainerDataSource();
        container.removeAllContainerFilters();
        for (Filter filter : m_filters) {
            container.addContainerFilter(filter);
        }
    }
144380
private void applyFilters(List<TreeModelFilter<SQLPPTriplesMap>> filters) {
		FilteredModel model = (FilteredModel) mappingList.getModel();
		model.removeAllFilters();
		model.addFilters(filters);
	}
581977
public function restore() 
    {
        $state = array_pop($this->savedStates);
        if ($state != NULL) {
            $this->transform = $state['transform'];
            $this->fillStyle = $state['fillStyle'];
        }
    }
1024108
private void saveContainers() {
        String workingDir = getMain().getFileSystemManager().getSystemDataLocation().getAbsolutePath();
        final String containerFile = workingDir + File.separator + "containers.ser";
        try {
            FileOutputStream fileOut = new FileOutputStream(containerFile);
            ObjectOutputStream out = new ObjectOutputStream(fileOut);
            out.writeObject(containers);
            out.close();
            fileOut.close();
        } catch(IOException e) {
            logger.error("Unable to save containers to file", e);
        }
    }
738062
public void cleanUpContainers() {

        List<String> removed = new ArrayList<String>();
        for (Entry<String, CmsContainerPageContainer> entry : m_targetContainers.entrySet()) {
            if (!RootPanel.getBodyElement().isOrHasChild(entry.getValue().getElement())) {
                removed.add(entry.getKey());
            }
        }
        for (String containerId : removed) {
            m_targetContainers.remove(containerId);
            m_containers.remove(containerId);
        }
        if (removed.size() > 0) {
            scheduleGalleryUpdate();
        }
    }
1089758
protected function resetStatusFilter(){
        foreach($this->options as $op=>$junk){
            if(preg_match("#ShipmentStatusList#",$op)){
                unset($this->options[$op]);
            }
        }
    }
51883
public void dispose() {
        LOGGER.debug("dispose all Filters for FilterFactory {}...", factory.getClass().getName());
        synchronized (filterCache) {
            if (maintainLifeCycle) {
                Collection<Filter> values = filterCache.values();
                for (Filter filter : values) {
                    try {
                        filter.destroy();
                    } catch (RuntimeException e) {
                        LOGGER.warn("RuntimeException while calling destroy() of filter {}", filter.getClass()
                            .getName(), e);
                    }
                }
            }
            filterCache.clear();
        }
    }
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)
1300133
def reset_filter_if_expired
      # Only clear out the current_filter after every `re_check_seconds`
      time = Time.now
      return unless (time - @re_check_start) > re_check_seconds

      @re_check_start     = time
      self.current_filter = filter.dup if current_filter != filter
    end
145237
private static Collection<Container> keepOnlyLastIndexedContainer(Collection<Container> existingContainers, final String partiallyApplied) {

        Collection<Container> result = new ArrayList<>(existingContainers);

        // No index place holder, so nothing to filters
        if (!partiallyApplied.contains(INDEX_PLACEHOLDER)) {
            return result;
        }

        Map<String,Container> containerMap = existingContainers.stream().collect(Collectors.toMap(Container::getName, Function.identity()));

        Container last = null;
        for (long i = 1; i < Long.MAX_VALUE; i++) {
            final String withIndexApplied = partiallyApplied.replaceAll(INDEX_PLACEHOLDER, String.valueOf(i));
            Container mapped = containerMap.get(withIndexApplied);
            if (mapped != null) {
                result.remove(mapped);
                last = mapped;
            } else {
                // Readd last one removed (if any)
                if (last != null) {
                    result.add(last);
                }
                return result;
            }
        }
        throw new IllegalStateException("Internal error: Cannot find a free container index slot in " + existingContainers);
    }
887317
public static void resetDefaultExcludes() {
        defaultExcludes = new Vector();
        for (int i = 0; i < DEFAULTEXCLUDES.length; i++) {
            defaultExcludes.add(DEFAULTEXCLUDES[i]);
        }
    }
907983
def clear_filters
      self.current_filter = {exclude: {actions: [], verbs: [], names: [], controllers: []},
                              include: {actions: [], verbs: [], names: [], controllers: []}}
      return nil
    end
1084686
public void restoreAfterSafeModeRestart() {
    for (Integer pendingRequestId : pendingRequestsList) {
      ResourceRequestInfo request = idToRequest.get(pendingRequestId);
      incrementRequestCount(request.getType(), 1);
      addPendingRequest(request);
    }

    for (Integer grantedRequestId : idToGrant.keySet()) {
      ResourceRequestInfo request = idToRequest.get(grantedRequestId);
      incrementRequestCount(request.getType(), 1);
      addGrantedRequest(request);
    }
  }
767934
private void restore() {

        Element parent = getElement().getParentElement();
        if (parent != null) {
            parent.getStyle().clearZIndex();
        }
        getElement().getStyle().setVisibility(Visibility.HIDDEN);
    }
236907
function getActiveFilter() {
        var filterSets        = PreferencesManager.get("fileFilters") || [],
            activeFilterIndex = PreferencesManager.getViewState("activeFileFilter"),
            oldFilter         = PreferencesManager.getViewState("search.exclusions") || [],
            activeFilter      = null;

        if (activeFilterIndex === undefined && oldFilter.length) {
            activeFilter = { name: "", patterns: oldFilter };
            activeFilterIndex = _getFilterIndex(filterSets, activeFilter);

            // Migrate the old filter into the new filter storage
            if (activeFilterIndex === -1) {
                activeFilterIndex = filterSets.length;
                filterSets.push(activeFilter);
                PreferencesManager.set("fileFilters", filterSets);
            }
            PreferencesManager.setViewState("activeFileFilter", activeFilterIndex);
        } else if (activeFilterIndex > -1 && activeFilterIndex < filterSets.length) {
            activeFilter = filterSets[activeFilterIndex];
        }

        return activeFilter;
    }
292481
def __format_filters(filters):
        
        if filters is not None:
            for k in filters:
                if 'filter[' not in k:
                    filters['filter[{}]'.format(k)] = filters.pop(k)
        return filters
65966
protected function updateFilters()
    {
        $request = request();

        if ($request->filled('_clear')) {
            $this->filters = [];
            $resetPage = ! empty($this->filters);
        } else {
            $this->filters = $request->get('filter', []);
            $resetPage = true;
        }

        $this->storeFiltersInSession();

        if ($resetPage) {
            $this->markResetActivePage();
        }

        return $this;
    }