/**
 * Deserialize the given byte string to an object using the given reader, employing the given codec algorithm.
 *
 * @param reader     object reader
 * @param byteString byte string to deserialize
 * @param codec      codec
 * @param logger     logger
 * @param <T>        object type of the deserialized object
 * @return deserialized object
 * @throws IOException in case of deserialization errors
 */
public static <T> T readValue(ObjectReader reader, ByteString byteString, Codec codec, Logger logger)
    throws IOException {

  if (logger.isTraceEnabled()) {
    // Costly conversion to UTF-8. Avoid if possible
    ByteSource bs = new ByteSource() {
      @Override
      public InputStream openStream() throws IOException {
        return codec.decompress(byteString.newInput());
      }};
    final String value = bs.asCharSource(StandardCharsets.UTF_8).read();
    logger.trace("Attempting to read {}", value);

    // Could reuse the value but to avoid so that logger level doesn't impact the program flow
    // Since level is trace, user probably doesn't care for performance right now
    // return reader.readValue(value);
  }

  try (InputStream is = codec.decompress(byteString.newInput())) {
    return reader.readValue(is);
  }
}
 

@Test
public void testStrictDeserializeFromEmptyString() throws Exception {

    final String key = "zoneOffset";
    final ObjectMapper mapper = mapperBuilder()
            .withCoercionConfig(LogicalType.DateTime,
                    cfg -> cfg.setCoercion(CoercionInputShape.EmptyString, CoercionAction.Fail))
            .build();
    final ObjectReader objectReader = mapper.readerFor(MAP_TYPE_REF);

    String valueFromNullStr = mapper.writeValueAsString(asMap(key, null));
    Map<String, ZoneOffset> actualMapFromNullStr = objectReader.readValue(valueFromNullStr);
    assertNull(actualMapFromNullStr.get(key));

    String valueFromEmptyStr = mapper.writeValueAsString(asMap(key, ""));
    try {
        objectReader.readValue(valueFromEmptyStr);
        fail("Should not pass");
    } catch (MismatchedInputException e) {
        verifyException(e, "Cannot coerce empty String");
        verifyException(e, ZoneOffset.class.getName());
    }
}
 

@Override
public Artifact deserialize(JsonParser parser, DeserializationContext ctxt) 
  throws IOException, JsonProcessingException 
{
    JsonNode node = parser.readValueAsTree();
    ObjectMapper mapper = (ObjectMapper)parser.getCodec();
    ObjectReader reader = null; 
    Object target = null;
    String artifcatType = node.get("artifactType").asText();

    System.out.println(artifcatType);

    if(artifcatType.equalsIgnoreCase("reservedinstance"))
    {
        reader = mapper.readerFor(ReservedInstanceArtifact.class);
    }
    else 
    {
        reader = mapper.readerFor(Artifact.class);
    }

    target = reader.readValue(node);

    return (Artifact)target;
}
 

/**
 * Converts an inputStream into an iterator of objects using Jackson CSV mapper.
 * @param inputStream inputStream in CSV format.
 * @return An iterator based on the inputStream.
 */
