aeron-io
diff --git a/‎sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/java/JavaGenerator.java
Copy file name to clipboard
+107-2Lines changed: 107 additions & 2 deletions b/‎sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/java/JavaGenerator.java
Copy file name to clipboard
+107-2Lines changed: 107 additions & 2 deletions
diff --git a/‎sbe-tool/src/test/java/uk/co/real_logic/sbe/generation/java/FixedSizeDataGeneratorTest.java
Copy file name to clipboard
+200Lines changed: 200 additions & 0 deletions b/‎sbe-tool/src/test/java/uk/co/real_logic/sbe/generation/java/FixedSizeDataGeneratorTest.java
Copy file name to clipboard
+200Lines changed: 200 additions & 0 deletions
diff --git a/‎sbe-tool/src/test/java/uk/co/real_logic/sbe/generation/java/JavaGeneratorTest.java
Copy file name to clipboard
+1Lines changed: 1 addition & 0 deletions b/‎sbe-tool/src/test/java/uk/co/real_logic/sbe/generation/java/JavaGeneratorTest.java
Copy file name to clipboard
+1Lines changed: 1 addition & 0 deletions
@@ -981,7 +981,7 @@ private void generateVarDataWrapDecoder(
             indent + "    }\n",
             propertyName,
             readOnlyBuffer,
-            generateVarWrapFieldNotPresentCondition(token.version(), indent),
+            generateWrapFieldNotPresentCondition(token.version(), indent),
             sizeOfLengthField,
             PrimitiveType.UINT32 == lengthType ? "(int)" : "",
             generateGet(lengthType, "limit", byteOrderStr));
@@ -1860,7 +1860,7 @@ private CharSequence generatePrimitivePropertyEncode(
             generatePut(encoding.primitiveType(), "offset + " + offset, "value", byteOrderStr));
     }
 
-    private CharSequence generateVarWrapFieldNotPresentCondition(final int sinceVersion, final String indent)
+    private CharSequence generateWrapFieldNotPresentCondition(final int sinceVersion, final String indent)
     {
         if (0 == sinceVersion)
         {
@@ -1871,6 +1871,7 @@ private CharSequence generateVarWrapFieldNotPresentCondition(final int sinceVers
             indent + "        if (parentMessage.actingVersion < " + sinceVersion + ")\n" +
             indent + "        {\n" +
             indent + "            wrapBuffer.wrap(buffer, offset, 0);\n" +
+            indent + "            return;\n" +
             indent + "        }\n\n";
     }
 
@@ -2060,6 +2061,51 @@ private CharSequence generatePrimitiveArrayPropertyDecode(
                     offset);
             }
         }
+        else if (encoding.primitiveType() == PrimitiveType.UINT8)
+        {
+            new Formatter(sb).format("\n" +
+                indent + "    public int get%s(final byte[] dst, final int dstOffset, final int length)\n" +
+                indent + "    {\n" +
+                "%s" +
+                indent + "        final int bytesCopied = Math.min(length, %d);\n" +
+                indent + "        buffer.getBytes(offset + %d, dst, dstOffset, bytesCopied);\n" +
+                indent + "        return bytesCopied;\n" +
+                indent + "    }\n",
+                Generators.toUpperFirstChar(propertyName),
+                generateArrayFieldNotPresentCondition(propertyToken.version(), indent),
+                fieldLength,
+                offset
+            );
+
+            new Formatter(sb).format("\n" +
+                indent + "    public int get%s(final %s dst, final int dstOffset, final int length)\n" +
+                indent + "    {\n" +
+                "%s" +
+                indent + "        final int bytesCopied = Math.min(length, %d);\n" +
+                indent + "        buffer.getBytes(offset + %d, dst, dstOffset, bytesCopied);\n" +
+                indent + "        return bytesCopied;\n" +
+                indent + "    }\n",
+                Generators.toUpperFirstChar(propertyName),
+                fqMutableBuffer,
+                generateArrayFieldNotPresentCondition(propertyToken.version(), indent),
+                fieldLength,
+                offset
+            );
+
+            new Formatter(sb).format("\n" +
+                indent + "    public void wrap%s(final %s wrapBuffer)\n" +
+                indent + "    {\n" +
+                indent + "        final int length = %d;\n" +
+                "%s" +
+                indent + "        wrapBuffer.wrap(buffer, offset + %d, length);\n" +
+                indent + "    }\n",
+                Generators.toUpperFirstChar(propertyName),
+                readOnlyBuffer,
+                fieldLength,
+                generateWrapFieldNotPresentCondition(propertyToken.version(), indent),
+                offset
+            );
+        }
 
         return sb;
     }
