private File localRepositoryPath;

    private boolean offline = false;

    private boolean interactiveMode = true;

    private boolean cacheTransferError = false;

    private boolean cacheNotFound = false;

    private boolean ignoreMissingArtifactDescriptor = true;

    private boolean ignoreInvalidArtifactDescriptor = true;

    private boolean ignoreTransitiveRepositories;

    private List<Proxy> proxies;

    @Nonnull
    Session getSession();

    @Nonnull
    Optional<Path> getPath();

    @Nonnull
    Optional<Source> getSource();

    boolean isAllowStubModel();

    boolean isRecursive();

    boolean isProcessPlugins();

    @Nullable
    List<RemoteRepository> getRepositories();

    @Nonnull

    }

    @Override
    public Optional<Boolean> offline() {
        if (commandLine.hasOption(CLIManager.OFFLINE)) {
            return Optional.of(Boolean.TRUE);
        }
        return Optional.empty();
    }

    @Override
    public Optional<Boolean> nonRecursive() {
        if (commandLine.hasOption(CLIManager.NON_RECURSIVE)) {
            return Optional.of(Boolean.TRUE);
        }
        return Optional.empty();

    }

    public boolean isVersionedVertices() {
        return versionedVertices;
    }

    public void setVersionedVertices(boolean versionedVertices) {
        this.versionedVertices = versionedVertices;
    }

    public boolean isScopedVertices() {
        return scopedVertices;
    }

    public void setScopedVertices(boolean scopedVertices) {

    private final Settings settings;

    private final boolean expand;

    private long reloadInterval = 0;

    private final Environment env;

    private volatile long lastModified;

    private volatile long lastChecked;

    private volatile SynonymMap synonymMap;

    public SynonymLoader(final Environment env, final Settings settings, final boolean expand, final Analyzer analyzer) {
        this.env = env;

        List<String> errors = []

        def inspectParametersNullabilityOf = { CtBehavior oldBehavior, CtBehavior newBehavior ->

            List<Boolean> oldParametersNullability = parametersNullabilityOf(oldBehavior)
            List<Boolean> newParametersNullability = parametersNullabilityOf(newBehavior)

            for (int idx = 0; idx < oldParametersNullability.size(); idx++) {

    private Field field;

    private final BeanDesc beanDesc;

    private Constructor<?> stringConstructor;

    private Method valueOfMethod;

    private boolean readable = false;

    private boolean writable = false;

    private ParameterizedClassDesc parameterizedClassDesc;

    /**
     * {@link PropertyDescImpl}を作成します。
     *
     * @param propertyName

  private final ImmutableSet<TestOption> options;

  private boolean outputStreamOpened;
  private boolean outputStreamClosed;

  public TestByteSink(TestOption... options) {
    this.options = ImmutableSet.copyOf(options);
  }

  byte[] getBytes() {
    return bytes.toByteArray();
  }

  @Override
  public boolean wasStreamOpened() {
    return outputStreamOpened;
  }

  @Override

     * this transport.
     */

    protected abstract boolean doDisconnect ( boolean hard, boolean inUse ) throws IOException;


    /**
     * Connect the transport
     * 
     * @param timeout
     * @return whether the transport was connected
     * @throws TransportException
     */
    public synchronized boolean connect ( long timeout ) throws TransportException {
        int st = this.state;

        }
    }

    public boolean isEnabled() {
        return enabled;
    }

    public String getUpdatePolicy() {
        return updatePolicy;
    }

    public String getChecksumPolicy() {
        return checksumPolicy;
    }

    public boolean checkOutOfDate(Date lastModified) {
        boolean checkForUpdates = false;