@Override
public Iterator<T> apply(InputStream inputStream) {
    try {
        CsvSchema csvSchema = mapper.schemaFor(objectClass);

        if (columnSeparator != null) {
            csvSchema = csvSchema.withColumnSeparator(columnSeparator);
        }
        
        ObjectReader reader = mapper.readerFor(objectClass).withFeatures(CsvParser.Feature.FAIL_ON_MISSING_COLUMNS)
                .with(csvSchema);

        return reader.readValues(inputStream);
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}
 

@Test
public void deserializesResponseUsinGivenReader() throws IOException {

    // given
    ObjectReader mockedObjectReader = mock(ObjectReader.class);
    BlockingResponseHandler<Response> handler = new BlockingResponseHandler<>(
            mockedObjectReader, ex -> null);

    InputStream inputStream = mock(InputStream.class);

    // when
    handler.deserializeResponse(inputStream);

    // then
    verify(mockedObjectReader).readValue(any(InputStream.class));

}
 

@Test
public void testLenientDeserializeFromEmptyString() throws Exception {

    String key = "zoneId";
    ObjectMapper mapper = newMapper();
    ObjectReader objectReader = mapper.readerFor(MAP_TYPE_REF);

    String valueFromNullStr = mapper.writeValueAsString(asMap(key, null));
    Map<String, ZoneId> actualMapFromNullStr = objectReader.readValue(valueFromNullStr);
    ZoneId actualDateFromNullStr = actualMapFromNullStr.get(key);
    assertNull(actualDateFromNullStr);

    String valueFromEmptyStr = mapper.writeValueAsString(asMap(key, ""));
    Map<String, ZoneId> actualMapFromEmptyStr = objectReader.readValue(valueFromEmptyStr);
    ZoneId actualDateFromEmptyStr = actualMapFromEmptyStr.get(key);
    assertEquals("empty string failed to deserialize to null with lenient setting", null, actualDateFromEmptyStr);
}
 

/**
 * 获取Reader
 * @author Frodez
 * @date 2019-05-24
 */
@SneakyThrows
public static ObjectReader reader(Class<?> parametrized, @Nullable Class<?>... genericClasses) {
	Assert.notNull(parametrized, "parametrized must not be null");
	if (EmptyUtil.yes(genericClasses)) {
		return singleClassReaderCache.computeIfAbsent(parametrized, (k) -> OBJECT_MAPPER.readerFor(OBJECT_MAPPER.getTypeFactory().constructType(
			parametrized)));
	} else {
		StringBuilder builder = new StringBuilder(parametrized.getName());
		for (Class<?> klass : genericClasses) {
			builder.append(klass.getName());
		}
		return multiClassReaderCache.computeIfAbsent(builder.toString(), (i) -> OBJECT_MAPPER.readerFor(OBJECT_MAPPER.getTypeFactory()
			.constructParametricType(parametrized, genericClasses)));
	}
}
 

public void chooseInvoker(FunqyConfig config) {
    // this is done at Runtime so that we can change it with an environment variable.
    if (config.export.isPresent()) {
        invoker = FunctionRecorder.registry.matchInvoker(config.export.get());
        if (invoker == null) {
            throw new RuntimeException("quarkus.funqy.export does not match a function: " + config.export.get());
        }
    } else if (FunctionRecorder.registry.invokers().size() == 0) {
        throw new RuntimeException("There are no functions to process lambda");

    } else if (FunctionRecorder.registry.invokers().size() > 1) {
        throw new RuntimeException("Too many functions.  You need to set quarkus.funqy.export");
    } else {
        invoker = FunctionRecorder.registry.invokers().iterator().next();
    }
    if (invoker.hasInput()) {
        reader = (ObjectReader) invoker.getBindingContext().get(ObjectReader.class.getName());
    }
    if (invoker.hasOutput()) {
        writer = (ObjectWriter) invoker.getBindingContext().get(ObjectWriter.class.getName());
    }

}
 

protected static Set<String> getUuids(DeviceId deviceId, DriverHandler handler) {
    RestSBController controller = checkNotNull(handler.get(RestSBController.class));
    ObjectMapper om = new ObjectMapper();
    final ObjectReader reader = om.reader();
    InputStream response = controller.get(deviceId, CONN_REQ_GET_API, MediaType.APPLICATION_JSON_TYPE);
    JsonNode jsonNode;
    try {
        jsonNode = reader.readTree(response);
        if (jsonNode == null) {
            log.error("JsonNode is null for response {}", response);
            return ImmutableSet.of();
        }
        return parseTapiGetConnectivityRequest(jsonNode);
    } catch (IOException e) {
        log.error("Exception while reading response {}", response, e);
        return ImmutableSet.of();
    }
}
 

@Test( expected =  MismatchedInputException.class)
public void testStrictDeserializeFromEmptyString() throws Exception {

    final String key = "localTime";
    final ObjectMapper mapper = mapperBuilder()
            .withConfigOverride(LocalTime.class,
                    c -> c.setFormat(JsonFormat.Value.forLeniency(false)))
            .build();
    final ObjectReader objectReader = mapper.readerFor(MAP_TYPE_REF);

    String valueFromNullStr = mapper.writeValueAsString(asMap(key, null));
    Map<String, LocalTime> actualMapFromNullStr = objectReader.readValue(valueFromNullStr);
    assertNull(actualMapFromNullStr.get(key));

    String valueFromEmptyStr = mapper.writeValueAsString(asMap("date", ""));
    objectReader.readValue(valueFromEmptyStr);
}
 

@Test
@Parameters(method = "getSerializeAndDeserializePathData")
@TestCaseName("canSerializeAndDeserializePath({0}_{1})")
public void canSerializeAndDeserializePath(Path path, boolean typed) throws Exception {
  Obj obj = new Obj();
  obj.path = path;

  ObjectWriter writer = typed ? ObjectMappers.WRITER_WITH_TYPE : ObjectMappers.WRITER;
  ObjectReader reader = typed ? ObjectMappers.READER_WITH_TYPE : ObjectMappers.READER;

  String data = writer.writeValueAsString(obj);

  Obj actual = reader.forType(Obj.class).readValue(data);

  assertEquals(path, actual.path);
}
 

@Override
public T fromString(Type type, String value, Map<String, String> attributes) {
    requireNonNull(type, "type cannot be null");

    if (value == null) {
        return null;
    }

    try {
        JavaType javaType = TypeFactory.defaultInstance().constructType(type);
        ObjectReader objectReader = objectMapper.readerFor(javaType);
        return objectReader.readValue(value);
    } catch (IOException e) {
        // should never happen
        throw new IllegalStateException(e);
    }
}
 

@Test ( expected =  MismatchedInputException.class)
public void testStrictDeserializeFromEmptyString() throws Exception {

    final String key = "OffsetDateTime";
    final ObjectMapper mapper = mapperBuilder()
            .withConfigOverride(OffsetDateTime.class,
                    o -> o.setFormat(JsonFormat.Value.forLeniency(false)))
        .build();

    final ObjectReader objectReader = mapper.readerFor(MAP_TYPE_REF);

    String valueFromNullStr = mapper.writeValueAsString(asMap(key, null));
    Map<String, OffsetDateTime> actualMapFromNullStr = objectReader.readValue(valueFromNullStr);
    assertNull(actualMapFromNullStr.get(key));

    String valueFromEmptyStr = mapper.writeValueAsString(asMap(key, ""));
    objectReader.readValue(valueFromEmptyStr);
}
 

@Test
public void testReadValue() throws Exception {
    String json_str = "{\"name\" : \"Jackson\"}";
    byte[] json_b = json_str.getBytes(UTF_8);
    
    ObjectReader reader = mapper.reader(__POJO.class);
    
    __POJO pojo = reader.readValue(json_str);
    pojo = reader.readValue(json_b);

    PluginTestVerifier verifier = PluginTestVerifierHolder.getInstance();
    verifier.printCache();

    Method readval1 = ObjectReader.class.getMethod("readValue", String.class);
    Method readval2 = ObjectReader.class.getMethod("readValue", byte[].class);

    verifier.verifyTrace(event("JACKSON", readval1, Expectations.annotation("jackson.json.length", json_str.length())));
    verifier.verifyTrace(event("JACKSON", readval2, Expectations.annotation("jackson.json.length", json_b.length)));

    verifier.verifyTraceCount(0);
}
 

public Map<String, Object> decode(String base64EncodedKey, String content) {
    try {
        byte[] decodedKey = Base64.getDecoder().decode(base64EncodedKey);
        SecretKey key = new SecretKeySpec(decodedKey, 0, decodedKey.length, "AES");
        JWEObject jwe = JWEObject.parse(content);
        jwe.decrypt(new AESDecrypter(key));

        ObjectMapper objectMapper = new ObjectMapper();
        ObjectReader reader = objectMapper.readerFor(Map.class);
        return reader.with(DeserializationFeature.USE_LONG_FOR_INTS)
                .readValue(jwe.getPayload().toString());
    } catch (Exception e) {
        throw new RuntimeException(e);
    }

}
 

@Override
public <T> T unmarshall(final Object marshalled, final Class<T> type) throws Exception {
  checkNotNull(marshalled);
  checkState(marshalled instanceof Map, "Marshalled data must be a Map; found: %s", marshalled.getClass());

  // FIXME: This allows the top-level object to be created, but if any children objects of this are missing
  // FIXME: ... no-arg CTOR then Jackson will fail to construct them.
  // FIXME: Is there any way to configure the basic instance creation for Jackson?
  Object value = instanceCreator.newInstance(type);

  // performs same basic logic as ObjectMapper.convertValue(Object, Class) helper
  ObjectReader reader = objectMapper.readerForUpdating(value);
  TokenBuffer buff = new TokenBuffer(objectMapper, false);
  objectMapper.writeValue(buff, marshalled);
  reader.readValue(buff.asParser());

  return type.cast(value);
}
 

protected static <T> T 	createInterfaceJsonAdapter(Class<T> interfaceClass, JsonNode data, final ObjectMapper mapper) {
	Class[] interfaces = new Class[] { interfaceClass };
	return (T) Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), interfaces, new InvocationHandler() {
		@Override
		public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
			if (method.getDeclaringClass().equals(Object.class)) {
				throw new UnsupportedOperationException("not implemented");
			}

			String name = ClassUtils.getGetterFieldName(method);
			JsonNode jsonNode = data.get(name);
			if(jsonNode != null) {
				Class<?> returnType = method.getReturnType();
				ObjectReader objectReader = mapper.readerFor(returnType);
				return objectReader.readValue(jsonNode);
			}
			return null;
		}
	});
}
 

