[Java]: Added support for groups to Java OTF decoder.

Author: mjpt777

examples/java/uk/co/real_logic/sbe/examples/ExampleTokenListener.java

@@ -124,6 +124,16 @@ public void onEndComposite(final Token fieldToken, final List<Token> tokens, fin
  namedScope.pop();
  }
 
+ public void onBeginGroup(final Token token, final int groupIndex, final int numInGroup)
+ {
+ namedScope.push(token.name() + ".");
+ }
+
+ public void onEndGroup(final Token token, final int groupIndex, final int numInGroup)
+ {
+ namedScope.pop();
+ }
+
  private static CharSequence readEncodingAsString(final DirectBuffer buffer,
  final int index,
  final Token typeToken,
@@ -158,7 +168,7 @@ private long readEncodingAsLong(final DirectBuffer buffer, final int bufferIndex
  return constOrNotPresentValue.longValue();
  }
 
- return readAsLong(buffer, bufferIndex, typeToken.encoding());
+ return getLong(buffer, bufferIndex, typeToken.encoding());
  }
 
  private static PrimitiveValue constOrNotPresentValue(final Token token, final int actingVersion)
@@ -229,7 +239,7 @@ private static void mapEncodingToString(final StringBuilder sb, final DirectBuff
  }
  }
 
