Java Code Examples for com.google.protobuf.Message#getDescriptorForType()

@Nonnull
@Override
public <M extends Message> List<Key.Evaluated> evaluateFunction(@Nullable FDBRecord<M> record,
                                                                @Nullable Message message,
                                                                @Nonnull Key.Evaluated arguments) {
    if (message == null) {
        return Collections.emptyList();
    }
    List<Key.Evaluated> keys = new ArrayList<>();
    Descriptors.Descriptor descriptor = message.getDescriptorForType();
    Descriptors.FieldDescriptor strField = descriptor.findFieldByNumber(TypesRecord.STR_VALUE_FIELD_NUMBER);
    Descriptors.FieldDescriptor strListField = descriptor.findFieldByNumber(TypesRecord.STR_LIST_VALUE_FIELD_NUMBER);
    if (message.hasField(strField)) {
        keys.add(toKey((String) message.getField(strField)));
    }
    final int len = message.getRepeatedFieldCount(strListField);
    for (int i = 0; i < len; i++) {
        keys.add(toKey((String) message.getRepeatedField(strListField, i)));
    }
    return keys;
}
 

/**
 * Returns the singular descriptor used by all non-null messages in the list.
 *
 * <p>If there is no descriptor, or more than one, returns {@code Optional.absent()}.
 */
static Optional<Descriptor> getSingleDescriptor(Iterable<? extends Message> messages) {
  Optional<Descriptor> optDescriptor = Optional.absent();
  for (Message message : messages) {
    if (message != null) {
      Descriptor descriptor = message.getDescriptorForType();
      if (!optDescriptor.isPresent()) {
        optDescriptor = Optional.of(descriptor);
      } else if (descriptor != optDescriptor.get()) {
        // Two different descriptors - abandon ship.
        return Optional.absent();
      }
    }
  }
  return optDescriptor;
}
 

@Test
public void exampleUsage() {
  Message originalMessage = SimpleMessage.newBuilder().setName("bob").build();
  DynamicMessage message = dynamic(originalMessage);

  TemplateEvaluator evaluator =
      new TemplateEvaluator(
          originalMessage.getDescriptorForType(),
          fragments(staticFragment("foo.bar/"), dynamicFragment("$.name")));

  assertThat(evaluator.evaluate(message), is("foo.bar/bob"));
}
 

@Test
public void exampleUsage() {
  Message originalMessage = SimpleMessage.newBuilder().setName("bob").build();
  DynamicMessage message = dynamic(originalMessage);

  TemplateEvaluator evaluator =
      new TemplateEvaluator(
          originalMessage.getDescriptorForType(),
          fragments(staticFragment("foo.bar/"), dynamicFragment("$.name")));

  assertThat(evaluator.evaluate(message), is("foo.bar/bob"));
}
 

/**
 * Returns the {@link TypeSpecificMarshaller} that can marshall protobufs with the same type as
 * {@code prototype}.
 */
TypeSpecificMarshaller<?> findForPrototype(Message prototype) {
  TypeSpecificMarshaller<?> marshaller = descriptorRegistry.get(prototype.getDescriptorForType());
  if (marshaller == null) {
    throw new IllegalArgumentException(
        "Could not find marshaller for type: "
            + prototype.getDescriptorForType()
            + ". Has it been registered?");
  }
  return marshaller;
}
 

DoWrite(
    Message prototype,
    boolean includeDefaults,
    boolean printingEnumsAsInts,
    boolean sortingMapKeys) {
  this.prototype = prototype;
  this.messageClass = prototype.getClass();
  this.descriptor = prototype.getDescriptorForType();
  this.includeDefaults = includeDefaults;
  this.printingEnumsAsInts = printingEnumsAsInts;
  this.sortingMapKeys = sortingMapKeys;
}
 

private static boolean notMessagesWithSameDescriptor(
    @NullableDecl Message actual, @NullableDecl Object expected) {
  if (actual != null && expected instanceof Message) {
    return actual.getDescriptorForType() != ((Message) expected).getDescriptorForType();
  }
  return true;
}
 

@Override
Object convertFromProtoValue(Object object) {
  Message timestamp = (Message) object;
  Descriptors.Descriptor timestampDescriptor = timestamp.getDescriptorForType();
  FieldDescriptor secondField = timestampDescriptor.findFieldByNumber(1);
  FieldDescriptor nanoField = timestampDescriptor.findFieldByNumber(2);
  long second = (long) timestamp.getField(secondField);
  int nano = (int) timestamp.getField(nanoField);
  return Instant.ofEpochSecond(second, nano);
}
 

@Override
Duration convertFromProtoValue(Object object) {
  Message timestamp = (Message) object;
  Descriptors.Descriptor timestampDescriptor = timestamp.getDescriptorForType();
  FieldDescriptor secondField = timestampDescriptor.findFieldByNumber(1);
  FieldDescriptor nanoField = timestampDescriptor.findFieldByNumber(2);
  long second = (long) timestamp.getField(secondField);
  int nano = (int) timestamp.getField(nanoField);
  return Duration.ofSeconds(second, nano);
}
 