protected void setMeta(Resource dataBody, Object instance, ResourceInformation resourceInformation) {
	ResourceField metaField = resourceInformation.getMetaField();
	if (dataBody.getMeta() != null && metaField != null) {
		JsonNode metaNode = dataBody.getMeta();

		Class<?> metaClass = metaField.getType();

		ObjectReader metaMapper = objectMapper.readerFor(metaClass);
		try {
			Object meta = metaMapper.readValue(metaNode);
			PropertyUtils.setProperty(instance, metaField.getUnderlyingName(), meta);
		} catch (IOException e) {
			throw new ResponseBodyException("failed to parse links information", e);
		}

	}
}
 

@Test
public void checkUrlFilteringForRoot() throws IOException {
	// add filter to include additional parameter `test`
	JsonApiUrlBuilder urlBuilder = (JsonApiUrlBuilder) boot.getUrlBuilder();
	urlBuilder.addPropagatedParameter("test");

	// e.g. /api/tasks/history/
	HttpRequestContextBase context = Mockito.mock(HttpRequestContextBase.class);
	Mockito.when(context.getMethod()).thenReturn("GET");
	Mockito.when(context.getPath()).thenReturn("/");
	Map<String, Set<String>> parameters = new HashMap<>();
	parameters.put("test", Sets.newHashSet("foo"));
	Mockito.when(context.getRequestParameters()).thenReturn(parameters);
	Mockito.when(context.getRequestHeader(Mockito.eq(HttpHeaders.HTTP_HEADER_ACCEPT))).thenReturn(HttpHeaders.JSON_CONTENT_TYPE);
	HttpRequestContextBaseAdapter contextAdapter = new HttpRequestContextBaseAdapter(context);

	HttpRequestDispatcherImpl requestDispatcher = boot.getRequestDispatcher();
	HttpResponse response = requestDispatcher.process(contextAdapter).get().get();

	ObjectReader reader = boot.getObjectMapper().readerFor(Document.class);
	String body = new String(response.getBody());
	Assert.assertTrue(body.contains("projects?test=foo"));
}
 

