Adds the specified data providers to the validator under construction.

@param dataProviders Data providers to be added.
@param <DPO>         Type of data provider output.

@return Context allowing further construction of the validator using the DSL.
491929
public <DPO> MultipleDataProviderContext<DPO> read(Collection<DataProvider<DPO>> dataProviders) {
        List<DataProvider<DPO>> addedDataProviders = new ArrayList<DataProvider<DPO>>();
        if (dataProviders != null) {
            addedDataProviders.addAll(dataProviders);
        }

        // Change context
        return new MultipleDataProviderContext<DPO>(addedTriggers, addedDataProviders);
    }
886645
public ResultHandlerContext<DPO, RI, RO, TRO> handleWith(Collection<ResultHandler<TRO>> resultHandlers) {
        List<ResultHandler<TRO>> addedResultHandlers = new ArrayList<ResultHandler<TRO>>();
        if (resultHandlers != null) {
            addedResultHandlers.addAll(resultHandlers);
        }

        // Change context
        return new ResultHandlerContext<DPO, RI, RO, TRO>(addedTriggers, addedDataProviders,
                dataProviderToRuleMapping, addedRuleInputTransformers, addedRules, ruleToResultHandlerMapping,
                addedResultHandlerInputTransformers, addedResultHandlers);
    }
29209
@SuppressWarnings("unchecked") // NOSONAR (Avoid Duplicate Literals)
    private void processEachDataProviderWithEachRule() {
        // For each data provider
        for (DataProvider<DPO> dataProvider : dataProviders) {
            // Get the data provider output
            Object transformedOutput = dataProvider.getData();

            // Transform the data provider output
            if (dataProviderOutputTransformers != null) {
                for (Transformer transformer : dataProviderOutputTransformers) {
                    transformedOutput = transformer.transform(transformedOutput);
                }
            }

            // Transform the transformed data provider output to rule input
            if (ruleInputTransformers != null) {
                for (Transformer transformer : ruleInputTransformers) {
                    transformedOutput = transformer.transform(transformedOutput);
                }
            }
            RI ruleInput = (RI) transformedOutput;

            // Process the rule input with the rules
            processRules(ruleInput);
        }
    }
501329
@Override
    public void installProvider(boolean clientSide, List<Object> providers, Set<String> features) {
        if (!clientSide) {
            if (getAddCustomExceptionMapperFlag(providers))
            {
                providers.add(new CustomWebApplicationExceptionMapper());
            }
        }

    }
1265013
public static ClientConfiguration createClient(final DataProvider provider) {
        return createClient(null, null, emptyList(), singletonList(provider));
    }
304147
@SuppressWarnings("unchecked")
	public <T> RestBuilder addProvider(Class<? extends ContextProvider<T>> provider) {

		Assert.notNull(provider, "Missing context provider!");
		registeredProviders.put(null, provider);
		return this;
	}
1034050
public void setCompilerOptionsProviders(List<CompilerOptionsProvider> compilerOptionsProviders) {
        if (compilerOptionsProviders == null)
            throw new NullPointerException();
        this.compilerOptionsProviders = new ArrayList<CompilerOptionsProvider>(compilerOptionsProviders);
    }
49205
public static ProviderContextBuilder of(String provider, Collection<RateType> rateTypes) {
        return new ProviderContextBuilder(provider, rateTypes);
    }
1147217
public static void addProvider(Class<? extends ContextProvider> provider) {

		Class clazz = (Class) ClassFactory.getGenericType(provider);
		addProvider(clazz, provider);
	}
1067547
@SuppressWarnings("unchecked")
    public void addValidator(CsvValidator<T>... validators ) {
        this.validators.addAll(Arrays.asList(validators));
    }
903891
public CellField<T> add(final List<FieldValidator<T>> validators) {

        if(validators.isEmpty()) {
            return this;
        }

        for(FieldValidator<T> validator : validators) {
            add(validator);
        }
        return this;
    }
211983
public void setCognitoIdentityProviders(java.util.Collection<CognitoIdentityProvider> cognitoIdentityProviders) {
        if (cognitoIdentityProviders == null) {
            this.cognitoIdentityProviders = null;
            return;
        }

        this.cognitoIdentityProviders = new java.util.ArrayList<CognitoIdentityProvider>(cognitoIdentityProviders);
    }
973429
public ResultHandlerContext<DPO, RI, RO, RHI> handleWith(Collection<ResultHandler<RHI>> resultHandlers) {
        if (resultHandlers != null) {
            this.addedResultHandlers.addAll(resultHandlers);

            for (ResultHandler<RHI> resultHandler : resultHandlers) {
                builtValidator.addResultHandler(resultHandler);
            }
        }

        // Stay in the same context and re-use the same instance because no type has changed
        return this;
    }
605032
public static ClientConfiguration createClient(final List<Endpoint> endpoints, final List<DataProvider> providers) {
        return createClient(null, null, endpoints, providers);
    }
1364973
private static ContextProvider createContextProvider(final Collection<LoggingProvider> loggingProviders) {
		Collection<ContextProvider> contextProviders = new ArrayList<ContextProvider>(loggingProviders.size());
		for (LoggingProvider loggingProvider : loggingProviders) {
			contextProviders.add(loggingProvider.getContextProvider());
		}
		return new BundleContextProvider(contextProviders);
	}
118913
public void addDataSource(int groupno, DataSource datasource) {
    // the loader takes care of validation
    if (groupno == 0)
      datasources.add(datasource);
    else if (groupno == 1)
      group1.add(datasource);
    else if (groupno == 2)
      group2.add(datasource);
  }
499571
public static ProviderList newList(Provider ... providers) {
        ProviderConfig[] configs = new ProviderConfig[providers.length];
        for (int i = 0; i < providers.length; i++) {
            configs[i] = new ProviderConfig(providers[i]);
        }
        return new ProviderList(configs, true);
    }