*
 * <p><b>Warning:</b> The methods of {@code ForwardingSet} forward <b>indiscriminately</b> to the
 * methods of the delegate. For example, overriding {@link #add} alone <b>will not</b> change the
 * behavior of {@link #addAll}, which can lead to unexpected behavior. In this case, you should
 * override {@code addAll} as well, either providing your own implementation, or delegating to the
 * provided {@code standardAddAll} method.
 *

## 숫자 검증: 부동소수, 크거나 및 작거나

숫자 검증은 `float` 값에도 동작합니다.

여기에서 <abbr title="greater than or equal"><code>ge</code></abbr>뿐만 아니라 <abbr title="greater than"><code>gt</code></abbr>를 선언 할 수있는 것이 중요해집니다. 예를 들어 필요한 경우, 값이 `1`보다 작더라도 반드시 `0`보다 커야합니다.

즉, `0.5`는 유효한 값입니다. 그러나 `0.0` 또는 `0`은 그렇지 않습니다.

<abbr title="less than"><code>lt</code></abbr> 역시 마찬가지입니다.

{* ../../docs_src/path_params_numeric_validations/tutorial006.py hl[11] *}

## 요약

 * method.
 *
 * <p><b>{@code default} method warning:</b> This class does <i>not</i> forward calls to {@code
 * default} methods. Instead, it inherits their default implementations. When those implementations
 * invoke methods, they invoke methods on the {@code ForwardingSortedMultiset}.
 *
 * <p>The {@code standard} methods and any collection views they return are not guaranteed to be

/**
 * {@link Error} variant of {@link java.util.concurrent.ExecutionException}. As with {@code
 * ExecutionException}, the error's {@linkplain #getCause() cause} comes from a failed task,
 * possibly run in another thread. That cause should itself be an {@code Error}; if not, use {@code
 * ExecutionException} or {@link UncheckedExecutionException}. This allows the client code to

   * {@code throws} clause: Some such methods can in fact throw a checked exception (e.g., by
   * calling code written in Kotlin).) Typically, we want to let a {@link Throwable} from such a
   * method propagate untouched, just as we'd typically let it do for a non-reflective call.
   * However, we can't usually write {@code throw t;} when {@code t} has a static type of {@link

        this.sequenceNumber = sequenceNumber;
    }

    /**
     * Gets the return code.
     *
     * @return the return code
     */
    public int getReturnCode() {
        return returnCode;
    }

    /**
     * Sets the return code.
     *
     * @param returnCode the return code
     */
    public void setReturnCode(int returnCode) {
        this.returnCode = returnCode;
    }

  @Deprecated(
    message = "moved to val",
    replaceWith = ReplaceWith(expression = "code"),
    level = DeprecationLevel.ERROR,
  )
  fun code(): Int = code

  /**
   * Returns true if the code is in [200..300), which means the request was successfully received,
   * understood, and accepted.
   */
  val isSuccessful: Boolean = code in 200..299

  @JvmName("-deprecated_message")
  @Deprecated(

    }

    /**
     * Constructs a new {@code MojoException} wrapping an underlying {@code Throwable}
     * and providing a {@code message}.
     */
    public MojoException(String message, Throwable cause) {
        super(message, cause);
    }

    /**
     * Constructs a new {@code MojoException} providing a {@code message}.
     */
    public MojoException(String message) {

     * does not actually resolve the artifact files.
     *
     * @param session the {@link Session}, must not be {@code null}
     * @param root the Maven Dependency, must not be {@code null}
     * @param scope the {link PathScope} to collect dependencies, must not be {@code null}
     * @return the collection result, never {@code null}
     * @throws DependencyResolverException if the dependency tree could not be built

   *
   * <p>Java 8 introduced a new method {@code getAnnotatedBounds()} in the {@link TypeVariable}
   * interface, whose return type {@code AnnotatedType[]} is also new in Java 8. As of 2025, Android
   * has not added {@link AnnotatedType}. That means that we cannot implement that interface in
   * source code in a way that will compile on both Java and Android. If we include the {@code