}

    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 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;

    private Map managedVersionMap;

    /** result type - flat list; the default */
    private boolean asList = true;

    /** result type - dirty tree */
    private boolean asDirtyTree = false;

    /** result type - resolved tree */
    private boolean asResolvedTree = false;

    /** result type - graph */
    private boolean asGraph = false;

    public MetadataResolutionRequest() {}

    }

    public boolean isDebugEnabled() {
        return logger.isDebugEnabled();
    }

    public void info(String message) {
        setMdc();
        logger.info(message);
    }

    public void info(String message, Throwable throwable) {
        setMdc();
        logger.info(message, throwable);
    }

    public boolean isInfoEnabled() {
        return logger.isInfoEnabled();

            return advance(true);
        }
        return null;
    }


    protected abstract FileEntry open () throws CIFSException;


    protected abstract boolean isDone ();


    protected abstract boolean fetchMore () throws CIFSException;


    protected abstract FileEntry[] getResults ();


    /**
     * 
     */

 * {@link #iterable(Class, boolean)}または{@link #ClassIterator(Class, boolean)}
 * の第2引数に{@literal false}を指定します。
 * </p>
 *
 * @author koichik
 */
public class ClassIterator implements Iterator<Class<?>> {

    /** クラス */
    protected Class<?> clazz;

    /** {@link Object}クラスも反復する場合は {@literal true} */
    protected final boolean includeObject;

    /**