if (0 != field.offset() && field.offset() < offset) handleError(node, "Offset provides insufficient space at field: " + field.name()); if (0 != field.offset()) offset = field.offset(); else if (null != field.dimensionType() && 0 != blockLength) else if (field.isVariableLength() && 0 != blockLength) field.computedOffset(variableLengthBlock ? Token.VARIABLE_LENGTH : offset); if (null != field.groupFields()) final int groupBlockLength = computeAndValidateOffsets(node, field.groupFields(), 0); validateBlockLength(node, field.blockLength(), groupBlockLength); field.computedBlockLength(Math.max(field.blockLength(), groupBlockLength)); else if (null != field.type() && Presence.CONSTANT != field.presence()) final int size = field.type().encodedLength(); field.computedBlockLength(size);
private void addFieldSignal(final Field field, final Signal signal) { final Encoding.Builder encodingBuilder = new Encoding.Builder() .epoch(field.epoch()) .timeUnit(field.timeUnit()) .presence(mapPresence(field.presence())) .semanticType(semanticTypeOf(null, field)); if (field.presence() == Presence.CONSTANT && null != field.valueRef()) { final String valueRef = field.valueRef(); final byte[] bytes; bytes = valueRef.getBytes(StandardCharsets.UTF_8); encodingBuilder.constValue(new PrimitiveValue(bytes, "UTF-8", valueRef.length())); encodingBuilder.primitiveType(PrimitiveType.CHAR); } final Token token = new Token.Builder() .signal(signal) .size(field.computedBlockLength()) .name(field.name()) .description(field.description()) .id(field.id()) .offset(field.computedOffset()) .version(field.sinceVersion()) .deprecated(field.deprecated()) .encoding(encodingBuilder.build()) .build(); tokenList.add(token); }
public Field build() { return new Field( name, description, id, type, offset, semanticType, presence, refValue, blockLength, dimensionType, variableLength, sinceVersion, deprecated, epoch, timeUnit); } }
private static int computeMessageRootBlockLength(final List<Field> fields) { int blockLength = 0; for (final Field field : fields) { if (field.groupFields() != null) { return blockLength; } else if (field.type() != null) { final int fieldLength = field.type().encodedLength(); if (Token.VARIABLE_LENGTH == fieldLength) { return blockLength; } if (field.presence() == Presence.CONSTANT) { blockLength = field.computedOffset(); } else { blockLength = field.computedOffset() + fieldLength; } } } return blockLength; }
final Type type = field.type(); add(field.dimensionType(), 0, field); addAllFields(field.groupFields()); addFieldSignal(field, Signal.END_GROUP); else if (type instanceof CompositeType && field.isVariableLength()) add((CompositeType)type, field.computedOffset(), field); addFieldSignal(field, Signal.END_VAR_DATA); add((EncodedDataType)type, field.computedOffset(), field); add((CompositeType)type, field.computedOffset(), field); add((EnumType)type, field.computedOffset(), field); add((SetType)type, field.computedOffset(), field);
.semanticType(semanticTypeOf(type, field)) .characterEncoding(type.characterEncoding()) .timeUnit(field.timeUnit()) .epoch(field.epoch()); .offset(offset); if (field.type() instanceof CompositeType) tokenBuilder.version(Math.max(field.sinceVersion(), type.sinceVersion())); switch (field.presence()) final String valueRef = field.valueRef(); tokenBuilder.size(0); encodingBuilder
private void addFieldSignal(final Field field, final Signal signal) { final Token token = new Token.Builder() .signal(signal) .size(field.computedBlockLength()) .name(field.name()) .id(field.id()) .offset(field.computedOffset()) .version(field.sinceVersion()) .encoding(new Encoding.Builder() .epoch(field.epoch()) .timeUnit(field.timeUnit()) .semanticType(semanticTypeOf(null, field)) .build()) .build(); tokenList.add(token); }
@Test public void shouldCalculateGroupOffsetWithPaddingFromBlockLength() throws Exception { final MessageSchema schema = parse(TestUtil.getLocalResource( "block-length-schema.xml"), ParserOptions.DEFAULT); final List<Field> fields = schema.getMessage(2).fields(); assertThat(valueOf(fields.get(0).computedOffset()), is(valueOf(0))); assertThat(valueOf(fields.get(0).type().encodedLength()), is(valueOf(8))); assertThat(valueOf(fields.get(1).computedOffset()), is(valueOf(64))); Assert.assertNull(fields.get(1).type()); assertThat(valueOf(fields.get(1).computedBlockLength()), is(valueOf(12))); final List<Field> groupFields = fields.get(1).groupFields(); assertThat(valueOf(groupFields.size()), is(valueOf(2))); assertThat(valueOf(groupFields.get(0).computedOffset()), is(valueOf(0))); assertThat(valueOf(groupFields.get(0).type().encodedLength()), is(valueOf(4))); assertThat(valueOf(groupFields.get(1).computedOffset()), is(valueOf(4))); assertThat(valueOf(groupFields.get(1).type().encodedLength()), is(valueOf(8))); }
@Test public void shouldHandleEmbeddedCountForGroup() throws Exception { final MessageSchema schema = parse( TestUtil.getLocalResource("embedded-length-and-count-schema.xml"), ParserOptions.DEFAULT); final List<Field> fields = schema.getMessage(1).fields(); assertThat(fields.get(1).name(), is("ListOrdGrp")); assertThat(valueOf(fields.get(1).id()), is(valueOf(73))); Assert.assertNotNull(fields.get(1).dimensionType()); final List<Field> groupFields = fields.get(1).groupFields(); Assert.assertNotNull(groupFields); }
@Test public void shouldParseSchemaSuccessfully() throws Exception { final MessageSchema schema = parse(TestUtil.getLocalResource( "group-with-data-schema.xml"), ParserOptions.DEFAULT); final List<Field> fields = schema.getMessage(1).fields(); final Field entriesGroup = fields.get(1); final CompositeType dimensionType = entriesGroup.dimensionType(); final List<Field> entriesFields = entriesGroup.groupFields(); assertThat(entriesGroup.name(), is("Entries")); assertThat(dimensionType.name(), is("groupSizeEncoding")); final Field varDataField = entriesFields.get(2); assertThat(varDataField.name(), is("varDataField")); assertTrue(varDataField.isVariableLength()); } }
@Test public void shouldCalculateGroupOffsetWithNoPaddingFromBlockLength() throws Exception { final MessageSchema schema = parse(TestUtil.getLocalResource( "block-length-schema.xml"), ParserOptions.DEFAULT); final Message msg = schema.getMessage(1); assertThat(valueOf(msg.blockLength()), is(valueOf(8))); final List<Field> fields = msg.fields(); assertThat(valueOf(fields.get(0).computedOffset()), is(valueOf(0))); assertThat(valueOf(fields.get(0).type().encodedLength()), is(valueOf(8))); assertThat(valueOf(fields.get(1).computedOffset()), is(valueOf(8))); Assert.assertNull(fields.get(1).type()); final List<Field> groupFields = fields.get(1).groupFields(); assertThat(valueOf(groupFields.size()), is(valueOf(2))); assertThat(valueOf(groupFields.get(0).computedOffset()), is(valueOf(0))); assertThat(valueOf(groupFields.get(0).type().encodedLength()), is(valueOf(4))); assertThat(valueOf(groupFields.get(1).computedOffset()), is(valueOf(4))); assertThat(valueOf(groupFields.get(1).type().encodedLength()), is(valueOf(8))); }
.build(); XmlSchemaParser.checkForValidName(node, field.name()); field.groupFields(parseMembers(node)); // recursive call
@Test public void shouldCalculateDataOffsetWithPaddingFromBlockLength() throws Exception { final MessageSchema schema = parse(TestUtil.getLocalResource( "block-length-schema.xml"), ParserOptions.DEFAULT); final List<Field> fields = schema.getMessage(4).fields(); assertThat(valueOf(fields.get(0).computedOffset()), is(valueOf(0))); assertThat(valueOf(fields.get(0).type().encodedLength()), is(valueOf(8))); assertThat(valueOf(fields.get(1).computedOffset()), is(valueOf(64))); assertThat(valueOf(fields.get(1).type().encodedLength()), is(valueOf(-1))); }
@Test public void shouldHandleEncodingTypesWithNamedTypes() throws Exception { final MessageSchema schema = parse(TestUtil.getLocalResource( "encoding-types-schema.xml"), ParserOptions.DEFAULT); final List<Field> fields = schema.getMessage(1).fields(); assertNotNull(fields); SetType type = (SetType)fields.get(3).type(); assertThat(type.encodingType(), is(PrimitiveType.UINT8)); type = (SetType)fields.get(4).type(); assertThat(type.encodingType(), is(PrimitiveType.UINT16)); type = (SetType)fields.get(5).type(); assertThat(type.encodingType(), is(PrimitiveType.UINT32)); type = (SetType)fields.get(6).type(); assertThat(type.encodingType(), is(PrimitiveType.UINT64)); }
@Test public void shouldHandleBasicAllTypes() throws Exception { final MessageSchema schema = parse(TestUtil.getLocalResource("basic-types-schema.xml"), ParserOptions.DEFAULT); final List<Field> fields = schema.getMessage(1).fields(); assertThat(fields.get(0).name(), is("header")); assertThat(fields.get(1).name(), is("EDTField")); assertThat(fields.get(2).name(), is("ENUMField")); assertThat(fields.get(3).name(), is("SETField")); assertThat(fields.get(4).name(), is("int64Field")); } }
@Test public void shouldCalculateDimensionSizeWithOffsetsSpecified() throws Exception { final MessageSchema schema = parse(TestUtil.getLocalResource( "composite-offsets-schema.xml"), ParserOptions.DEFAULT); final CompositeType dimensions = schema.getMessage(1).fields().get(0).dimensionType(); assertThat(valueOf(dimensions.encodedLength()), is(valueOf(8))); } }
final Type type = field.type(); add(field.dimensionType(), 0, field); addAllFields(field.groupFields()); addFieldSignal(field, Signal.END_GROUP); else if (type instanceof CompositeType && field.isVariableLength()) add((CompositeType)type, field.computedOffset(), field); addFieldSignal(field, Signal.END_VAR_DATA); add((EncodedDataType)type, field.computedOffset(), field); add((CompositeType)type, field.computedOffset(), field); add((EnumType)type, field.computedOffset(), field); add((SetType)type, field.computedOffset(), field);
.semanticType(semanticTypeOf(type, field)) .characterEncoding(type.characterEncoding()) .timeUnit(field.timeUnit()) .epoch(field.epoch()); .offset(offset); if (field.type() instanceof CompositeType) tokenBuilder.version(Math.max(field.sinceVersion(), type.sinceVersion())); switch (field.presence()) final String valueRef = field.valueRef(); tokenBuilder.size(0); encodingBuilder