@sitevision/api 2023.2.1 → 2023.2.2-beta.1

package/types/java/nio/channels/SeekableByteChannel/index.d.ts

@@ -0,0 +1,110 @@
+import type { ByteChannel } from "../ByteChannel";
+
+/**
+ * A byte channel that maintains a current <i>position</i> and allows the
+ *  position to be changed.
+ *
+ *  <p> A seekable byte channel is connected to an entity, typically a file,
+ *  that contains a variable-length sequence of bytes that can be read and
+ *  written. The current position can be {@link #position() <i>queried</i>} and
+ *  {@link #position(long) <i>modified</i>}. The channel also provides access to
+ *  the current <i>size</i> of the entity to which the channel is connected. The
+ *  size increases when bytes are written beyond its current size; the size
+ *  decreases when it is {@link #truncate <i>truncated</i>}.
+ *
+ *  <p> The {@link #position(long) position} and {@link #truncate truncate} methods
+ *  which do not otherwise have a value to return are specified to return the
+ *  channel upon which they are invoked. This allows method invocations to be
+ *  chained. Implementations of this interface should specialize the return type
+ *  so that method invocations on the implementation class can be chained.
+ * @since 1.7
+ * @see java.nio.file.Files#newByteChannel
+ */
+export type SeekableByteChannel = ByteChannel & {
+  /**
+ * Reads a sequence of bytes from this channel into the given buffer.
+ * 
+ *  <p> Bytes are read starting at this channel's current position, and
+ *  then the position is updated with the number of bytes actually read.
+ *  Otherwise this method behaves exactly as specified in the {@link
+ *  ReadableByteChannel} interface.
+  
+    */
+  read(dst: unknown): number;
+
+  /**
+ * Writes a sequence of bytes to this channel from the given buffer.
+ * 
+ *  <p> Bytes are written starting at this channel's current position, unless
+ *  the channel is connected to an entity such as a file that is opened with
+ *  the {@link java.nio.file.StandardOpenOption#APPEND APPEND} option, in
+ *  which case the position is first advanced to the end. The entity to which
+ *  the channel is connected is grown, if necessary, to accommodate the
+ *  written bytes, and then the position is updated with the number of bytes
+ *  actually written. Otherwise this method behaves exactly as specified by
+ *  the {@link WritableByteChannel} interface.
+  
+    */
+  write(src: unknown): number;
+
+  /**
+   * Returns this channel's position.
+   * @return This channel's position,&#xA; a non-negative integer counting the number of bytes&#xA; from the beginning of the entity to the current position
+   * @throws ClosedChannelException&#xA; If this channel is closed
+   * @throws IOException&#xA; If some other I/O error occurs
+   */
+  position(): number;
+
+  /**
+   * Sets this channel's position.
+   *
+   *  <p> Setting the position to a value that is greater than the current size
+   *  is legal but does not change the size of the entity.  A later attempt to
+   *  read bytes at such a position will immediately return an end-of-file
+   *  indication.  A later attempt to write bytes at such a position will cause
+   *  the entity to grow to accommodate the new bytes; the values of any bytes
+   *  between the previous end-of-file and the newly-written bytes are
+   *  unspecified.
+   *
+   *  <p> Setting the channel's position is not recommended when connected to
+   *  an entity, typically a file, that is opened with the {@link
+   *  java.nio.file.StandardOpenOption#APPEND APPEND} option. When opened for
+   *  append, the position is first advanced to the end before writing.
+   * @param newPosition&#xA; The new position, a non-negative integer counting&#xA; the number of bytes from the beginning of the entity
+   * @return This channel
+   * @throws ClosedChannelException&#xA; If this channel is closed
+   * @throws IllegalArgumentException&#xA; If the new position is negative
+   * @throws IOException&#xA; If some other I/O error occurs
+   */
+  position(newPosition: number): SeekableByteChannel;
+
+  /**
+   * Returns the current size of entity to which this channel is connected.
+   * @return The current size, measured in bytes
+   * @throws ClosedChannelException&#xA; If this channel is closed
+   * @throws IOException&#xA; If some other I/O error occurs
+   */
+  size(): number;
+
+  /**
+   * Truncates the entity, to which this channel is connected, to the given
+   *  size.
+   *
+   *  <p> If the given size is less than the current size then the entity is
+   *  truncated, discarding any bytes beyond the new end. If the given size is
+   *  greater than or equal to the current size then the entity is not modified.
+   *  In either case, if the current position is greater than the given size
+   *  then it is set to that size.
+   *
+   *  <p> An implementation of this interface may prohibit truncation when
+   *  connected to an entity, typically a file, opened with the {@link
+   *  java.nio.file.StandardOpenOption#APPEND APPEND} option.
+   * @param size&#xA; The new size, a non-negative byte count
+   * @return This channel
+   * @throws NonWritableChannelException&#xA; If this channel was not opened for writing
+   * @throws ClosedChannelException&#xA; If this channel is closed
+   * @throws IllegalArgumentException&#xA; If the new size is negative
+   * @throws IOException&#xA; If some other I/O error occurs
+   */
+  truncate(size: number): SeekableByteChannel;
+};

