this.versionScheme = versionScheme;
            try {
                this.delegate = versionScheme.parseVersion(delegateValue);
            } catch (InvalidVersionSpecificationException e) {
                throw new VersionParserException("Unable to parse version: " + delegateValue, e);
            }
        }

        @Override
        public int compareTo(Version o) {
            if (o instanceof DefaultVersion) {

        jobManager.schedule(cron -> register(cron, scheduledJob));
    }

    public void register(final LaCron cron, final ScheduledJob scheduledJob) {
        if (scheduledJob == null) {
            throw new ScheduledJobException("No job.");
        }

        final String id = scheduledJob.getId();
        if (!Constants.T.equals(scheduledJob.getAvailable())) {

  public final T next() {
    if (!hasNext()) {
      throw new NoSuchElementException();
    }
    state = State.NOT_READY;
    // Safe because hasNext() ensures that tryToComputeNext() has put a T into `next`.
    T result = uncheckedCastNullableTToT(next);
    next = null;
    return result;
  }

  @Override
  public final void remove() {
    throw new UnsupportedOperationException();
  }

     */
    public void write(Writer writer, Metadata metadata) throws java.io.IOException {
        try {
            delegate.write(writer, metadata.getDelegate());
        } catch (XMLStreamException e) {
            throw new IOException(e);
        }
    }

    /**
     * Method write.
     *
     * @param stream a stream object
     * @param metadata a Metadata object

    public static ZipEntry getNextEntry(final ZipInputStream zis) {
        assertArgumentNotNull("zis", zis);

        try {
            return zis.getNextEntry();
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }
    }

    /**
     * {@link ZipInputStream#reset()}の例外処理をラップするメソッドです。
     *
     * @param zis
     *            {@link ZipInputStream}。{@literal null}であってはいけません

        } catch (final IOException e) {
            throw new SuggesterException(e);
        }

        if (contentsReadingConverter == null) {
            contentsReadingConverter = SuggestUtil.createDefaultContentsReadingConverter(client, settings);
        }
        try {
            contentsReadingConverter.init();
        } catch (final IOException e) {
            throw new SuggesterException(e);
        }

abstract class CheckSubprojectsInfo : SubprojectsInfo() {

    @TaskAction
    fun checkSubprojectsInfo() {
        if (subprojectsJson.asFile.readText() != generateSubprojectsJson()) {
            throw GradleException(
                "New project(s) added without updating subproject JSON. Please run `:${GenerateSubprojectsInfo.TASK_NAME}` task."
            )
        }
    }

        @ParametricNullness V value) {
      throw new UnsupportedOperationException();
    }

    @Override
    public void putAll(Table<? extends R, ? extends C, ? extends V> table) {
      throw new UnsupportedOperationException();
    }

    @Override
    @CheckForNull
    public V remove(@CheckForNull Object rowKey, @CheckForNull Object columnKey) {
      throw new UnsupportedOperationException();
    }

            try {
              ready.countDown()
              waiting.await()
            } catch (e: InterruptedException) {
              throw AssertionError()
            }
            throw IOException()
          },
        )
        .build()
    val a1 = client.newCall(newRequest("http://a/1"))
    val a2 = client.newCall(newRequest("http://a/2"))

        return;
      } catch (InterruptedException ie) {
        throw new RuntimeException("Unexpected interrupt while waiting for future", ie);
      } catch (TimeoutException tryHarder) {
        /* OK */
      }
    } while (System.nanoTime() - deadline < 0);
    throw formatRuntimeException("Future not done within %d second timeout", timeoutSeconds);
  }

  /**