From af76c2a7a522ab03cc6f6efebdc7dbabb61abcc5 Mon Sep 17 00:00:00 2001 From: Davide Angelocola Date: Fri, 19 Jun 2026 20:14:15 +0200 Subject: [PATCH 1/2] docs: Markdown Javadoc links in remaining files (Sonar S7474) Convert the remaining {@link X} to [X] and {@code x} to `x` across the rest of the codebase (older code outside the prior new-code sweep). Javadoc resolves every reference (build enforces failOnError + failOnWarnings). Co-Authored-By: Claude Opus 4.8 --- .../main/java/io/github/dfa1/vortex/cli/CliHandles.java | 2 +- .../main/java/io/github/dfa1/vortex/cli/tui/IoWorker.java | 2 +- .../io/github/dfa1/vortex/cli/tui/VortexInspectorTui.java | 2 +- .../dfa1/vortex/cli/tui/term/PosixTerminalSmokeTest.java | 2 +- core/src/main/java/io/github/dfa1/vortex/core/DType.java | 8 ++++---- core/src/main/java/io/github/dfa1/vortex/core/PType.java | 2 +- .../java/io/github/dfa1/vortex/proto/ProtoReader.java | 4 ++-- .../java/io/github/dfa1/vortex/proto/ProtoWriter.java | 2 +- .../java/io/github/dfa1/vortex/inspect/InspectorTree.java | 2 +- .../io/github/dfa1/vortex/inspect/ZonedStatsSchema.java | 2 +- .../java/io/github/dfa1/vortex/jdbc/JdbcImporter.java | 2 +- .../main/java/io/github/dfa1/vortex/protogen/CodeGen.java | 2 +- .../main/java/io/github/dfa1/vortex/protogen/Token.java | 2 +- .../src/main/java/io/github/dfa1/vortex/reader/Chunk.java | 2 +- .../io/github/dfa1/vortex/reader/ExtensionDecoder.java | 2 +- .../io/github/dfa1/vortex/reader/FlatSegmentDecoder.java | 2 +- .../java/io/github/dfa1/vortex/reader/ReadRegistry.java | 8 ++++---- .../java/io/github/dfa1/vortex/reader/VortexHandle.java | 2 +- .../io/github/dfa1/vortex/reader/VortexHttpReader.java | 2 +- .../io/github/dfa1/vortex/reader/array/ArraySegments.java | 4 ++-- .../github/dfa1/vortex/reader/array/ChunkedBoolArray.java | 2 +- .../github/dfa1/vortex/reader/array/ChunkedByteArray.java | 2 +- .../dfa1/vortex/reader/array/ChunkedDoubleArray.java | 4 ++-- .../dfa1/vortex/reader/array/ChunkedFloatArray.java | 2 +- .../github/dfa1/vortex/reader/array/ChunkedIntArray.java | 2 +- .../github/dfa1/vortex/reader/array/ChunkedLongArray.java | 4 ++-- .../dfa1/vortex/reader/array/ChunkedShortArray.java | 2 +- .../dfa1/vortex/reader/array/DateTimePartsArrays.java | 2 +- .../dfa1/vortex/reader/array/DecimalBytePartsArrays.java | 4 ++-- .../github/dfa1/vortex/reader/array/DictDoubleArray.java | 4 ++-- .../github/dfa1/vortex/reader/array/DictFloatArray.java | 4 ++-- .../io/github/dfa1/vortex/reader/array/DictIntArray.java | 4 ++-- .../io/github/dfa1/vortex/reader/array/DictLongArray.java | 4 ++-- .../io/github/dfa1/vortex/reader/array/GenericArray.java | 2 +- .../vortex/reader/array/LazyDateTimePartsLongArray.java | 2 +- .../github/dfa1/vortex/reader/array/LazyDecimalArray.java | 4 ++-- .../vortex/reader/array/LazyDecimalBytePartsArray.java | 4 ++-- .../io/github/dfa1/vortex/reader/array/VarBinArray.java | 6 +++--- .../dfa1/vortex/reader/decode/ChunkedEncodingDecoder.java | 2 +- .../reader/decode/DateTimePartsEncodingDecoder.java | 2 +- .../github/dfa1/vortex/reader/decode/DecodeContext.java | 4 ++-- .../github/dfa1/vortex/reader/decode/EncodingDecoder.java | 2 +- .../github/dfa1/vortex/reader/decode/PcoTansDecoder.java | 2 +- .../dfa1/vortex/reader/decode/SegmentBroadcast.java | 2 +- .../dfa1/vortex/reader/decode/UnknownArrayNode.java | 2 +- .../vortex/reader/extension/DateExtensionDecoder.java | 2 +- .../dfa1/vortex/reader/extension/ExtensionStorage.java | 2 +- .../vortex/reader/extension/TimeExtensionDecoder.java | 4 ++-- .../reader/extension/TimestampExtensionDecoder.java | 2 +- .../vortex/reader/extension/UuidExtensionDecoder.java | 2 +- .../dfa1/vortex/reader/decode/SegmentBroadcastTest.java | 2 +- .../io/github/dfa1/vortex/reader/decode/TestRegistry.java | 2 +- .../io/github/dfa1/vortex/writer/ExtensionEncoder.java | 2 +- .../java/io/github/dfa1/vortex/writer/VortexWriter.java | 6 +++--- .../java/io/github/dfa1/vortex/writer/WriteRegistry.java | 8 ++++---- .../io/github/dfa1/vortex/writer/encode/CascadeStep.java | 4 ++-- .../dfa1/vortex/writer/encode/CascadingCompressor.java | 2 +- .../dfa1/vortex/writer/encode/DateExtensionEncoder.java | 2 +- .../github/dfa1/vortex/writer/encode/EncodeContext.java | 2 +- .../github/dfa1/vortex/writer/encode/EncodingEncoder.java | 2 +- .../dfa1/vortex/writer/encode/TimeExtensionEncoder.java | 2 +- .../vortex/writer/encode/TimestampExtensionEncoder.java | 2 +- .../dfa1/vortex/writer/encode/UuidExtensionEncoder.java | 2 +- .../dfa1/vortex/writer/encode/DecodeTestHelper.java | 2 +- .../dfa1/vortex/writer/encode/EncodeTestHelper.java | 2 +- 65 files changed, 92 insertions(+), 92 deletions(-) diff --git a/cli/src/main/java/io/github/dfa1/vortex/cli/CliHandles.java b/cli/src/main/java/io/github/dfa1/vortex/cli/CliHandles.java index 1c9d9b4b..4e967251 100644 --- a/cli/src/main/java/io/github/dfa1/vortex/cli/CliHandles.java +++ b/cli/src/main/java/io/github/dfa1/vortex/cli/CliHandles.java @@ -16,7 +16,7 @@ /// Shared handle plumbing for the interactive subcommands (`view`, `tui`). /// /// A [VortexReader] uses a confined [java.lang.foreign.Arena], so the file must be -/// opened and closed on the same {@link IoWorker} thread the TUI later dispatches I/O to. These +/// opened and closed on the same [IoWorker] thread the TUI later dispatches I/O to. These /// helpers centralise that worker round-trip plus the local-file / http(s) target resolution. @SuppressWarnings("java:S106") // CLI tool: user-facing diagnostics go to System.err by design. final class CliHandles { diff --git a/cli/src/main/java/io/github/dfa1/vortex/cli/tui/IoWorker.java b/cli/src/main/java/io/github/dfa1/vortex/cli/tui/IoWorker.java index 7bf3ff68..b62a0c34 100644 --- a/cli/src/main/java/io/github/dfa1/vortex/cli/tui/IoWorker.java +++ b/cli/src/main/java/io/github/dfa1/vortex/cli/tui/IoWorker.java @@ -7,7 +7,7 @@ /// Single-threaded I/O executor that owns one [io.github.dfa1.vortex.reader.VortexHandle]. /// -/// Vortex readers use a confined {@link java.lang.foreign.Arena}, so every +/// Vortex readers use a confined [java.lang.foreign.Arena], so every /// `slice()` / `scan()` call must happen on the same thread that /// opened the file. The TUI dispatches all such calls to this worker so the /// render loop on the main thread never crosses the arena's owning thread. diff --git a/cli/src/main/java/io/github/dfa1/vortex/cli/tui/VortexInspectorTui.java b/cli/src/main/java/io/github/dfa1/vortex/cli/tui/VortexInspectorTui.java index 3f76751a..ba49cd21 100644 --- a/cli/src/main/java/io/github/dfa1/vortex/cli/tui/VortexInspectorTui.java +++ b/cli/src/main/java/io/github/dfa1/vortex/cli/tui/VortexInspectorTui.java @@ -62,7 +62,7 @@ public static void show(VortexHandle handle, InspectorTree.Progress progress) th /// Variant that dispatches every `handle` I/O call onto the supplied /// [IoWorker]. Required when the handle was opened on a different - /// thread (Vortex readers use a confined {@link java.lang.foreign.Arena}, + /// thread (Vortex readers use a confined [java.lang.foreign.Arena], /// so cross-thread access throws `WrongThreadException`). /// /// Passing `null` for `worker` falls back to synchronous I/O diff --git a/cli/src/test/java/io/github/dfa1/vortex/cli/tui/term/PosixTerminalSmokeTest.java b/cli/src/test/java/io/github/dfa1/vortex/cli/tui/term/PosixTerminalSmokeTest.java index 30cb57ad..3d690fa9 100644 --- a/cli/src/test/java/io/github/dfa1/vortex/cli/tui/term/PosixTerminalSmokeTest.java +++ b/cli/src/test/java/io/github/dfa1/vortex/cli/tui/term/PosixTerminalSmokeTest.java @@ -17,7 +17,7 @@ /// into the alternate screen / raw mode. Class load alone is the safe, meaningful /// assertion: it forces every `Linker.downcallHandle` in the static initializer /// (tcgetattr, tcsetattr, cfmakeraw, ioctl) to resolve its libc symbol, throwing -/// {@link UnsatisfiedLinkError} during `` if an entry point is missing. +/// [UnsatisfiedLinkError] during `` if an entry point is missing. class PosixTerminalSmokeTest { @Test diff --git a/core/src/main/java/io/github/dfa1/vortex/core/DType.java b/core/src/main/java/io/github/dfa1/vortex/core/DType.java index 6cba7390..10e9b45b 100644 --- a/core/src/main/java/io/github/dfa1/vortex/core/DType.java +++ b/core/src/main/java/io/github/dfa1/vortex/core/DType.java @@ -28,7 +28,7 @@ public sealed interface DType /// [#withNullable(boolean)] so call sites read as a fluent adjective: /// `DType.i64().asNullable()`. /// - /// @return a new {@link DType} identical to this one but with `nullable = true` + /// @return a new [DType] identical to this one but with `nullable = true` default DType asNullable() { return withNullable(true); } @@ -158,13 +158,13 @@ static Decimal decimal(int precision, int scale) { /// .build(); /// ``` /// - /// @return a new {@link StructBuilder} + /// @return a new [StructBuilder] static StructBuilder structBuilder() { return new StructBuilder(); } /// Fluent builder for [Struct] dtypes. Use [#structBuilder()] to obtain one. - /// Preserves insertion order and rejects duplicate field names at {@link #build()}. + /// Preserves insertion order and rejects duplicate field names at [#build()]. final class StructBuilder { private final LinkedHashMap fields = new LinkedHashMap<>(); private boolean nullable; @@ -195,7 +195,7 @@ public StructBuilder asNullable() { /// Builds the [Struct] dtype. /// - /// @return a new {@link Struct} reflecting every field added so far + /// @return a new [Struct] reflecting every field added so far public Struct build() { return new Struct( java.util.List.copyOf(fields.keySet()), diff --git a/core/src/main/java/io/github/dfa1/vortex/core/PType.java b/core/src/main/java/io/github/dfa1/vortex/core/PType.java index 85033fb9..64371830 100644 --- a/core/src/main/java/io/github/dfa1/vortex/core/PType.java +++ b/core/src/main/java/io/github/dfa1/vortex/core/PType.java @@ -60,7 +60,7 @@ public boolean isSigned() { /// uses to identify a physical type. /// /// Unlike `PType.values()[ordinal]`, this method validates the ordinal against the - /// declared range and throws {@link VortexException} for crafted out-of-range values rather + /// declared range and throws [VortexException] for crafted out-of-range values rather /// than the JDK's {@link ArrayIndexOutOfBoundsException}. Use this at every decode site that /// reads a ptype from untrusted metadata. /// diff --git a/core/src/main/java/io/github/dfa1/vortex/proto/ProtoReader.java b/core/src/main/java/io/github/dfa1/vortex/proto/ProtoReader.java index eaf08eff..f39aa65d 100644 --- a/core/src/main/java/io/github/dfa1/vortex/proto/ProtoReader.java +++ b/core/src/main/java/io/github/dfa1/vortex/proto/ProtoReader.java @@ -6,7 +6,7 @@ import java.nio.charset.StandardCharsets; /// Stateful cursor over a [MemorySegment] that decodes proto3 wire-format primitives. -/// Generated record types call into this from their {@code decode(...)} static factories. +/// Generated record types call into this from their `decode(...)` static factories. /// Package-private — generated code lives in the same package. final class ProtoReader { @@ -108,7 +108,7 @@ String readString() throws IOException { } /// Reads a length-delimited byte sequence into a fresh `byte[]`. - /// Use {@link #readLenDelimSegment()} for zero-copy access when the consumer can hold a segment slice. + /// Use [#readLenDelimSegment()] for zero-copy access when the consumer can hold a segment slice. byte[] readBytes() throws IOException { int len = readVarint32(); ensureBytes(len); diff --git a/core/src/main/java/io/github/dfa1/vortex/proto/ProtoWriter.java b/core/src/main/java/io/github/dfa1/vortex/proto/ProtoWriter.java index 4bbc4e92..8d1c4060 100644 --- a/core/src/main/java/io/github/dfa1/vortex/proto/ProtoWriter.java +++ b/core/src/main/java/io/github/dfa1/vortex/proto/ProtoWriter.java @@ -93,7 +93,7 @@ void writeEmbedded(byte[] encoded) { /// Reserves space for a length-delimited region whose payload size is unknown until written. /// Returns a mark to pass back to [#endLenDelim(int)]; the caller writes the payload - /// in between. Avoids the alloc/copy round-trip of writing into a temporary {@code ProtoWriter}. + /// in between. Avoids the alloc/copy round-trip of writing into a temporary `ProtoWriter`. /// /// Reserves the worst-case 5 bytes for a varint32 length; {@link #endLenDelim} backpatches /// the actual length and shifts the payload left if a shorter varint suffices. diff --git a/inspector/src/main/java/io/github/dfa1/vortex/inspect/InspectorTree.java b/inspector/src/main/java/io/github/dfa1/vortex/inspect/InspectorTree.java index a37ff937..d86fb408 100644 --- a/inspector/src/main/java/io/github/dfa1/vortex/inspect/InspectorTree.java +++ b/inspector/src/main/java/io/github/dfa1/vortex/inspect/InspectorTree.java @@ -87,7 +87,7 @@ public static InspectorTree build(VortexHandle handle) { /// resulting tree contains only structure derived from the file's footer /// and layout, so the call is essentially free on remote handles. /// - /// Use with {@link #peek(Node, VortexHandle)} for lazy on-demand resolution. + /// Use with [#peek(Node, VortexHandle)] for lazy on-demand resolution. /// /// @param handle open file handle /// @return immutable shallow inspector tree diff --git a/inspector/src/main/java/io/github/dfa1/vortex/inspect/ZonedStatsSchema.java b/inspector/src/main/java/io/github/dfa1/vortex/inspect/ZonedStatsSchema.java index 6a9435e0..5b3f7fb3 100644 --- a/inspector/src/main/java/io/github/dfa1/vortex/inspect/ZonedStatsSchema.java +++ b/inspector/src/main/java/io/github/dfa1/vortex/inspect/ZonedStatsSchema.java @@ -16,7 +16,7 @@ /// vortex-layout/src/layouts/zoned/mod.rs — `ZonedMetadata`): /// bytes [0..4) are the zone length as a little-endian `u32`; /// remaining bytes form a `Stat` bitset (LSB-first per byte). Each -/// set bit at index `i` indicates that the {@link Stat} with that +/// set bit at index `i` indicates that the [Stat] with that /// ordinal is present in the auxiliary stats table. /// - Schema construction /// ( diff --git a/jdbc/src/main/java/io/github/dfa1/vortex/jdbc/JdbcImporter.java b/jdbc/src/main/java/io/github/dfa1/vortex/jdbc/JdbcImporter.java index 1195bede..0b0ab6a3 100644 --- a/jdbc/src/main/java/io/github/dfa1/vortex/jdbc/JdbcImporter.java +++ b/jdbc/src/main/java/io/github/dfa1/vortex/jdbc/JdbcImporter.java @@ -27,7 +27,7 @@ /// Reads rows from a JDBC [ResultSet] and writes a Vortex file. /// -/// The schema is derived from {@link ResultSetMetaData} — no type inference is needed. +/// The schema is derived from [ResultSetMetaData] — no type inference is needed. /// SQL NULL values are mapped to `0`, `0.0`, `false`, or `""` depending on column type. /// Use {@link JdbcImportOptions#withFetchSize} to control driver-side streaming for large tables. public final class JdbcImporter { diff --git a/proto-gen/src/main/java/io/github/dfa1/vortex/protogen/CodeGen.java b/proto-gen/src/main/java/io/github/dfa1/vortex/protogen/CodeGen.java index a7ff06a7..94e1f125 100644 --- a/proto-gen/src/main/java/io/github/dfa1/vortex/protogen/CodeGen.java +++ b/proto-gen/src/main/java/io/github/dfa1/vortex/protogen/CodeGen.java @@ -589,7 +589,7 @@ private static String writeStmtOnWriter(Ast.Scalar s, String writer, String valu // ------------------------------------------------------------------ /// Emits a try/catch wrapper that translates [IllegalArgumentException] from - /// `Enum.fromValue(int)` into a checked {@link IOException}. The caller must already be + /// `Enum.fromValue(int)` into a checked [IOException]. The caller must already be /// inside a `throws IOException` context (every `decode(...)` factory is). private static void emitEnumDecodeWrap(StringBuilder sb, String indent, String javaName, String assignTarget) { sb.append(indent).append("int __ev = r.readVarint32();\n"); diff --git a/proto-gen/src/main/java/io/github/dfa1/vortex/protogen/Token.java b/proto-gen/src/main/java/io/github/dfa1/vortex/protogen/Token.java index bbc12617..d7577210 100644 --- a/proto-gen/src/main/java/io/github/dfa1/vortex/protogen/Token.java +++ b/proto-gen/src/main/java/io/github/dfa1/vortex/protogen/Token.java @@ -3,7 +3,7 @@ /// A token emitted by [Lexer]. /// /// @param kind token kind -/// @param text source text — meaningful for {@link Kind#IDENT}, {@link Kind#INT_LITERAL}, {@link Kind#STRING_LITERAL} +/// @param text source text — meaningful for [Kind#IDENT], [Kind#INT_LITERAL], [Kind#STRING_LITERAL] /// @param line 1-based source line number for diagnostics public record Token(Kind kind, String text, int line) { diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/Chunk.java b/reader/src/main/java/io/github/dfa1/vortex/reader/Chunk.java index 6788a135..982aef03 100644 --- a/reader/src/main/java/io/github/dfa1/vortex/reader/Chunk.java +++ b/reader/src/main/java/io/github/dfa1/vortex/reader/Chunk.java @@ -103,7 +103,7 @@ public T column(String name) { /// /// @param name column name as declared in the file's schema /// @param domainType the spec extension's Java domain type (e.g. [LocalDate] for - /// `vortex.date`, {@link Instant} for `vortex.timestamp`) + /// `vortex.date`, [Instant] for `vortex.timestamp`) /// @param domain element type /// @return decoded values in row order /// @throws VortexException if `name` isn't present, isn't an extension column, diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/ExtensionDecoder.java b/reader/src/main/java/io/github/dfa1/vortex/reader/ExtensionDecoder.java index d43ff82f..7d32c15d 100644 --- a/reader/src/main/java/io/github/dfa1/vortex/reader/ExtensionDecoder.java +++ b/reader/src/main/java/io/github/dfa1/vortex/reader/ExtensionDecoder.java @@ -6,7 +6,7 @@ /// Read-side contract for a Vortex extension type. /// /// Implementations pair a spec identity ([ExtensionId]) with the matching -/// {@link DType.Extension} dtype. Typed decode methods live on each concrete +/// [DType.Extension] dtype. Typed decode methods live on each concrete /// implementation — they are not on this interface, so read callers get typed return /// values without casting through `Object`. public interface ExtensionDecoder { diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/FlatSegmentDecoder.java b/reader/src/main/java/io/github/dfa1/vortex/reader/FlatSegmentDecoder.java index 1c764adf..3359b6f9 100644 --- a/reader/src/main/java/io/github/dfa1/vortex/reader/FlatSegmentDecoder.java +++ b/reader/src/main/java/io/github/dfa1/vortex/reader/FlatSegmentDecoder.java @@ -21,7 +21,7 @@ /// Flat segment wire format: /// `buffer_data... | FlatBuffer(Array) | u32 LE = FlatBuffer byte length` /// -/// {@link ReadRegistry} is pure dispatch; this class owns all file-format knowledge: +/// [ReadRegistry] is pure dispatch; this class owns all file-format knowledge: /// FlatBuffer parsing, buffer-offset arithmetic, and encoding-spec lookup. public final class FlatSegmentDecoder { diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/ReadRegistry.java b/reader/src/main/java/io/github/dfa1/vortex/reader/ReadRegistry.java index 29a4f71d..f6c9c617 100644 --- a/reader/src/main/java/io/github/dfa1/vortex/reader/ReadRegistry.java +++ b/reader/src/main/java/io/github/dfa1/vortex/reader/ReadRegistry.java @@ -18,7 +18,7 @@ /// Read-side registry: maps [EncodingId] to [EncodingDecoder] implementations. /// -/// Instances are immutable after construction. Build one via {@link #builder()} or +/// Instances are immutable after construction. Build one via [#builder()] or /// via the {@link #loadAll()} and {@link #empty()} convenience factories. public final class ReadRegistry { @@ -32,7 +32,7 @@ private ReadRegistry(Map decoders, boolean allowUnk /// Loads all service-discovered [EncodingDecoder] implementations. /// - /// @return an immutable {@link ReadRegistry} populated with all service-loaded decoders + /// @return an immutable [ReadRegistry] populated with all service-loaded decoders public static ReadRegistry loadAll() { return builder().registerServiceLoaded().build(); } @@ -134,7 +134,7 @@ private static UnknownArray decodeUnknown(DecodeContext ctx, ArrayNode node) { /// Builder for [ReadRegistry]. /// - /// Not thread-safe. Build once, use everywhere — the produced {@link ReadRegistry} is immutable. + /// Not thread-safe. Build once, use everywhere — the produced [ReadRegistry] is immutable. public static final class Builder { private final Map decoders = new HashMap<>(); @@ -170,7 +170,7 @@ public Builder registerServiceLoaded() { /// Enable passthrough decode for unknown encoding ids. /// /// Default is strict: unknown ids throw [VortexException]. When enabled, unknown - /// nodes are wrapped as {@link io.github.dfa1.vortex.reader.array.UnknownArray}. + /// nodes are wrapped as [io.github.dfa1.vortex.reader.array.UnknownArray]. /// Mirrors Rust `VortexSession::allow_unknown()`. /// /// @return this builder, for chaining diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/VortexHandle.java b/reader/src/main/java/io/github/dfa1/vortex/reader/VortexHandle.java index 15ae5958..07d94f20 100644 --- a/reader/src/main/java/io/github/dfa1/vortex/reader/VortexHandle.java +++ b/reader/src/main/java/io/github/dfa1/vortex/reader/VortexHandle.java @@ -49,7 +49,7 @@ public interface VortexHandle extends Closeable { /// /// **Internal escape hatch.** Exposed for tooling /// (e.g. the inspector's dictionary preview) that needs to decode an - /// internal subtree node directly via {@link io.github.dfa1.vortex.reader.FlatSegmentDecoder}. + /// internal subtree node directly via [io.github.dfa1.vortex.reader.FlatSegmentDecoder]. /// Not part of the supported stability contract; signatures may change /// without deprecation. /// diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/VortexHttpReader.java b/reader/src/main/java/io/github/dfa1/vortex/reader/VortexHttpReader.java index f8bab8ec..941affd7 100644 --- a/reader/src/main/java/io/github/dfa1/vortex/reader/VortexHttpReader.java +++ b/reader/src/main/java/io/github/dfa1/vortex/reader/VortexHttpReader.java @@ -259,7 +259,7 @@ public io.github.dfa1.vortex.reader.array.Array decodeFlatSegment( /// Returns an off-heap [MemorySegment] tied to this reader's [Arena]. /// /// @param spec the segment to fetch - /// @return a read-only {@link MemorySegment} containing the fetched bytes + /// @return a read-only [MemorySegment] containing the fetched bytes @Override public MemorySegment rawSegment(SegmentSpec spec) { long offset = spec.offset(); diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/array/ArraySegments.java b/reader/src/main/java/io/github/dfa1/vortex/reader/array/ArraySegments.java index ea71e6f5..90051d8e 100644 --- a/reader/src/main/java/io/github/dfa1/vortex/reader/array/ArraySegments.java +++ b/reader/src/main/java/io/github/dfa1/vortex/reader/array/ArraySegments.java @@ -8,7 +8,7 @@ import java.util.Optional; /// Internal materialization engine: turns any [Array] into its primary -/// {@link MemorySegment}, allocating from a caller-supplied arena for lazy variants. +/// [MemorySegment], allocating from a caller-supplied arena for lazy variants. /// /// If `arr` is a {@link MaskedArray}, the inner (data) segment is returned; /// the validity mask is not surfaced here — callers that need validity must unwrap manually. @@ -69,7 +69,7 @@ private static MemorySegment primarySegment(Array arr) { /// /// @param arr the array whose segment is needed /// @param arena allocator used to materialise lazy variants - /// @return the primary {@link MemorySegment} + /// @return the primary [MemorySegment] /// @throws VortexException if the array type has no primary segment public static MemorySegment of(Array arr, SegmentAllocator arena) { Array data = arr instanceof MaskedArray m ? m.inner() : arr; diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/array/ChunkedBoolArray.java b/reader/src/main/java/io/github/dfa1/vortex/reader/array/ChunkedBoolArray.java index 87cde5dc..dc0abb04 100644 --- a/reader/src/main/java/io/github/dfa1/vortex/reader/array/ChunkedBoolArray.java +++ b/reader/src/main/java/io/github/dfa1/vortex/reader/array/ChunkedBoolArray.java @@ -25,7 +25,7 @@ public record ChunkedBoolArray(DType dtype, long length, BoolArray[] children, l /// @param dtype logical element type /// @param totalRows expected total row count /// @param chunks non-empty list of chunk arrays - /// @return a new {@link ChunkedBoolArray} + /// @return a new [ChunkedBoolArray] /// @throws VortexException on empty input, non-{@link BoolArray} chunks, or row-count mismatch public static ChunkedBoolArray of(DType dtype, long totalRows, List chunks) { if (chunks.isEmpty()) { diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/array/ChunkedByteArray.java b/reader/src/main/java/io/github/dfa1/vortex/reader/array/ChunkedByteArray.java index 744c3f6f..1e9cebda 100644 --- a/reader/src/main/java/io/github/dfa1/vortex/reader/array/ChunkedByteArray.java +++ b/reader/src/main/java/io/github/dfa1/vortex/reader/array/ChunkedByteArray.java @@ -22,7 +22,7 @@ public record ChunkedByteArray(DType dtype, long length, ByteArray[] children, l /// @param dtype logical element type /// @param totalRows expected total row count /// @param chunks non-empty list of chunk arrays - /// @return a new {@link ChunkedByteArray} + /// @return a new [ChunkedByteArray] /// @throws VortexException on empty input, non-{@link ByteArray} chunks, or row-count mismatch public static ChunkedByteArray of(DType dtype, long totalRows, List chunks) { if (chunks.isEmpty()) { diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/array/ChunkedDoubleArray.java b/reader/src/main/java/io/github/dfa1/vortex/reader/array/ChunkedDoubleArray.java index 67a05ca6..21481d29 100644 --- a/reader/src/main/java/io/github/dfa1/vortex/reader/array/ChunkedDoubleArray.java +++ b/reader/src/main/java/io/github/dfa1/vortex/reader/array/ChunkedDoubleArray.java @@ -10,7 +10,7 @@ import java.util.function.DoubleConsumer; /// Multi-chunk [DoubleArray] view; record per ADR 0012 with stateless -/// {@link ChunkedLongArray#findChunk(long[], long)} dispatch. +/// [ChunkedLongArray#findChunk(long[], long)] dispatch. /// /// @param dtype logical element type /// @param length total logical row count @@ -20,7 +20,7 @@ public record ChunkedDoubleArray(DType dtype, long length, DoubleArray[] children, long[] offsets) implements DoubleArray { /// Builds a [ChunkedDoubleArray]. Flattens nested chunked arrays; - /// unwraps {@link MaskedArray} chunks. + /// unwraps [MaskedArray] chunks. /// /// @param dtype logical element type /// @param totalRows expected total row count diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/array/ChunkedFloatArray.java b/reader/src/main/java/io/github/dfa1/vortex/reader/array/ChunkedFloatArray.java index 518591ba..15e1aaba 100644 --- a/reader/src/main/java/io/github/dfa1/vortex/reader/array/ChunkedFloatArray.java +++ b/reader/src/main/java/io/github/dfa1/vortex/reader/array/ChunkedFloatArray.java @@ -22,7 +22,7 @@ public record ChunkedFloatArray(DType dtype, long length, FloatArray[] children, /// @param dtype logical element type /// @param totalRows expected total row count /// @param chunks non-empty list of chunk arrays - /// @return a new {@link ChunkedFloatArray} + /// @return a new [ChunkedFloatArray] /// @throws VortexException on empty input, non-{@link FloatArray} chunks, or row-count mismatch public static ChunkedFloatArray of(DType dtype, long totalRows, List chunks) { if (chunks.isEmpty()) { diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/array/ChunkedIntArray.java b/reader/src/main/java/io/github/dfa1/vortex/reader/array/ChunkedIntArray.java index 43bee57e..861014b1 100644 --- a/reader/src/main/java/io/github/dfa1/vortex/reader/array/ChunkedIntArray.java +++ b/reader/src/main/java/io/github/dfa1/vortex/reader/array/ChunkedIntArray.java @@ -23,7 +23,7 @@ public record ChunkedIntArray(DType dtype, long length, IntArray[] children, lon /// @param dtype logical element type /// @param totalRows expected total row count /// @param chunks non-empty list of chunk arrays - /// @return a new {@link ChunkedIntArray} + /// @return a new [ChunkedIntArray] /// @throws VortexException on empty input, non-{@link IntArray} chunks, or row-count mismatch public static ChunkedIntArray of(DType dtype, long totalRows, List chunks) { if (chunks.isEmpty()) { diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/array/ChunkedLongArray.java b/reader/src/main/java/io/github/dfa1/vortex/reader/array/ChunkedLongArray.java index cfc1ffb7..6d8de9ba 100644 --- a/reader/src/main/java/io/github/dfa1/vortex/reader/array/ChunkedLongArray.java +++ b/reader/src/main/java/io/github/dfa1/vortex/reader/array/ChunkedLongArray.java @@ -12,7 +12,7 @@ /// Multi-chunk [LongArray] view backed by an immutable array of child /// chunks plus their cumulative row offsets. Scalar access is stateless — -/// {@link #getLong(long)} resolves the chunk index via {@link #findChunk(long[], long)} +/// [#getLong(long)] resolves the chunk index via [#findChunk(long[], long)] /// (a binary search over `offsets`) on every call. /// /// Per ADR 0012, this preserves zero-copy on multi-chunk reads: each chunk @@ -28,7 +28,7 @@ public record ChunkedLongArray(DType dtype, long length, LongArray[] children, long[] offsets) implements LongArray { /// Builds a [ChunkedLongArray] from a list of chunk arrays. Nested - /// chunked arrays are flattened; {@link MaskedArray} chunks are unwrapped + /// chunked arrays are flattened; [MaskedArray] chunks are unwrapped /// to their inner data (validity dropped — matches prior concat behaviour). /// /// @param dtype logical element type diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/array/ChunkedShortArray.java b/reader/src/main/java/io/github/dfa1/vortex/reader/array/ChunkedShortArray.java index 841e690f..b43c7163 100644 --- a/reader/src/main/java/io/github/dfa1/vortex/reader/array/ChunkedShortArray.java +++ b/reader/src/main/java/io/github/dfa1/vortex/reader/array/ChunkedShortArray.java @@ -23,7 +23,7 @@ public record ChunkedShortArray(DType dtype, long length, ShortArray[] children, /// @param dtype logical element type /// @param totalRows expected total row count /// @param chunks non-empty list of chunk arrays - /// @return a new {@link ChunkedShortArray} + /// @return a new [ChunkedShortArray] /// @throws VortexException on empty input, non-{@link ShortArray} chunks, or row-count mismatch public static ChunkedShortArray of(DType dtype, long totalRows, List chunks) { if (chunks.isEmpty()) { diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/array/DateTimePartsArrays.java b/reader/src/main/java/io/github/dfa1/vortex/reader/array/DateTimePartsArrays.java index 2d46ecba..5e27ff61 100644 --- a/reader/src/main/java/io/github/dfa1/vortex/reader/array/DateTimePartsArrays.java +++ b/reader/src/main/java/io/github/dfa1/vortex/reader/array/DateTimePartsArrays.java @@ -6,7 +6,7 @@ /// /// `days`, `seconds` and `subseconds` children can each be one of /// the four signed-integer typed array interfaces; the writer picks the narrowest -/// ptype that fits. {@link #readLong(Array, long)} centralises the per-row read so +/// ptype that fits. [#readLong(Array, long)] centralises the per-row read so /// the record itself stays compact. final class DateTimePartsArrays { diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/array/DecimalBytePartsArrays.java b/reader/src/main/java/io/github/dfa1/vortex/reader/array/DecimalBytePartsArrays.java index f4eddd96..11bd87e3 100644 --- a/reader/src/main/java/io/github/dfa1/vortex/reader/array/DecimalBytePartsArrays.java +++ b/reader/src/main/java/io/github/dfa1/vortex/reader/array/DecimalBytePartsArrays.java @@ -9,7 +9,7 @@ /// `vortex.decimal_byte_parts` with `lower_part_count == 0` stores the /// decimal mantissa as a single signed-integer child column whose ptype the /// encoder picks (one of `i8 / i16 / i32 / i64`). The child may be wrapped -/// in {@link MaskedArray} for nullable columns. {@link #readMantissa(Array, long)} +/// in [MaskedArray] for nullable columns. [#readMantissa(Array, long)] /// centralises the per-row dispatch so the record itself stays compact. final class DecimalBytePartsArrays { @@ -17,7 +17,7 @@ private DecimalBytePartsArrays() { } /// Reads `arr[i]` as a signed-magnitude [BigInteger] mantissa. - /// Recurses through {@link MaskedArray}; throws on null cells so callers + /// Recurses through [MaskedArray]; throws on null cells so callers /// don't silently get a zero mantissa for invalid rows. /// /// @param arr source typed Array (must be one of Byte/Short/Int/Long, optionally MaskedArray-wrapped) diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/array/DictDoubleArray.java b/reader/src/main/java/io/github/dfa1/vortex/reader/array/DictDoubleArray.java index 942f7f78..ab1ff41b 100644 --- a/reader/src/main/java/io/github/dfa1/vortex/reader/array/DictDoubleArray.java +++ b/reader/src/main/java/io/github/dfa1/vortex/reader/array/DictDoubleArray.java @@ -13,7 +13,7 @@ /// `getDouble(i) = values.getDouble(codes.getCode(i))`. Per ADR 0012, /// this preserves zero-copy on dict-encoded categorical columns. /// -/// The `codes` array is typed as {@link Array} because the codes ptype +/// The `codes` array is typed as [Array] because the codes ptype /// varies with dictionary size — U8/U16/U32/U64 backed by /// {@link ByteArray}/{@link ShortArray}/{@link IntArray}/{@link LongArray}. /// @@ -30,7 +30,7 @@ public record DictDoubleArray(DType dtype, long length, DoubleArray values, Arra /// @param dtype logical element type /// @param length total logical row count /// @param values dictionary pool - /// @param codes per-row code array (must be {@link ByteArray}, {@link ShortArray}, + /// @param codes per-row code array (must be [ByteArray], [ShortArray], /// {@link IntArray}, or {@link LongArray}) /// @return a new {@link DictDoubleArray} /// @throws VortexException if `codes` is not a supported code-array type or diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/array/DictFloatArray.java b/reader/src/main/java/io/github/dfa1/vortex/reader/array/DictFloatArray.java index 8ac59b42..60a63349 100644 --- a/reader/src/main/java/io/github/dfa1/vortex/reader/array/DictFloatArray.java +++ b/reader/src/main/java/io/github/dfa1/vortex/reader/array/DictFloatArray.java @@ -12,7 +12,7 @@ /// `getFloat(i) = values.getFloat(codes.getCode(i))`. Per ADR 0012, /// this preserves zero-copy on dict-encoded categorical columns. /// -/// The `codes` array is typed as {@link Array} because the codes ptype +/// The `codes` array is typed as [Array] because the codes ptype /// varies with dictionary size — U8/U16/U32/U64 backed by /// {@link ByteArray}/{@link ShortArray}/{@link IntArray}/{@link LongArray}. /// @@ -29,7 +29,7 @@ public record DictFloatArray(DType dtype, long length, FloatArray values, Array /// @param dtype logical element type /// @param length total logical row count /// @param values dictionary pool - /// @param codes per-row code array (must be {@link ByteArray}, {@link ShortArray}, + /// @param codes per-row code array (must be [ByteArray], [ShortArray], /// {@link IntArray}, or {@link LongArray}) /// @return a new {@link DictFloatArray} /// @throws VortexException if `codes` is not a supported code-array type or diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/array/DictIntArray.java b/reader/src/main/java/io/github/dfa1/vortex/reader/array/DictIntArray.java index c463c89f..7be87078 100644 --- a/reader/src/main/java/io/github/dfa1/vortex/reader/array/DictIntArray.java +++ b/reader/src/main/java/io/github/dfa1/vortex/reader/array/DictIntArray.java @@ -13,7 +13,7 @@ /// `getInt(i) = values.getInt(codes.getCode(i))`. Per ADR 0012, this /// preserves zero-copy on dict-encoded categorical columns. /// -/// The `codes` array is typed as {@link Array} because the codes ptype +/// The `codes` array is typed as [Array] because the codes ptype /// varies with dictionary size — U8/U16/U32/U64 backed by /// {@link ByteArray}/{@link ShortArray}/{@link IntArray}/{@link LongArray}. /// @@ -30,7 +30,7 @@ public record DictIntArray(DType dtype, long length, IntArray values, Array code /// @param dtype logical element type /// @param length total logical row count /// @param values dictionary pool - /// @param codes per-row code array (must be {@link ByteArray}, {@link ShortArray}, + /// @param codes per-row code array (must be [ByteArray], [ShortArray], /// {@link IntArray}, or {@link LongArray}) /// @return a new {@link DictIntArray} /// @throws VortexException if `codes` is not a supported code-array type or diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/array/DictLongArray.java b/reader/src/main/java/io/github/dfa1/vortex/reader/array/DictLongArray.java index 8f015948..2423359b 100644 --- a/reader/src/main/java/io/github/dfa1/vortex/reader/array/DictLongArray.java +++ b/reader/src/main/java/io/github/dfa1/vortex/reader/array/DictLongArray.java @@ -15,7 +15,7 @@ /// `values` into a per-row buffer happens until a downstream caller /// genuinely requires a contiguous segment. /// -/// The `codes` array is typed as {@link Array} because the codes ptype +/// The `codes` array is typed as [Array] because the codes ptype /// varies with dictionary size — U8/U16/U32/U64 backed by /// {@link ByteArray}/{@link ShortArray}/{@link IntArray}/{@link LongArray}. /// {@link #of} validates that `codes` is one of those four types. @@ -33,7 +33,7 @@ public record DictLongArray(DType dtype, long length, LongArray values, Array co /// @param dtype logical element type /// @param length total logical row count /// @param values dictionary pool - /// @param codes per-row code array (must be {@link ByteArray}, {@link ShortArray}, + /// @param codes per-row code array (must be [ByteArray], [ShortArray], /// {@link IntArray}, or {@link LongArray}) /// @return a new {@link DictLongArray} /// @throws VortexException if `codes` is not a supported code-array type or diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/array/GenericArray.java b/reader/src/main/java/io/github/dfa1/vortex/reader/array/GenericArray.java index 462df9d5..5af74ddd 100644 --- a/reader/src/main/java/io/github/dfa1/vortex/reader/array/GenericArray.java +++ b/reader/src/main/java/io/github/dfa1/vortex/reader/array/GenericArray.java @@ -86,7 +86,7 @@ MemorySegment buffer(int i) { /// than the precision alone would allow. /// /// The child-array shape produced by `vortex.decimal_byte_parts` is now - /// handled by {@link LazyDecimalBytePartsArray} directly. + /// handled by [LazyDecimalBytePartsArray] directly. /// /// @param i row index, `0 <= i < length()` /// @return decoded value as a {@link BigDecimal} with the dtype's scale diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/array/LazyDateTimePartsLongArray.java b/reader/src/main/java/io/github/dfa1/vortex/reader/array/LazyDateTimePartsLongArray.java index 813255c8..e6272b32 100644 --- a/reader/src/main/java/io/github/dfa1/vortex/reader/array/LazyDateTimePartsLongArray.java +++ b/reader/src/main/java/io/github/dfa1/vortex/reader/array/LazyDateTimePartsLongArray.java @@ -21,7 +21,7 @@ /// (`TimestampExtensionDecoder`, `DateExtensionDecoder`, etc.) expects; /// no buffer materialisation occurs at construction time. /// -/// The record's {@link #dtype()} is the parent Extension dtype (e.g. +/// The record's [#dtype()] is the parent Extension dtype (e.g. /// `vortex.timestamp`) so it slots transparently into the extension-decode /// pipeline. Children may be any signed integer typed Array /// ({@link ByteArray}/{@link ShortArray}/{@link IntArray}/{@link LongArray}); the diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/array/LazyDecimalArray.java b/reader/src/main/java/io/github/dfa1/vortex/reader/array/LazyDecimalArray.java index e7894e7d..7d8f310f 100644 --- a/reader/src/main/java/io/github/dfa1/vortex/reader/array/LazyDecimalArray.java +++ b/reader/src/main/java/io/github/dfa1/vortex/reader/array/LazyDecimalArray.java @@ -15,7 +15,7 @@ /// the integer's byte width (1/2/4/8/16) is fixed for the whole array and chosen /// by the writer based on precision. The buffer is a mmap slice — decode wraps /// it; per-row [#getDecimal(long)] reads `byteWidth` bytes and combines -/// them with the parent dtype's scale into a {@link BigDecimal} on demand. No +/// them with the parent dtype's scale into a [BigDecimal] on demand. No /// arena allocation happens at construction time. /// /// @param dtype the parent {@link DType.Decimal} dtype (precision + scale + nullable) @@ -35,7 +35,7 @@ public record LazyDecimalArray(DType dtype, long length, MemorySegment buf, int /// /// @param i row index, `0 <= i < length()` /// @return decoded `BigDecimal` - /// @throws VortexException if the dtype isn't a {@link DType.Decimal} + /// @throws VortexException if the dtype isn't a [DType.Decimal] /// @throws IndexOutOfBoundsException if `i` is outside `[0, length())` public BigDecimal getDecimal(long i) { if (i < 0 || i >= length) { diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/array/LazyDecimalBytePartsArray.java b/reader/src/main/java/io/github/dfa1/vortex/reader/array/LazyDecimalBytePartsArray.java index ac09b629..00b17f43 100644 --- a/reader/src/main/java/io/github/dfa1/vortex/reader/array/LazyDecimalBytePartsArray.java +++ b/reader/src/main/java/io/github/dfa1/vortex/reader/array/LazyDecimalBytePartsArray.java @@ -10,7 +10,7 @@ /// With `lower_part_count == 0` (the only shape this codebase currently /// emits or accepts) the encoding stores its mantissa as a single signed-integer /// child column, paired with the parent's [DType.Decimal] precision and -/// scale. {@link #getDecimal(long)} reads one cell from the child via +/// scale. [#getDecimal(long)] reads one cell from the child via /// {@link DecimalBytePartsArrays#readMantissa(Array, long)} and combines it with /// the dtype scale to produce a {@link BigDecimal} on demand — no buffer /// materialisation occurs at construction time. @@ -24,7 +24,7 @@ public record LazyDecimalBytePartsArray(DType dtype, long length, Array msp) imp /// /// @param i row index, `0 <= i < length()` /// @return decoded `BigDecimal` - /// @throws VortexException if the dtype isn't a {@link DType.Decimal} or the + /// @throws VortexException if the dtype isn't a [DType.Decimal] or the /// mantissa cell is null /// @throws IndexOutOfBoundsException if `i` is outside `[0, length())` public BigDecimal getDecimal(long i) { diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/array/VarBinArray.java b/reader/src/main/java/io/github/dfa1/vortex/reader/array/VarBinArray.java index 9e46dec6..54cf714f 100644 --- a/reader/src/main/java/io/github/dfa1/vortex/reader/array/VarBinArray.java +++ b/reader/src/main/java/io/github/dfa1/vortex/reader/array/VarBinArray.java @@ -108,7 +108,7 @@ public VarBinArray limited(long rows) { VarBinArray limited(long rows); /// Materialises any `VarBinArray` into a flat [OffsetMode]. The fast path - /// returns `src` unchanged when it is already an {@link OffsetMode}. Other modes + /// returns `src` unchanged when it is already an [OffsetMode]. Other modes /// (ViewMode in particular) walk every row through the typed accessors, copy the bytes /// into a fresh contiguous segment allocated from `arena`, and build an I64 /// offsets table. Used by parent decoders (dict, sparse, runend) whose downstream code @@ -315,7 +315,7 @@ private long dictReadOff(long i) { /// /// @param dtype logical element type (Utf8 or Binary) /// @param length total logical row count - /// @param children chunk arrays in scan order; each is itself a {@link VarBinArray} + /// @param children chunk arrays in scan order; each is itself a [VarBinArray] /// @param offsets cumulative row counts; length = `children.length + 1` @SuppressWarnings("java:S6218") // internal data carrier; record components are arrays of immutable primitives or refs that flow through pipelines without ever being compared. record ChunkedMode(DType dtype, long length, VarBinArray[] children, long[] offsets) @@ -327,7 +327,7 @@ record ChunkedMode(DType dtype, long length, VarBinArray[] children, long[] offs /// @param totalRows expected total row count /// @param chunks non-empty list of [VarBinArray] chunks /// @return a new `ChunkedMode` - /// @throws VortexException on empty input, non-{@link VarBinArray} chunks, or row-count mismatch + /// @throws VortexException on empty input, non-[VarBinArray] chunks, or row-count mismatch public static ChunkedMode of(DType dtype, long totalRows, java.util.List chunks) { if (chunks.isEmpty()) { diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/decode/ChunkedEncodingDecoder.java b/reader/src/main/java/io/github/dfa1/vortex/reader/decode/ChunkedEncodingDecoder.java index 9275381c..96f30a41 100644 --- a/reader/src/main/java/io/github/dfa1/vortex/reader/decode/ChunkedEncodingDecoder.java +++ b/reader/src/main/java/io/github/dfa1/vortex/reader/decode/ChunkedEncodingDecoder.java @@ -75,7 +75,7 @@ private static long[] readOffsets(DecodeContext ctx, int nchunks) { /// Wraps the decoded chunk children in a zero-copy view: a `ChunkedXxxArray` /// for primitives and Bool, a [StructArray] of per-field chunked views for - /// {@link DType.Struct}. No concat / no per-row materialise. + /// [DType.Struct]. No concat / no per-row materialise. private static Array wrap(List chunks, DType dtype, long totalRows) { if (dtype instanceof DType.Primitive pt) { return wrapPrimitive(chunks, pt, dtype, totalRows); diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/decode/DateTimePartsEncodingDecoder.java b/reader/src/main/java/io/github/dfa1/vortex/reader/decode/DateTimePartsEncodingDecoder.java index a34fa228..d6328a20 100644 --- a/reader/src/main/java/io/github/dfa1/vortex/reader/decode/DateTimePartsEncodingDecoder.java +++ b/reader/src/main/java/io/github/dfa1/vortex/reader/decode/DateTimePartsEncodingDecoder.java @@ -17,7 +17,7 @@ /// /// Reassembles the three children (days, seconds, subseconds) into a /// [LazyDateTimePartsLongArray] of epoch counts in the extension's -/// {@link TimeUnit}. No per-row materialisation happens at decode time — +/// [TimeUnit]. No per-row materialisation happens at decode time — /// the downstream extension decoder reads the reassembled long via the /// lazy `getLong` accessor. public final class DateTimePartsEncodingDecoder implements EncodingDecoder { diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/decode/DecodeContext.java b/reader/src/main/java/io/github/dfa1/vortex/reader/decode/DecodeContext.java index cb822e52..1d1bbc79 100644 --- a/reader/src/main/java/io/github/dfa1/vortex/reader/decode/DecodeContext.java +++ b/reader/src/main/java/io/github/dfa1/vortex/reader/decode/DecodeContext.java @@ -11,7 +11,7 @@ /// Decoding context passed to each [EncodingDecoder]. /// -/// Buffers are {@link MemorySegment} slices materialized from the file's segment table; +/// Buffers are [MemorySegment] slices materialized from the file's segment table; /// children are decoded recursively via {@link #decodeChild(int)}. /// The arena is scoped to one chunk epoch — all decode output allocated from it is /// valid until the next chunk is opened. @@ -87,7 +87,7 @@ public MemorySegment decodeChildSegment(int i, DType dtype, long rowCount) { /// raw buffer for a bulk read, rather than re-decoding via [#decodeChildSegment(int)]. /// /// @param arr the decoded array to materialise - /// @return the array's primary {@link MemorySegment} + /// @return the array's primary [MemorySegment] public MemorySegment materialize(Array arr) { return ArraySegments.of(arr, arena); } diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/decode/EncodingDecoder.java b/reader/src/main/java/io/github/dfa1/vortex/reader/decode/EncodingDecoder.java index b5817cec..581453c1 100644 --- a/reader/src/main/java/io/github/dfa1/vortex/reader/decode/EncodingDecoder.java +++ b/reader/src/main/java/io/github/dfa1/vortex/reader/decode/EncodingDecoder.java @@ -7,7 +7,7 @@ /// Read-side decoding interface. Implementations live in the `reader` module and /// are discovered via [java.util.ServiceLoader]. /// -/// Register via {@link io.github.dfa1.vortex.reader.ReadRegistry} — implementations +/// Register via [io.github.dfa1.vortex.reader.ReadRegistry] — implementations /// are discoverable via {@link java.util.ServiceLoader}. public interface EncodingDecoder { diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/decode/PcoTansDecoder.java b/reader/src/main/java/io/github/dfa1/vortex/reader/decode/PcoTansDecoder.java index 877fb0e8..2a9cead0 100644 --- a/reader/src/main/java/io/github/dfa1/vortex/reader/decode/PcoTansDecoder.java +++ b/reader/src/main/java/io/github/dfa1/vortex/reader/decode/PcoTansDecoder.java @@ -95,7 +95,7 @@ static int[] spreadStateSymbols(int[] weights, int tableSize) { /// [LeBitReader#alignToByte()] before this call. /// `ansStateIdxs` is modified in place and not valid after return. /// `batchLowers` and `batchOffsetBits` are caller-provided scratch arrays of - /// length ≥ {@link #BATCH_N}; they are fully overwritten before use. + /// length ≥ [#BATCH_N]; they are fully overwritten before use. public void decodePage(LeBitReader reader, int[] ansStateIdxs, int n, MemorySegment out, long outByteOffset, long[] batchLowers, int[] batchOffsetBits) { diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/decode/SegmentBroadcast.java b/reader/src/main/java/io/github/dfa1/vortex/reader/decode/SegmentBroadcast.java index 4105ec9e..6201fa63 100644 --- a/reader/src/main/java/io/github/dfa1/vortex/reader/decode/SegmentBroadcast.java +++ b/reader/src/main/java/io/github/dfa1/vortex/reader/decode/SegmentBroadcast.java @@ -27,7 +27,7 @@ private SegmentBroadcast() { /// @param i logical element index in `[0, rowCount)` /// @param elemBytes element width in bytes (>= 1) /// @return byte offset suitable for [MemorySegment#get] or - /// {@link MemorySegment#copy(MemorySegment, long, MemorySegment, long, long)} + /// [MemorySegment#copy(MemorySegment, long, MemorySegment, long, long)] /// @throws VortexException if `seg` is empty (zero elements) public static long elementOffset(MemorySegment seg, long i, int elemBytes) { long cap = seg.byteSize() / elemBytes; diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/decode/UnknownArrayNode.java b/reader/src/main/java/io/github/dfa1/vortex/reader/decode/UnknownArrayNode.java index 04cf80c1..cc0f662c 100644 --- a/reader/src/main/java/io/github/dfa1/vortex/reader/decode/UnknownArrayNode.java +++ b/reader/src/main/java/io/github/dfa1/vortex/reader/decode/UnknownArrayNode.java @@ -4,7 +4,7 @@ /// Array node whose encoding id is not a recognised [io.github.dfa1.vortex.encoding.EncodingId]. /// Produced when a file uses an encoding this build does not know about. Decoded as -/// {@link io.github.dfa1.vortex.reader.array.UnknownArray} when +/// [io.github.dfa1.vortex.reader.array.UnknownArray] when /// {@link io.github.dfa1.vortex.reader.ReadRegistry#isAllowUnknown()} is set; otherwise the decode call throws. /// /// @param rawEncodingId the raw encoding id string from the file diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/extension/DateExtensionDecoder.java b/reader/src/main/java/io/github/dfa1/vortex/reader/extension/DateExtensionDecoder.java index d0a8a1fe..da2adf37 100644 --- a/reader/src/main/java/io/github/dfa1/vortex/reader/extension/DateExtensionDecoder.java +++ b/reader/src/main/java/io/github/dfa1/vortex/reader/extension/DateExtensionDecoder.java @@ -22,7 +22,7 @@ public final class DateExtensionDecoder implements ExtensionDecoder { public static final DateExtensionDecoder INSTANCE = new DateExtensionDecoder(); /// Public no-arg constructor for [java.util.ServiceLoader]. - /// Prefer the {@link #INSTANCE} singleton in application code. + /// Prefer the [#INSTANCE] singleton in application code. public DateExtensionDecoder() { } diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/extension/ExtensionStorage.java b/reader/src/main/java/io/github/dfa1/vortex/reader/extension/ExtensionStorage.java index 89e44946..1e981b8c 100644 --- a/reader/src/main/java/io/github/dfa1/vortex/reader/extension/ExtensionStorage.java +++ b/reader/src/main/java/io/github/dfa1/vortex/reader/extension/ExtensionStorage.java @@ -61,7 +61,7 @@ public static TimeUnit readUnit(DType.Extension ext) { /// Constructs an [Instant] from a signed epoch count in the given unit. /// /// @param raw epoch count - /// @param unit time resolution; must not be {@link TimeUnit#Days} + /// @param unit time resolution; must not be [TimeUnit#Days] /// @return matching {@link Instant} /// @throws VortexException if `unit` is {@link TimeUnit#Days} public static Instant instantFromRaw(long raw, TimeUnit unit) { diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/extension/TimeExtensionDecoder.java b/reader/src/main/java/io/github/dfa1/vortex/reader/extension/TimeExtensionDecoder.java index 861930b2..e24b38a0 100644 --- a/reader/src/main/java/io/github/dfa1/vortex/reader/extension/TimeExtensionDecoder.java +++ b/reader/src/main/java/io/github/dfa1/vortex/reader/extension/TimeExtensionDecoder.java @@ -21,7 +21,7 @@ public final class TimeExtensionDecoder implements ExtensionDecoder { public static final TimeExtensionDecoder INSTANCE = new TimeExtensionDecoder(); /// Public no-arg constructor for [java.util.ServiceLoader]. - /// Prefer the {@link #INSTANCE} singleton in application code. + /// Prefer the [#INSTANCE] singleton in application code. public TimeExtensionDecoder() { } @@ -52,7 +52,7 @@ public DType.Extension dtype(TimeUnit unit, boolean nullable) { /// @param storage signed-integer storage (I32 for s/ms, I64 for μs/ns) /// @param i row index, `0 <= i < storage.length()` /// @return decoded local time - /// @throws VortexException if the metadata unit is {@link TimeUnit#Days} + /// @throws VortexException if the metadata unit is [TimeUnit#Days] /// or storage isn't an integer primitive public LocalTime decode(DType.Extension ext, Array storage, long i) { ExtensionStorage.checkBounds(i, storage.length()); diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/extension/TimestampExtensionDecoder.java b/reader/src/main/java/io/github/dfa1/vortex/reader/extension/TimestampExtensionDecoder.java index 023ba91f..6ce78ab1 100644 --- a/reader/src/main/java/io/github/dfa1/vortex/reader/extension/TimestampExtensionDecoder.java +++ b/reader/src/main/java/io/github/dfa1/vortex/reader/extension/TimestampExtensionDecoder.java @@ -57,7 +57,7 @@ public DType.Extension dtype(TimeUnit unit, ZoneId zone, boolean nullable) { /// @param storage signed-integer storage array /// @param i row index, `0 <= i < storage.length()` /// @return decoded instant - /// @throws VortexException if the metadata unit is {@link TimeUnit#Days} + /// @throws VortexException if the metadata unit is [TimeUnit#Days] /// or storage isn't an integer primitive public Instant instant(DType.Extension ext, Array storage, long i) { ExtensionStorage.checkBounds(i, storage.length()); diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/extension/UuidExtensionDecoder.java b/reader/src/main/java/io/github/dfa1/vortex/reader/extension/UuidExtensionDecoder.java index d3f3cf72..cc751cc9 100644 --- a/reader/src/main/java/io/github/dfa1/vortex/reader/extension/UuidExtensionDecoder.java +++ b/reader/src/main/java/io/github/dfa1/vortex/reader/extension/UuidExtensionDecoder.java @@ -23,7 +23,7 @@ public final class UuidExtensionDecoder implements ExtensionDecoder { public static final UuidExtensionDecoder INSTANCE = new UuidExtensionDecoder(); /// Public no-arg constructor for [java.util.ServiceLoader]. - /// Prefer the {@link #INSTANCE} singleton in application code. + /// Prefer the [#INSTANCE] singleton in application code. public UuidExtensionDecoder() { } diff --git a/reader/src/test/java/io/github/dfa1/vortex/reader/decode/SegmentBroadcastTest.java b/reader/src/test/java/io/github/dfa1/vortex/reader/decode/SegmentBroadcastTest.java index 21bc25b0..e1b866fb 100644 --- a/reader/src/test/java/io/github/dfa1/vortex/reader/decode/SegmentBroadcastTest.java +++ b/reader/src/test/java/io/github/dfa1/vortex/reader/decode/SegmentBroadcastTest.java @@ -10,7 +10,7 @@ /// Unit tests for [SegmentBroadcast]. These verify the wrap-on-broadcast /// semantics that protect downstream encoders/decoders from IOOB when a child -/// segment was produced by {@link ConstantEncoding} (single-element buffer). +/// segment was produced by [ConstantEncoding] (single-element buffer). class SegmentBroadcastTest { @Test diff --git a/reader/src/test/java/io/github/dfa1/vortex/reader/decode/TestRegistry.java b/reader/src/test/java/io/github/dfa1/vortex/reader/decode/TestRegistry.java index 978814f6..f0eda8f0 100644 --- a/reader/src/test/java/io/github/dfa1/vortex/reader/decode/TestRegistry.java +++ b/reader/src/test/java/io/github/dfa1/vortex/reader/decode/TestRegistry.java @@ -23,7 +23,7 @@ public static ReadRegistry ofDecoders(EncodingDecoder... decoders) { } /// Builds a [ReadRegistry] containing the supplied decoder plus a - /// {@link PrimitiveEncodingDecoder} fallback (so child decodes of primitive segments work). + /// [PrimitiveEncodingDecoder] fallback (so child decodes of primitive segments work). /// /// @param sut decoder under test /// @return registry instance diff --git a/writer/src/main/java/io/github/dfa1/vortex/writer/ExtensionEncoder.java b/writer/src/main/java/io/github/dfa1/vortex/writer/ExtensionEncoder.java index 16e0573c..e8e8e1e6 100644 --- a/writer/src/main/java/io/github/dfa1/vortex/writer/ExtensionEncoder.java +++ b/writer/src/main/java/io/github/dfa1/vortex/writer/ExtensionEncoder.java @@ -9,7 +9,7 @@ /// Write-side contract for a Vortex extension type. /// /// Implementations pair a spec identity ([ExtensionId]) with the matching -/// {@link DType.Extension} dtype and a polymorphic {@link #encodeAll} entry point used +/// [DType.Extension] dtype and a polymorphic [#encodeAll] entry point used /// by the writer's auto-routing path. public interface ExtensionEncoder { diff --git a/writer/src/main/java/io/github/dfa1/vortex/writer/VortexWriter.java b/writer/src/main/java/io/github/dfa1/vortex/writer/VortexWriter.java index 85d949b0..93776f7a 100644 --- a/writer/src/main/java/io/github/dfa1/vortex/writer/VortexWriter.java +++ b/writer/src/main/java/io/github/dfa1/vortex/writer/VortexWriter.java @@ -185,7 +185,7 @@ public static VortexWriter create( /// Creates a [VortexWriter] with a custom encoder list. /// - /// Creates a {@link VortexWriter} with a custom encoder list. + /// Creates a [VortexWriter] with a custom encoder list. /// /// @param channel the channel to write to /// @param schema the struct schema for the file @@ -215,7 +215,7 @@ public static VortexWriter create( } /// Counts rows for the length-consistency check in [#writeChunk]. Accepts the - /// same shapes the writer takes plus pre-conversion {@link java.util.Collection}s + /// same shapes the writer takes plus pre-conversion [java.util.Collection]s /// from the extension-column auto-route path. private static long rowCountForValidation(String colName, Object data) { if (data instanceof java.util.Collection coll) { @@ -359,7 +359,7 @@ private static ByteBuffer buildPostscript( /// .put("volume", new Long[] {100L, null})); // boxed → nullable /// ``` /// - /// @param builder consumer that populates a {@link Chunk} with all schema columns + /// @param builder consumer that populates a [Chunk] with all schema columns /// @throws IOException if an I/O error occurs writing to the underlying channel public void writeChunk(java.util.function.Consumer builder) throws IOException { var impl = new io.github.dfa1.vortex.writer.ChunkImpl(schema); diff --git a/writer/src/main/java/io/github/dfa1/vortex/writer/WriteRegistry.java b/writer/src/main/java/io/github/dfa1/vortex/writer/WriteRegistry.java index 2a4aa85a..5463a253 100644 --- a/writer/src/main/java/io/github/dfa1/vortex/writer/WriteRegistry.java +++ b/writer/src/main/java/io/github/dfa1/vortex/writer/WriteRegistry.java @@ -10,7 +10,7 @@ import java.util.ServiceLoader; /// Write-side registry: maps [EncodingId] to [EncodingEncoder] implementations, -/// and {@link ExtensionId} to {@link ExtensionEncoder} implementations. +/// and [ExtensionId] to [ExtensionEncoder] implementations. /// /// Instances are immutable after construction. Build one via {@link #builder()} or via the /// {@link #loadAll()} and {@link #empty()} convenience factories. @@ -33,7 +33,7 @@ private WriteRegistry(Map encoders, /// Loads all service-discovered [EncodingEncoder] and [ExtensionEncoder] implementations. /// - /// @return an immutable {@link WriteRegistry} populated with all service-loaded entries + /// @return an immutable [WriteRegistry] populated with all service-loaded entries public static WriteRegistry loadAll() { return builder().registerServiceLoaded().build(); } @@ -69,7 +69,7 @@ public ExtensionEncoder lookup(ExtensionId extensionId) { /// Builder for [WriteRegistry]. /// - /// Not thread-safe. Build once, use everywhere — the produced {@link WriteRegistry} is immutable. + /// Not thread-safe. Build once, use everywhere — the produced [WriteRegistry] is immutable. public static final class Builder { private final Map encoders = new HashMap<>(); @@ -105,7 +105,7 @@ public Builder register(ExtensionEncoder extension) { } /// Registers every [EncodingEncoder] and [ExtensionEncoder] discovered via - /// {@link ServiceLoader}. + /// [ServiceLoader]. /// /// @return this builder, for chaining /// @throws VortexException if a service-loaded entry collides with one already registered diff --git a/writer/src/main/java/io/github/dfa1/vortex/writer/encode/CascadeStep.java b/writer/src/main/java/io/github/dfa1/vortex/writer/encode/CascadeStep.java index 2d8226f3..7b43644d 100644 --- a/writer/src/main/java/io/github/dfa1/vortex/writer/encode/CascadeStep.java +++ b/writer/src/main/java/io/github/dfa1/vortex/writer/encode/CascadeStep.java @@ -12,7 +12,7 @@ /// (e.g. patch index/value buffers for ALP). Child recursion results are appended after these; /// child `bufferIndices` are remapped by `+ownedBuffers.size()`. /// -/// When `applicable` is false the encoding cannot handle this data; {@link #ownedBytes()} +/// When `applicable` is false the encoding cannot handle this data; [#ownedBytes()] /// returns {@link Long#MAX_VALUE}/2 so the step never wins in size-based selection. /// /// @param partialRoot partially-assembled root encode node (may be `null` when not applicable) @@ -56,7 +56,7 @@ public boolean isTerminal() { /// Total byte size of owned buffers (used for size-based winner selection on samples). /// Returns [Long#MAX_VALUE]/2 for non-applicable steps. /// - /// @return total size in bytes of all owned buffers, or {@link Long#MAX_VALUE}/2 if not applicable + /// @return total size in bytes of all owned buffers, or [Long#MAX_VALUE]/2 if not applicable public long ownedBytes() { if (!applicable) { return Long.MAX_VALUE / 2; diff --git a/writer/src/main/java/io/github/dfa1/vortex/writer/encode/CascadingCompressor.java b/writer/src/main/java/io/github/dfa1/vortex/writer/encode/CascadingCompressor.java index b3674b5e..b04a7d4d 100644 --- a/writer/src/main/java/io/github/dfa1/vortex/writer/encode/CascadingCompressor.java +++ b/writer/src/main/java/io/github/dfa1/vortex/writer/encode/CascadingCompressor.java @@ -142,7 +142,7 @@ private static long primitiveBytes(DType dtype, int n) { /// @param dtype the logical type of the data to encode /// @param data input data in the format expected by the candidate encodings /// @param ctx encoding context supplying the arena, encoder map, and cascade parameters - /// @return the {@link EncodeResult} produced by the winning encoding + /// @return the [EncodeResult] produced by the winning encoding public EncodeResult encode(DType dtype, Object data, EncodeContext ctx) { return encodeWithCtx(dtype, data, ctx); } diff --git a/writer/src/main/java/io/github/dfa1/vortex/writer/encode/DateExtensionEncoder.java b/writer/src/main/java/io/github/dfa1/vortex/writer/encode/DateExtensionEncoder.java index 0a06e09f..98826453 100644 --- a/writer/src/main/java/io/github/dfa1/vortex/writer/encode/DateExtensionEncoder.java +++ b/writer/src/main/java/io/github/dfa1/vortex/writer/encode/DateExtensionEncoder.java @@ -19,7 +19,7 @@ public final class DateExtensionEncoder implements ExtensionEncoder { public static final DateExtensionEncoder INSTANCE = new DateExtensionEncoder(); /// Public no-arg constructor for [java.util.ServiceLoader]. - /// Prefer the {@link #INSTANCE} singleton in application code. + /// Prefer the [#INSTANCE] singleton in application code. public DateExtensionEncoder() { } diff --git a/writer/src/main/java/io/github/dfa1/vortex/writer/encode/EncodeContext.java b/writer/src/main/java/io/github/dfa1/vortex/writer/encode/EncodeContext.java index 88c83db3..aba649aa 100644 --- a/writer/src/main/java/io/github/dfa1/vortex/writer/encode/EncodeContext.java +++ b/writer/src/main/java/io/github/dfa1/vortex/writer/encode/EncodeContext.java @@ -11,7 +11,7 @@ import java.util.Set; /// Encoding context passed to every [EncodingEncoder#encode] and -/// {@link EncodingEncoder#encodeCascade} call. +/// [EncodingEncoder#encodeCascade] call. /// /// Carries a caller-scoped {@link Arena} for encode output buffers, a /// {@link WriteRegistry} for cross-encoder delegation and extension lookup, diff --git a/writer/src/main/java/io/github/dfa1/vortex/writer/encode/EncodingEncoder.java b/writer/src/main/java/io/github/dfa1/vortex/writer/encode/EncodingEncoder.java index bd19d727..319142b6 100644 --- a/writer/src/main/java/io/github/dfa1/vortex/writer/encode/EncodingEncoder.java +++ b/writer/src/main/java/io/github/dfa1/vortex/writer/encode/EncodingEncoder.java @@ -9,7 +9,7 @@ /// point itself. /// /// Encoder implementations live in the `writer` module and are registered via -/// {@link java.util.ServiceLoader}. +/// [java.util.ServiceLoader]. public interface EncodingEncoder { /// @return the wire identifier of this encoding diff --git a/writer/src/main/java/io/github/dfa1/vortex/writer/encode/TimeExtensionEncoder.java b/writer/src/main/java/io/github/dfa1/vortex/writer/encode/TimeExtensionEncoder.java index abbb5c3a..a60c4ed4 100644 --- a/writer/src/main/java/io/github/dfa1/vortex/writer/encode/TimeExtensionEncoder.java +++ b/writer/src/main/java/io/github/dfa1/vortex/writer/encode/TimeExtensionEncoder.java @@ -18,7 +18,7 @@ public final class TimeExtensionEncoder implements ExtensionEncoder { public static final TimeExtensionEncoder INSTANCE = new TimeExtensionEncoder(); /// Public no-arg constructor for [java.util.ServiceLoader]. - /// Prefer the {@link #INSTANCE} singleton in application code. + /// Prefer the [#INSTANCE] singleton in application code. public TimeExtensionEncoder() { } diff --git a/writer/src/main/java/io/github/dfa1/vortex/writer/encode/TimestampExtensionEncoder.java b/writer/src/main/java/io/github/dfa1/vortex/writer/encode/TimestampExtensionEncoder.java index 8cd09fa9..9103dbdf 100644 --- a/writer/src/main/java/io/github/dfa1/vortex/writer/encode/TimestampExtensionEncoder.java +++ b/writer/src/main/java/io/github/dfa1/vortex/writer/encode/TimestampExtensionEncoder.java @@ -19,7 +19,7 @@ public final class TimestampExtensionEncoder implements ExtensionEncoder { public static final TimestampExtensionEncoder INSTANCE = new TimestampExtensionEncoder(); /// Public no-arg constructor for [java.util.ServiceLoader]. - /// Prefer the {@link #INSTANCE} singleton in application code. + /// Prefer the [#INSTANCE] singleton in application code. public TimestampExtensionEncoder() { } diff --git a/writer/src/main/java/io/github/dfa1/vortex/writer/encode/UuidExtensionEncoder.java b/writer/src/main/java/io/github/dfa1/vortex/writer/encode/UuidExtensionEncoder.java index 2941c3bf..6d2959d5 100644 --- a/writer/src/main/java/io/github/dfa1/vortex/writer/encode/UuidExtensionEncoder.java +++ b/writer/src/main/java/io/github/dfa1/vortex/writer/encode/UuidExtensionEncoder.java @@ -18,7 +18,7 @@ public final class UuidExtensionEncoder implements ExtensionEncoder { public static final UuidExtensionEncoder INSTANCE = new UuidExtensionEncoder(); /// Public no-arg constructor for [java.util.ServiceLoader]. - /// Prefer the {@link #INSTANCE} singleton in application code. + /// Prefer the [#INSTANCE] singleton in application code. public UuidExtensionEncoder() { } diff --git a/writer/src/test/java/io/github/dfa1/vortex/writer/encode/DecodeTestHelper.java b/writer/src/test/java/io/github/dfa1/vortex/writer/encode/DecodeTestHelper.java index f96a82d5..5c9ab806 100644 --- a/writer/src/test/java/io/github/dfa1/vortex/writer/encode/DecodeTestHelper.java +++ b/writer/src/test/java/io/github/dfa1/vortex/writer/encode/DecodeTestHelper.java @@ -23,7 +23,7 @@ private DecodeTestHelper() { /// @param rowCount logical row count /// @param dtype decoded dtype /// @param registry registry used for nested decode dispatch - /// @return decode context ready for {@link EncodingDecoder#decode} + /// @return decode context ready for [EncodingDecoder#decode] public static DecodeContext toDecodeContext( EncodeResult result, long rowCount, DType dtype, ReadRegistry registry ) { diff --git a/writer/src/test/java/io/github/dfa1/vortex/writer/encode/EncodeTestHelper.java b/writer/src/test/java/io/github/dfa1/vortex/writer/encode/EncodeTestHelper.java index 7d5703dc..34bd53cb 100644 --- a/writer/src/test/java/io/github/dfa1/vortex/writer/encode/EncodeTestHelper.java +++ b/writer/src/test/java/io/github/dfa1/vortex/writer/encode/EncodeTestHelper.java @@ -13,7 +13,7 @@ private EncodeTestHelper() { } /// Creates a non-cascading [EncodeContext] using a GC-managed arena and all - /// service-loaded {@link EncodingEncoder}s. + /// service-loaded [EncodingEncoder]s. /// /// @return a test-suitable {@link EncodeContext} public static EncodeContext testCtx() { From 6ef9d4c126bd120323eb3a7da74c2f2a6a3afd69 Mon Sep 17 00:00:00 2001 From: Davide Angelocola Date: Fri, 19 Jun 2026 20:14:15 +0200 Subject: [PATCH 2/2] test: use dedicated AssertJ assertions (Sonar S5838) Replace size/toString/hashCode/map/array equality checks with hasSize, hasToString, hasSameHashCodeAs, containsEntry, hasSameSizeAs, isNotEmpty. Co-Authored-By: Claude Opus 4.8 --- .../java/io/github/dfa1/vortex/encoding/EncodingIdTest.java | 2 +- .../java/io/github/dfa1/vortex/proto/ProtoRuntimeTest.java | 2 +- .../integration/RustJavaReaderComparisonIntegrationTest.java | 4 ++-- .../integration/RustWritesJavaReadsIntegrationTest.java | 2 +- .../github/dfa1/vortex/reader/array/VarBinViewModeTest.java | 2 +- .../dfa1/vortex/writer/encode/ZstdEncodingEncoderTest.java | 2 +- 6 files changed, 7 insertions(+), 7 deletions(-) diff --git a/core/src/test/java/io/github/dfa1/vortex/encoding/EncodingIdTest.java b/core/src/test/java/io/github/dfa1/vortex/encoding/EncodingIdTest.java index 0ef98280..740ae417 100644 --- a/core/src/test/java/io/github/dfa1/vortex/encoding/EncodingIdTest.java +++ b/core/src/test/java/io/github/dfa1/vortex/encoding/EncodingIdTest.java @@ -40,7 +40,7 @@ void id_isNonBlankString(EncodingId id) { @EnumSource(EncodingId.class) void toString_equalsId(EncodingId id) { // Given / When / Then - assertThat(id.toString()).isEqualTo(id.id()); + assertThat(id).hasToString(id.id()); } } } diff --git a/core/src/test/java/io/github/dfa1/vortex/proto/ProtoRuntimeTest.java b/core/src/test/java/io/github/dfa1/vortex/proto/ProtoRuntimeTest.java index b05b1ce7..4f329a5c 100644 --- a/core/src/test/java/io/github/dfa1/vortex/proto/ProtoRuntimeTest.java +++ b/core/src/test/java/io/github/dfa1/vortex/proto/ProtoRuntimeTest.java @@ -316,7 +316,7 @@ void recordsWithEqualByteArraysAreEqual() { // When + Then assertThat(a).isEqualTo(b); - assertThat(a.hashCode()).isEqualTo(b.hashCode()); + assertThat(a).hasSameHashCodeAs(b); } @Test diff --git a/integration/src/test/java/io/github/dfa1/vortex/integration/RustJavaReaderComparisonIntegrationTest.java b/integration/src/test/java/io/github/dfa1/vortex/integration/RustJavaReaderComparisonIntegrationTest.java index e0c0a9c2..2eaec3c5 100644 --- a/integration/src/test/java/io/github/dfa1/vortex/integration/RustJavaReaderComparisonIntegrationTest.java +++ b/integration/src/test/java/io/github/dfa1/vortex/integration/RustJavaReaderComparisonIntegrationTest.java @@ -428,9 +428,9 @@ void rust_vs_javaReader_statsMatch(String fixture, @TempDir Path tmp) throws Exc .as("string column names in %s", fixture) .containsAll(resultRust.strLenSums().keySet()); for (Map.Entry entry : resultRust.strLenSums().entrySet()) { - assertThat(resultJava.strLenSums().get(entry.getKey())) + assertThat(resultJava.strLenSums()) .describedAs("string column '%s' byte-length sum in %s", entry.getKey(), fixture) - .isEqualTo(entry.getValue()); + .containsEntry(entry.getKey(), entry.getValue()); } } } diff --git a/integration/src/test/java/io/github/dfa1/vortex/integration/RustWritesJavaReadsIntegrationTest.java b/integration/src/test/java/io/github/dfa1/vortex/integration/RustWritesJavaReadsIntegrationTest.java index c63dff90..a34851a1 100644 --- a/integration/src/test/java/io/github/dfa1/vortex/integration/RustWritesJavaReadsIntegrationTest.java +++ b/integration/src/test/java/io/github/dfa1/vortex/integration/RustWritesJavaReadsIntegrationTest.java @@ -549,7 +549,7 @@ void jniWriter_javaReader_f16_primitiveRoundTrip(@TempDir Path tmp) throws IOExc assertThat(results).hasSize(1); // F16 column snapshots as a short[] (raw float16 bits) short[] decoded = (short[]) results.getFirst().columns().get("v"); - assertThat(decoded.length).isEqualTo(f16bits.length); + assertThat(decoded).hasSameSizeAs(f16bits); for (int i = 0; i < f16bits.length; i++) { assertThat(Float.float16ToFloat(decoded[i])) .as("index %d", i) diff --git a/reader/src/test/java/io/github/dfa1/vortex/reader/array/VarBinViewModeTest.java b/reader/src/test/java/io/github/dfa1/vortex/reader/array/VarBinViewModeTest.java index e507c148..e3a6bf8a 100644 --- a/reader/src/test/java/io/github/dfa1/vortex/reader/array/VarBinViewModeTest.java +++ b/reader/src/test/java/io/github/dfa1/vortex/reader/array/VarBinViewModeTest.java @@ -60,7 +60,7 @@ void getStringFromReferencedDataBuffer() { try (Arena arena = Arena.ofConfined()) { // Given a 13-byte string (exceeds 12-byte inline limit) stored in a shared data buffer. String longStr = "thirteen-byte"; - assertThat(longStr.length()).isEqualTo(13); + assertThat(longStr).hasSize(13); MemorySegment dataBuf = arena.allocate(longStr.length()); MemorySegment.copy(MemorySegment.ofArray(longStr.getBytes(StandardCharsets.UTF_8)), 0, dataBuf, 0, longStr.length()); diff --git a/writer/src/test/java/io/github/dfa1/vortex/writer/encode/ZstdEncodingEncoderTest.java b/writer/src/test/java/io/github/dfa1/vortex/writer/encode/ZstdEncodingEncoderTest.java index 4bb795ce..e2f1895e 100644 --- a/writer/src/test/java/io/github/dfa1/vortex/writer/encode/ZstdEncodingEncoderTest.java +++ b/writer/src/test/java/io/github/dfa1/vortex/writer/encode/ZstdEncodingEncoderTest.java @@ -283,7 +283,7 @@ void encode_i32_metadata_framesCount_isNonZero() throws Exception { var metaSeg = java.lang.foreign.MemorySegment.ofBuffer(result.rootNode().metadata().duplicate()); ZstdMetadata meta = ZstdMetadata.decode(metaSeg, 0, metaSeg.byteSize()); - assertThat(meta.frames().size()).isGreaterThan(0); + assertThat(meta.frames()).isNotEmpty(); } } }