}

    @Execute
    @Secured({ ROLE })
    public HtmlResponse crawlingConfig(final CrawlingConfigForm form) {
        validate(form, messages -> {}, () -> asHtml(path_AdminWizard_AdminWizardConfigJsp));
        verifyTokenKeep(this::asIndexHtml);
        final String name = crawlingConfigInternal(form);

    ImmutableSet<N> validated = validate(startNodes);
    return new Iterable<N>() {
      @Override
      public Iterator<N> iterator() {
        return newTraversal().postOrder(validated.iterator());
      }
    };
  }

  abstract Traversal<N> newTraversal();

  @SuppressWarnings("CheckReturnValue")
  private ImmutableSet<N> validate(Iterable<? extends N> startNodes) {

@Singleton
public final class DefaultLifecycleProvider extends AbstractLifecycleProvider {
    static final String LIFECYCLE_ID = "default";

    // START SNIPPET: default
    private static final String[] PHASES = {
        "validate",
        "initialize",
        "generate-sources",
        "process-sources",
        "generate-resources",
        "process-resources",
        "compile",
        "process-classes",

                        Build.newBuilder(build).plugins(normalized.values()).build());
            }
        }

        /*
         * NOTE: This is primarily to keep backward-compat with Maven 2.x which did not validate that dependencies are
         * unique within a single POM. Upon multiple declarations, 2.x just kept the last one but retained the order of

        } catch (IOException e) {
            throw new PluginDescriptorParsingException(plugin, pluginFile.getAbsolutePath(), e);
        }

        List<String> errors = new ArrayList<>();
        pluginValidator.validate(pluginArtifact, pluginDescriptor, errors);

        if (!errors.isEmpty()) {
            throw new InvalidPluginDescriptorException(

    //                                         -------------
    @Execute
    @Secured({ ROLE })
    public HtmlResponse delete(final EditForm form) {
        verifyCrudMode(form.crudMode, CrudMode.DETAILS);
        validate(form, messages -> {}, this::asDetailsHtml);
        verifyToken(this::asDetailsHtml);
        searchLogService.getSearchLog(form.logType, form.id).alwaysPresent(e -> {
            searchLogService.deleteSearchLog(e);

    //                                         -------------
    @Execute
    @Secured({ ROLE })
    public HtmlResponse delete(final EditForm form) {
        verifyCrudMode(form.crudMode, CrudMode.DETAILS);
        validate(form, messages -> {}, this::asDetailsHtml);
        verifyToken(this::asDetailsHtml);
        final String id = form.id;
        jobLogService.getJobLog(id).alwaysPresent(entity -> {
            jobLogService.delete(entity);

      inverse.delegate.remove(entry.getValue());
      /*
       * Remove the mapping in inverse before removing from esDelegate because
       * if entry is part of esDelegate, entry might be invalidated after the
       * mapping is removed from esDelegate.
       */
      esDelegate.remove(entry);
      return true;
    }

    @Override
    public Iterator<Entry<K, V>> iterator() {

        return false;
    }

    @Override
    public final void validate(
            MavenSession mavenSession,
            MojoDescriptor mojoDescriptor,
            Class<?> mojoClass,
            PlexusConfiguration pomConfiguration,
            ExpressionEvaluator expressionEvaluator) {
        doValidate(mavenSession, mojoDescriptor, mojoClass, pomConfiguration, expressionEvaluator);
    }

                    try {
                        return interrogate(getTransportContext(), this.dcList[ i ]);
                    }
                    catch ( SmbException se ) {
                        log.warn("Failed validate DC: " + this.dcList[ i ], se);
                    }
                    this.dcList[ i ] = null;
                }
            }

            /*