public static CharSequence concatTokens( final List<Token> tokens, final Signal signal, final Function<Token, CharSequence> mapper) { return tokens .stream() .filter((token) -> token.signal() == signal) .map(mapper) .collect(joining()); }
public static List<String> findSubGroupNames(final List<Token> tokens) { final ArrayList<String> groupNames = new ArrayList<>(); int level = 0; for (final Token token : tokens) { if (token.signal() == Signal.BEGIN_GROUP) { if (level++ == 0) { groupNames.add(token.name()); } } if (token.signal() == Signal.END_GROUP) { level--; } } return groupNames; } }
public static int findEndSignal( final List<Token> tokens, final int startIndex, final Signal signal, final String name) { int result = tokens.size() - 1; for (int i = startIndex, endIndex = tokens.size() - 1; i < endIndex; i++) { final Token token = tokens.get(i); if (signal == token.signal() && name.equals(token.name())) { result = i; break; } } return result; }
public List<String> generateTypesToIncludes(final List<Token> tokens) { final List<String> typesToInclude = new ArrayList<>(); for (final Token token : tokens) { switch (token.signal()) { case BEGIN_ENUM: case BEGIN_SET: case BEGIN_COMPOSITE: typesToInclude.add(token.applicableTypeName()); break; } } return typesToInclude; }
public static int collect( final Signal signal, final List<Token> tokens, final int index, final List<Token> collected) { int i = index; while (i < tokens.size()) { final Token token = tokens.get(i); if (signal != token.signal()) { break; } final int tokenCount = token.componentTokenCount(); for (final int limit = i + tokenCount; i < limit; i++) { collected.add(tokens.get(i)); } } return i; }
private static void generateComposites(final Ir ir, final OutputManager outputManager) throws IOException { for (final List<Token> tokens : ir.types()) { if (!tokens.isEmpty() && tokens.get(0).signal() == Signal.BEGIN_COMPOSITE) { generateSingleComposite(tokens, outputManager); } } }
private static int captureMessage(final List<Token> tokens, final int index, final Ir ir) { final List<Token> messageTokens = new ArrayList<>(); int i = index; Token token = tokens.get(i); messageTokens.add(token); do { token = tokens.get(++i); messageTokens.add(token); } while (Signal.END_MESSAGE != token.signal()); ir.addMessage(tokens.get(i).id(), messageTokens); return i; }
private static void generateBitSets(final Ir ir, final OutputManager outputManager) throws IOException { for (final List<Token> tokens : ir.types()) { if (!tokens.isEmpty() && tokens.get(0).signal() == BEGIN_SET) { generateSingleBitSet(tokens, outputManager); } } }
private int captureHeader(final List<Token> tokens) { final List<Token> headerTokens = new ArrayList<>(); int index = 0; Token token = tokens.get(index); final String headerName = token.name(); headerTokens.add(token); do { token = tokens.get(++index); headerTokens.add(token); } while (Signal.END_COMPOSITE != token.signal() || !headerName.equals(token.name())); irHeader = headerTokens; return index; }
private int captureType( final List<Token> tokens, final int index, final Signal endSignal, final String name, final String referencedName) { final List<Token> typeTokens = new ArrayList<>(); int i = index; Token token = tokens.get(i); typeTokens.add(token); do { token = tokens.get(++i); typeTokens.add(token); } while (endSignal != token.signal() || !name.equals(token.name())); updateComponentTokenCounts(typeTokens); typesByNameMap.put(null == referencedName ? name : referencedName, typeTokens); return i; } }
static List<VarDataSummary> gatherVarDataSummaries(final List<Token> tokens) { final List<VarDataSummary> summaries = new ArrayList<>(); for (int i = 0; i < tokens.size(); i++) { final Token beginToken = tokens.get(i); if (beginToken.signal() != Signal.BEGIN_VAR_DATA) { throw new IllegalStateException("tokens must begin with BEGIN_VAR_DATA: token=" + beginToken); } ++i; final Token dimensionsToken = tokens.get(i); final int headerTokenCount = dimensionsToken.componentTokenCount(); final List<Token> currentEncodingTokens = tokens.subList(i, i + headerTokenCount); final PrimitiveType lengthType = findPrimitiveByTokenName(currentEncodingTokens, "length"); final PrimitiveType dataType = findPrimitiveByTokenName(currentEncodingTokens, "varData"); summaries.add(new VarDataSummary(beginToken.name(), lengthType, dataType)); i += headerTokenCount; } return summaries; } }
private CharSequence generateChoices(final List<Token> tokens) { final StringBuilder sb = new StringBuilder(); for (final Token token : tokens) { if (token.signal() == Signal.CHOICE) { final String choiceName = toUpperFirstChar(token.applicableTypeName()); final String choiceBitPosition = token.encoding().constValue().toString(); final int choiceValue = (int)Math.pow(2, Integer.parseInt(choiceBitPosition)); sb.append(String.format(INDENT + INDENT + "%s = %s,\n", choiceName, choiceValue)); } } return sb; }
public List<String> generateTypeStubs() throws IOException { final List<String> typesToInclude = new ArrayList<>(); for (final List<Token> tokens : ir.types()) { switch (tokens.get(0).signal()) { case BEGIN_ENUM: generateEnum(tokens); break; case BEGIN_SET: generateChoiceSet(tokens); break; case BEGIN_COMPOSITE: generateComposite(tokens); break; } typesToInclude.add(tokens.get(0).applicableTypeName()); } return typesToInclude; }
public void generateTypeStubs() throws IOException { for (final List<Token> tokens : ir.types()) { switch (tokens.get(0).signal()) { case BEGIN_ENUM: generateEnum(tokens); break; case BEGIN_SET: generateChoiceSet(tokens); break; case BEGIN_COMPOSITE: generateComposite(tokens, ""); break; case BEGIN_MESSAGE: break; default: break; } } }
public void generateTypeStubs() throws IOException { generateMetaAttributeEnum(); for (final List<Token> tokens : ir.types()) { switch (tokens.get(0).signal()) { case BEGIN_ENUM: generateEnum(tokens); break; case BEGIN_SET: generateBitSet(tokens); break; case BEGIN_COMPOSITE: generateComposite(tokens); break; } } }
public void generateTypeStubs() throws IOException { generateMetaAttributeEnum(); for (final List<Token> tokens : ir.types()) { switch (tokens.get(0).signal()) { case BEGIN_ENUM: generateEnum(tokens); break; case BEGIN_SET: generateBitSet(tokens); break; case BEGIN_COMPOSITE: generateComposite(tokens); break; } } }
private void generateVarData( final StringBuilder sb, final String typeName, final List<Token> tokens) { for (int i = 0, size = tokens.size(); i < size;) { final Token token = tokens.get(i); if (token.signal() != Signal.BEGIN_VAR_DATA) { throw new IllegalStateException("tokens must begin with BEGIN_VAR_DATA: token=" + token); } final String propertyName = toUpperFirstChar(token.name()); final Token lengthToken = Generators.findFirst("length", tokens, i); final int lengthOfLengthField = lengthToken.encodedLength(); final Token varDataToken = Generators.findFirst("varData", tokens, i); final String characterEncoding = varDataToken.encoding().characterEncoding(); generateFieldMetaAttributeMethod(sb, typeName, propertyName, token); generateVarDataDescriptors(sb, token, typeName, propertyName, characterEncoding, lengthOfLengthField); i += token.componentTokenCount(); } }
private void captureTypes(final List<Token> tokens, final int beginIndex, final int endIndex) { for (int i = beginIndex; i <= endIndex; i++) { final Token token = tokens.get(i); final int typeBeginIndex = i; switch (token.signal()) { case BEGIN_COMPOSITE: i = captureType(tokens, i, Signal.END_COMPOSITE, token.name(), token.referencedName()); captureTypes(tokens, typeBeginIndex + 1, i - 1); break; case BEGIN_ENUM: i = captureType(tokens, i, Signal.END_ENUM, token.name(), token.referencedName()); break; case BEGIN_SET: i = captureType(tokens, i, Signal.END_SET, token.name(), token.referencedName()); break; } } }
private void assertEqual(final Token lhs, final Token rhs) { assertThat(lhs.name(), is(rhs.name())); assertThat(lhs.version(), is(rhs.version())); assertThat(lhs.offset(), is(rhs.offset())); assertThat((long)lhs.id(), is((long)rhs.id())); assertThat(lhs.signal(), is(rhs.signal())); assertThat(lhs.encodedLength(), is(rhs.encodedLength())); assertThat(lhs.encoding().byteOrder(), is(rhs.encoding().byteOrder())); assertThat(lhs.encoding().primitiveType(), is(rhs.encoding().primitiveType())); assertThat(lhs.encoding().presence(), is(rhs.encoding().presence())); assertThat(lhs.encoding().constValue(), is(rhs.encoding().constValue())); assertThat(lhs.encoding().minValue(), is(rhs.encoding().minValue())); assertThat(lhs.encoding().maxValue(), is(rhs.encoding().maxValue())); assertThat(lhs.encoding().nullValue(), is(rhs.encoding().nullValue())); assertThat(lhs.encoding().characterEncoding(), is(rhs.encoding().characterEncoding())); assertThat(lhs.encoding().epoch(), is(rhs.encoding().epoch())); assertThat(lhs.encoding().timeUnit(), is(rhs.encoding().timeUnit())); assertThat(lhs.encoding().semanticType(), is(rhs.encoding().semanticType())); }