@SuppressWarnings("unchecked") @Override public IN apply(byte[] bytes) { try { Message msg = messages.get(type); if(null == msg) { msg = (Message)type.getMethod("getDefaultInstance").invoke(null); messages.put(type, msg); } IN obj = (IN)msg.newBuilderForType().mergeFrom(bytes).build(); if(null != next) { next.accept(obj); return null; } else { return obj; } } catch(Exception e) { throw new IllegalStateException(e.getMessage(), e); } } };
private static void eagerlyMergeMessageSetExtension( CodedInputStream input, ExtensionRegistry.ExtensionInfo extension, ExtensionRegistryLite extensionRegistry, Message.Builder builder, FieldSet<FieldDescriptor> extensions) throws IOException { FieldDescriptor field = extension.descriptor; Message value = null; if (hasOriginalMessage(builder, extensions, field)) { Message originalMessage = getOriginalMessage(builder, extensions, field); Message.Builder subBuilder = originalMessage.toBuilder(); input.readMessage(subBuilder, extensionRegistry); value = subBuilder.buildPartial(); } else { value = input.readMessage(extension.defaultInstance.getParserForType(), extensionRegistry); } if (builder != null) { builder.setField(field, value); } else { extensions.setField(field, value); } }
@SuppressWarnings("unchecked") @Override public Mono<Void> write(Publisher<? extends Message> inputStream, ResolvableType elementType, @Nullable MediaType mediaType, ReactiveHttpOutputMessage message, Map<String, Object> hints) { try { Message.Builder builder = getMessageBuilder(elementType.toClass()); Descriptors.Descriptor descriptor = builder.getDescriptorForType(); message.getHeaders().add(X_PROTOBUF_SCHEMA_HEADER, descriptor.getFile().getName()); message.getHeaders().add(X_PROTOBUF_MESSAGE_HEADER, descriptor.getFullName()); if (inputStream instanceof Flux) { if (mediaType == null) { message.getHeaders().setContentType(((HttpMessageEncoder<?>)getEncoder()).getStreamingMediaTypes().get(0)); } else if (!ProtobufEncoder.DELIMITED_VALUE.equals(mediaType.getParameters().get(ProtobufEncoder.DELIMITED_KEY))) { Map<String, String> parameters = new HashMap<>(mediaType.getParameters()); parameters.put(ProtobufEncoder.DELIMITED_KEY, ProtobufEncoder.DELIMITED_VALUE); message.getHeaders().setContentType(new MediaType(mediaType.getType(), mediaType.getSubtype(), parameters)); } } return super.write(inputStream, elementType, mediaType, message, hints); } catch (Exception ex) { return Mono.error(new DecodingException("Could not read Protobuf message: " + ex.getMessage(), ex)); } }
public BuilderType mergeFrom(final Message other) { if (other.getDescriptorForType() != getDescriptorForType()) { throw new IllegalArgumentException( "mergeFrom(Message) can only merge messages of the same type."); other.getAllFields().entrySet()) { final FieldDescriptor field = entry.getKey(); if (field.isRepeated()) { for (final Object element : (List)entry.getValue()) { addRepeatedField(field, element); } else if (field.getJavaType() == FieldDescriptor.JavaType.MESSAGE) { final Message existingValue = (Message)getField(field); if (existingValue == existingValue.getDefaultInstanceForType()) { setField(field, entry.getValue()); } else { setField(field, existingValue.newBuilderForType() .mergeFrom(existingValue) .mergeFrom((Message)entry.getValue()) .build());
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()) { 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("]}");
public static Message getResponse( org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.CoprocessorServiceResponse result, com.google.protobuf.Message responsePrototype) throws IOException { Message response; if (result.getValue().hasValue()) { Message.Builder builder = responsePrototype.newBuilderForType(); builder.mergeFrom(result.getValue().getValue().newInput()); response = builder.build(); } else { response = responsePrototype.getDefaultInstanceForType(); } if (LOG.isTraceEnabled()) { LOG.trace("Master Result is value=" + response); } return response; }
@Override public KeyValue next() throws IOException { Builder messageBuilder = (Builder) reader.read(); if (messageBuilder != null) { return new KeyValue(offset++, messageBuilder.build().toByteArray()); } return null; }
/** * Merges all fields specified by this FieldMaskTree from {@code source} to {@code destination}. */ void merge(Message source, Message.Builder destination, FieldMaskUtil.MergeOptions options) { if (source.getDescriptorForType() != destination.getDescriptorForType()) { throw new IllegalArgumentException("Cannot merge messages of different types."); } if (root.children.isEmpty()) { return; } merge(root, "", source, destination, options); }
if (methodDescriptor.getOutputDescriptor().getName().equals("VoidResponse")) { builder.setField(errorMessageField, "OKE"); builder.setField(valueField, valueField.getEnumType().findValueByName(result.toString())); builder.setField(valueField, ((Date)result).getTime()); builder.setField(valueField, new ArrayList()); } else { builder.setField(valueField, result); builder.setField(valueField, list); } else if (result instanceof Set) { List list = new ArrayList(); builder.setField(valueField, list); } else { builder.setField(valueField, convertSObjectToProtocolBuffersObject((SBase) result, sMethod.getBestReturnType())); builder.setField(errorMessageField, "OKE"); return builder.build(); errorMessage.setField(errorMessageField, e.getMessage()); } else { LOGGER.error("", e); errorMessage.setField(errorMessageField, "Unknown error"); return errorMessage.build();
private Message coerceType(Message value) { if (value == null) { return null; } if (mapEntryMessageDefaultInstance.getClass().isInstance(value)) { return value; } // The value is not the exact right message type. However, if it // is an alternative implementation of the same type -- e.g. a // DynamicMessage -- we should accept it. In this case we can make // a copy of the message. return mapEntryMessageDefaultInstance.toBuilder().mergeFrom(value).build(); }
@Override public Mono<Message> decodeToMono(Publisher<DataBuffer> inputStream, ResolvableType elementType, @Nullable MimeType mimeType, @Nullable Map<String, Object> hints) { return DataBufferUtils.join(inputStream).map(dataBuffer -> { try { Message.Builder builder = getMessageBuilder(elementType.toClass()); ByteBuffer buffer = dataBuffer.asByteBuffer(); builder.mergeFrom(CodedInputStream.newInstance(buffer), this.extensionRegistry); return builder.build(); } catch (IOException ex) { throw new DecodingException("I/O error while parsing input stream", ex); } catch (Exception ex) { throw new DecodingException("Could not read Protobuf message: " + ex.getMessage(), ex); } finally { DataBufferUtils.release(dataBuffer); } } ); }
@Override protected Message readInternal(Class<? extends Message> clazz, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException { MediaType contentType = inputMessage.getHeaders().getContentType(); if (contentType == null) { contentType = PROTOBUF; } Charset charset = contentType.getCharset(); if (charset == null) { charset = DEFAULT_CHARSET; } Message.Builder builder = getMessageBuilder(clazz); if (PROTOBUF.isCompatibleWith(contentType)) { builder.mergeFrom(inputMessage.getBody(), this.extensionRegistry); } else if (TEXT_PLAIN.isCompatibleWith(contentType)) { InputStreamReader reader = new InputStreamReader(inputMessage.getBody(), charset); TextFormat.merge(reader, this.extensionRegistry, builder); } else if (this.protobufFormatSupport != null) { this.protobufFormatSupport.merge( inputMessage.getBody(), charset, contentType, this.extensionRegistry, builder); } return builder.build(); }
public static <T extends Message.Builder> T readToBuilder(DataInputStream input, T builder) throws IOException { int size = input.readInt(); CodedInputStream codedIn = CodedInputStream.newInstance(input); codedIn.pushLimit(size); builder.mergeFrom(codedIn); return builder; } }
/** helper method to handle {@code builder} and {@code extensions}. */ private static void setField( Message.Builder builder, FieldSet<FieldDescriptor> extensions, FieldDescriptor field, Object value) { if (builder != null) { builder.setField(field, value); } else { extensions.setField(field, value); } }
/** helper method to handle {@code builder} and {@code extensions}. */ private static void addRepeatedField( Message.Builder builder, FieldSet<FieldDescriptor> extensions, FieldDescriptor field, Object value) { if (builder != null) { builder.addRepeatedField(field, value); } else { extensions.addRepeatedField(field, value); } }
/** * This version of protobuf's mergeFrom avoids the hard-coded 64MB limit for decoding * buffers when working with byte arrays * @param builder current message builder * @param b byte array * @throws IOException */ public static void mergeFrom(Message.Builder builder, byte[] b) throws IOException { final CodedInputStream codedInput = CodedInputStream.newInstance(b); codedInput.setSizeLimit(b.length); builder.mergeFrom(codedInput); codedInput.checkLastTagWas(0); }
/** helper method to handle {@code builder} and {@code extensions}. */ private static void mergeOriginalMessage( Message.Builder builder, FieldSet<FieldDescriptor> extensions, FieldDescriptor field, Message.Builder subBuilder) { Message originalMessage = getOriginalMessage(builder, extensions, field); if (originalMessage != null) { subBuilder.mergeFrom(originalMessage); } }
private Object coerceType(final Object value) { if (type.isInstance(value)) { return value; } else { // The value is not the exact right message type. However, if it // is an alternative implementation of the same type -- e.g. a // DynamicMessage -- we should accept it. In this case we can make // a copy of the message. return ((Message.Builder) invokeOrDie(newBuilderMethod, null)) .mergeFrom((Message) value).build(); } }
private Object coerceType(final Object value) { if (type.isInstance(value)) { return value; } else { // The value is not the exact right message type. However, if it // is an alternative implementation of the same type -- e.g. a // DynamicMessage -- we should accept it. In this case we can make // a copy of the message. return ((Message.Builder) invokeOrDie(newBuilderMethod, null)) .mergeFrom((Message) value).build(); } }
@Override public MergeTarget addRepeatedField(Descriptors.FieldDescriptor field, Object value) { builder.addRepeatedField(field, value); return this; }