Adds the specified result handlers to the validator under construction.

@param resultHandlers Result handlers to be added.

@return Context allowing further construction of the validator using the DSL.
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;
    }
1331249
@Api
	public final HandlerRegistration addMapModelClearHandler(final MapModelClearHandler handler) {
		return handlerManager.addHandler(MapModelClearHandler.TYPE, handler);
	}
1314539
public MultipleResultCollectorContext<DPO> collect(ResultCollector<?, DPO> resultCollector) {
        if (resultCollector != null) {
            addedTriggers.add(resultCollector);
            addedDataProviders.add(resultCollector);
        }

        // Stay in the same context and re-use the same instance because no type has changed
        return this;
    }
872349
public JsHandlerRegistration addGeometryEditResumeHandler(final GeometryEditResumeHandler handler) {
		org.geomajas.plugin.editing.client.event.GeometryEditResumeHandler h;
		h = new org.geomajas.plugin.editing.client.event.GeometryEditResumeHandler() {

			public void onGeometryEditResume(GeometryEditResumeEvent event) {
				handler.onGeometryEditResume(new org.geomajas.plugin.editing.jsapi.client.event.GeometryEditResumeEvent(
						event.getGeometry()));
			}
		};
		return new JsHandlerRegistration(new HandlerRegistration[] { delegate.addGeometryEditResumeHandler(h) });
	}
792132
def add_result(self, result):
        
        for handler in self._handlers:
            handler(result)
        if self._successful and result.status not in _successful_results:
            self._successful = False
590610
@Override
    public HandlerRegistration addSearchNoResultHandler(final SearchNoResultEvent.SearchNoResultHandler handler) {
        return addHandler(handler, SearchNoResultEvent.TYPE);
    }
244013
public ResultHandlerContext<DPO, RI, RO, RHI> handleWith(ResultHandler<RHI> resultHandler) {
        if (resultHandler != null) {
            addedResultHandlers.add(resultHandler);
            builtValidator.addResultHandler(resultHandler);
        }

        // Stay in the same context and re-use the same instance because no type has changed
        return this;
    }
156698
function handleResults(results) {
    ctrl.matches = results;
    ctrl.hidden  = shouldHide();

    // If loading is in progress, then we'll end the progress. This is needed for example,
    // when the `clear` button was clicked, because there we always show the loading process, to prevent flashing.
    if (ctrl.loading) setLoading(false);

    if ($scope.selectOnMatch) selectItemOnMatch();

    positionDropdown();
    reportMessages(true, ReportType.Count);
  }
1122526
public void validationResultsChanged(ValidationResults results) {
		if (resultsModel.getMessageCount() == 0) {
			messageReceiver.setMessage(null);
		}
		else {
			ValidationMessage message = getValidationMessage(resultsModel);
			messageReceiver.setMessage(message);
		}
	}
725440
public static <E extends Extension> IterableResult<E> appendSearchResults(IterableResult<E> previousSearchResult,
        IterableResult<E> result)
    {
        AggregatedIterableResult<E> newResult;

        if (previousSearchResult instanceof AggregatedIterableResult) {
            newResult = ((AggregatedIterableResult<E>) previousSearchResult);
        } else if (previousSearchResult != null) {
            newResult = new AggregatedIterableResult<>(previousSearchResult.getOffset());
            newResult.addSearchResult(previousSearchResult);
        } else {
            return result;
        }

        newResult.addSearchResult(result);

        return newResult;
    }
432934
@Override
    public void handleResult(RHI result) {
        if (wrappedResultHandler != null) {
            wrappedResultHandler.handleResult(resultTransformer.transform(result));
        }
    }
320740
protected void handleImportResults(List<CmsAliasImportResult> results) {

        clearResults();
        for (CmsAliasImportResult singleResult : results) {
            addImportResult(singleResult);
        }
    }
197956
@Override
    public Result addTokenToResult(Context context, String newToken, Result result) {
        if (isCached(context)) {
            LOGGER.debug("Not adding token to a cached result");
            return result;
        }

        LOGGER.debug("Adding token to result");
        if (getCookieName() != null) {
            Cookie cookie = context.cookie(getCookieName());
            if (cookie != null) {
                return result.with(Cookie.builder(cookie).setValue(newToken).build());
            } else {
                // Create a new cookie
                return result.with(Cookie.cookie(getCookieName(), newToken)
                        .setSecure(isSecureCookie())
                        .setPath(getCookiePath())
                        .setDomain(getCookieDomain())
                        .setMaxAge(3600)
                        .build());
            }
        } else {
            // Session
            context.session().put(getTokenName(), newToken);
            return result;
        }
    }
676640
public ApiPreprocessingContext validateWith(IValidator... apiValidators) {
		for (IValidator apiValidator : apiValidators) {
			if (apiValidator == null) {
				throw new IllegalArgumentException("Validator cannot be null");
			}
			this.validators.add(apiValidator);
		}
		return this;
	}
1373864
def add_result_hook(self, hook: Type["QueryResultHook"]) -> Type["QueryResultHook"]:
        
        hook.next_hook = self._query_result_hook
        self._query_result_hook = hook
        return hook
85945
@Override
    public T addHandlers(ArchiveEventHandler... handlers) {
       for (ArchiveEventHandler handler : handlers) {
          this.handlers.add(handler);
       }
       return covariantReturn();
    }
786724
@Nonnull
  public final ValidationExecutionManager addExecutors (@Nullable final IValidationExecutor... aExecutors)
  {
    if (aExecutors != null)
      for (final IValidationExecutor aExecutor : aExecutors)
        addExecutor (aExecutor);
    return this;
  }