@sitevision/api 2023.2.1 → 2023.2.2-beta.2

package/types/java/nio/file/CopyOption/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * An object that configures how to copy or move a file.
+ *
+ *  <p> Objects of this type may be used with the {@link
+ *  Files#copy(Path,Path,CopyOption[]) Files.copy(Path,Path,CopyOption...)},
+ *  {@link Files#copy(java.io.InputStream,Path,CopyOption[])
+ *  Files.copy(InputStream,Path,CopyOption...)} and {@link Files#move
+ *  Files.move(Path,Path,CopyOption...)} methods to configure how a file is
+ *  copied or moved.
+ *
+ *  <p> The {@link StandardCopyOption} enumeration type defines the
+ *  <i>standard</i> options.
+ * @since 1.7
+ */
+export type CopyOption = {};

package/types/java/nio/file/CopyOption/index.js

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

package/types/java/nio/file/DirectoryStream/index.d.ts

@@ -0,0 +1,97 @@
+import type { Iterator } from "../../../util/Iterator";
+import type { Closeable } from "../../../io/Closeable";
+import type { Iterable } from "../../../lang/Iterable";
+
+/**
+ * An object to iterate over the entries in a directory. A directory stream
+ *  allows for the convenient use of the for-each construct to iterate over a
+ *  directory.
+ *
+ *  <p> <b> While {@code DirectoryStream} extends {@code Iterable}, it is not a
+ *  general-purpose {@code Iterable} as it supports only a single {@code
+ *  Iterator}; invoking the {@link #iterator iterator} method to obtain a second
+ *  or subsequent iterator throws {@code IllegalStateException}. </b>
+ *
+ *  <p> An important property of the directory stream's {@code Iterator} is that
+ *  its {@link Iterator#hasNext() hasNext} method is guaranteed to read-ahead by
+ *  at least one element. If {@code hasNext} method returns {@code true}, and is
+ *  followed by a call to the {@code next} method, it is guaranteed that the
+ *  {@code next} method will not throw an exception due to an I/O error, or
+ *  because the stream has been {@link #close closed}. The {@code Iterator} does
+ *  not support the {@link Iterator#remove remove} operation.
+ *
+ *  <p> A {@code DirectoryStream} is opened upon creation and is closed by
+ *  invoking the {@code close} method. Closing a directory stream releases any
+ *  resources associated with the stream. Failure to close the stream may result
+ *  in a resource leak. The try-with-resources statement provides a useful
+ *  construct to ensure that the stream is closed:
+ *  <pre>
+ *    Path dir = ...
+ *    try (DirectoryStream&lt;Path&gt; stream = Files.newDirectoryStream(dir)) {
+ *        for (Path entry: stream) {
+ *            ...
+ *        }
+ *    }
+ *  </pre>
+ *
+ *  <p> Once a directory stream is closed, then further access to the directory,
+ *  using the {@code Iterator}, behaves as if the end of stream has been reached.
+ *  Due to read-ahead, the {@code Iterator} may return one or more elements
+ *  after the directory stream has been closed. Once these buffered elements
+ *  have been read, then subsequent calls to the {@code hasNext} method returns
+ *  {@code false}, and subsequent calls to the {@code next} method will throw
+ *  {@code NoSuchElementException}.
+ *
+ *  <p> A directory stream is not required to be <i>asynchronously closeable</i>.
+ *  If a thread is blocked on the directory stream's iterator reading from the
+ *  directory, and another thread invokes the {@code close} method, then the
+ *  second thread may block until the read operation is complete.
+ *
+ *  <p> If an I/O error is encountered when accessing the directory then it
+ *  causes the {@code Iterator}'s {@code hasNext} or {@code next} methods to
+ *  throw {@link DirectoryIteratorException} with the {@link IOException} as the
+ *  cause. As stated above, the {@code hasNext} method is guaranteed to
+ *  read-ahead by at least one element. This means that if {@code hasNext} method
+ *  returns {@code true}, and is followed by a call to the {@code next} method,
+ *  then it is guaranteed that the {@code next} method will not fail with a
+ *  {@code DirectoryIteratorException}.
+ *
+ *  <p> The elements returned by the iterator are in no specific order. Some file
+ *  systems maintain special links to the directory itself and the directory's
+ *  parent directory. Entries representing these links are not returned by the
+ *  iterator.
+ *
+ *  <p> The iterator is <i>weakly consistent</i>. It is thread safe but does not
+ *  freeze the directory while iterating, so it may (or may not) reflect updates
+ *  to the directory that occur after the {@code DirectoryStream} is created.
+ *
+ *  <p> <b>Usage Examples:</b>
+ *  Suppose we want a list of the source files in a directory. This example uses
+ *  both the for-each and try-with-resources constructs.
+ *  <pre>
+ *    List&lt;Path&gt; listSourceFiles(Path dir) throws IOException {
+ *        List&lt;Path&gt; result = new ArrayList&lt;&gt;();
+ *        try (DirectoryStream&lt;Path&gt; stream = Files.newDirectoryStream(dir, "*.{c,h,cpp,hpp,java}")) {
+ *            for (Path entry: stream) {
+ *                result.add(entry);
+ *            }
+ *        } catch (DirectoryIteratorException ex) {
+ *            // I/O error encounted during the iteration, the cause is an IOException
+ *            throw ex.getCause();
+ *        }
+ *        return result;
+ *    }
+ *  </pre>
+ * @param <T> The type of element returned by the iterator
+ * @since 1.7
+ * @see Files#newDirectoryStream(Path)
+ */
+export type DirectoryStream = Closeable &
+  Iterable & {
+    /**
+     * Returns the iterator associated with this {@code DirectoryStream}.
+     * @return the iterator associated with this {@code DirectoryStream}
+     * @throws IllegalStateException&#xA; if this directory stream is closed or the iterator has already&#xA; been returned
+     */
+    iterator(): Iterator;
+  };

package/types/java/nio/file/DirectoryStream/index.js

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

package/types/java/nio/file/DirectoryStream.Filter/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * An interface that is implemented by objects that decide if a directory
+ *  entry should be accepted or filtered. A {@code Filter} is passed as the
+ *  parameter to the {@link Files#newDirectoryStream(Path,DirectoryStream.Filter)}
+ *  method when opening a directory to iterate over the entries in the
+ *  directory.
+ * @param <T> the type of the directory entry
+ * @since 1.7
+ */
+export type Filter = {
+  /**
+   * Decides if the given directory entry should be accepted or filtered.
+   * @param entry&#xA; the directory entry to be tested
+   * @return {@code true} if the directory entry should be accepted
+   * @throws IOException&#xA; If an I/O error occurs
+   */
+  accept(entry: unknown): boolean;
+};

package/types/java/nio/file/DirectoryStream.Filter/index.js

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

package/types/java/nio/file/FileStore/index.d.ts

@@ -0,0 +1,154 @@
+import type { String } from "../../../lang/String";
+
+import type { Class } from "../../../lang/Class";
+
+import type { Object } from "../../../lang/Object";
+
+/**
+ * Storage for files. A {@code FileStore} represents a storage pool, device,
+ *  partition, volume, concrete file system or other implementation specific means
+ *  of file storage. The {@code FileStore} for where a file is stored is obtained
+ *  by invoking the {@link Files#getFileStore getFileStore} method, or all file
+ *  stores can be enumerated by invoking the {@link FileSystem#getFileStores
+ *  getFileStores} method.
+ *
+ *  <p> In addition to the methods defined by this class, a file store may support
+ *  one or more {@link FileStoreAttributeView FileStoreAttributeView} classes
+ *  that provide a read-only or updatable view of a set of file store attributes.
+ * @since 1.7
+ */
+export type FileStore = Object & {
+  /**
+   * Returns the name of this file store. The format of the name is highly
+   *  implementation specific. It will typically be the name of the storage
+   *  pool or volume.
+   *
+   *  <p> The string returned by this method may differ from the string
+   *  returned by the {@link Object#toString() toString} method.
+   * @return the name of this file store
+   */
+  name(): string;
+
+  /**
+   * Returns the <em>type</em> of this file store. The format of the string
+   *  returned by this method is highly implementation specific. It may
+   *  indicate, for example, the format used or if the file store is local
+   *  or remote.
+   * @return a string representing the type of this file store
+   */
+  type(): string;
+
+  /**
+   * Tells whether this file store is read-only. A file store is read-only if
+   *  it does not support write operations or other changes to files. Any
+   *  attempt to create a file, open an existing file for writing etc. causes
+   *  an {@code IOException} to be thrown.
+   * @return {@code true} if, and only if, this file store is read-only
+   */
+  isReadOnly(): boolean;
+
+  /**
+   * Returns the size, in bytes, of the file store.
+   * @return the size of the file store, in bytes
+   * @throws IOException&#xA; if an I/O error occurs
+   */
+  getTotalSpace(): number;
+
+  /**
+   * Returns the number of bytes available to this Java virtual machine on the
+   *  file store.
+   *
+   *  <p> The returned number of available bytes is a hint, but not a
+   *  guarantee, that it is possible to use most or any of these bytes.  The
+   *  number of usable bytes is most likely to be accurate immediately
+   *  after the space attributes are obtained. It is likely to be made inaccurate
+   *  by any external I/O operations including those made on the system outside
+   *  of this Java virtual machine.
+   * @return the number of bytes available
+   * @throws IOException&#xA; if an I/O error occurs
+   */
+  getUsableSpace(): number;
+
+  /**
+   * Returns the number of unallocated bytes in the file store.
+   *
+   *  <p> The returned number of unallocated bytes is a hint, but not a
+   *  guarantee, that it is possible to use most or any of these bytes.  The
+   *  number of unallocated bytes is most likely to be accurate immediately
+   *  after the space attributes are obtained. It is likely to be
+   *  made inaccurate by any external I/O operations including those made on
+   *  the system outside of this virtual machine.
+   * @return the number of unallocated bytes
+   * @throws IOException&#xA; if an I/O error occurs
+   */
+  getUnallocatedSpace(): number;
+
+  /**
+   * Tells whether or not this file store supports the file attributes
+   *  identified by the given file attribute view.
+   *
+   *  <p> Invoking this method to test if the file store supports {@link
+   *  BasicFileAttributeView} will always return {@code true}. In the case of
+   *  the default provider, this method cannot guarantee to give the correct
+   *  result when the file store is not a local storage device. The reasons for
+   *  this are implementation specific and therefore unspecified.
+   * @param type&#xA; the file attribute view type
+   * @return {@code true} if, and only if, the file attribute view is&#xA; supported
+   */
+  supportsFileAttributeView(type: Class): boolean;
+
+  /**
+   * Tells whether or not this file store supports the file attributes
+   *  identified by the given file attribute view.
+   *
+   *  <p> Invoking this method to test if the file store supports {@link
+   *  BasicFileAttributeView}, identified by the name "{@code basic}" will
+   *  always return {@code true}. In the case of the default provider, this
+   *  method cannot guarantee to give the correct result when the file store is
+   *  not a local storage device. The reasons for this are implementation
+   *  specific and therefore unspecified.
+   * @param name&#xA; the {@link FileAttributeView#name name} of file attribute view
+   * @return {@code true} if, and only if, the file attribute view is&#xA; supported
+   */
+  supportsFileAttributeView(name: String | string): boolean;
+
+  /**
+   * Returns a {@code FileStoreAttributeView} of the given type.
+   *
+   *  <p> This method is intended to be used where the file store attribute
+   *  view defines type-safe methods to read or update the file store attributes.
+   *  The {@code type} parameter is the type of the attribute view required and
+   *  the method returns an instance of that type if supported.
+   * @param <V>&#xA; The {@code FileStoreAttributeView} type
+   * @param type&#xA; the {@code Class} object corresponding to the attribute view
+   * @return a file store attribute view of the specified type or&#xA; {@code null} if the attribute view is not available
+   */
+  getFileStoreAttributeView(type: Class): unknown;
+
+  /**
+   * Reads the value of a file store attribute.
+   *
+   *  <p> The {@code attribute} parameter identifies the attribute to be read
+   *  and takes the form:
+   *  <blockquote>
+   *  <i>view-name</i><b>:</b><i>attribute-name</i>
+   *  </blockquote>
+   *  where the character {@code ':'} stands for itself.
+   *
+   *  <p> <i>view-name</i> is the {@link FileStoreAttributeView#name name} of
+   *  a {@link FileStore AttributeView} that identifies a set of file attributes.
+   *  <i>attribute-name</i> is the name of the attribute.
+   *
+   *  <p> <b>Usage Example:</b>
+   *  Suppose we want to know if ZFS compression is enabled (assuming the "zfs"
+   *  view is supported):
+   *  <pre>
+   *     boolean compression = (Boolean)fs.getAttribute("zfs:compression");
+   *  </pre>
+   * @param attribute&#xA; the attribute to read
+   * @return the attribute value; {@code null} may be a valid valid for some&#xA; attributes
+   * @throws UnsupportedOperationException&#xA; if the attribute view is not available or it does not support&#xA; reading the attribute
+   * @throws IOException&#xA; if an I/O error occurs
+   */
+  getAttribute(attribute: String | string): unknown;
+};

package/types/java/nio/file/FileStore/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  name: function name() {},
+  type: function type() {},
+  isReadOnly: function isReadOnly() {},
+  getTotalSpace: function getTotalSpace() {},
+  getUsableSpace: function getUsableSpace() {},
+  getUnallocatedSpace: function getUnallocatedSpace() {},
+  supportsFileAttributeView: function supportsFileAttributeView() {},
+  getFileStoreAttributeView: function getFileStoreAttributeView() {},
+  getAttribute: function getAttribute() {}
+};
+exports["default"] = _default;