package/types/java/nio/channels/SeekableByteChannel/index.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  read: function read() {},
+  write: function write() {},
+  position: function position() {},
+  size: function size() {},
+  truncate: function truncate() {}
+};
+exports["default"] = _default;

package/types/java/nio/channels/WritableByteChannel/index.d.ts

@@ -0,0 +1,52 @@
+import type { Channel } from "../Channel";
+
+/**
+ * A channel that can write bytes.
+ *
+ *  <p> Only one write operation upon a writable channel may be in progress at
+ *  any given time.  If one thread initiates a write operation upon a channel
+ *  then any other thread that attempts to initiate another write operation will
+ *  block until the first operation is complete.  Whether or not other kinds of
+ *  I/O operations may proceed concurrently with a write operation depends upon
+ *  the type of the channel. </p>
+ * @author Mark Reinhold
+ * @author JSR-51 Expert Group
+ * @since 1.4
+ */
+export type WritableByteChannel = Channel & {
+  /**
+   * Writes a sequence of bytes to this channel from the given buffer.
+   *
+   *  <p> An attempt is made to write up to <i>r</i> bytes to the channel,
+   *  where <i>r</i> is the number of bytes remaining in the buffer, that is,
+   *  <tt>src.remaining()</tt>, at the moment this method is invoked.
+   *
+   *  <p> Suppose that a byte sequence of length <i>n</i> is written, where
+   *  <tt>0</tt>&nbsp;<tt>&lt;=</tt>&nbsp;<i>n</i>&nbsp;<tt>&lt;=</tt>&nbsp;<i>r</i>.
+   *  This byte sequence will be transferred from the buffer starting at index
+   *  <i>p</i>, where <i>p</i> is the buffer's position at the moment this
+   *  method is invoked; the index of the last byte written will be
+   *  <i>p</i>&nbsp;<tt>+</tt>&nbsp;<i>n</i>&nbsp;<tt>-</tt>&nbsp;<tt>1</tt>.
+   *  Upon return the buffer's position will be equal to
+   *  <i>p</i>&nbsp;<tt>+</tt>&nbsp;<i>n</i>; its limit will not have changed.
+   *
+   *  <p> Unless otherwise specified, a write operation will return only after
+   *  writing all of the <i>r</i> requested bytes.  Some types of channels,
+   *  depending upon their state, may write only some of the bytes or possibly
+   *  none at all.  A socket channel in non-blocking mode, for example, cannot
+   *  write any more bytes than are free in the socket's output buffer.
+   *
+   *  <p> This method may be invoked at any time.  If another thread has
+   *  already initiated a write operation upon this channel, however, then an
+   *  invocation of this method will block until the first operation is
+   *  complete. </p>
+   * @param src&#xA; The buffer from which bytes are to be retrieved
+   * @return The number of bytes written, possibly zero
+   * @throws NonWritableChannelException&#xA; If this channel was not opened for writing
+   * @throws ClosedChannelException&#xA; If this channel is closed
+   * @throws AsynchronousCloseException&#xA; If another thread closes this channel&#xA; while the write operation is in progress
+   * @throws ClosedByInterruptException&#xA; If another thread interrupts the current thread&#xA; while the write operation is in progress, thereby&#xA; closing the channel and setting the current thread's&#xA; interrupt status
+   * @throws IOException&#xA; If some other I/O error occurs
+   */
+  write(src: unknown): number;
+};

package/types/java/nio/channels/WritableByteChannel/index.js

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

package/types/java/nio/channels/spi/AbstractInterruptibleChannel/index.d.ts

