delegate!!.startHandshake()
  }

  override fun setUseClientMode(mode: Boolean) {
    delegate!!.useClientMode = mode
  }

  override fun getUseClientMode(): Boolean = delegate!!.useClientMode

  override fun setNeedClientAuth(need: Boolean) {
    delegate!!.needClientAuth = need
  }

  override fun setWantClientAuth(want: Boolean) {
    delegate!!.wantClientAuth = want
  }

    @Override
    public boolean canDetermineActivation(Profile profile) {
        Activation activation = profile.getActivation();
        return activation != null && activation.getOs() != null;
    }

    @Override
    public boolean isActive(Profile profile) {
        Activation activation = profile.getActivation();
        ActivationOS os = activation.getOs();

        boolean result = ensureAtLeastOneNonNull(os);

     */
    @Nonnull
    Optional<Boolean> nonRecursive();

    /**
     * Indicates whether Maven should force a check for updated snapshots on remote repositories.
     *
     * @return an {@link Optional} containing true if snapshot updates should be forced, false if not, or empty if not specified
     */
    @Nonnull
    Optional<Boolean> updateSnapshots();

    /**

    // This is like a filter but overrides all transitive versions
    private Map<String, Artifact> managedVersionMap;

    private boolean resolveRoot = true;

    private boolean resolveTransitively = false;

    private boolean offline;

    private boolean forceUpdate;

    private List<Server> servers;

    private List<Mirror> mirrors;

    private List<Proxy> proxies;

    }

    @Override
    public Optional<Boolean> showVersionAndExit() {
        return returnFirstPresentOrEmpty(Options::showVersionAndExit);
    }

    @Override
    public Optional<Boolean> showVersion() {
        return returnFirstPresentOrEmpty(Options::showVersion);
    }

    @Override
    public Optional<Boolean> quiet() {
        return returnFirstPresentOrEmpty(Options::quiet);
    }

    private final ArtifactVersion lowerBound;

    private final boolean lowerBoundInclusive;

    private final ArtifactVersion upperBound;

    private final boolean upperBoundInclusive;

    public static final Restriction EVERYTHING = new Restriction(null, false, null, false);

    public Restriction(
            ArtifactVersion lowerBound,
            boolean lowerBoundInclusive,
            ArtifactVersion upperBound,

class BlockDoc implements DslElementDoc {
    private final MethodDoc blockMethod
    private final PropertyDoc blockProperty
    private final TypeMetaData type
    private boolean multiValued

    BlockDoc(MethodDoc blockMethod, PropertyDoc blockProperty, TypeMetaData type, boolean multiValued) {
        this.blockMethod = blockMethod
        this.type = type
        this.blockProperty = blockProperty
        this.multiValued = multiValued
    }

        @Override
        public boolean removeAll(Collection<?> c) {
            throw uoe();
        }

        @Override
        public boolean add(E e) {
            throw uoe();
        }

        @Override
        public boolean remove(Object o) {
            throw uoe();
        }

        @Override
        public boolean retainAll(Collection<?> c) {
            throw uoe();

 *
 */
abstract class AbstractScopeArtifactFilter implements ArtifactFilter {

    private boolean compileScope;

    private boolean runtimeScope;

    private boolean testScope;

    private boolean providedScope;

    private boolean systemScope;

    void addScopeInternal(String scope) {
        if (Artifact.SCOPE_COMPILE.equals(scope)) {
            systemScope = true;

package org.apache.maven.plugin.descriptor;

/**
 */
public class Parameter implements Cloneable {
    private String alias;

    private String name;

    private String type;

    private boolean required;

    private boolean editable = true;

    private String description;

    private String expression;

    private String deprecated;

    private String defaultValue;

    private String implementation;