@sitevision/api 2023.2.1 → 2023.2.2-beta.2

package/types/java/util/OptionalLong/index.d.ts

@@ -0,0 +1,108 @@
+import type { LongConsumer } from "../function/LongConsumer";
+
+import type { LongSupplier } from "../function/LongSupplier";
+import type { Supplier } from "../function/Supplier";
+import type { Object } from "../../lang/Object";
+
+import type { String } from "../../lang/String";
+
+/**
+ * A container object which may or may not contain a {@code long} value.
+ *  If a value is present, {@code isPresent()} will return {@code true} and
+ *  {@code getAsLong()} will return the value.
+ *
+ *  <p>Additional methods that depend on the presence or absence of a contained
+ *  value are provided, such as {@link #orElse(long) orElse()}
+ *  (return a default value if value not present) and
+ *  {@link #ifPresent(java.util.function.LongConsumer) ifPresent()} (execute a block
+ *  of code if the value is present).
+ *
+ *  <p>This is a <a href="../lang/doc-files/ValueBased.html">value-based</a>
+ *  class; use of identity-sensitive operations (including reference equality
+ *  ({@code ==}), identity hash code, or synchronization) on instances of
+ *  {@code OptionalLong} may have unpredictable results and should be avoided.
+ * @since 1.8
+ */
+export type OptionalLong = Object & {
+  /**
+   * If a value is present in this {@code OptionalLong}, returns the value,
+   *  otherwise throws {@code NoSuchElementException}.
+   * @return the value held by this {@code OptionalLong}
+   * @throws NoSuchElementException if there is no value present
+   * @see OptionalLong#isPresent()
+   */
+  getAsLong(): number;
+
+  /**
+   * Return {@code true} if there is a value present, otherwise {@code false}.
+   * @return {@code true} if there is a value present, otherwise {@code false}
+   */
+  isPresent(): boolean;
+
+  /**
+   * Have the specified consumer accept the value if a value is present,
+   *  otherwise do nothing.
+   * @param consumer block to be executed if a value is present
+   * @throws NullPointerException if value is present and {@code consumer} is&#xA; null
+   */
+  ifPresent(consumer: LongConsumer): void;
+
+  /**
+   * Return the value if present, otherwise return {@code other}.
+   * @param other the value to be returned if there is no value present
+   * @return the value, if present, otherwise {@code other}
+   */
+  orElse(other: number): number;
+
+  /**
+   * Return the value if present, otherwise invoke {@code other} and return
+   *  the result of that invocation.
+   * @param other a {@code LongSupplier} whose result is returned if no value&#xA; is present
+   * @return the value if present otherwise the result of {@code other.getAsLong()}
+   * @throws NullPointerException if value is not present and {@code other} is&#xA; null
+   */
+  orElseGet(other: LongSupplier): number;
+
+  /**
+   * Return the contained value, if present, otherwise throw an exception
+   *  to be created by the provided supplier.
+   * @apiNote A method reference to the exception constructor with an empty&#xA; argument list can be used as the supplier. For example,&#xA; {@code IllegalStateException::new}
+   * @param <X> Type of the exception to be thrown
+   * @param exceptionSupplier The supplier which will return the exception to&#xA; be thrown
+   * @return the present value
+   * @throws X if there is no value present
+   * @throws NullPointerException if no value is present and&#xA; {@code exceptionSupplier} is null
+   */
+  orElseThrow(exceptionSupplier: Supplier): number;
+
+  /**
+   * Indicates whether some other object is "equal to" this OptionalLong. The
+   *  other object is considered equal if:
+   *  <ul>
+   *  <li>it is also an {@code OptionalLong} and;
+   *  <li>both instances have no value present or;
+   *  <li>the present values are "equal to" each other via {@code ==}.
+   *  </ul>
+   * @param obj an object to be tested for equality
+   * @return {code true} if the other object is "equal to" this object&#xA; otherwise {@code false}
+   */
+  equals(obj: unknown): boolean;
+
+  /**
+   * Returns the hash code value of the present value, if any, or 0 (zero) if
+   *  no value is present.
+   * @return hash code value of the present value or 0 if no value is present
+   */
+  hashCode(): number;
+
+  /**
+   * {@inheritDoc}
+   *
+   *  Returns a non-empty string representation of this object suitable for
+   *  debugging. The exact presentation format is unspecified and may vary
+   *  between implementations and versions.
+   * @implSpec If a value is present the result must include its string&#xA; representation in the result. Empty and present instances must be&#xA; unambiguously differentiable.
+   * @return the string representation of this instance
+   */
+  toString(): string;
+};