@@ -0,0 +1,104 @@
+import type { Object } from "../../../../lang/Object";
+import type { Channel } from "../../Channel";
+import type { InterruptibleChannel } from "../../InterruptibleChannel";
+
+/**
+ * Base implementation class for interruptible channels.
+ *
+ *  <p> This class encapsulates the low-level machinery required to implement
+ *  the asynchronous closing and interruption of channels.  A concrete channel
+ *  class must invoke the {@link #begin begin} and {@link #end end} methods
+ *  before and after, respectively, invoking an I/O operation that might block
+ *  indefinitely.  In order to ensure that the {@link #end end} method is always
+ *  invoked, these methods should be used within a
+ *  <tt>try</tt>&nbsp;...&nbsp;<tt>finally</tt> block:
+ *
+ *  <blockquote><pre>
+ *  boolean completed = false;
+ *  try {
+ *      begin();
+ *      completed = ...;    // Perform blocking I/O operation
+ *      return ...;         // Return result
+ *  } finally {
+ *      end(completed);
+ *  }</pre></blockquote>
+ *
+ *  <p> The <tt>completed</tt> argument to the {@link #end end} method tells
+ *  whether or not the I/O operation actually completed, that is, whether it had
+ *  any effect that would be visible to the invoker.  In the case of an
+ *  operation that reads bytes, for example, this argument should be
+ *  <tt>true</tt> if, and only if, some bytes were actually transferred into the
+ *  invoker's target buffer.
+ *
+ *  <p> A concrete channel class must also implement the {@link
+ *  #implCloseChannel implCloseChannel} method in such a way that if it is
+ *  invoked while another thread is blocked in a native I/O operation upon the
+ *  channel then that operation will immediately return, either by throwing an
+ *  exception or by returning normally.  If a thread is interrupted or the
+ *  channel upon which it is blocked is asynchronously closed then the channel's
+ *  {@link #end end} method will throw the appropriate exception.
+ *
+ *  <p> This class performs the synchronization required to implement the {@link
+ *  java.nio.channels.Channel} specification.  Implementations of the {@link
+ *  #implCloseChannel implCloseChannel} method need not synchronize against
+ *  other threads that might be attempting to close the channel.  </p>
+ * @author Mark Reinhold
+ * @author JSR-51 Expert Group
+ * @since 1.4
+ */
+export type AbstractInterruptibleChannel = Object &
+  Channel &
+  InterruptibleChannel & {
+    /**
+     * Closes this channel.
+     *
+     *  <p> If the channel has already been closed then this method returns
+     *  immediately.  Otherwise it marks the channel as closed and then invokes
+     *  the {@link #implCloseChannel implCloseChannel} method in order to
+     *  complete the close operation.  </p>
+     * @throws IOException&#xA; If an I/O error occurs
+     */
+    close(): void;
+
+    /**
+     * Closes this channel.
+     *
+     *  <p> This method is invoked by the {@link #close close} method in order
+     *  to perform the actual work of closing the channel.  This method is only
+     *  invoked if the channel has not yet been closed, and it is never invoked
+     *  more than once.
+     *
+     *  <p> An implementation of this method must arrange for any other thread
+     *  that is blocked in an I/O operation upon this channel to return
+     *  immediately, either by throwing an exception or by returning normally.
+     *  </p>
+     * @throws IOException&#xA; If an I/O error occurs while closing the channel
+     */
+    implCloseChannel(): void;
+
+    isOpen(): boolean;
+
+    /**
+ * Marks the beginning of an I/O operation that might block indefinitely.
+ * 
+ *  <p> This method should be invoked in tandem with the {@link #end end}
+ *  method, using a <tt>try</tt>&nbsp;...&nbsp;<tt>finally</tt> block as
+ *  shown <a href="#be">above</a>, in order to implement asynchronous
+ *  closing and interruption for this channel.  </p>
+  
+    */
+    begin(): void;
+
+    /**
+     * Marks the end of an I/O operation that might block indefinitely.
+     *
+     *  <p> This method should be invoked in tandem with the {@link #begin
+     *  begin} method, using a <tt>try</tt>&nbsp;...&nbsp;<tt>finally</tt> block
+     *  as shown <a href="#be">above</a>, in order to implement asynchronous
+     *  closing and interruption for this channel.  </p>
+     * @param completed&#xA; <tt>true</tt> if, and only if, the I/O operation completed&#xA; successfully, that is, had some effect that would be visible to&#xA; the operation's invoker
+     * @throws AsynchronousCloseException&#xA; If the channel was asynchronously closed
+     * @throws ClosedByInterruptException&#xA; If the thread blocked in the I/O operation was interrupted
+     */
+    end(completed: boolean): void;
+  };

package/types/java/nio/channels/spi/AbstractInterruptibleChannel/index.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  close: function close() {},
+  implCloseChannel: function implCloseChannel() {},
+  isOpen: function isOpen() {},
+  begin: function begin() {},
+  end: function end() {}
+};
+exports["default"] = _default;