Creates the validator and makes all the connections.

@return Newly created and configured validator.
328535
public ResultCollectorValidator<D, O> build() {
        final ResultCollectorValidator<D, O> validator = new ResultCollectorValidator<D, O>();

        for (final ResultCollector<?, D> resultCollector : registeredResultCollectors) {
            validator.addResultCollector(resultCollector);
        }
        for (final Rule<Collection<D>, O> rule : registeredRules) {
            validator.addRule(rule);
        }
        for (final ResultHandler<O> resultHandler : registeredResultHandlers) {
            validator.addResultHandler(resultHandler);
        }

        return validator;
    }
1371144
public Mapper newInstance() {
        Mapper mapper;

        mapper = new Mapper(name, parser.newInstance(), oag.newInstance());
        mapper.setLogging(logParsing, logAttribution);
        return mapper;
    }
643449
@Nonnull
  public static <T> UBLTRValidatorBuilder <T> create (@Nonnull final Class <T> aClass)
  {
    return new UBLTRValidatorBuilder <> (aClass);
  }
811534
public RestRouterConfiguration build() {
        if (this.enabled) {
            try {
                validate();
            } catch (Exception e) {
                throw logger.configurationValidationError(e);
            }
            return new RestRouterConfiguration(ip, port);
        }
        return null;
    }
1050033
public X509CertChainValidatorExt build() {

    RevocationParametersExt revocationParameters = new RevocationParametersExt(
      crlChecks, new CRLParameters(), new OCSPParametes(ocspChecks));

    ValidatorParamsExt validationParams = new ValidatorParamsExt(
      revocationParameters, ProxySupport.ALLOW);

    if (storeUpdateListener != null){
      validationParams.setInitialListeners(Arrays.asList(storeUpdateListener));
    }
    
    boolean openssl1xMode = false;
    
    if (opensslHashFunction == OpensslHashFunction.SHA1){
      openssl1xMode = true;
    }
    
    OpensslCertChainValidator validator = new OpensslCertChainValidator(
      trustAnchorsDir, openssl1xMode, namespaceChecks, trustAnchorsUpdateInterval,
      validationParams, lazyAnchorsLoading);

    if (validationErrorListener != null){
      validator.addValidationListener(validationErrorListener);
    }
    
    return validator;
  }
765795
public function getValidator(): Validator
    {
        if ($this->validator === null) {
            $this->validator = new Validator(new ValidatorCollection(), $this->getPlaceholder());
        }

        return $this->validator;
    }
1368702
function() {
  if (! (this instanceof Chain)) {
    return new Chain();
  }

  this.validators = [];
  this.target = null;
  this.isOptional = false;
  this.isImmutable = false;
  this.isUpdateRequired = false;
  this._validatorCount = 0;
  this._numItemsValidator = null;
}
545014
static ValidatorFactory createValidatorFactory()
   {
      Configuration configuration = Validation.byDefaultProvider().configure();
      Configuration<?> conf = configuration.traversableResolver(new IronJacamarTraversableResolver());

      return conf.buildValidatorFactory();
   }
469667
public function getValidator()
    {
        if (!$this->validator) {
            $this->validator = new Validator($this);
        }
        return $this->validator->onEntity();
    }
937440
public function validation()
    {

        $validator = new Validation();

        $validator->add('name', new PresenceOf([
            'message' => 'User type name must be supplied'
        ]));

        $validator->add('name', new Uniqueness([
            'message' => 'Sorry, the user type already exists'
        ]));

        return $this->validate($validator);
    }
1268978
@Override
    protected Object createPoolOrConnection()
    {
        try
        {
            this.connection = ConnectionFactory.createConnection(conf);
            return connection;
        }
        catch (IOException e)
        {
            logger.error("Connection could not be established", e);
            throw new KunderaException("Connection could not be established", e);
        }
    }
222
public Client build() {
    validate();
    Client client = new Client(database, credentials, host, scheme);
    return client;
  }
1278259
public static WebSocketFactory createWebSocketFactory() {
        Class<WebSocketFactory>         clazz = WebSocketFactory.class;
        ServiceLoader<WebSocketFactory> loader = ServiceLoader.load(clazz);
        return loader.iterator().next();    
    }
675659
public function validator()
    {
        return Validator::make(
            $this->params, $this->rules(),
            $this->messages(), $this->attributes()
        );
    }
13180
public Object createConnectionFactory(
            final ConnectionManager connectionManager) {

        if (TRACE.isEntryEnabled()) {
            SibTr.entry(this, TRACE, "createConnectionFactory",
                    connectionManager);
        }

        final Object connectionFactory = new SibRaConnectionFactory(this,
                connectionManager);

        if (TRACE.isEntryEnabled()) {
            SibTr.exit(this, TRACE, "createConnectionFactory",
                    connectionFactory);
        }
        return connectionFactory;

    }
531005
protected SICoreConnection createConnection() throws SIResourceException {
        if (TraceComponent.isAnyTracingEnabled()
            && tc.isEntryEnabled())
            SibTr.entry(tc, "createConnection");

        SICoreConnection newConn = new ConnectionImpl(this, null, null);

        // Lock the connections so that we can't be stopped midway through a
        // create
        _connectionsLockManager.lock();

        try {
            // Now we have a lock make sure we are started.
            checkStarted();

            synchronized (_connections) {
                _connections.put(newConn, newConn);
            }
        } finally {
            _connectionsLockManager.unlock();
        }

        if (TraceComponent.isAnyTracingEnabled()
            && tc.isEntryEnabled())
            SibTr.exit(tc, "createConnection", newConn);

        return newConn;
    }
730782
protected<T, C extends Collection<T>> ParamListValidator<T, C> getListValidator(ParamValidator<T> validator) {

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

        return new ParamListValidator<T, C>(validator);
    }