package/types/java/util/OptionalLong/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  getAsLong: function getAsLong() {},
+  isPresent: function isPresent() {},
+  ifPresent: function ifPresent() {},
+  orElse: function orElse() {},
+  orElseGet: function orElseGet() {},
+  orElseThrow: function orElseThrow() {},
+  equals: function equals() {},
+  hashCode: function hashCode() {},
+  toString: function toString() {}
+};
+exports["default"] = _default;

package/types/java/util/PrimitiveIterator/index.d.ts

@@ -0,0 +1,38 @@
+import type { Iterator } from "../Iterator";
+
+/**
+ * A base type for primitive specializations of {@code Iterator}.  Specialized
+ *  subtypes are provided for {@link OfInt int}, {@link OfLong long}, and
+ *  {@link OfDouble double} values.
+ *
+ *  <p>The specialized subtype default implementations of {@link Iterator#next}
+ *  and {@link Iterator#forEachRemaining(java.util.function.Consumer)} box
+ *  primitive values to instances of their corresponding wrapper class.  Such
+ *  boxing may offset any advantages gained when using the primitive
+ *  specializations.  To avoid boxing, the corresponding primitive-based methods
+ *  should be used.  For example, {@link PrimitiveIterator.OfInt#nextInt()} and
+ *  {@link PrimitiveIterator.OfInt#forEachRemaining(java.util.function.IntConsumer)}
+ *  should be used in preference to {@link PrimitiveIterator.OfInt#next()} and
+ *  {@link PrimitiveIterator.OfInt#forEachRemaining(java.util.function.Consumer)}.
+ *
+ *  <p>Iteration of primitive values using boxing-based methods
+ *  {@link Iterator#next next()} and
+ *  {@link Iterator#forEachRemaining(java.util.function.Consumer) forEachRemaining()},
+ *  does not affect the order in which the values, transformed to boxed values,
+ *  are encountered.
+ * @implNote If the boolean system property {@code org.openjdk.java.util.stream.tripwire}&#xA; is set to {@code true} then diagnostic warnings are reported if boxing of&#xA; primitive values occur when operating on primitive subtype specializations.
+ * @param <T> the type of elements returned by this PrimitiveIterator. The&#xA; type must be a wrapper type for a primitive type, such as&#xA; {@code Integer} for the primitive {@code int} type.
+ * @param <T_CONS> the type of primitive consumer. The type must be a&#xA; primitive specialization of {@link java.util.function.Consumer} for&#xA; {@code T}, such as {@link java.util.function.IntConsumer} for&#xA; {@code Integer}.
+ * @since 1.8
+ */
+export type PrimitiveIterator = Iterator & {
+  /**
+   * Performs the given action for each remaining element, in the order
+   *  elements occur when iterating, until all elements have been processed
+   *  or the action throws an exception.  Errors or runtime exceptions
+   *  thrown by the action are relayed to the caller.
+   * @param action The action to be performed for each element
+   * @throws NullPointerException if the specified action is null
+   */
+  forEachRemaining(action: unknown): void;
+};

package/types/java/util/PrimitiveIterator/index.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  forEachRemaining: function forEachRemaining() {}
+};
+exports["default"] = _default;

package/types/java/util/PrimitiveIterator.OfDouble/index.d.ts

@@ -0,0 +1,41 @@
+import type { DoubleConsumer } from "../function/DoubleConsumer";
+
+import type { Double } from "../../lang/Double";
+import type { Consumer } from "../function/Consumer";
+import type { PrimitiveIterator } from "../PrimitiveIterator";
+
+/**
+ * An Iterator specialized for {@code double} values.
+ * @since 1.8
+ */
+export type OfDouble = PrimitiveIterator & {
+  /**
+   * Returns the next {@code double} element in the iteration.
+   * @return the next {@code double} element in the iteration
+   * @throws NoSuchElementException if the iteration has no more elements
+   */
+  nextDouble(): number;
+
+  /**
+   * Performs the given action for each remaining element until all elements
+   *  have been processed or the action throws an exception.  Actions are
+   *  performed in the order of iteration, if that order is specified.
+   *  Exceptions thrown by the action are relayed to the caller.
+   * @implSpec <p>The default implementation behaves as if:&#xA; <pre>{@code&#xA; while (hasNext())&#xA; action.accept(nextDouble());&#xA; }</pre>
+   * @param action The action to be performed for each element
+   * @throws NullPointerException if the specified action is null
+   */
+  forEachRemaining(action: DoubleConsumer): void;
+
+  /**
+   * {@inheritDoc}
+   * @implSpec The default implementation boxes the result of calling&#xA; {@link #nextDouble()}, and returns that boxed result.
+   */
+  next(): number;
+
+  /**
+   * {@inheritDoc}
+   * @implSpec If the action is an instance of {@code DoubleConsumer} then it is&#xA; cast to {@code DoubleConsumer} and passed to&#xA; {@link #forEachRemaining}; otherwise the action is adapted to&#xA; an instance of {@code DoubleConsumer}, by boxing the argument of&#xA; {@code DoubleConsumer}, and then passed to&#xA; {@link #forEachRemaining}.
+   */
+  forEachRemaining(action: Consumer): void;
+};