@Test
public void testLenientDeserializeFromEmptyString() throws Exception {

    String key = "duration";
    ObjectMapper mapper = newMapper();
    ObjectReader objectReader = mapper.readerFor(MAP_TYPE_REF);

    String dateValAsNullStr = null;
    String dateValAsEmptyStr = "";

    String valueFromNullStr = mapper.writeValueAsString(asMap(key, dateValAsNullStr));
    Map<String, Duration> actualMapFromNullStr = objectReader.readValue(valueFromNullStr);
    Duration actualDateFromNullStr = actualMapFromNullStr.get(key);
    assertNull(actualDateFromNullStr);

    String valueFromEmptyStr = mapper.writeValueAsString(asMap(key, dateValAsEmptyStr));
    Map<String, Duration> actualMapFromEmptyStr = objectReader.readValue(valueFromEmptyStr);
    Duration actualDateFromEmptyStr = actualMapFromEmptyStr.get(key);
    assertEquals("empty string failed to deserialize to null with lenient setting", null, actualDateFromEmptyStr);
}
 

/** Convenient way to read a JSON Array String into a List */
public static <T> List<T> readJsonArray(ObjectMapper objectMapper, String value) {
  ObjectReader reader = JacksonUtils.readerForType(objectMapper, List.class);
  //noinspection OverlyBroadCatchBlock
  try {
    return reader.readValue(value);
  } catch (IOException e) {
    throw new RuntimeException(e);
  }
}
 

