Resolves filters.
518396
private function resolveFilters(
        array $filters,
        array $propertyParameter,
        array $options = [],
        $limit = null,
        $page = 1,
        $pageSize = null
    ) {
        $emptyFilterResult = [[], false];

        if (!array_key_exists('dataSource', $filters)
            || '' === $filters['dataSource']
            || (null !== $limit && $limit < 1)
        ) {
            return $emptyFilterResult;
        }

        try {
            $this->session->getNodeByIdentifier($filters['dataSource']);
        } catch (ItemNotFoundException $e) {
            return $emptyFilterResult;
        }

        $properties = array_key_exists('properties', $propertyParameter) ?
            $propertyParameter['properties']->getValue() : [];

        $excluded = isset($filters['excluded']) ? $filters['excluded'] : [];
        if (array_key_exists('exclude_duplicates', $propertyParameter)
            && $propertyParameter['exclude_duplicates']->getValue()
        ) {
            $excluded = array_merge($excluded, $this->referenceStore->getAll());
        }

        $this->contentQueryBuilder->init(
            [
                'config' => $filters,
                'properties' => $properties,
                'excluded' => $excluded,
                'published' => !$this->showDrafts,
            ]
        );

        $hasNextPage = false;
        if (null !== $pageSize) {
            $result = $this->loadPaginated($options, $limit, $page, $pageSize);
            $hasNextPage = (count($result) > $pageSize);
            $items = array_splice($result, 0, $pageSize);
        } else {
            $items = $this->load($options, $limit);
        }

        return [$items, $hasNextPage];
    }
974767
function resolveDeferreds() {
      for (var i = 0; i < manager.deferreds.length; i++){
        manager.deferreds[i].resolveWith(root, [root]);
      }
      manager.deferreds = [];
    }
859966
function resolve() {
    if (l.search) {
      var q = {};
      l.search.slice(1).split('&').forEach(function(v) {
        var a = v.split('=');
        q[a[0]] = a.slice(1).join('=').replace(/~and~/g, '&')
      });
      if (q.p !== undefined) {
        window.history.replaceState(null, null,
          repo + (q.p || '') +
          (q.q ? ('?' + q.q) : '') +
          l.hash
        )
      }
    }
  }
263053
public void setFilters(java.util.Collection<DeviceFilter> filters) {
        if (filters == null) {
            this.filters = null;
            return;
        }

        this.filters = new java.util.ArrayList<DeviceFilter>(filters);
    }
352030
def resolve(self, *pargs, **kwargs):
        """"""
        self._cached = (pargs, kwargs)
        self._try_then()
1031202
private function applyFilters()
    {
        $layer      = $this->layerResolver->get();
        $filterList = $this->getFilterList();

        foreach ($filterList->getFilters($layer) as $filter) {
            $filter->apply($this->getRequest());
        }

        $layer->apply();

        return $this;
    }
589075
function resolve(files, opts) {
  var fn = opts.filter || function(fp) {
    return true;
  };

  if (opts.realpath === true) {
    return files.filter(fn);
  }

  var len = files.length;
  var idx = -1;
  var res = [];

  while (++idx < len) {
    var fp = path.resolve(opts.cwd, files[idx]);
    if (!fn(fp) || ~res.indexOf(fp)) continue;
    res.push(fp);
  }
  return res;
}
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)
1125648
def resolve(self, definitions):
        
        if not self.__resolved:
            self.do_resolve(definitions)
            self.__resolved = True
152605
function resolve(){
		LRState::clear_index();
		LRStation::clear_index();
		// create Root Set
		// we SHOULD have a single etransition to an intial state
		return LRStateSet::init( $this->etransitions[0], $this->Grammar );
	}
1211196
protected void restoreFilterAndSorter() {
		final ProblemTreeViewer viewer = getViewer();
		viewer.addFilter(new EmptyInnerPackageFilter());
		viewer.addFilter(new HiddenFileFilter());
	}
926835
def addFilter(self, filterclass):
        """"""
        if filterclass not in self.filters:
            self.filters.append(filterclass)
766747
def solvers(self, refresh=False, **filters):
        """"""
        warnings.warn("'solvers' is deprecated in favor of 'get_solvers'.", DeprecationWarning)
        return self.get_solvers(refresh=refresh, **filters)
1357452
function resolveResolution (
  ref,
  resolver,
  bootedServices
) {
  const refParts = ref.split(':')
  return resolver(refParts, bootedServices)
}
1312777
private void addFilter(Filter filter) {
        boolean exists = false;
        for (Filter initedFilter : this.filters) {
            if (initedFilter.getClass() == filter.getClass()) {
                exists = true;
                break;
            }
        }

        if (!exists) {
            filter.init(this);
            this.filters.add(filter);
        }

    }
470568
def filter_by(self, **filters):
        ''' '''
        for name, value in filters.items():
            self.filter(resolve_name(self.type, name) == value)
        return self
102187
function registerFilters (filters) {
  if (isArray(filters)) {
    lazyStringFilters = lazyStringFilters.concat(filters)
  } else if (isObject(filters)) {
    Object.keys(filters).forEach(name => {
      addFilter(name, filters[name])
    })
  }
}