Builds the filter and returns the result.

@return the ClassFilter built.

@throws IllegalStateException if no filter has been added.
509283
public ClassFilter build() throws IllegalStateException {
        if(filters.isEmpty()) {
            throw new IllegalStateException("No filters set.");
        }
        if(filters.size() == 1) {
            return filters.get(0);
        }
        ClassFilter[] classFilters = new ClassFilter[filters.size()];
        filters.toArray(classFilters);
        return new ClassFilterList(classFilters);
    }
688928
public Query build() {
            Query.Builder root = this;
            while (true) {
                if (root.parent == null) {
                    break;
                }
                root = root.parent;
            }

            root.done();
            return root.tree;
        }
289880
public FieldFilter build() throws IllegalStateException {
        if (filters.isEmpty()) {
            throw new IllegalStateException("No field filters configured!");
        }
        if (filters.size() == 1) {
           return filters.get(0); 
        }
        FieldFilter[] fieldFilters = new FieldFilter[filters.size()];
        filters.toArray(fieldFilters);
        return new FieldFilterList(fieldFilters);
    }
1012001
public static FilterChain buildConsumerChain(ConsumerConfig<?> consumerConfig, FilterInvoker lastFilter) {
        return new FilterChain(selectActualFilters(consumerConfig, CONSUMER_AUTO_ACTIVES), lastFilter, consumerConfig);
    }
304819
public ClassDoc[] innerClasses(boolean filter) {
        ListBuffer<ClassDocImpl> innerClasses = new ListBuffer<>();
        for (Symbol sym : tsym.members().getSymbols(NON_RECURSIVE)) {
            if (sym != null && sym.kind == TYP) {
                ClassSymbol s = (ClassSymbol)sym;
                if ((s.flags_field & Flags.SYNTHETIC) != 0) continue;
                if (!filter || env.isVisible(s)) {
                    innerClasses.prepend(env.getClassDoc(s));
                }
            }
        }
        //### Cache classes here?
        return innerClasses.toArray(new ClassDocImpl[innerClasses.length()]);
    }
1249084
@Override
    protected FilterChainResolver createFilterChainResolver() {

        FilterChainResolver originalFilterChainResolver = super.createFilterChainResolver();

        if (originalFilterChainResolver == null) {
            return null;
        }

        return getFilterChainResolverFactory(originalFilterChainResolver).getInstance();
    }
889676
protected function filter()
    {
        $filter = null;

        if (   (!$filter = $this->is("classFilter"))
            && (!$filter = $this->is("idFilter"))
            && (!$filter = $this->is("attrFilter"))
            && (!$filter = $this->is("pseudoFilter"))
        ) {
            return false;
        }
        return $filter;
    }
480051
public JSType build() {
    if (result == null) {
      result = reduceAlternatesWithoutUnion();
      if (result == null) {
        result = new UnionType(registry, ImmutableList.copyOf(getAlternates()));
      }
    }
    return result;
  }
1139506
@Override
  public <T extends Filter> T createFilter(Class<T> classToCreate) throws ServletException {
      
      logger.logp(Level.FINE, CLASS_NAME, "createFilter", "called for class: " + classToCreate);
      return super.createFilter(classToCreate);
  }
1353457
private Filter createFilter() {
    return new FilterList(FilterList.Operator.MUST_PASS_ONE, processedStateFilter, new SingleColumnValueFilter(
      QueueEntryRow.COLUMN_FAMILY, stateColumnName, CompareFilter.CompareOp.GREATER,
      new BinaryPrefixComparator(Bytes.toBytes(transaction.getReadPointer()))
    ));
  }
396838
@Nonnull
	public final LCharSupplier build() {

		final LCharSupplier eventuallyFinal = this.eventually;

		LCharSupplier retval;

		final Case<LBoolSupplier, LCharSupplier>[] casesArray = cases.toArray(new Case[cases.size()]);
		retval = LCharSupplier.charSup(() -> {
			try {
				for (Case<LBoolSupplier, LCharSupplier> aCase : casesArray) {
					if (aCase.casePredicate().getAsBool()) {
						return aCase.caseFunction().getAsChar();
					}
				}

				return eventuallyFinal.getAsChar();
			} catch (Error e) { // NOSONAR
					throw e;
				} catch (Throwable e) { // NOSONAR
					throw Handler.handleOrPropagate(e, handling);
				}
			});

		if (consumer != null) {
			consumer.accept(retval);
		}
		return retval;
	}
772735
public Iterator getFilterIterator()
    {
        if (m_filter instanceof Map)
            return ((Map)m_filter).values().iterator();
        else if (m_filter != null)
            return new OneFilterIterator();
        else
            return null;    // Okay
    }
409046
public static FilterChain buildProviderChain(ProviderConfig<?> providerConfig, FilterInvoker lastFilter) {
        return new FilterChain(selectActualFilters(providerConfig, PROVIDER_AUTO_ACTIVES), lastFilter, providerConfig);
    }
1256865
public function build()
    {
        // load filter
        // 1. App/Controller/filter.yml
        // 2. App/Controller/foo.filter.yml
        $filters = $this->controller->getFilters();
        for ($i = 0; $i < count($filters); $i++) {
            $this->loadFilter($filters[$i], $i !== count($filters) - 1);
        }

        // action filter is already last.
        if (! $this->has_action_filter) {
            $this->addFilter('Action');
        } else {
            $action = null;
            $names = array();
            foreach ($this->filter_names as $name) {
                if (strtolower($name) === 'action') {
                    $action = $name;
                } else {
                    $names[] = $name;
                }
            }
            $names[] = $action;
            $this->filter_names = $names;
        }
    }
288900
protected ResourceFilter buildTreeFilter(ResourceFilter configuredFilter) {
        return new ResourceFilter.FilterSet(
                ResourceFilter.FilterSet.Rule.tree, // a tree filter including intermediate folders
                new ResourceFilter.FilterSet(ResourceFilter.FilterSet.Rule.and,
                        // the combination with the default mapping filter excludes 'rep:...' nodes
                        configuredFilter,
                        nodesConfig.getDefaultNodeFilter()),
                nodesConfig.getTreeIntermediateFilter());
    }
1181860
public IFilterTerm buildFilter(IAssetType assetType, V1Instance instance) {
        FilterBuilder builder = new FilterBuilder(assetType, instance);

        internalModifyFilter(builder);
        internalModifyState(builder);
        return builder.root.hasTerm() ? builder.root : null;
    }
502671
public <ResultT> ResultT findOne(final Bson filter, final Class<ResultT> resultClass) {
    return proxy.findOne(filter, resultClass);
  }