private ObjectReader configureObjReader() {
    this.count=0;
    CsvSchema firstLineSchema = getCsvSchema()!=null? getCsvSchema():CsvSchema.emptySchema().withHeader();
    CsvMapper csvMapper = getCsvMapper()!=null ? getCsvMapper() : configureCsvMapper();
    ObjectReader objectReader = csvMapper.readerFor(JsonNode.class);
    
    return objectReader.with(firstLineSchema);
}
 

private void expectFailure(ObjectReader reader, String json) throws Throwable {
    try {
        reader.readValue(aposToQuotes(json));
        fail("expected DateTimeParseException");
    } catch (JsonProcessingException e) {
        if (e.getCause() == null) {
            throw e;
        }
        if (!(e.getCause() instanceof DateTimeParseException)) {
            throw e.getCause();
        }
    }
}
 

@Test
public void createFromJSONPredictionsOnly() throws JsonProcessingException, IOException
{
	String json = "{\"predictions\":[{\"predictedClass\":\"cl1\",\"prediction\":1.0,\"confidence\":0.9}]}";
	ObjectMapper mapper = new ObjectMapper();
	ObjectReader reader = mapper.reader(PredictionServiceResult.class);
	PredictionServiceResult res = reader.readValue(json);
	Assert.assertNotNull(res);
	Assert.assertEquals(1.0, res.predictions.get(0).prediction);
}
 

JettyReactiveHttpResponse(Response clientResponse, Publisher<ContentChunk> contentChunks,
						  Class returnPublisherType, Class returnActualClass,
						  JsonFactory jsonFactory, ObjectReader objectReader) {
	this.clientResponse = clientResponse;
	this.contentChunks = contentChunks;
	this.returnPublisherType = returnPublisherType;
	this.returnActualClass = returnActualClass;
	this.objectReader = objectReader;
	this.jsonFactory = jsonFactory;
}
 

protected <T> T execGet(String suffix, ObjectReader reader) {
    // @formatter:off
    return executeGetMethodWithRuntimeException(
            suffix,
            uriBuilder -> {},
            httpGet -> {
                httpGet.setHeader(AUTH_HEADER_NAME, getBearer());
                httpGet.setHeader(HttpHeaders.ACCEPT, MediaType.APPLICATION_JSON);
            },
            entity -> reader.readValue(entity.getContent()),
            () -> StringUtils.isEmpty(suffix) ? serviceURI() : suffix
    );
    // @formatter:on
}
 

