FieldUtil.java

  1. /*
  2.  * Copyright 2020 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.proto.utils;

  23. import com.google.protobuf.ByteString;
  24. import com.google.protobuf.Descriptors;
  25. import net.morimekta.collect.SetBuilder;
  26. import net.morimekta.collect.UnmodifiableList;
  27. import net.morimekta.collect.UnmodifiableMap;
  28. import net.morimekta.collect.UnmodifiableSet;
  29. import net.morimekta.proto.ProtoEnum;
  30. import net.morimekta.proto.ProtoMessage;

  32. import java.util.ArrayList;
  33. import java.util.List;
  34. import java.util.Optional;
  35. import java.util.Set;
  36. import java.util.stream.Collectors;

  38. import static java.util.Objects.requireNonNull;
  39. import static net.morimekta.proto.utils.ValueUtil.toJavaValue;

  41. /**
  42.  * Utilities regarding handling fields and field types.
  43.  */
  44. public final class FieldUtil {
  45.     /**
  46.      * @param field A map type field descriptor.
  47.      * @return The key field type for the map.
  48.      */
  49.     public static Descriptors.FieldDescriptor getMapKeyDescriptor(Descriptors.FieldDescriptor field) {
  50.         requireNonNull(field, "field == null");
  51.         if (!field.isMapField()) {
  52.             throw new IllegalArgumentException(
  53.                     "Not a map field: " + field.getFullName());
  54.         }
  55.         return requireNonNull(field.getMessageType().findFieldByNumber(1), "keyDescriptor == null");
  56.     }

  58.     /**
  59.      * @param field A map type field descriptor.
  60.      * @return The value field type for the map.
  61.      */
  62.     public static Descriptors.FieldDescriptor getMapValueDescriptor(Descriptors.FieldDescriptor field) {
  63.         requireNonNull(field, "field == null");
  64.         if (!field.isMapField()) {
  65.             throw new IllegalArgumentException(
  66.                     "Not a map field: " + field.getFullName());
  67.         }
  68.         return requireNonNull(field.getMessageType().findFieldByNumber(2), "valueDescriptor == null");
  69.     }

  71.     /**
  72.      * @param field A field descriptor.
  73.      * @return The default value for the type for the field.
  74.      */
  75.     public static Object getDefaultTypeValue(Descriptors.FieldDescriptor field) {
  76.         requireNonNull(field, "field == null");
  77.         if (field.isRepeated()) {
  78.             if (field.isMapField()) {
  79.                 return UnmodifiableMap.mapOf();
  80.             }
  81.             return UnmodifiableList.listOf();
  82.         } else {
  83.             switch (field.getType().getJavaType()) {
  84.                 case MESSAGE: {
  85.                     return ProtoMessage.getDefaultInstance(field.getMessageType());
  86.                 }
  87.                 case ENUM: {
  88.                     return ProtoEnum.getEnumDescriptor(field.getEnumType())
  89.                                     .getDefaultValue()
  90.                                     .orElse(null);
  91.                 }
  92.                 case STRING:
  93.                     return "";
  94.                 case INT:
  95.                     return 0;
  96.                 case LONG:
  97.                     return 0L;
  98.                 case FLOAT:
  99.                     return 0.0F;
  100.                 case DOUBLE:
  101.                     return 0.0D;
  102.                 case BOOLEAN:
  103.                     return Boolean.FALSE;
  104.                 case BYTE_STRING:
  105.                     return ByteString.EMPTY;
  106.                 default:
  107.                     // not testable, should be impossible to happen.
  108.                     return null;
  109.             }
  110.         }
  111.     }

  113.     /**
  114.      * @param field A field descriptor.
  115.      * @return The default value for the field.
  116.      */
  117.     public static Object getDefaultFieldValue(Descriptors.FieldDescriptor field) {
  118.         if (field.getJavaType() == Descriptors.FieldDescriptor.JavaType.MESSAGE) {
  119.             return getDefaultTypeValue(field);
  120.         } else {
  121.             return Optional.ofNullable(toJavaValue(field, field.getDefaultValue()))
  122.                            .orElseGet(() -> getDefaultTypeValue(field));
  123.         }
  124.     }

  126.     /**
  127.      * Convert a key path to a list of consecutive fields for recursive lookup.
  128.      *
  129.      * @param rootDescriptor The root message descriptor.
  130.      * @param path           The '.' joined field name key.
  131.      * @return Array of fields.
  132.      */
  133.     public static List<Descriptors.FieldDescriptor> fieldPathToFields(
  134.             Descriptors.Descriptor rootDescriptor,
  135.             String path) {
  136.         requireNonNull(rootDescriptor, "rootDescriptor == null");
  137.         requireNonNull(path, "path == null");
  138.         if (path.isEmpty()) {
  139.             throw new IllegalArgumentException("Empty path");
  140.         }
  141.         Descriptors.Descriptor descriptor = rootDescriptor;

  143.         ArrayList<Descriptors.FieldDescriptor> fields = new ArrayList<>();
  144.         String[] parts = path.split("\\.", Byte.MAX_VALUE);
  145.         for (int i = 0; i < (parts.length - 1); ++i) {
  146.             String name = parts[i];
  147.             if (name.isEmpty()) {
  148.                 throw new IllegalArgumentException("Empty field name in '" + path + "'");
  149.             }
  150.             Descriptors.FieldDescriptor field = descriptor.findFieldByName(name);
  151.             if (field == null) {
  152.                 throw new IllegalArgumentException(
  153.                         "Message " + descriptor.getFullName() + " has no field named " + name);
  154.             }
  155.             if (field.isMapField()) {
  156.                 var valueField = FieldUtil.getMapValueDescriptor(field);
  157.                 if (valueField.getType() != Descriptors.FieldDescriptor.Type.MESSAGE) {
  158.                     throw new IllegalArgumentException(
  159.                             "Intermediate map field '" + field.getFullName() + "' does not have message value type");
  160.                 }
  161.                 fields.add(field);
  162.                 descriptor = valueField.getMessageType();
  163.             } else {
  164.                 if (field.getType() != Descriptors.FieldDescriptor.Type.MESSAGE) {
  165.                     throw new IllegalArgumentException(
  166.                             "Intermediate field '" + field.getFullName() + "' is not a message");
  167.                 }
  168.                 fields.add(field);
  169.                 descriptor = field.getMessageType();
  170.             }
  171.         }

  173.         String name = parts[parts.length - 1];
  174.         if (name.isEmpty()) {
  175.             throw new IllegalArgumentException("Empty field name in '" + path + "'");
  176.         }
  177.         Descriptors.FieldDescriptor field = descriptor.findFieldByName(name);
  178.         if (field == null) {
  179.             throw new IllegalArgumentException(
  180.                     "Message " + descriptor.getFullName() + " has no field named " + name);
  181.         }
  182.         fields.add(field);
  183.         return fields;
  184.     }

  186.     /**
  187.      * Append field to the given path.
  188.      *
  189.      * @param fields Fields to make key path of.
  190.      * @return The new appended key path.
  191.      */
  192.     public static String fieldPath(List<Descriptors.FieldDescriptor> fields) {
  193.         requireNonNull(fields, "fields == null");
  194.         if (fields.isEmpty()) {
  195.             throw new IllegalArgumentException("No field arguments");
  196.         }
  197.         return fields.stream().map(Descriptors.FieldDescriptor::getName).collect(Collectors.joining("."));
  198.     }

  200.     /**
  201.      * Append field to the given path.
  202.      *
  203.      * @param path  The path to be appended to.
  204.      * @param field The field who's name should be appended.
  205.      * @return The new appended key path.
  206.      */
  207.     public static String fieldPathAppend(
  208.             String path,
  209.             Descriptors.FieldDescriptor field) {
  210.         if (path == null || path.isEmpty()) {
  211.             return field.getName();
  212.         }
  213.         return path + "." + field.getName();
  214.     }

  216.     /**
  217.      * Filter a set of field descriptor paths to only contain the continuations
  218.      * of paths starting with the given field.
  219.      *
  220.      * @param fieldDesc   The set of field descriptor paths.
  221.      * @param fieldsUnder The field to get paths under.
  222.      * @return The filtered set of field paths.
  223.      */
  224.     public static Set<String> filterFields(Set<String> fieldDesc, Descriptors.FieldDescriptor fieldsUnder) {
  225.         // extensions are not covered by this, so an extension will have no
  226.         // fields undet it.
  227.         if (fieldsUnder.isExtension()) {
  228.             return Set.of();
  229.         }
  230.         SetBuilder<String> out = UnmodifiableSet.newBuilder();
  231.         var subPathPrefix = fieldsUnder.getName() + ".";
  232.         for (var fd : fieldDesc) {
  233.             if (fd.startsWith(subPathPrefix)) {
  234.                 out.add(fd.substring(subPathPrefix.length()));
  235.             }
  236.         }
  237.         return out.build();
  238.     }
  239. }
Created with JaCoCo 0.8.8.202204050719