ConstValueProvider.java

  1. /*
  2.  * Copyright 2016 Providence Authors
  3.  *
  4.  * Licensed to the Apache Software Foundation (ASF) under one
  5.  * or more contributor license agreements. See the NOTICE file
  6.  * distributed with this work for additional information
  7.  * regarding copyright ownership. The ASF licenses this file
  8.  * to you under the Apache License, Version 2.0 (the
  9.  * "License"); you may not use this file except in compliance
  10.  * with the License. You may obtain a copy of the License at
  11.  *
  12.  *   http://www.apache.org/licenses/LICENSE-2.0
  13.  *
  14.  * Unless required by applicable law or agreed to in writing,
  15.  * software distributed under the License is distributed on an
  16.  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17.  * KIND, either express or implied. See the License for the
  18.  * specific language governing permissions and limitations
  19.  * under the License.
  20.  */
  21. package net.morimekta.providence.reflect.util;

  23. import net.morimekta.providence.PEnumBuilder;
  24. import net.morimekta.providence.PEnumValue;
  25. import net.morimekta.providence.PMessage;
  26. import net.morimekta.providence.PMessageBuilder;
  27. import net.morimekta.providence.PType;
  28. import net.morimekta.providence.descriptor.PDeclaredDescriptor;
  29. import net.morimekta.providence.descriptor.PDescriptor;
  30. import net.morimekta.providence.descriptor.PEnumDescriptor;
  31. import net.morimekta.providence.descriptor.PField;
  32. import net.morimekta.providence.descriptor.PList;
  33. import net.morimekta.providence.descriptor.PMap;
  34. import net.morimekta.providence.descriptor.PMessageDescriptor;
  35. import net.morimekta.providence.descriptor.PSet;
  36. import net.morimekta.providence.descriptor.PValueProvider;
  37. import net.morimekta.providence.reflect.parser.ThriftException;
  38. import net.morimekta.providence.reflect.parser.ThriftLexer;
  39. import net.morimekta.providence.reflect.parser.ThriftToken;
  40. import net.morimekta.providence.reflect.parser.ThriftTokenType;
  41. import net.morimekta.providence.types.TypeReference;
  42. import net.morimekta.providence.types.TypeRegistry;
  43. import net.morimekta.util.Binary;
  44. import net.morimekta.util.Strings;
  45. import net.morimekta.util.collect.UnmodifiableList;
  46. import net.morimekta.util.collect.UnmodifiableMap;
  47. import net.morimekta.util.collect.UnmodifiableSet;
  48. import net.morimekta.util.json.JsonException;
  49. import net.morimekta.util.json.JsonToken;
  50. import net.morimekta.util.json.JsonTokenizer;
  51. import net.morimekta.util.lexer.LexerException;
  52. import net.morimekta.util.lexer.Tokenizer;
  53. import net.morimekta.util.lexer.TokenizerRepeater;
  54. import net.morimekta.util.lexer.UncheckedLexerException;

  56. import javax.annotation.Nonnull;
  57. import java.io.ByteArrayInputStream;
  58. import java.io.IOException;
  59. import java.io.UncheckedIOException;
  60. import java.util.Collections;
  61. import java.util.List;
  62. import java.util.Optional;
  63. import java.util.concurrent.atomic.AtomicReference;

  65. import static java.nio.charset.StandardCharsets.US_ASCII;
  66. import static net.morimekta.providence.reflect.parser.ThriftTokenizer.kNull;
  67. import static net.morimekta.providence.types.TypeReference.parseType;
  68. import static net.morimekta.providence.util.MessageUtil.coerceStrict;

  70. /**
  71.  * A value provider for thrift constants.
  72.  */
  73. public class ConstValueProvider implements PValueProvider<Object> {
  74.     private final TypeRegistry      registry;
  75.     private final String            programName;
  76.     private final TypeReference     constType;
  77.     private final List<ThriftToken> constTokens;
  78.     private AtomicReference<Object> parsedValue;

  80.     public ConstValueProvider(@Nonnull TypeRegistry registry,
  81.                               @Nonnull String programName,
  82.                               @Nonnull TypeReference constType,
  83.                               @Nonnull List<ThriftToken> constTokens) {
  84.         this.registry = registry;
  85.         this.programName = programName;
  86.         this.constType = constType;
  87.         this.constTokens = constTokens;
  88.         this.parsedValue = null;
  89.     }

  91.     @Override
  92.     public Object get() {
  93.         if (parsedValue == null) {
  94.             PDescriptor type = registry
  95.                     .getTypeProvider(constType, Collections.emptyMap())
  96.                     .descriptor();
  97.             Tokenizer<ThriftTokenType, ThriftToken> tokenizer = new TokenizerRepeater<>(constTokens);
  98.             ThriftLexer                             lexer     = new ThriftLexer(tokenizer);
  99.             try {
  100.                 parsedValue = new AtomicReference<>(
  101.                         parseTypedValue(lexer.expect("const value"), lexer, type, true));
  102.             } catch (LexerException e) {
  103.                 throw new UncheckedLexerException(e);
  104.             } catch (IOException e) {
  105.                 throw new UncheckedIOException(e.getMessage(), e);
  106.             }
  107.         }

  109.         return parsedValue.get();
  110.     }

  112.     /**
  113.      * Parse JSON object as a message.
  114.      *
  115.      * @param lexer     The thrift lexer.
  116.      * @param type      The message type.
  117.      * @param <Message> Message generic type.
  118.      * @return The parsed message.
  119.      */
  120.     private <Message extends PMessage<Message>>
  121.     Message parseMessage(ThriftLexer lexer,
  122.                          PMessageDescriptor<Message> type) throws IOException {
  123.         PMessageBuilder<Message> builder = type.builder();

  125.         ThriftToken token = lexer.expect("message field or end");
  126.         while (!token.isSymbol(ThriftToken.kMessageEnd)) {
  127.             if (token.type() != ThriftTokenType.STRING) {
  128.                 throw lexer.failure(token, "Invalid field name token");
  129.             }
  130.             PField<?> field = type.findFieldByName(token.decodeString(true));
  131.             if (field == null) {
  132.                 throw lexer.failure(
  133.                         token, "No such field in %s: %s",
  134.                         type.getQualifiedName(), token.decodeString(true));
  135.             }
  136.             lexer.expectSymbol("message key-value sep", ThriftToken.kKeyValueSep);

  138.             builder.set(field.getId(),
  139.                         parseTypedValue(lexer.expect("parsing field value"),
  140.                                         lexer,
  141.                                         field.getDescriptor(),
  142.                                         false));

  144.             token = lexer.expect("message sep, field or end");
  145.             if (token.isSymbol(ThriftToken.kLineSep1) || token.isSymbol(ThriftToken.kLineSep2)) {
  146.                 token = lexer.expect("message field or end");
  147.             }
  148.         }

  150.         return builder.build();
  151.     }

  153.     private Object parseTypedValue(ThriftToken token,
  154.                                    ThriftLexer lexer,
  155.                                    PDescriptor valueType,
  156.                                    boolean allowNull)
  157.             throws IOException {
  158.         // Enum.VALUE
  159.         // program.Enum.VALUE
  160.         if (token.isQualifiedIdentifier() ||
  161.             token.isDoubleQualifiedIdentifier()) {
  162.             // Possible enum value. First strip after last '.' to get enum type name.
  163.             String typeName = token.toString().replaceAll("\\.[^.]+$", "");

  165.             Optional<PDeclaredDescriptor<?>> desc;
  166.             if (typeName.equals(valueType.getName()) &&
  167.                 valueType.getType() == PType.ENUM) {
  168.                 desc = Optional.of((PDeclaredDescriptor<?>) valueType);
  169.             } else {
  170.                 TypeReference ref = parseType(this.programName, typeName);
  171.                 desc = registry.getDeclaredType(ref);
  172.             }

  174.             if (desc.isPresent()) {
  175.                 if (!(desc.get() instanceof PEnumDescriptor)) {
  176.                     throw new IllegalArgumentException("Not an enum type " + desc.get().getQualifiedName());
  177.                 }

  179.                 String        valueName = token.toString().replaceAll("^.*\\.", "");
  180.                 PEnumValue<?> value     = ((PEnumDescriptor<?>) desc.get()).findByName(valueName);
  181.                 if (value != null) {
  182.                     return coerceStrict(valueType, value).orElseThrow(() -> new IllegalArgumentException("Non-matching enum value"));
  183.                 } else if (allowNull) {
  184.                     return null;
  185.                 } else {
  186.                     throw new IllegalArgumentException("No such " + desc.get().getQualifiedName() + " value " + valueName);
  187.                 }
  188.             }
  189.         }

  191.         // kConstName
  192.         // program.kConstName
  193.         if (token.isIdentifier() || token.isQualifiedIdentifier()) {
  194.             if (kNull.equals(token.toString())) {
  195.                 if (allowNull) {
  196.                     return null;
  197.                 }
  198.             }

  200.             Optional<Object> optional = registry.getConstantValue(parseType(this.programName, token.toString()));
  201.             if (optional.isPresent()) {
  202.                 return coerceStrict(valueType, optional.get()).orElse(null);
  203.             }
  204.         }

  206.         // Direct value.
  207.         switch (valueType.getType()) {
  208.             case BOOL:
  209.                 if (token.isIdentifier()) {
  210.                     return Boolean.parseBoolean(token.toString());
  211.                 } else if (token.isInteger()) {
  212.                     return token.parseInteger() != 0L;
  213.                 }
  214.                 throw lexer.failure(token, "Not boolean value: %s", token.toString());
  215.             case BYTE:
  216.                 if (token.isInteger()) {
  217.                     return (byte) token.parseInteger();
  218.                 }
  219.                 return (byte) findEnumValue(token.toString(), token, lexer, "byte");
  220.             case I16:
  221.                 if (token.isInteger()) {
  222.                     return (short) token.parseInteger();
  223.                 }
  224.                 return (short) findEnumValue(token.toString(), token, lexer, "i16");
  225.             case I32:
  226.                 if (token.isInteger()) {
  227.                     return (int) token.parseInteger();
  228.                 }
  229.                 return findEnumValue(token.toString(), token, lexer, "i32");
  230.             case I64:
  231.                 if (token.isInteger()) {
  232.                     return token.parseInteger();
  233.                 }
  234.                 return (long) findEnumValue(token.toString(), token, lexer, "i64");
  235.             case DOUBLE:
  236.                 if (token.type() == ThriftTokenType.NUMBER) {
  237.                     return token.parseDouble();
  238.                 }
  239.                 throw lexer.failure(token, token + " is not a valid double value.");
  240.             case STRING:
  241.                 if (token.type() == ThriftTokenType.STRING) {
  242.                     return token.decodeString(true);
  243.                 } else if (allowNull && token.toString().equals(kNull)) {
  244.                     return null;
  245.                 }
  246.                 throw lexer.failure(token, "Not a valid string value.");
  247.             case BINARY:
  248.                 if (token.type() == ThriftTokenType.STRING) {
  249.                     return parseBinary(token.substring(1, -1)
  250.                                             .toString());
  251.                 } else if (allowNull && token.toString().equals(kNull)) {
  252.                     return null;
  253.                 }
  254.                 throw lexer.failure(token, "Not a valid binary value.");
  255.             case ENUM: {
  256.                 // Enum reference already handled.
  257.                 PEnumBuilder<?> eb   = ((PEnumDescriptor<?>) valueType).builder();
  258.                 String          name = token.toString();
  259.                 if (Strings.isInteger(name)) {
  260.                     Object ev = eb.setById(Integer.parseInt(name)).build();
  261.                     if (ev == null) {
  262.                         if (allowNull && token.toString().equals(kNull)) {
  263.                             return null;
  264.                         }
  265.                         throw lexer.failure(token,
  266.                                                 "No such " + valueType.getQualifiedName() + " enum value \"" + name);
  267.                     }
  268.                     return ev;
  269.                 }
  270.                 throw lexer.failure(token, "Not valid enum reference '" + name + "'");
  271.             }
  272.             case MESSAGE: {
  273.                 if (token.isSymbol(ThriftToken.kMessageStart)) {
  274.                     return parseMessage(lexer, (PMessageDescriptor<?>) valueType);
  275.                 } else if (allowNull && token.toString().equals(kNull)) {
  276.                     // messages can be null values in constants.
  277.                     return null;
  278.                 }
  279.                 throw lexer.failure(token, "Not a valid message start.");
  280.             }
  281.             case LIST: {
  282.                 PDescriptor                      itemType = ((PList<?>) valueType).itemDescriptor();
  283.                 UnmodifiableList.Builder<Object> list     = UnmodifiableList.builder();

  285.                 if (!token.isSymbol(ThriftToken.kListStart)) {
  286.                     throw lexer.failure(token, "Expected list start, found " + token.toString());
  287.                 }
  288.                 token = lexer.expect("list item or end");
  289.                 while (!token.isSymbol(ThriftToken.kListEnd)) {
  290.                     list.add(parseTypedValue(token, lexer, itemType, false));
  291.                     token = lexer.expect("list item, sep or end");
  292.                     if (token.isSymbol(ThriftToken.kLineSep1) || token.isSymbol(ThriftToken.kLineSep2)) {
  293.                         token = lexer.expect("list item or end");
  294.                     }
  295.                 }

  297.                 return list.build();
  298.             }
  299.             case SET: {
  300.                 PDescriptor                     itemType = ((PSet<?>) valueType).itemDescriptor();
  301.                 UnmodifiableSet.Builder<Object> set      = UnmodifiableSet.builder();

  303.                 if (!token.isSymbol(ThriftToken.kListStart)) {
  304.                     throw lexer.failure(token, "Expected list start, found " + token.toString());
  305.                 }

  307.                 if (!token.isSymbol(ThriftToken.kListStart)) {
  308.                     throw lexer.failure(token, "Expected list start, found " + token.toString());
  309.                 }
  310.                 token = lexer.expect("list item or end");
  311.                 while (!token.isSymbol(ThriftToken.kListEnd)) {
  312.                     set.add(parseTypedValue(token, lexer, itemType, false));
  313.                     token = lexer.expect("list item, sep or end");
  314.                     if (token.isSymbol(ThriftToken.kLineSep1) || token.isSymbol(ThriftToken.kLineSep2)) {
  315.                         token = lexer.expect("list item or end");
  316.                     }
  317.                 }

  319.                 return set.build();
  320.             }
  321.             case MAP: {
  322.                 PDescriptor itemType = ((PMap<?, ?>) valueType).itemDescriptor();
  323.                 PDescriptor keyType = ((PMap<?, ?>) valueType).keyDescriptor();

  325.                 UnmodifiableMap.Builder<Object, Object> map = UnmodifiableMap.builder();

  327.                 if (!token.isSymbol(ThriftToken.kMessageStart)) {
  328.                     throw lexer.failure(token, "Expected map start, found " + token.toString());
  329.                 }

  331.                 token = lexer.expect("map key or end");
  332.                 while (!token.isSymbol(ThriftToken.kMessageEnd)) {
  333.                     Object key;
  334.                     if (token.type() == ThriftTokenType.STRING) {
  335.                         key = parsePrimitiveKey(token.decodeString(true), token, lexer, keyType);
  336.                     } else if (token.isIdentifier() || token.isQualifiedIdentifier()) {
  337.                         key = registry.getConstantValue(parseType(programName, token.toString())).orElse(null);
  338.                         if (key == null) {
  339.                             if (keyType.getType().equals(PType.STRING) ||
  340.                                 keyType.getType().equals(PType.BINARY)) {
  341.                                 throw lexer.failure(token, "Expected string literal for string key");
  342.                             }
  343.                             key = parsePrimitiveKey(token.toString(), token, lexer, keyType);
  344.                         }
  345.                     } else {
  346.                         if (keyType.getType().equals(PType.STRING) ||
  347.                             keyType.getType().equals(PType.BINARY)) {
  348.                             throw lexer.failure(token, "Expected string literal for string key");
  349.                         }
  350.                         key = parsePrimitiveKey(token.toString(), token, lexer, keyType);
  351.                     }
  352.                     lexer.expectSymbol("map KV separator", ThriftToken.kKeyValueSep);
  353.                     map.put(key, parseTypedValue(lexer.expect("map value"), lexer, itemType, false));

  355.                     token = lexer.expect("map key, sep or end");
  356.                     if (token.isSymbol(ThriftToken.kLineSep1) || token.isSymbol(ThriftToken.kLineSep2)) {
  357.                         token = lexer.expect("map key or end");
  358.                     }
  359.                 }

  361.                 return map.build();
  362.             }
  363.             default:
  364.                 throw new IllegalArgumentException("Unhandled item type " + valueType.getQualifiedName());
  365.         }
  366.     }

  368.     private Object parsePrimitiveKey(String key, ThriftToken token, ThriftLexer tokenizer, PDescriptor keyType)
  369.             throws IOException {
  370.         switch (keyType.getType()) {
  371.             case ENUM:
  372.                 PEnumBuilder<?> eb = ((PEnumDescriptor<?>) keyType).builder();
  373.                 if (Strings.isInteger(key)) {
  374.                     return eb.setById(Integer.parseInt(key))
  375.                              .build();
  376.                 } else {
  377.                     if (key.startsWith(keyType.getProgramName() + "." + keyType.getName() + ".")) {
  378.                         // Check for qualified type prefixed identifier ( e.g. program.EnumName.VALUE ).
  379.                         key = key.substring(keyType.getProgramName().length() + keyType.getName().length() + 2);
  380.                     } else if (key.startsWith(keyType.getName() + ".")) {
  381.                         // Check for type prefixed identifier ( e.g. EnumName.VALUE ).
  382.                         key = key.substring(keyType.getName().length() + 1);
  383.                     }
  384.                     return eb.setByName(key)
  385.                              .build();
  386.                 }
  387.             case BOOL:
  388.                 return Boolean.parseBoolean(key);
  389.             case BYTE:
  390.                 if (Strings.isInteger(key)) {
  391.                     return Byte.parseByte(key);
  392.                 } else {
  393.                     return (byte) findEnumValue(key, token, tokenizer, "byte");
  394.                 }
  395.             case I16:
  396.                 if (Strings.isInteger(key)) {
  397.                     return Short.parseShort(key);
  398.                 } else {
  399.                     return (short) findEnumValue(key, token, tokenizer, "i16");
  400.                 }
  401.             case I32:
  402.                 if (Strings.isInteger(key)) {
  403.                     return Integer.parseInt(key);
  404.                 } else {
  405.                     return findEnumValue(key, token, tokenizer, "i32");
  406.                 }
  407.             case I64:
  408.                 if (Strings.isInteger(key)) {
  409.                     return Long.parseLong(key);
  410.                 } else {
  411.                     return (long) findEnumValue(key, token, tokenizer, "i64");
  412.                 }
  413.             case DOUBLE: {
  414.                 try {
  415.                     ByteArrayInputStream bais    = new ByteArrayInputStream(key.getBytes(US_ASCII));
  416.                     JsonTokenizer        tokener = new JsonTokenizer(bais);
  417.                     JsonToken            jt      = tokener.expect("parsing double value");
  418.                     return jt.doubleValue();
  419.                 } catch (NumberFormatException | IOException | JsonException e) {
  420.                     throw new ThriftException(token, "Unable to parse double value").initCause(e);
  421.                 }
  422.             }
  423.             case STRING:
  424.                 return key;
  425.             case BINARY:
  426.                 return parseBinary(key);
  427.             default:
  428.                 throw new ThriftException("Illegal key type: " + keyType.getType());
  429.         }
  430.     }

  432.     private int findEnumValue(String identifier, ThriftToken token, ThriftLexer tokenizer, String expectedType)
  433.             throws IOException {
  434.         String[] parts = identifier.split("\\.", Byte.MAX_VALUE);
  435.         String typeName;
  436.         String valueName;
  437.         if (parts.length == 3) {
  438.             typeName = parts[0] + "." + parts[1];
  439.             valueName = parts[2];
  440.         } else if (parts.length == 2) {
  441.             typeName = parts[0];
  442.             valueName = parts[1];
  443.         } else {
  444.             throw tokenizer.failure(token, identifier + " is not a valid " + expectedType + " value.");
  445.         }

  447.         try {
  448.             PDeclaredDescriptor descriptor = registry.requireDeclaredType(parseType(programName, typeName));
  449.             if (descriptor instanceof PEnumDescriptor) {
  450.                 PEnumDescriptor desc = (PEnumDescriptor) descriptor;
  451.                 PEnumValue value = desc.findByName(valueName);
  452.                 if (value != null) {
  453.                     return value.asInteger();
  454.                 }
  455.             }

  457.             throw tokenizer.failure(token, typeName + " is not an enum.");
  458.         } catch (IllegalArgumentException e) {
  459.             throw tokenizer.failure(token, "No type named " + typeName + ".");
  460.         }
  461.     }

  463.     /**
  464.      * Parse a string into binary format using the same rules as above.
  465.      *
  466.      * @param value The string to decode.
  467.      * @return The decoded byte array.
  468.      */
  469.     private Binary parseBinary(String value) {
  470.         return Binary.fromBase64(value);
  471.     }

  473. }
Created with JaCoCo 0.8.5.201910111838