@Override public Optional<MediaTypeCodec> findCodec(MediaType mediaType) { return decoderRegistry.findCodec(mediaType); }
@Override public Optional<MediaTypeCodec> findCodec(MediaType mediaType, Class<?> type) { return decoderRegistry.findCodec(mediaType, type); }
@Override public Optional<MediaTypeCodec> findCodec(MediaType mediaType) { if (localFunctionRegistry instanceof MediaTypeCodecRegistry) { return ((MediaTypeCodecRegistry) localFunctionRegistry).findCodec(mediaType); } return Optional.empty(); }
@Override public Optional<MediaTypeCodec> findCodec(MediaType mediaType, Class<?> type) { if (localFunctionRegistry instanceof MediaTypeCodecRegistry) { return ((MediaTypeCodecRegistry) localFunctionRegistry).findCodec(mediaType, type); } return Optional.empty(); }
return Optional.of(content.toString(charset)); } else { Optional<MediaTypeCodec> foundCodec = mediaTypeCodecRegistry.findCodec(contentType.get()); if (foundCodec.isPresent()) { MediaTypeCodec codec = foundCodec.get();
@Override public <I, B> Flowable<Event<B>> eventStream(io.micronaut.http.HttpRequest<I> request, Argument<B> eventType) { return eventStream(request).map(byteBufferEvent -> { ByteBuffer<?> data = byteBufferEvent.getData(); Optional<MediaTypeCodec> registeredCodec; if (mediaTypeCodecRegistry != null) { registeredCodec = mediaTypeCodecRegistry.findCodec(MediaType.APPLICATION_JSON_TYPE); } else { registeredCodec = Optional.empty(); } if (registeredCodec.isPresent()) { B decoded = registeredCodec.get().decode(eventType, data); return Event.of(byteBufferEvent, decoded); } else { throw new CodecException("JSON codec not present"); } }); }
writable.writeTo(output, environment.getProperty(LocalFunctionRegistry.FUNCTION_CHARSET, Charset.class, StandardCharsets.UTF_8)); } else { Optional<MediaTypeCodec> codec = registry instanceof MediaTypeCodecRegistry ? ((MediaTypeCodecRegistry) registry).findCodec(MediaType.APPLICATION_JSON_TYPE) : Optional.empty();
Optional<MediaTypeCodec> registeredCodec = mediaTypeCodecRegistry.findCodec(responseMediaType, body.getClass()); if (registeredCodec.isPresent()) { MediaTypeCodec codec = registeredCodec.get(); Optional<MediaTypeCodec> registeredCodec = mediaTypeCodecRegistry.findCodec(MediaType.APPLICATION_JSON_TYPE, body.getClass()); if (registeredCodec.isPresent()) { MediaTypeCodec codec = registeredCodec.get();
Optional<MediaTypeCodec> registeredCodec = mediaTypeCodecRegistry.findCodec(responseMediaType, body.getClass()); if (registeredCodec.isPresent()) { MediaTypeCodec codec = registeredCodec.get(); Optional<MediaTypeCodec> registeredCodec = mediaTypeCodecRegistry.findCodec(defaultResponseMediaType, body.getClass()); if (registeredCodec.isPresent()) { MediaTypeCodec codec = registeredCodec.get();
@Override public Optional<Object> convert(FileUpload object, Class<Object> targetType, ConversionContext context) { try { if (!object.isCompleted()) { return Optional.empty(); } String contentType = object.getContentType(); ByteBuf byteBuf = object.getByteBuf(); if (StringUtils.isNotEmpty(contentType)) { MediaType mediaType = new MediaType(contentType); Optional<MediaTypeCodec> registered = decoderRegistryProvider.get().findCodec(mediaType); if (registered.isPresent()) { MediaTypeCodec decoder = registered.get(); Object val = decoder.decode(targetType, new ByteBufInputStream(byteBuf)); return Optional.of(val); } else { return conversionService.convert(byteBuf, targetType, context); } } return conversionService.convert(byteBuf, targetType, context); } catch (Exception e) { context.reject(e); return Optional.empty(); } } }
private Object decodeInputArgument( ConversionService<?> conversionService, LocalFunctionRegistry localFunctionRegistry, Argument<?> arg, InputStream input) { Class<?> argType = arg.getType(); ClassLoadingReporter.reportBeanPresent(argType); if (ClassUtils.isJavaLangType(argType)) { Object converted = doConvertInput(conversionService, arg, input); if (converted != null) { return converted; } } else if (argType.isInstance(input)) { return input; } else { if (localFunctionRegistry instanceof MediaTypeCodecRegistry) { Optional<MediaTypeCodec> registeredDecoder = ((MediaTypeCodecRegistry) localFunctionRegistry).findCodec(MediaType.APPLICATION_JSON_TYPE); if (registeredDecoder.isPresent()) { MediaTypeCodec decoder = registeredDecoder.get(); return decoder.decode(arg, input); } } } throw new CodecException("Unable to decode argument from stream: " + arg); }
/** * Encode the given message with the given media type. * @param message The message * @param mediaType The media type * @return The encoded frame */ public WebSocketFrame encodeMessage(Object message, MediaType mediaType) { if (message instanceof byte[]) { return new BinaryWebSocketFrame(Unpooled.wrappedBuffer((byte[]) message)); } else if (ClassUtils.isJavaLangType(message.getClass())) { String s = message.toString(); return new TextWebSocketFrame(s); } else if (message instanceof ByteBuf) { return new BinaryWebSocketFrame((ByteBuf) message); } else if (message instanceof ByteBuffer) { return new BinaryWebSocketFrame(Unpooled.wrappedBuffer((ByteBuffer) message)); } else { Optional<MediaTypeCodec> codec = codecRegistry.findCodec(mediaType != null ? mediaType : MediaType.APPLICATION_JSON_TYPE); if (codec.isPresent()) { io.micronaut.core.io.buffer.ByteBuffer encoded = codec.get().encode(message, new NettyByteBufferFactory(UnpooledByteBufAllocator.DEFAULT)); return new TextWebSocketFrame((ByteBuf) encoded.asNativeBuffer()); } } throw new WebSocketSessionException("Unable to encode WebSocket message: " + message); } }
/** * Get. * * @param type type * @param <T> generic return type * @return Type */ public final <T> T get(Class<T> type) { if (ClassUtils.isJavaLangType(type)) { return applicationContext .getConversionService() .convert(data, type).orElseThrow(() -> newIllegalArgument(type, data)); } else { MediaTypeCodecRegistry codecRegistry = applicationContext.getBean(MediaTypeCodecRegistry.class); return codecRegistry.findCodec(MediaType.APPLICATION_JSON_TYPE) .map(codec -> { if (data != null) { return codec.decode(type, data); } else { // try System.in return codec.decode(type, System.in); } }) .orElseThrow(() -> newIllegalArgument(type, data)); } }
JsonMediaTypeCodec mediaTypeCodec = (JsonMediaTypeCodec) mediaTypeCodecRegistry.findCodec(MediaType.APPLICATION_JSON_TYPE) .orElseThrow(() -> new IllegalStateException("No JSON codec found"));
Optional<MediaTypeCodec> existingCodec = defaultClient.getMediaTypeCodecRegistry().findCodec(MediaType.APPLICATION_JSON_TYPE); ObjectMapper objectMapper = null; if (existingCodec.isPresent()) {
Optional<MediaTypeCodec> registeredCodec = mediaTypeCodecRegistry.findCodec(requestContentType); ByteBuf encoded = registeredCodec.map(codec -> (ByteBuf) codec.encode(o, byteBufferFactory).asNativeBuffer()) .orElse(null); bodyContent = charSequenceToByteBuf((CharSequence) bodyValue, requestContentType); } else if (mediaTypeCodecRegistry != null) { Optional<MediaTypeCodec> registeredCodec = mediaTypeCodecRegistry.findCodec(requestContentType); bodyContent = registeredCodec.map(codec -> (ByteBuf) codec.encode(bodyValue, byteBufferFactory).asNativeBuffer()) .orElse(null);
MediaType mediaType = messageHandler.getValue(Consumes.class, MediaType.class).orElse(MediaType.APPLICATION_JSON_TYPE); try { converted = mediaTypeCodecRegistry.findCodec(mediaType).map(codec -> codec.decode(bodyArgument, new NettyByteBufferFactory(ctx.alloc()).wrap(msg.content()))); } catch (CodecException e) { if (LOG.isErrorEnabled()) {
body = allocator.copiedBuffer(data.toString().getBytes(defaultCharset)); } else { MediaTypeCodec jsonCodec = resolveMediaTypeCodecRegistry().findCodec(MediaType.APPLICATION_JSON_TYPE) .orElseThrow(() -> new CodecException("No possible JSON encoders found!")); body = jsonCodec.encode(data, allocator);
@Override public <I, B> Flowable<Event<B>> eventStream(io.micronaut.http.HttpRequest<I> request, Argument<B> eventType) { return eventStream(request).map(byteBufferEvent -> { ByteBuffer<?> data = byteBufferEvent.getData(); Optional<MediaTypeCodec> registeredCodec; if (mediaTypeCodecRegistry != null) { registeredCodec = mediaTypeCodecRegistry.findCodec(MediaType.APPLICATION_JSON_TYPE); } else { registeredCodec = Optional.empty(); } if (registeredCodec.isPresent()) { B decoded = registeredCodec.get().decode(eventType, data); return Event.of(byteBufferEvent, decoded); } else { throw new CodecException("JSON codec not present"); } }); }
@Override public <I, B> Flowable<Event<B>> eventStream(io.micronaut.http.HttpRequest<I> request, Argument<B> eventType) { return eventStream(request).map(byteBufferEvent -> { ByteBuffer<?> data = byteBufferEvent.getData(); Optional<MediaTypeCodec> registeredCodec; if (mediaTypeCodecRegistry != null) { registeredCodec = mediaTypeCodecRegistry.findCodec(MediaType.APPLICATION_JSON_TYPE); } else { registeredCodec = Optional.empty(); } if (registeredCodec.isPresent()) { B decoded = registeredCodec.get().decode(eventType, data); return Event.of(byteBufferEvent, decoded); } else { throw new CodecException("JSON codec not present"); } }); }