@Nonnull
@Override
@SuppressWarnings("unchecked")
public <M extends Message> List<Key.Evaluated> evaluateMessage(@Nullable FDBRecord<M> record, @Nullable Message message) {
    if (message == null) {
        return getNullResult();
    }
    Descriptors.Descriptor recordDescriptor = message.getDescriptorForType();
    Descriptors.FieldDescriptor fieldDescriptor = recordDescriptor.findFieldByName(fieldName);
    // TODO: Part of this is working around a deficiency in DynamicMessage.getField() prior
    //  to 2.5, where a repeated message field returns an empty message instead of an
    //  empty collection.
    if (fieldDescriptor != null && fieldDescriptor.isRepeated()) {
        List<Object> values;
        if (message.getRepeatedFieldCount(fieldDescriptor) > 0) {
            values = (List<Object>)message.getField(fieldDescriptor);
        } else {
            values = Collections.emptyList();
        }

        switch (fanType) {
            case FanOut:
                return Key.Evaluated.fan(values);
            case Concatenate:
                return Collections.singletonList(Key.Evaluated.scalar(values));
            case None:
                throw new RecordCoreException("FanType.None with repeated field");
            default:
                throw new RecordCoreException(String.format("unknown fan type: %s", fanType));
        }
    } else if (fieldDescriptor != null && (nullStandin == Key.Evaluated.NullStandin.NOT_NULL || message.hasField(fieldDescriptor))) {
        Object value = message.getField(fieldDescriptor);
        if (fieldDescriptor.getJavaType() == Descriptors.FieldDescriptor.JavaType.MESSAGE &&
                TupleFieldsHelper.isTupleField(fieldDescriptor.getMessageType())) {
            value = TupleFieldsHelper.fromProto((Message)value, fieldDescriptor.getMessageType());
        }
        // ignore FanType
        return Collections.singletonList(Key.Evaluated.scalar(value));
    } else {
        return getNullResult();
    }
}
 

private static void compare(
    FieldMask.Builder mask, String currentField, Message original, Message modified) {
  Descriptor descriptor = original.getDescriptorForType();
  for (FieldDescriptor field : descriptor.getFields()) {
    String fieldName = getFieldName(currentField, field);
    Object originalValue = original.getField(field);
    Object modifiedValue = modified.getField(field);
    if (field.isRepeated()) {
      if (!Objects.equals(originalValue, modifiedValue)) {
        mask.addPaths(fieldName);
      }
    } else {
      switch (field.getJavaType()) {
        case MESSAGE:
          // Because getField never returns null, we use hasField to distinguish null
          // from empty message when getType() == MESSAGE
          if (original.hasField(field) != modified.hasField(field)
              || !Objects.equals(originalValue, modifiedValue)) {
            if (isWrapperType(field.getMessageType())) {
              // For wrapper types, just emit the field name.
              mask.addPaths(fieldName);
            } else if (!modified.hasField(field)) {
              // Just emit the deleted field name
              mask.addPaths(fieldName);
            } else {
              // Recursively compare to find different values
              compare(mask, fieldName, (Message) originalValue, (Message) modifiedValue);
            }
          }
          break;
        case INT:
        case LONG:
        case FLOAT:
        case DOUBLE:
        case BOOLEAN:
        case STRING:
        case BYTE_STRING:
        case ENUM:
          // Handle all java types except MESSAGE
          if (!Objects.equals(originalValue, modifiedValue)) {
            mask.addPaths(fieldName);
          }
          break;
        default:
          throw new IllegalArgumentException(
              "Unexpected java type "
                  + field.getJavaType()
                  + " encountered for field "
                  + fieldName);
      }
    }
  }
}
 

protected String getProtobufClassFieldDescriptions(Class<? extends Message> messageClass, Set<Class<? extends Message>> visited)
        throws Exception {

    if (visited.contains(messageClass)) {
        return "";
    }
    visited.add(messageClass);

    StringBuilder sb = new StringBuilder();
    Constructor<?> constructor = null;
    try {
        constructor = messageClass.getDeclaredConstructor();
    } catch (NoSuchMethodException nsmex) {
        //Issue #35
        logger.info("Unsupported protobuf field: {}", messageClass.getName());
        return sb.toString();
    }
    constructor.setAccessible(true);
    Object instance = constructor.newInstance();
    Message.Builder builder = ((Message)instance).newBuilderForType();
    Message message = builder.build();

    Descriptors.Descriptor requestDesc = message.getDescriptorForType();
    List<Descriptors.FieldDescriptor> requestFields = requestDesc.getFields();
    Iterator<Descriptors.FieldDescriptor> iter = requestFields.iterator();
    while (iter.hasNext()) {
        Descriptors.FieldDescriptor fd = iter.next();
        //TODO: deal with repeated fields
        sb.append("{\"name\":\"");
        sb.append(fd.getName());
        sb.append("\",\"type\":\"");
        if (fd.getType().toString().equalsIgnoreCase("message")) {
            sb.append(getLastComponent(fd.getMessageType().getFullName()));
            sb.append("\",\"values\":[");
            Descriptors.FieldDescriptor childDescriptor = requestDesc.findFieldByName(fd.getName());
            Message.Builder subMessageBuilder = builder.newBuilderForField(childDescriptor);
            Message subMessage = subMessageBuilder.build();
            sb.append(getProtobufClassFieldDescriptions(subMessage.getClass(), visited));
            sb.append("]}");
        } else {
            sb.append(fd.getType().toString().toLowerCase());
            sb.append("\",\"values\":null}");
        }
        if (iter.hasNext()) {
            sb.append(",");
        }
    }
    return sb.toString();
}
 

DoParse(Message prototype, boolean ignoringUnknownFields) {
  this.prototype = prototype;
  builderClass = prototype.newBuilderForType().getClass();
  descriptor = prototype.getDescriptorForType();
  this.ignoringUnknownFields = ignoringUnknownFields;
}
 

RootPartialScopeLogic(Message message) {
  super(FieldNumberTree.fromMessage(message));
  this.message = message;
  this.expectedDescriptor = message.getDescriptorForType();
}