From 35f7a20b22271f8f28d15da8df85cff2fc9cd716 Mon Sep 17 00:00:00 2001 From: Matthias Andreas Benkard Date: Tue, 14 Dec 2021 19:29:26 +0100 Subject: Simplify types, replace Value with Variant. Change-Id: I2e492ebfefc7e9a47c874ed22ff199412e9948ee --- src/main/java/eu/mulk/jgvariant/core/Decoder.java | 108 ++++++++---------- src/main/java/eu/mulk/jgvariant/core/Value.java | 112 ------------------- src/main/java/eu/mulk/jgvariant/core/Variant.java | 102 +++++++++++++++++ .../java/eu/mulk/jgvariant/core/package-info.java | 20 ++-- src/main/java/module-info.java | 6 +- .../java/eu/mulk/jgvariant/core/DecoderTest.java | 123 +++++++-------------- 6 files changed, 207 insertions(+), 264 deletions(-) delete mode 100644 src/main/java/eu/mulk/jgvariant/core/Value.java create mode 100644 src/main/java/eu/mulk/jgvariant/core/Variant.java (limited to 'src') diff --git a/src/main/java/eu/mulk/jgvariant/core/Decoder.java b/src/main/java/eu/mulk/jgvariant/core/Decoder.java index c51a723..8134d45 100644 --- a/src/main/java/eu/mulk/jgvariant/core/Decoder.java +++ b/src/main/java/eu/mulk/jgvariant/core/Decoder.java @@ -2,17 +2,6 @@ package eu.mulk.jgvariant.core; import static java.nio.ByteOrder.LITTLE_ENDIAN; -import eu.mulk.jgvariant.core.Value.Array; -import eu.mulk.jgvariant.core.Value.Bool; -import eu.mulk.jgvariant.core.Value.Float64; -import eu.mulk.jgvariant.core.Value.Int16; -import eu.mulk.jgvariant.core.Value.Int32; -import eu.mulk.jgvariant.core.Value.Int64; -import eu.mulk.jgvariant.core.Value.Int8; -import eu.mulk.jgvariant.core.Value.Maybe; -import eu.mulk.jgvariant.core.Value.Str; -import eu.mulk.jgvariant.core.Value.Structure; -import eu.mulk.jgvariant.core.Value.Variant; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.RecordComponent; import java.nio.ByteBuffer; @@ -25,7 +14,7 @@ import java.util.Optional; import org.jetbrains.annotations.Nullable; /** - * Type class for decodable {@link Value} types. + * Type class for decodable {@link Variant} types. * *

Use the {@code of*} family of constructor methods to acquire a suitable {@link Decoder} for * the type you wish to decode. @@ -36,23 +25,23 @@ import org.jetbrains.annotations.Nullable; * {@code int}, you can use the following code: * * 

{@code
- * record ExampleRecord(Value.Str s, Value.Int32 i) {}
+ * record ExampleRecord(String s, int i) {}
  *
  * var decoder =
  *   Decoder.ofArray(
  *     Decoder.ofStructure(
  *       ExampleRecord.class,
- *       Decoder.ofStr(UTF_8),
- *       Decoder.ofInt32().withByteOrder(LITTLE_ENDIAN)));
+ *       Decoder.ofString(UTF_8),
+ *       Decoder.ofInt().withByteOrder(LITTLE_ENDIAN)));
  *
  * byte[] bytes = ...;
- * Value.Array> example = decoder.decode(ByteBuffer.wrap(bytes));
+ * List example = decoder.decode(ByteBuffer.wrap(bytes));
  * }
* * @param the type that the {@link Decoder} can decode. */ @SuppressWarnings("java:S1610") -public abstract class Decoder { +public abstract class Decoder { private Decoder() {} @@ -100,13 +89,13 @@ public abstract class Decoder { } /** - * Creates a {@link Decoder} for an {@link Array} type. + * Creates a {@link Decoder} for an {@code Array} type. * * @param elementDecoder a {@link Decoder} for the elements of the array. * @param the element type. * @return a new {@link Decoder}. */ - public static Decoder> ofArray(Decoder elementDecoder) { + public static Decoder> ofArray(Decoder elementDecoder) { return new Decoder<>() { @Override public byte alignment() { @@ -120,7 +109,7 @@ public abstract class Decoder { } @Override - public Array decode(ByteBuffer byteSlice) { + public List decode(ByteBuffer byteSlice) { List elements; var elementSize = elementDecoder.fixedSize(); @@ -150,7 +139,7 @@ public abstract class Decoder { } } - return new Array<>(elements); + return elements; } }; } @@ -171,13 +160,13 @@ public abstract class Decoder { } /** - * Creates a {@link Decoder} for a {@link Maybe} type. + * Creates a {@link Decoder} for a {@code Maybe} type. * * @param elementDecoder a {@link Decoder} for the contained element. * @param the element type. * @return a new {@link Decoder}. */ - public static Decoder> ofMaybe(Decoder elementDecoder) { + public static Decoder> ofMaybe(Decoder elementDecoder) { return new Decoder<>() { @Override public byte alignment() { @@ -191,32 +180,31 @@ public abstract class Decoder { } @Override - public Maybe decode(ByteBuffer byteSlice) { + public Optional decode(ByteBuffer byteSlice) { if (!byteSlice.hasRemaining()) { - return new Maybe<>(Optional.empty()); + return Optional.empty(); } else { if (!elementDecoder.hasFixedSize()) { // Remove trailing zero byte. byteSlice.limit(byteSlice.limit() - 1); } - return new Maybe<>(Optional.of(elementDecoder.decode(byteSlice))); + return Optional.of(elementDecoder.decode(byteSlice)); } } }; } /** - * Creates a {@link Decoder} for a {@link Structure} type. + * Creates a {@link Decoder} for a {@code Structure} type. * * @param recordType the {@link Record} type that represents the components of the structure. * @param componentDecoders a {@link Decoder} for each component of the structure. * @param the {@link Record} type that represents the components of the structure. * @return a new {@link Decoder}. */ - @SafeVarargs - public static Decoder> ofStructure( - Class recordType, Decoder... componentDecoders) { + public static Decoder ofStructure( + Class recordType, Decoder... componentDecoders) { var recordComponents = recordType.getRecordComponents(); if (componentDecoders.length != recordComponents.length) { throw new IllegalArgumentException( @@ -251,7 +239,7 @@ public abstract class Decoder { } @Override - public Structure decode(ByteBuffer byteSlice) { + public U decode(ByteBuffer byteSlice) { int framingOffsetSize = byteCount(byteSlice.limit()); var recordConstructorArguments = new Object[recordComponents.length]; @@ -296,7 +284,7 @@ public abstract class Decoder { .map(RecordComponent::getType) .toArray(Class[]::new); var recordConstructor = recordType.getDeclaredConstructor(recordComponentTypes); - return new Structure<>(recordConstructor.newInstance(recordConstructorArguments)); + return recordConstructor.newInstance(recordConstructorArguments); } catch (NoSuchMethodException | InstantiationException | IllegalAccessException @@ -334,11 +322,11 @@ public abstract class Decoder { } /** - * Creates a {@link Decoder} for the {@link Bool} type. + * Creates a {@link Decoder} for the {@code Boolean} type. * * @return a new {@link Decoder}. */ - public static Decoder ofBool() { + public static Decoder ofBoolean() { return new Decoder<>() { @Override public byte alignment() { @@ -351,21 +339,21 @@ public abstract class Decoder { } @Override - public Bool decode(ByteBuffer byteSlice) { - return new Bool(byteSlice.get() != 0); + public Boolean decode(ByteBuffer byteSlice) { + return byteSlice.get() != 0; } }; } /** - * Creates a {@link Decoder} for the {@link Int8} type. + * Creates a {@link Decoder} for the 8-bit {@ode byte} type. * *

Note: It is often useful to apply {@link #withByteOrder(ByteOrder)} to the * result of this method. * * @return a new {@link Decoder}. */ - public static Decoder ofInt8() { + public static Decoder ofByte() { return new Decoder<>() { @Override public byte alignment() { @@ -378,21 +366,21 @@ public abstract class Decoder { } @Override - public Int8 decode(ByteBuffer byteSlice) { - return new Int8(byteSlice.get()); + public Byte decode(ByteBuffer byteSlice) { + return byteSlice.get(); } }; } /** - * Creates a {@link Decoder} for the {@link Int16} type. + * Creates a {@link Decoder} for the 16-bit {@code short} type. * *

Note: It is often useful to apply {@link #withByteOrder(ByteOrder)} to the * result of this method. * * @return a new {@link Decoder}. */ - public static Decoder ofInt16() { + public static Decoder ofShort() { return new Decoder<>() { @Override public byte alignment() { @@ -405,21 +393,21 @@ public abstract class Decoder { } @Override - public Int16 decode(ByteBuffer byteSlice) { - return new Int16(byteSlice.getShort()); + public Short decode(ByteBuffer byteSlice) { + return byteSlice.getShort(); } }; } /** - * Creates a {@link Decoder} for the {@link Int32} type. + * Creates a {@link Decoder} for the 32-bit {@code int} type. * *

Note: It is often useful to apply {@link #withByteOrder(ByteOrder)} to the * result of this method. * * @return a new {@link Decoder}. */ - public static Decoder ofInt32() { + public static Decoder ofInt() { return new Decoder<>() { @Override public byte alignment() { @@ -432,21 +420,21 @@ public abstract class Decoder { } @Override - public Int32 decode(ByteBuffer byteSlice) { - return new Int32(byteSlice.getInt()); + public Integer decode(ByteBuffer byteSlice) { + return byteSlice.getInt(); } }; } /** - * Creates a {@link Decoder} for the {@link Int64} type. + * Creates a {@link Decoder} for the 64-bit {@code long} type. * *

Note: It is often useful to apply {@link #withByteOrder(ByteOrder)} to the * result of this method. * * @return a new {@link Decoder}. */ - public static Decoder ofInt64() { + public static Decoder ofLong() { return new Decoder<>() { @Override public byte alignment() { @@ -459,18 +447,18 @@ public abstract class Decoder { } @Override - public Int64 decode(ByteBuffer byteSlice) { - return new Int64(byteSlice.getLong()); + public Long decode(ByteBuffer byteSlice) { + return byteSlice.getLong(); } }; } /** - * Creates a {@link Decoder} for the {@link Float64} type. + * Creates a {@link Decoder} for the {@code double} type. * * @return a new {@link Decoder}. */ - public static Decoder ofFloat64() { + public static Decoder ofDouble() { return new Decoder<>() { @Override public byte alignment() { @@ -483,21 +471,21 @@ public abstract class Decoder { } @Override - public Float64 decode(ByteBuffer byteSlice) { - return new Float64(byteSlice.getDouble()); + public Double decode(ByteBuffer byteSlice) { + return byteSlice.getDouble(); } }; } /** - * Creates a {@link Decoder} for the {@link Str} type. + * Creates a {@link Decoder} for the {@link String} type. * *

Note: While GVariant does not prescribe any particular encoding, {@link * java.nio.charset.StandardCharsets#UTF_8} is the most common choice. * * @return a new {@link Decoder}. */ - public static Decoder ofStr(Charset charset) { + public static Decoder ofString(Charset charset) { return new Decoder<>() { @Override public byte alignment() { @@ -511,9 +499,9 @@ public abstract class Decoder { } @Override - public Str decode(ByteBuffer byteSlice) { + public String decode(ByteBuffer byteSlice) { byteSlice.limit(byteSlice.limit() - 1); - return new Str(charset.decode(byteSlice).toString()); + return charset.decode(byteSlice).toString(); } }; } diff --git a/src/main/java/eu/mulk/jgvariant/core/Value.java b/src/main/java/eu/mulk/jgvariant/core/Value.java deleted file mode 100644 index 54c0b79..0000000 --- a/src/main/java/eu/mulk/jgvariant/core/Value.java +++ /dev/null @@ -1,112 +0,0 @@ -package eu.mulk.jgvariant.core; - -import java.util.List; -import java.util.Optional; - -/** - * A value representable by the GVariant - * serialization format. - * - *

{@link Value} is a sum type (sealed interface) that represents a GVariant value. Its subtypes - * represent the different types of values that GVariant supports. - * - * @see Decoder - */ -public sealed interface Value { - - /** - * A homogeneous sequence of GVariant values. - * - *

Arrays of fixed width (i.e. of values of fixed size) are represented in a similar way to - * plain C arrays. Arrays of variable width require additional space for padding and framing. - * - *

Heterogeneous sequences are represented by {@code Array}. - * - * @param the type of the elements of the array. - * @see Decoder#ofArray - */ - record Array(List values) implements Value {} - - /** - * A value that is either present or absent. - * - * @param the contained type. - * @see Decoder#ofMaybe - */ - record Maybe(Optional value) implements Value {} - - /** - * A tuple of values of fixed types. - * - *

GVariant structures are represented as {@link Record} types. For example, a two-element - * structure consisting of a string and an int can be modelled as follows: - * - * 

{@code
-   * record TestRecord(Str s, Int32 i) {}
-   * var testStruct = new Structure<>(new TestRecord(new Str("hello"), new Int32(123));
-   * }
- * - * @param the {@link Record} type that represents the components of the structure. - * @see Decoder#ofStructure - */ - record Structure(T values) implements Value {} - - /** - * A dynamically typed box that can hold a single value of any GVariant type. - * - * @see Decoder#ofVariant - */ - record Variant(Class type, Value value) implements Value {} - - /** - * Either true or false. - * - * @see Decoder#ofBool() - */ - record Bool(boolean value) implements Value { - static Bool TRUE = new Bool(true); - static Bool FALSE = new Bool(false); - } - - /** - * A {@code byte}-sized integer. - * - * @see Decoder#ofInt8() - */ - record Int8(byte value) implements Value {} - - /** - * A {@code short}-sized integer. - * - * @see Decoder#ofInt16() - */ - record Int16(short value) implements Value {} - - /** - * An {@code int}-sized integer. - * - * @see Decoder#ofInt32() - */ - record Int32(int value) implements Value {} - - /** - * A {@code long}-sized integer. - * - * @see Decoder#ofInt64() - */ - record Int64(long value) implements Value {} - - /** - * A double-precision floating point number. - * - * @see Decoder#ofFloat64() - */ - record Float64(double value) implements Value {} - - /** - * A character string. - * - * @see Decoder#ofStr - */ - record Str(String value) implements Value {} -} diff --git a/src/main/java/eu/mulk/jgvariant/core/Variant.java b/src/main/java/eu/mulk/jgvariant/core/Variant.java new file mode 100644 index 0000000..05e28d5 --- /dev/null +++ b/src/main/java/eu/mulk/jgvariant/core/Variant.java @@ -0,0 +1,102 @@ +package eu.mulk.jgvariant.core; + +import java.util.List; +import java.util.Optional; + +/** + * A value representable by the GVariant + * serialization format, tagged with its type. + * + *

{@link Variant} is a sum type (sealed interface) that represents a GVariant value. Its + * subtypes represent the different types of values that GVariant supports. + * + * @see Decoder#ofVariant() + */ +public sealed interface Variant { + + /** + * A homogeneous sequence of GVariant values. + * + *

Arrays of fixed width (i.e. of values of fixed size) are represented in a similar way to + * plain C arrays. Arrays of variable width require additional space for padding and framing. + * + *

Heterogeneous sequences are represented by {@code Array}. + * + * @param the type of the elements of the array. + * @see Decoder#ofArray + */ + record Array(List values) implements Variant {} + + /** + * A value that is either present or absent. + * + * @param the contained type. + * @see Decoder#ofMaybe + */ + record Maybe(Optional value) implements Variant {} + + /** + * A tuple of values of fixed types. + * + *

GVariant structures are represented as {@link Record} types. For example, a two-element + * structure consisting of a string and an int can be modelled as follows: + * + * 

{@code
+   * record TestRecord(String s, int i) {}
+   * var testStruct = new Structure<>(new TestRecord("hello", 123);
+   * }
+ * + * @param the {@link Record} type that represents the components of the structure. + * @see Decoder#ofStructure + */ + record Structure(T values) implements Variant {} + + /** + * Either true or false. + * + * @see Decoder#ofBoolean() + */ + record Bool(boolean value) implements Variant {} + + /** + * A {@code byte}-sized integer. + * + * @see Decoder#ofByte() + */ + record Byte(byte value) implements Variant {} + + /** + * A {@code short}-sized integer. + * + * @see Decoder#ofShort() + */ + record Short(short value) implements Variant {} + + /** + * An {@code int}-sized integer. + * + * @see Decoder#ofInt() + */ + record Int(int value) implements Variant {} + + /** + * A {@code long}-sized integer. + * + * @see Decoder#ofLong() + */ + record Long(long value) implements Variant {} + + /** + * A double-precision floating point number. + * + * @see Decoder#ofDouble() + */ + record Double(double value) implements Variant {} + + /** + * A character string. + * + * @see Decoder#ofString + */ + record String(java.lang.String value) implements Variant {} +} diff --git a/src/main/java/eu/mulk/jgvariant/core/package-info.java b/src/main/java/eu/mulk/jgvariant/core/package-info.java index dba7a09..1b819c5 100644 --- a/src/main/java/eu/mulk/jgvariant/core/package-info.java +++ b/src/main/java/eu/mulk/jgvariant/core/package-info.java @@ -1,32 +1,32 @@ /** - * Provides {@link eu.mulk.jgvariant.core.Value} and {@link eu.mulk.jgvariant.core.Decoder}, the + * Provides {@link eu.mulk.jgvariant.core.Variant} and {@link eu.mulk.jgvariant.core.Decoder}, the * foundational classes for GVariant * parsing. * - *

{@link eu.mulk.jgvariant.core.Value} is a sum type (sealed interface) that represents a + *

{@link eu.mulk.jgvariant.core.Variant} is a sum type (sealed interface) that represents a * GVariant value. Its subtypes represent the different types of values that GVariant supports. * *

Instances of {@link eu.mulk.jgvariant.core.Decoder} read a given concrete subtype of {@link - * eu.mulk.jgvariant.core.Value} from a {@link java.nio.ByteBuffer}. The class also contains factory - * methods to create those instances. + * eu.mulk.jgvariant.core.Variant} from a {@link java.nio.ByteBuffer}. The class also contains + * factory methods to create those instances. * *

Example * - *

To parse a GVariant of type {@code "a(si)"}, which is an array of pairs of {@link String} and - * {@code int}, you can use the following code: + *

To parse a GVariant of type {@code "a(si)"}, which is an array of pairs of {@link + * java.lang.String} and {@code int}, you can use the following code: * * 

{@code
- * record ExampleRecord(Value.Str s, Value.Int32 i) {}
+ * record ExampleRecord(String s, int i) {}
  *
  * var decoder =
  *   Decoder.ofArray(
  *     Decoder.ofStructure(
  *       ExampleRecord.class,
- *       Decoder.ofStr(UTF_8),
- *       Decoder.ofInt32().withByteOrder(LITTLE_ENDIAN)));
+ *       Decoder.ofString(UTF_8),
+ *       Decoder.ofInt().withByteOrder(LITTLE_ENDIAN)));
  *
  * byte[] bytes = ...;
- * Value.Array> example = decoder.decode(ByteBuffer.wrap(bytes));
+ * List example = decoder.decode(ByteBuffer.wrap(bytes));
  * }
*/ package eu.mulk.jgvariant.core; diff --git a/src/main/java/module-info.java b/src/main/java/module-info.java index 403cf1f..af28413 100644 --- a/src/main/java/module-info.java +++ b/src/main/java/module-info.java @@ -1,9 +1,11 @@ +import eu.mulk.jgvariant.core.Variant; + /** * Provides a parser for the GVariant * serialization format. * - *

The {@link eu.mulk.jgvariant.core} package contains the {@link eu.mulk.jgvariant.core.Value} - * and {@link eu.mulk.jgvariant.core.Decoder} types. which form the foundation of this library. + *

The {@link eu.mulk.jgvariant.core} package contains the {@link Variant} and {@link + * eu.mulk.jgvariant.core.Decoder} types. which form the foundation of this library. */ module eu.mulk.jgvariant.core { requires com.google.errorprone.annotations; diff --git a/src/test/java/eu/mulk/jgvariant/core/DecoderTest.java b/src/test/java/eu/mulk/jgvariant/core/DecoderTest.java index 13cd398..d37f6a2 100644 --- a/src/test/java/eu/mulk/jgvariant/core/DecoderTest.java +++ b/src/test/java/eu/mulk/jgvariant/core/DecoderTest.java @@ -4,13 +4,6 @@ import static java.nio.ByteOrder.LITTLE_ENDIAN; import static java.nio.charset.StandardCharsets.UTF_8; import static org.junit.jupiter.api.Assertions.assertEquals; -import eu.mulk.jgvariant.core.Value.Array; -import eu.mulk.jgvariant.core.Value.Bool; -import eu.mulk.jgvariant.core.Value.Int32; -import eu.mulk.jgvariant.core.Value.Int8; -import eu.mulk.jgvariant.core.Value.Maybe; -import eu.mulk.jgvariant.core.Value.Str; -import eu.mulk.jgvariant.core.Value.Structure; import java.nio.ByteBuffer; import java.util.List; import java.util.Optional; @@ -25,26 +18,23 @@ class DecoderTest { @Test void testString() { var data = new byte[] {0x68, 0x65, 0x6C, 0x6C, 0x6F, 0x20, 0x77, 0x6F, 0x72, 0x6C, 0x64, 0x00}; - var decoder = Decoder.ofStr(UTF_8); - assertEquals(new Str("hello world"), decoder.decode(ByteBuffer.wrap(data))); + var decoder = Decoder.ofString(UTF_8); + assertEquals("hello world", decoder.decode(ByteBuffer.wrap(data))); } @Test void testMaybe() { var data = new byte[] {0x68, 0x65, 0x6C, 0x6C, 0x6F, 0x20, 0x77, 0x6F, 0x72, 0x6C, 0x64, 0x00, 0x00}; - var decoder = Decoder.ofMaybe(Decoder.ofStr(UTF_8)); - assertEquals( - new Maybe<>(Optional.of(new Str("hello world"))), decoder.decode(ByteBuffer.wrap(data))); + var decoder = Decoder.ofMaybe(Decoder.ofString(UTF_8)); + assertEquals(Optional.of("hello world"), decoder.decode(ByteBuffer.wrap(data))); } @Test void testBooleanArray() { var data = new byte[] {0x01, 0x00, 0x00, 0x01, 0x01}; - var decoder = Decoder.ofArray(Decoder.ofBool()); - assertEquals( - new Array<>(List.of(Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.TRUE)), - decoder.decode(ByteBuffer.wrap(data))); + var decoder = Decoder.ofArray(Decoder.ofBoolean()); + assertEquals(List.of(true, false, false, true, true), decoder.decode(ByteBuffer.wrap(data))); } @Test @@ -54,12 +44,10 @@ class DecoderTest { 0x66, 0x6F, 0x6F, 0x00, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, 0x04 }; - record TestRecord(Str s, Int32 i) {} + record TestRecord(String s, int i) {} - var decoder = Decoder.ofStructure(TestRecord.class, Decoder.ofStr(UTF_8), Decoder.ofInt32()); - assertEquals( - new Structure<>(new TestRecord(new Str("foo"), new Int32(-1))), - decoder.decode(ByteBuffer.wrap(data))); + var decoder = Decoder.ofStructure(TestRecord.class, Decoder.ofString(UTF_8), Decoder.ofInt()); + assertEquals(new TestRecord("foo", -1), decoder.decode(ByteBuffer.wrap(data))); } @Test @@ -91,19 +79,16 @@ class DecoderTest { 0x15 }; - record TestRecord(Str s, Int32 i) {} + record TestRecord(String s, int i) {} var decoder = Decoder.ofArray( Decoder.ofStructure( TestRecord.class, - Decoder.ofStr(UTF_8), - Decoder.ofInt32().withByteOrder(LITTLE_ENDIAN))); + Decoder.ofString(UTF_8), + Decoder.ofInt().withByteOrder(LITTLE_ENDIAN))); assertEquals( - new Array<>( - List.of( - new Structure<>(new TestRecord(new Str("hi"), new Int32(-2))), - new Structure<>(new TestRecord(new Str("bye"), new Int32(-1))))), + List.of(new TestRecord("hi", -2), new TestRecord("bye", -1)), decoder.decode(ByteBuffer.wrap(data))); } @@ -114,10 +99,8 @@ class DecoderTest { 0x69, 0x00, 0x63, 0x61, 0x6E, 0x00, 0x68, 0x61, 0x73, 0x00, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x73, 0x3F, 0x00, 0x02, 0x06, 0x0a, 0x13 }; - var decoder = Decoder.ofArray(Decoder.ofStr(UTF_8)); - assertEquals( - new Array<>(List.of(new Str("i"), new Str("can"), new Str("has"), new Str("strings?"))), - decoder.decode(ByteBuffer.wrap(data))); + var decoder = Decoder.ofArray(Decoder.ofString(UTF_8)); + assertEquals(List.of("i", "can", "has", "strings?"), decoder.decode(ByteBuffer.wrap(data))); } @Test @@ -128,20 +111,17 @@ class DecoderTest { 0x73, 0x3F, 0x00, 0x04, 0x0d, 0x05 }; - record TestChild(Int8 b, Str s) {} - record TestParent(Structure tc, Array as) {} + record TestChild(byte b, String s) {} + record TestParent(TestChild tc, List as) {} var decoder = Decoder.ofStructure( TestParent.class, - Decoder.ofStructure(TestChild.class, Decoder.ofInt8(), Decoder.ofStr(UTF_8)), - Decoder.ofArray(Decoder.ofStr(UTF_8))); + Decoder.ofStructure(TestChild.class, Decoder.ofByte(), Decoder.ofString(UTF_8)), + Decoder.ofArray(Decoder.ofString(UTF_8))); assertEquals( - new Structure<>( - new TestParent( - new Structure<>(new TestChild(new Int8((byte) 0x69), new Str("can"))), - new Array<>(List.of(new Str("has"), new Str("strings?"))))), + new TestParent(new TestChild((byte) 0x69, "can"), List.of("has", "strings?")), decoder.decode(ByteBuffer.wrap(data))); } @@ -149,51 +129,45 @@ class DecoderTest { void testSimpleStructure() { var data = new byte[] {0x60, 0x70}; - record TestRecord(Int8 b1, Int8 b2) {} + record TestRecord(byte b1, byte b2) {} var decoder = Decoder.ofStructure( TestRecord.class, - Decoder.ofInt8().withByteOrder(LITTLE_ENDIAN), - Decoder.ofInt8().withByteOrder(LITTLE_ENDIAN)); + Decoder.ofByte().withByteOrder(LITTLE_ENDIAN), + Decoder.ofByte().withByteOrder(LITTLE_ENDIAN)); - assertEquals( - new Structure<>(new TestRecord(new Int8((byte) 0x60), new Int8((byte) 0x70))), - decoder.decode(ByteBuffer.wrap(data))); + assertEquals(new TestRecord((byte) 0x60, (byte) 0x70), decoder.decode(ByteBuffer.wrap(data))); } @Test void testPaddedStructureRight() { var data = new byte[] {0x60, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00}; - record TestRecord(Int32 b1, Int8 b2) {} + record TestRecord(int b1, byte b2) {} var decoder = Decoder.ofStructure( TestRecord.class, - Decoder.ofInt32().withByteOrder(LITTLE_ENDIAN), - Decoder.ofInt8().withByteOrder(LITTLE_ENDIAN)); + Decoder.ofInt().withByteOrder(LITTLE_ENDIAN), + Decoder.ofByte().withByteOrder(LITTLE_ENDIAN)); - assertEquals( - new Structure<>(new TestRecord(new Int32(0x60), new Int8((byte) 0x70))), - decoder.decode(ByteBuffer.wrap(data))); + assertEquals(new TestRecord(0x60, (byte) 0x70), decoder.decode(ByteBuffer.wrap(data))); } @Test void testPaddedStructureLeft() { var data = new byte[] {0x60, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00}; - record TestRecord(Int8 b1, Int32 b2) {} + record TestRecord(byte b1, int b2) {} var decoder = Decoder.ofStructure( TestRecord.class, - Decoder.ofInt8().withByteOrder(LITTLE_ENDIAN), - Decoder.ofInt32().withByteOrder(LITTLE_ENDIAN)); + Decoder.ofByte().withByteOrder(LITTLE_ENDIAN), + Decoder.ofInt().withByteOrder(LITTLE_ENDIAN)); - assertEquals( - new Structure<>(new TestRecord(new Int8((byte) 0x60), new Int32(0x70))), - decoder.decode(ByteBuffer.wrap(data))); + assertEquals(new TestRecord((byte) 0x60, 0x70), decoder.decode(ByteBuffer.wrap(data))); } @Test @@ -218,20 +192,17 @@ class DecoderTest { 0x00 }; - record TestRecord(Int32 b1, Int8 b2) {} + record TestRecord(int b1, byte b2) {} var decoder = Decoder.ofArray( Decoder.ofStructure( TestRecord.class, - Decoder.ofInt32().withByteOrder(LITTLE_ENDIAN), - Decoder.ofInt8().withByteOrder(LITTLE_ENDIAN))); + Decoder.ofInt().withByteOrder(LITTLE_ENDIAN), + Decoder.ofByte().withByteOrder(LITTLE_ENDIAN))); assertEquals( - new Array<>( - List.of( - new Structure<>(new TestRecord(new Int32(96), new Int8((byte) 0x70))), - new Structure<>(new TestRecord(new Int32(648), new Int8((byte) 0xf7))))), + List.of(new TestRecord(96, (byte) 0x70), new TestRecord(648, (byte) 0xf7)), decoder.decode(ByteBuffer.wrap(data))); } @@ -239,15 +210,10 @@ class DecoderTest { void testByteArray() { var data = new byte[] {0x04, 0x05, 0x06, 0x07}; - var decoder = Decoder.ofArray(Decoder.ofInt8()); + var decoder = Decoder.ofArray(Decoder.ofByte()); assertEquals( - new Array<>( - List.of( - new Int8((byte) 0x04), - new Int8((byte) 0x05), - new Int8((byte) 0x06), - new Int8((byte) 0x07))), + List.of((byte) 0x04, (byte) 0x05, (byte) 0x06, (byte) 0x07), decoder.decode(ByteBuffer.wrap(data))); } @@ -255,10 +221,9 @@ class DecoderTest { void testIntegerArray() { var data = new byte[] {0x04, 0x00, 0x00, 0x00, 0x02, 0x01, 0x00, 0x00}; - var decoder = Decoder.ofArray(Decoder.ofInt32().withByteOrder(LITTLE_ENDIAN)); + var decoder = Decoder.ofArray(Decoder.ofInt().withByteOrder(LITTLE_ENDIAN)); - assertEquals( - new Array<>(List.of(new Int32(4), new Int32(258))), decoder.decode(ByteBuffer.wrap(data))); + assertEquals(List.of(4, 258), decoder.decode(ByteBuffer.wrap(data))); } @Test @@ -266,13 +231,11 @@ class DecoderTest { var data = new byte[] {0x61, 0x20, 0x6B, 0x65, 0x79, 0x00, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x06}; - record TestEntry(Str key, Int32 value) {} + record TestEntry(String key, int value) {} var decoder = Decoder.ofStructure( - TestEntry.class, Decoder.ofStr(UTF_8), Decoder.ofInt32().withByteOrder(LITTLE_ENDIAN)); - assertEquals( - new Structure<>(new TestEntry(new Str("a key"), new Int32(514))), - decoder.decode(ByteBuffer.wrap(data))); + TestEntry.class, Decoder.ofString(UTF_8), Decoder.ofInt().withByteOrder(LITTLE_ENDIAN)); + assertEquals(new TestEntry("a key", 514), decoder.decode(ByteBuffer.wrap(data))); } } -- cgit v1.2.3