package/types/java/util/PrimitiveIterator.OfDouble/index.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  nextDouble: function nextDouble() {},
+  forEachRemaining: function forEachRemaining() {},
+  next: function next() {}
+};
+exports["default"] = _default;

package/types/java/util/PrimitiveIterator.OfInt/index.d.ts

@@ -0,0 +1,41 @@
+import type { IntConsumer } from "../function/IntConsumer";
+
+import type { Integer } from "../../lang/Integer";
+import type { Consumer } from "../function/Consumer";
+import type { PrimitiveIterator } from "../PrimitiveIterator";
+
+/**
+ * An Iterator specialized for {@code int} values.
+ * @since 1.8
+ */
+export type OfInt = PrimitiveIterator & {
+  /**
+   * Returns the next {@code int} element in the iteration.
+   * @return the next {@code int} element in the iteration
+   * @throws NoSuchElementException if the iteration has no more elements
+   */
+  nextInt(): number;
+
+  /**
+   * Performs the given action for each remaining element until all elements
+   *  have been processed or the action throws an exception.  Actions are
+   *  performed in the order of iteration, if that order is specified.
+   *  Exceptions thrown by the action are relayed to the caller.
+   * @implSpec <p>The default implementation behaves as if:&#xA; <pre>{@code&#xA; while (hasNext())&#xA; action.accept(nextInt());&#xA; }</pre>
+   * @param action The action to be performed for each element
+   * @throws NullPointerException if the specified action is null
+   */
+  forEachRemaining(action: IntConsumer): void;
+
+  /**
+   * {@inheritDoc}
+   * @implSpec The default implementation boxes the result of calling&#xA; {@link #nextInt()}, and returns that boxed result.
+   */
+  next(): number;
+
+  /**
+   * {@inheritDoc}
+   * @implSpec If the action is an instance of {@code IntConsumer} then it is cast&#xA; to {@code IntConsumer} and passed to {@link #forEachRemaining};&#xA; otherwise the action is adapted to an instance of&#xA; {@code IntConsumer}, by boxing the argument of {@code IntConsumer},&#xA; and then passed to {@link #forEachRemaining}.
+   */
+  forEachRemaining(action: Consumer): void;
+};

package/types/java/util/PrimitiveIterator.OfInt/index.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  nextInt: function nextInt() {},
+  forEachRemaining: function forEachRemaining() {},
+  next: function next() {}
+};
+exports["default"] = _default;

package/types/java/util/PrimitiveIterator.OfLong/index.d.ts

@@ -0,0 +1,41 @@
+import type { LongConsumer } from "../function/LongConsumer";
+
+import type { Long } from "../../lang/Long";
+import type { Consumer } from "../function/Consumer";
+import type { PrimitiveIterator } from "../PrimitiveIterator";
+
+/**
+ * An Iterator specialized for {@code long} values.
+ * @since 1.8
+ */
+export type OfLong = PrimitiveIterator & {
+  /**
+   * Returns the next {@code long} element in the iteration.
+   * @return the next {@code long} element in the iteration
+   * @throws NoSuchElementException if the iteration has no more elements
+   */
+  nextLong(): number;
+
+  /**
+   * Performs the given action for each remaining element until all elements
+   *  have been processed or the action throws an exception.  Actions are
+   *  performed in the order of iteration, if that order is specified.
+   *  Exceptions thrown by the action are relayed to the caller.
+   * @implSpec <p>The default implementation behaves as if:&#xA; <pre>{@code&#xA; while (hasNext())&#xA; action.accept(nextLong());&#xA; }</pre>
+   * @param action The action to be performed for each element
+   * @throws NullPointerException if the specified action is null
+   */
+  forEachRemaining(action: LongConsumer): void;
+
+  /**
+   * {@inheritDoc}
+   * @implSpec The default implementation boxes the result of calling&#xA; {@link #nextLong()}, and returns that boxed result.
+   */
+  next(): number;
+
+  /**
+   * {@inheritDoc}
+   * @implSpec If the action is an instance of {@code LongConsumer} then it is cast&#xA; to {@code LongConsumer} and passed to {@link #forEachRemaining};&#xA; otherwise the action is adapted to an instance of&#xA; {@code LongConsumer}, by boxing the argument of {@code LongConsumer},&#xA; and then passed to {@link #forEachRemaining}.
+   */
+  forEachRemaining(action: Consumer): void;
+};

package/types/java/util/PrimitiveIterator.OfLong/index.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  nextLong: function nextLong() {},
+  forEachRemaining: function forEachRemaining() {},
+  next: function next() {}
+};
+exports["default"] = _default;