@@ -2150,6 +2196,11 @@ private CharSequence generatePrimitiveArrayPropertyEncode(
             generateCharArrayEncodeMethods(
                 containingClassName, propertyName, indent, encoding, offset, arrayLength, sb);
         }
+        else if (primitiveType == PrimitiveType.UINT8)
+        {
+            generateByteArrayEncodeMethods(
+                containingClassName, propertyName, indent, offset, arrayLength, sb);
+        }
 
         return sb;
     }
@@ -2261,6 +2312,60 @@ private void generateCharArrayEncodeMethods(
         }
     }
 
+    private void generateByteArrayEncodeMethods(
+        final String containingClassName,
+        final String propertyName,
+        final String indent,
+        final int offset,
+        final int fieldLength,
+        final StringBuilder sb)
+    {
+        new Formatter(sb).format("\n" +
+            indent + "    public %s put%s(final byte[] src, final int srcOffset, final int length)\n" +
+            indent + "    {\n" +
+            indent + "        if (length > %d)\n" +
+            indent + "        {\n" +
+            indent + "            throw new IllegalStateException(" +
+            "\"length > maxValue for type: \" + length);" +
+            indent + "        }\n\n" +
+            indent + "        buffer.putBytes(offset + %d, src, srcOffset, length);\n" +
+            indent + "        for (int i = length; i < %d; i++)\n" +
+            indent + "        {\n" +
+            indent + "            buffer.putByte(offset + %d + i, (byte)0);\n" +
+            indent + "        }\n" +
+            indent + "        return this;\n" +
+            indent + "    }\n",
+            formatClassName(containingClassName),
+            Generators.toUpperFirstChar(propertyName),
+            fieldLength,
+            offset,
+            fieldLength,
+            offset);
+
+        new Formatter(sb).format("\n" +
+            indent + "    public %s put%s(final %s src, final int srcOffset, final int length)\n" +
+            indent + "    {\n" +
+            indent + "        if (length > %d)\n" +
+            indent + "        {\n" +
+            indent + "            throw new IllegalStateException(" +
+            "\"length > maxValue for type: \" + length);" +
+            indent + "        }\n\n" +
+            indent + "        buffer.putBytes(offset + %d, src, srcOffset, length);\n" +
+            indent + "        for (int i = length; i < %d; i++)\n" +
+            indent + "        {\n" +
+            indent + "            buffer.putByte(offset + %d + i, (byte)0);\n" +
+            indent + "        }\n" +
+            indent + "        return this;\n" +
+            indent + "    }\n",
+            formatClassName(containingClassName),
+            Generators.toUpperFirstChar(propertyName),
+            fqReadOnlyBuffer,
+            fieldLength,
+            offset,
+            fieldLength,
+            offset);
+    }
+
     private static int sizeOfPrimitive(final Encoding encoding)
     {
         return encoding.primitiveType().size();
 
@@ -0,0 +1,200 @@
+/*
+ * Copyright 2013-2020 Real Logic Limited.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package uk.co.real_logic.sbe.generation.java;
+
+import org.agrona.DirectBuffer;
+import org.agrona.MutableDirectBuffer;
+import org.agrona.concurrent.UnsafeBuffer;
+import org.agrona.generation.CompilerUtil;
+import org.agrona.generation.StringWriterOutputManager;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import uk.co.real_logic.sbe.Tests;
+import uk.co.real_logic.sbe.ir.Ir;
+import uk.co.real_logic.sbe.xml.IrGenerator;
+import uk.co.real_logic.sbe.xml.MessageSchema;
+import uk.co.real_logic.sbe.xml.ParserOptions;
+
+import java.nio.charset.StandardCharsets;
+import java.util.Map;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.*;
+import static uk.co.real_logic.sbe.generation.java.ReflectionUtil.*;
+import static uk.co.real_logic.sbe.xml.XmlSchemaParser.parse;
+
+public class FixedSizeDataGeneratorTest
+{
+    private static final Class<?> BUFFER_CLASS = MutableDirectBuffer.class;
+    private static final String BUFFER_NAME = BUFFER_CLASS.getName();
+    private static final Class<DirectBuffer> READ_ONLY_BUFFER_CLASS = DirectBuffer.class;
+    private static final String READ_ONLY_BUFFER_NAME = READ_ONLY_BUFFER_CLASS.getName();
+
+    private final StringWriterOutputManager outputManager = new StringWriterOutputManager();
+
+    private Ir ir;
+
+    @BeforeEach
+    public void setUp() throws Exception
+    {
+        final ParserOptions options = ParserOptions.builder().stopOnError(true).build();
+        final MessageSchema schema = parse(Tests.getLocalResource("extension-schema.xml"), options);
+        final IrGenerator irg = new IrGenerator();
+        ir = irg.generate(schema);
+
+        outputManager.clear();
+        outputManager.setPackageName(ir.applicableNamespace());
+
+        generator().generate();
+    }
+
+    @Test
+    public void shouldGeneratePutAndGetByteArrayForFixedLengthBlob() throws Exception
+    {
+        final UnsafeBuffer buffer = new UnsafeBuffer(new byte[4096]);
+
+        final Object encoder = getTestMessage2Encoder(buffer);
+        final Object decoder = getTestMessage2Decoder(buffer, encoder);
+
+        final byte[] encodedData = "  **DATA**  ".getBytes(StandardCharsets.US_ASCII);
+        byte[] decodedData;
+        int decodedDataLength;
+
+        // Every byte written, every byte read
+        putByteArray(encoder, "putTag6", encodedData, 2, 8);
+        decodedData = "            ".getBytes(StandardCharsets.US_ASCII);
+        decodedDataLength = getByteArray(decoder, "getTag6", decodedData, 1, 8);
+        assertThat(decodedDataLength, is(8));
+        assertThat(new String(decodedData, StandardCharsets.US_ASCII), is(" **DATA**   "));
+
+        // Every byte written, less bytes read
+        putByteArray(encoder, "putTag6", encodedData, 2, 8);
+        decodedData = "            ".getBytes(StandardCharsets.US_ASCII);
+        decodedDataLength = getByteArray(decoder, "getTag6", decodedData, 1, 6);
+        assertThat(decodedDataLength, is(6));
+        assertThat(new String(decodedData, StandardCharsets.US_ASCII), is(" **DATA     "));
+
+        // Less bytes written (padding), every byte read
+        putByteArray(encoder, "putTag6", encodedData, 2, 6);
+        decodedData = "            ".getBytes(StandardCharsets.US_ASCII);
+        decodedDataLength = getByteArray(decoder, "getTag6", decodedData, 1, 8);
+        assertThat(decodedDataLength, is(8));
+        assertThat(new String(decodedData, StandardCharsets.US_ASCII), is(" **DATA\u0000\u0000   "));
+    }
+
+    @Test
+    public void shouldGeneratePutAndGetDirectBufferForFixedLengthBlob() throws Exception
+    {
+        final UnsafeBuffer buffer = new UnsafeBuffer(new byte[4096]);
+
+        final Object encoder = getTestMessage2Encoder(buffer);
+        final Object decoder = getTestMessage2Decoder(buffer, encoder);
+
+        final UnsafeBuffer encodedData = new UnsafeBuffer("  **DATA**  ".getBytes(StandardCharsets.US_ASCII));
+        UnsafeBuffer decodedData;
+        int decodedDataLength;
+
+        // Every byte written, every byte read
+        putDirectBuffer(encoder, "putTag6", encodedData, 2, 8);
+        decodedData = new UnsafeBuffer("            ".getBytes(StandardCharsets.US_ASCII));
+        decodedDataLength = getDirectBuffer(decoder, "getTag6", decodedData, 1, 8);
+        assertThat(decodedDataLength, is(8));
+        assertThat(decodedData.getStringWithoutLengthAscii(0, 12), is(" **DATA**   "));
+
+        // Every byte written, less bytes read
+        putDirectBuffer(encoder, "putTag6", encodedData, 2, 8);
+        decodedData = new UnsafeBuffer("            ".getBytes(StandardCharsets.US_ASCII));
+        decodedDataLength = getDirectBuffer(decoder, "getTag6", decodedData, 1, 6);
+        assertThat(decodedDataLength, is(6));
+        assertThat(decodedData.getStringWithoutLengthAscii(0, 12), is(" **DATA     "));
+
+        // Less bytes written (padding), every byte read
+        putDirectBuffer(encoder, "putTag6", encodedData, 2, 6);
+        decodedData = new UnsafeBuffer("            ".getBytes(StandardCharsets.US_ASCII));
+        decodedDataLength = getDirectBuffer(decoder, "getTag6", decodedData, 1, 8);
+        assertThat(decodedDataLength, is(8));
+        assertThat(decodedData.getStringWithoutLengthAscii(0, 12), is(" **DATA\u0000\u0000   "));
+    }
+
+    @Test
+    public void shouldGenerateWrapForFixedLengthBlob() throws Exception
+    {
+        final UnsafeBuffer buffer = new UnsafeBuffer(new byte[4096]);
+
+        final Object encoder = getTestMessage2Encoder(buffer);
+        final Object decoder = getTestMessage2Decoder(buffer, encoder);
+
+        final UnsafeBuffer encodedData = new UnsafeBuffer("  **DATA**  ".getBytes(StandardCharsets.US_ASCII));
+        putDirectBuffer(encoder, "putTag6", encodedData, 2, 8);
+
+        final UnsafeBuffer decodedData = new UnsafeBuffer();
+        wrapDirectBuffer(decoder, "wrapTag6", decodedData);
+        assertThat(decodedData.getStringWithoutLengthAscii(0, decodedData.capacity()), is("**DATA**"));
+    }
+
+    private JavaGenerator generator()
+    {
+        return new JavaGenerator(ir, BUFFER_NAME, READ_ONLY_BUFFER_NAME, false, false, false, outputManager);
+    }
+
+    private Class<?> compile(final String className) throws Exception
+    {
+        final String fqClassName = ir.applicableNamespace() + "." + className;
+        final Map<String, CharSequence> sources = outputManager.getSources();
+        final Class<?> aClass = CompilerUtil.compileInMemory(fqClassName, sources);
+        if (aClass == null)
+        {
+            System.out.println(sources);
+        }
+
+        return aClass;
+    }
+
+    private Object getTestMessage2Encoder(final UnsafeBuffer buffer) throws Exception
+    {
+        final Object encoder = compile("TestMessage2Encoder").getConstructor().newInstance();
+        return wrap(0, encoder, buffer, BUFFER_CLASS);
+    }
+
+    private Object getTestMessage2Decoder(final UnsafeBuffer buffer, final Object encoder) throws Exception
+    {
+        final Object decoder = compile("TestMessage2Decoder").getConstructor().newInstance();
+        return wrap(buffer, decoder, getSbeBlockLength(encoder), getSbeSchemaVersion(encoder));
+    }
+
+    private static Object wrap(
+        final UnsafeBuffer buffer, final Object decoder, final int blockLength, final int version) throws Exception
+    {
+        decoder
+            .getClass()
+            .getMethod("wrap", READ_ONLY_BUFFER_CLASS, int.class, int.class, int.class)
+            .invoke(decoder, buffer, 0, blockLength, version);
+
+        return decoder;
+    }
+
+    private static Object wrap(
+        final int bufferOffset, final Object flyweight, final MutableDirectBuffer buffer, final Class<?> bufferClass)
+        throws Exception
+    {
+        flyweight
+            .getClass()
+            .getDeclaredMethod("wrap", bufferClass, int.class)
+            .invoke(flyweight, buffer, bufferOffset);
+        return flyweight;
+    }
+
+}
@@ -442,6 +442,7 @@ public void shouldGeneratePutCharSequence() throws Exception
         assertThat(get(decoder, "vehicleCode"), is("R11R12"));
     }
 
+
     private Class<?> getModelClass(final Object encoder) throws ClassNotFoundException
     {
         final String className = "Model";
Original file line number	Diff line number	Diff line change
`@@ -442,6 +442,7 @@ public void shouldGeneratePutCharSequence() throws Exception`
`442`	`442`	`assertThat(get(decoder, "vehicleCode"), is("R11R12"));`
`443`	`443`	`}`
`444`	`444`
	`445`	`+`
`445`	`446`	`private Class<?> getModelClass(final Object encoder) throws ClassNotFoundException`
`446`	`447`	`{`
`447`	`448`	`final String className = "Model";`