/**
 * @return {@code com.fasterxml.jackson.databind.ObjectReader} to deserialize {@link BufferedBulkResult}
 */
protected ObjectReader configuredReader() {
    return new ObjectMapper()
            .setVisibility(VisibilityChecker.Std.defaultInstance().with(JsonAutoDetect.Visibility.ANY))
            .setSerializationInclusion(JsonInclude.Include.NON_EMPTY)
            .configure(SerializationFeature.CLOSE_CLOSEABLE, false)
            .configure(DeserializationFeature.ACCEPT_EMPTY_ARRAY_AS_NULL_OBJECT, true)
            .addMixIn(BufferedBulkResult.class, BufferedBulkResultMixIn.class)
            .addMixIn(BulkError.class, BulkErrorMixIn.class)
            .addMixIn(BulkResultItem.class, BulkResultItemMixIn.class)
            .readerFor(BufferedBulkResult.class);
}
 

@Override
public ConfigBuilder<T> read(String content) {
    String json = resolvePlaceholders(content);
    try {
        if (appConfig != null) {
            ObjectReader merger = objectMapper.readerForUpdating(appConfig);
            appConfig = merger.readValue(json);
        } else {
            appConfig = objectMapper.readValue(json, appConfigType);
        }
    } catch (IOException e) {
        throw new IllegalStateException(e);
    }
    return this;
}
 

public void init() {
    typeTriggers = new HashMap<>();
    objectMapper = getObjectMapper()
            .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)
            .configure(MapperFeature.ACCEPT_CASE_INSENSITIVE_PROPERTIES, true);
    for (FunctionInvoker invoker : FunctionRecorder.registry.invokers()) {
        Method method = invoker.getMethod();
        CloudEventMapping annotation = method.getAnnotation(CloudEventMapping.class);
        if (annotation != null && !annotation.trigger().isEmpty()) {
            typeTriggers.put(annotation.trigger(), invoker);
        } else {
            typeTriggers.put(invoker.getName(), invoker);
        }

        if (invoker.hasInput()) {
            ObjectReader reader = objectMapper.readerFor(invoker.getInputType());
            invoker.getBindingContext().put(ObjectReader.class.getName(), reader);
        }
        if (invoker.hasOutput()) {
            ObjectWriter writer = objectMapper.writerFor(invoker.getOutputType());
            invoker.getBindingContext().put(ObjectWriter.class.getName(), writer);

            String functionName = invoker.getName();
            if (annotation != null && !annotation.responseType().isEmpty()) {
                invoker.getBindingContext().put(RESPONSE_TYPE, annotation.responseType());
            } else {
                invoker.getBindingContext().put(RESPONSE_TYPE, functionName + ".output");
            }
            if (annotation != null && !annotation.responseSource().isEmpty()) {
                invoker.getBindingContext().put(RESPONSE_SOURCE, annotation.responseSource());
            } else {
                invoker.getBindingContext().put(RESPONSE_SOURCE, functionName);
            }
        }
    }
}
 

public void init(BeanContainer bc) {
    beanContainer = bc;
    FunctionConstructor.CONTAINER = bc;
    ObjectMapper objectMapper = AmazonLambdaMapperRecorder.objectMapper;
    for (FunctionInvoker invoker : FunctionRecorder.registry.invokers()) {
        if (invoker.hasInput()) {
            ObjectReader reader = objectMapper.readerFor(invoker.getInputType());
            invoker.getBindingContext().put(ObjectReader.class.getName(), reader);
        }
        if (invoker.hasOutput()) {
            ObjectWriter writer = objectMapper.writerFor(invoker.getOutputType());
            invoker.getBindingContext().put(ObjectWriter.class.getName(), writer);
        }
    }
}