@Override JavaType emulatedJavaType(JavaType type, TypeFactory typeFactory) { return typeFactory.constructArrayType(byte.class); }
@Override public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint) throws JsonMappingException { JsonMapFormatVisitor v2 = (visitor == null) ? null : visitor.expectMapFormat(typeHint); if (v2 != null) { v2.keyFormat(_keySerializer, _type.getKeyType()); JsonSerializer<?> valueSer = _valueSerializer; final JavaType vt = _type.getContentType(); final SerializerProvider prov = visitor.getProvider(); if (valueSer == null) { valueSer = _findAndAddDynamic(_dynamicValueSerializers, vt, prov); } final JsonSerializer<?> valueSer2 = valueSer; v2.valueFormat(new JsonFormatVisitable() { final JavaType arrayType = prov.getTypeFactory().constructArrayType(vt); @Override public void acceptJsonFormatVisitor( JsonFormatVisitorWrapper v3, JavaType hint3) throws JsonMappingException { JsonArrayFormatVisitor v4 = v3.expectArrayFormat(arrayType); if (v4 != null) { v4.itemsFormat(valueSer2, vt); } } }, vt); } }
public static <V> V[] toArray(String json, Class<V> valueTypeClass, ObjectMapper mapper) throws IOException { JavaType arrayStringObjectType = mapper.getTypeFactory().constructArrayType(valueTypeClass); return mapper.readValue(json, arrayStringObjectType); }
public static <T> T toArray(String value, Class<?> elementType) { ArrayType arrayType = TypeFactory.defaultInstance().constructArrayType(elementType); try { return OBJECT_MAPPER.readValue(value, arrayType); } catch (IOException e) { throw new RuntimeException(e); } }
public static List<Event> fromString(String eventsString, EventTypeMatcher eventTypeMatcher, ObjectMapper objectMapper) { try { EventJson[] eventsJson = objectMapper.readValue(eventsString, objectMapper.getTypeFactory().constructArrayType(EventJson.class)); return Stream.of(eventsJson) .map(eventJson -> eventJson.toEvent(eventTypeMatcher, objectMapper)) .filter(Optional::isPresent) .map(Optional::get) .collect(toList()); } catch (IOException e) { throw new RuntimeException(e); } }
/** * Sets expected return type as an array * * @param elementType type of elements of an array * @param <E> generic array type * @return new builder */ @NotNull public <E> RequestBuilder<E[]> returnAsArray(@NotNull Class<E> elementType) { return new RequestBuilder<E[]>(transport, mapper, method, id, objectParams, arrayParams, mapper.getTypeFactory().constructArrayType(elementType)); }
@Override public <T> List<T> parseArray(String json, Class<T> type) { try { return this.mapper().readValue(json, this.mapper().getTypeFactory().constructArrayType(type)); } catch (IOException e) { throw new RuntimeException(e); } }
/** * Deserialise the supplied JSON array of events to a List of {@link Event}s. * @param eventsString The JSON to deserialise. * @param eventTypeMatcher The {@link EventTypeMatcher} to use to match * {@link com.opencredo.concursus.domain.events.EventType}s to * {@link com.opencredo.concursus.data.tuples.TupleSchema}s * @param objectMapper The {@link ObjectMapper} to use. * @return The deserialised list of {@link Event}s. */ public static List<Event> fromString(String eventsString, EventTypeMatcher eventTypeMatcher, ObjectMapper objectMapper) { try { EventJson[] eventsJson = objectMapper.readValue(eventsString, objectMapper.getTypeFactory().constructArrayType(EventJson.class)); return Stream.of(eventsJson) .map(eventJson -> eventJson.toEvent(eventTypeMatcher, objectMapper)) .filter(Optional::isPresent) .map(Optional::get) .collect(toList()); } catch (IOException e) { throw new RuntimeException(e); } }
/** * Get the value of the given property as an array. This method never returns {@code null}. If * the property is not set, an empty array is returned. * * @param aName * the property name. * @param aToValueType * the array component type. * @return the array. */ @SuppressWarnings("unchecked") public <T> T[] getArrayProperty(String aName, Class<T> aToValueType) { Object value = properties.get(aName); if (value != null) { ObjectMapper mapper = JSONUtil.getObjectMapper(); return JSONUtil.getObjectMapper().convertValue(value, mapper.getTypeFactory().constructArrayType(aToValueType)); } else { return (T[]) Array.newInstance(aToValueType, 0); } }
if (genericType instanceof Class<?>) { if (((Class) genericType).isArray()) { javaType = objectMapper.getTypeFactory().constructArrayType(((Class) genericType).getComponentType()); } else { List<Class<?>> parameterClasses = new ArrayList<Class<?>>();
throw new IllegalArgumentException("Need exactly 1 parameter type for arrays ("+parametrized.getName()+")"); resultType = constructArrayType(parameterTypes[0]);
throw new IllegalArgumentException("Need exactly 1 parameter type for arrays ("+parametrized.getName()+")"); resultType = constructArrayType(parameterTypes[0]);
throw new IllegalArgumentException("Need exactly 1 parameter type for arrays ("+parametrized.getName()+")"); resultType = constructArrayType(parameterTypes[0]);
throw new IllegalArgumentException("Need exactly 1 parameter type for arrays ("+parametrized.getName()+")"); resultType = constructArrayType(parameterTypes[0]);
private static <T> JavaType constructType(Class<T> dataType, TypeFactory typeFactory) { if (dataType == String.class || dataType == Boolean.TYPE || dataType == Integer.TYPE || dataType == Long.TYPE) { return typeFactory.constructSimpleType(dataType, null); } if (dataType.isArray()) { return typeFactory.constructArrayType(dataType.getComponentType()); } else if (dataType.isEnum()) { return typeFactory.constructSimpleType(dataType, new JavaType[0]); } else if (Map.class.isAssignableFrom(dataType)) { return typeFactory.constructRawMapType((Class<? extends Map>) dataType); } else if (Collection.class.isAssignableFrom(dataType)) { return typeFactory.constructRawCollectionType((Class<? extends Collection>) dataType); } TypeVariable<Class<T>>[] types = dataType.getTypeParameters(); JavaType[] javaTypes = new JavaType[types.length]; for (int i = 0; i < javaTypes.length; i++) { javaTypes[i] = TypeFactory.unknownType(); } return typeFactory.constructSimpleType(dataType, javaTypes); }
@Override public Map<?, ?> deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException { if (JsonToken.START_OBJECT.equals(jp.currentToken())) { return (Map<?, ?>) fallback.deserialize(jp, ctxt); } // deserialize the map from array of map entries Map<Object, Object> map = Maps.newLinkedHashMap(); JavaType mapEntryType = TypeFactory.defaultInstance().constructSimpleType(MapEntry.class, new JavaType[] { keyType, valueType }); JavaType mapEntryArrayType = TypeFactory.defaultInstance().constructArrayType(mapEntryType); ObjectCodec codec = jp.getCodec(); if (codec == null) { throw new IllegalStateException("No ObjectCodec defined for the parser, can not deserialize JSON into Java objects"); } MapEntry<Object, Object>[] entries = codec.readValue(jp, mapEntryArrayType); for (MapEntry<Object, Object> entry : entries) { map.put(entry.getKey(), entry.getValue()); } return map; }
@Test public final void testIsValidYaml() throws Exception { final StringBuilder buff = new StringBuilder(); formatTo(buff); System.out.println(buff.toString()); final YAMLFactory yamlFactory = new YAMLFactory(); final ObjectMapper mapper = new ObjectMapper(yamlFactory); final JavaType parsedType = mapper.getTypeFactory().constructArrayType(Map.class); final Map<String, Object> parsed = ((Map<String, Object>[]) mapper.readValue(buff.toString(), parsedType))[0]; assertEquals(STEP_ID, parsed.get("Load Step Id")); assertEquals(OP_TYPE.name(), parsed.get("Operation Type")); assertEquals(COUNT, ((Map<String, Object>) parsed.get("Operations Count")).get("Successful")); } }
JavaType type = typeFactory.constructArrayType( td.getElementTypeDescriptor().getType()); return this.objectMapper.convertValue(argument, type);
.constructArrayType(td.getElementTypeDescriptor().getType()); return this.objectMapper.convertValue(argument, type);
.constructArrayType(methodParameter.getTypeDescriptor() .getElementTypeDescriptor().getType()); return this.jsonHandler.convertValue(value, type);