- private static long readAsLong(final DirectBuffer buffer, final int index, final Encoding encoding)
+ private static long getLong(final DirectBuffer buffer, final int index, final Encoding encoding)
  {
  switch (encoding.primitiveType())
  {

examples/java/uk/co/real_logic/sbe/examples/OtfExample.java

@@ -4,7 +4,8 @@
 import baseline.MessageHeader;
 import uk.co.real_logic.sbe.codec.java.DirectBuffer;
 import uk.co.real_logic.sbe.ir.*;
-import uk.co.real_logic.sbe.otf.OtfDecoder;
+import uk.co.real_logic.sbe.otf.OtfGroupSizeDecoder;
+import uk.co.real_logic.sbe.otf.OtfMessageDecoder;
 import uk.co.real_logic.sbe.otf.OtfHeaderDecoder;
 import uk.co.real_logic.sbe.xml.IrGenerator;
 import uk.co.real_logic.sbe.xml.MessageSchema;
@@ -39,23 +40,25 @@ public static void main(final String[] args) throws Exception
  // Now we have IR we can read the message header
  int bufferOffset = 0;
  final DirectBuffer buffer = new DirectBuffer(encodedMsgBuffer);
- final OtfHeaderDecoder otfHeaderDecoder = new OtfHeaderDecoder(ir.headerStructure());
+ final OtfHeaderDecoder headerDecoder = new OtfHeaderDecoder(ir.headerStructure());
 
- final int templateId = otfHeaderDecoder.getTemplateId(buffer, bufferOffset);
- final int actingVersion = otfHeaderDecoder.getTemplateVersion(buffer, bufferOffset);
- final int blockLength = otfHeaderDecoder.getBlockLength(buffer, bufferOffset);
+ final int templateId = headerDecoder.getTemplateId(buffer, bufferOffset);
+ final int actingVersion = headerDecoder.getTemplateVersion(buffer, bufferOffset);
+ final int blockLength = headerDecoder.getBlockLength(buffer, bufferOffset);
 
- bufferOffset += otfHeaderDecoder.size();
+ bufferOffset += headerDecoder.size();
 
  // Given the header information we can select the appropriate message template to do the decode.
+ final OtfGroupSizeDecoder groupSizeDecoder = new OtfGroupSizeDecoder(ir.getType(OtfGroupSizeDecoder.GROUP_SIZE_ENCODING_NAME));
  final List<Token> msgTokens = ir.getMessage(templateId);
- final OtfDecoder oftDecoder = new OtfDecoder();
- bufferOffset = oftDecoder.decode(buffer,
- bufferOffset,
- actingVersion,
- blockLength,
- msgTokens,
- new ExampleTokenListener(new PrintWriter(System.out, true)));
+
+ final OtfMessageDecoder messageDecoder = new OtfMessageDecoder(groupSizeDecoder);
+ bufferOffset = messageDecoder.decode(buffer,
+ bufferOffset,
+ actingVersion,
+ blockLength,
+ msgTokens,
+ new ExampleTokenListener(new PrintWriter(System.out, true)));
 
  if (bufferOffset != encodedMsgBuffer.position())
  {

examples/resources/TestSchema.xml

@@ -11,7 +11,7 @@
  <type name="version" primitiveType="uint8"/>
  <type name="reserved" primitiveType="uint8"/>
  </composite>
- <composite name="groupSizeEncoding" description="Repeating group dimensions" >
+ <composite name="groupSizeEncoding" description="Repeating group dimensions">
  <type name="blockLength" primitiveType="uint16"/>
  <type name="numInGroup" primitiveType="uint8"/>
  </composite>

main/java/uk/co/real_logic/sbe/otf/OtfDecoder.java

@@ -0,0 +1,133 @@
+/*
+ * Copyright 2012 Real Logic Ltd.
+ *
+ * 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
+ *
+ * http://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.otf;
+
+import uk.co.real_logic.sbe.PrimitiveType;
+import uk.co.real_logic.sbe.codec.java.DirectBuffer;
+import uk.co.real_logic.sbe.ir.Signal;
+import uk.co.real_logic.sbe.ir.Token;
+
+import java.nio.ByteOrder;
+import java.util.List;
+
+/**
+ * Used to decode the group size header.
+ */
+public class OtfGroupSizeDecoder
+{
+ public static final String GROUP_SIZE_ENCODING_NAME = "groupSizeEncoding";
+ public static final String BLOCK_LENGTH_NAME = "blockLength";
+ public static final String NUM_IN_GROUP_NAME = "numInGroup";
+
+ private final int size;
+ private final int groupHeaderTokenCount;
+ private int blockLengthOffset = -1;
+ private int numInGroupOffset = -1;
+ private PrimitiveType blockLengthType;
+ private PrimitiveType numInGroupType;
+ private ByteOrder blockLengthByteOrder;
+ private ByteOrder numInGroupByteOrder;
+
+ /**
+ * Scan the tokens and cache meta data to make decoding more efficient.
+ *
+ * @param tokens describing the group header.
+ */
+ public OtfGroupSizeDecoder(final List<Token> tokens)
+ {
+ final Token compositeToken = tokens.get(0);
+ if (!GROUP_SIZE_ENCODING_NAME.equals(compositeToken.name()) ||
+ Signal.BEGIN_COMPOSITE != compositeToken.signal())
+ {
+ throw new IllegalArgumentException("Invalid Group: " + compositeToken);
+ }
+
+ size = compositeToken.size();
+ groupHeaderTokenCount = tokens.size();
+
+ for (final Token token : tokens)
+ {
+ switch (token.name())
+ {
+ case BLOCK_LENGTH_NAME:
+ blockLengthOffset = token.offset();
+ blockLengthType = token.encoding().primitiveType();
+ blockLengthByteOrder = token.encoding().byteOrder();
+ break;
+
+ case NUM_IN_GROUP_NAME:
+ numInGroupOffset = token.offset();
+ numInGroupType = token.encoding().primitiveType();
+ numInGroupByteOrder = token.encoding().byteOrder();
+ break;
+ }
+ }
+
+ if (-1 == blockLengthOffset)
+ {
+ throw new IllegalStateException(BLOCK_LENGTH_NAME + " is missing");
+ }
+
+ if (-1 == numInGroupOffset)
+ {
+ throw new IllegalStateException(NUM_IN_GROUP_NAME + " is missing");
+ }
+ }
+
+ /**
+ * Get the block length that is used for each iteration of the group fields.
+ *
+ * @param buffer to be read.
+ * @param bufferIndex at which he group header begins.
+ * @return the blockLength for an iteration of the group fields.
+ */
+ public int getBlockLength(final DirectBuffer buffer, final int bufferIndex)
+ {
+ return Util.getInt(buffer, bufferIndex + blockLengthOffset, blockLengthType, blockLengthByteOrder);
+ }
+
+ /**
+ * Get the number of times the group fields will be repeated.
+ *
+ * @param buffer to be read.
+ * @param bufferIndex at which he group header begins.
+ * @return the number of times the group fields will be repeated.
+ */
+ public int getNumInGroup(final DirectBuffer buffer, final int bufferIndex)
+ {
+ return Util.getInt(buffer, bufferIndex + numInGroupOffset, numInGroupType, numInGroupByteOrder);
+ }
+
+ /**
+ * Get the size of the group header in bytes.
+ *
+ * @return the size of the group header in bytes.
+ */
+ public int size()
+ {
+ return size;
+ }
+
+ /**
+ * The number of tokens in the group header.
+ *
+ * @return the number of tokens in the group header.
+ */
+ public int groupHeaderTokenCount()
+ {
+ return groupHeaderTokenCount;
+ }
+}