/** * Method for constructing a {@link MapLikeType} instance *<p> * NOTE: type modifiers are NOT called on constructed type itself; but are called * for contained types. */ public MapLikeType constructMapLikeType(Class<?> mapClass, Class<?> keyClass, Class<?> valueClass) { return constructMapLikeType(mapClass, _fromClass(null, keyClass, EMPTY_BINDINGS), _fromClass(null, valueClass, EMPTY_BINDINGS)); }
/** * Method that can be used to construct "raw" Map-like type; meaning that its * parameterization is unknown. * This is similar to using <code>Object.class</code> parameterization, * and is equivalent to calling: *<pre> * typeFactory.constructMapLikeType(collectionClass, typeFactory.unknownType(), typeFactory.unknownType()); *</pre> *<p> * This method should only be used if parameterization is completely unavailable. */ public MapLikeType constructRawMapLikeType(Class<?> mapClass) { return constructMapLikeType(mapClass, unknownType(), unknownType()); }
@Override public JavaType getInputType(final TypeFactory typeFactory) { return typeFactory.constructMapLikeType(HashMap.class, String.class, String.class); }
@Override public JavaType toJavaType(Headers headers) { String typeIdHeader = retrieveHeaderAsString(headers, getClassIdFieldName()); if (typeIdHeader != null) { JavaType classType = getClassIdType(typeIdHeader); if (!classType.isContainerType() || classType.isArrayType()) { return classType; } JavaType contentClassType = getClassIdType(retrieveHeader(headers, getContentClassIdFieldName())); if (classType.getKeyType() == null) { return TypeFactory.defaultInstance() .constructCollectionLikeType(classType.getRawClass(), contentClassType); } JavaType keyClassType = getClassIdType(retrieveHeader(headers, getKeyClassIdFieldName())); return TypeFactory.defaultInstance() .constructMapLikeType(classType.getRawClass(), keyClassType, contentClassType); } return null; }
@Override public JavaType getInputType(final TypeFactory typeFactory) { return typeFactory.constructMapLikeType(HashMap.class, String.class, String.class); }
@Override public JavaType getInputType(final TypeFactory typeFactory) { return typeFactory.constructMapLikeType(HashMap.class, String.class, String.class); }
@Override public JavaType getInputType(final TypeFactory typeFactory) { return typeFactory.constructMapLikeType(HashMap.class, String.class, String.class); }
private Map<String, JsonNode> readDefaultConfig(File config) { try (InputStream stream = config == null ? getDefaultConfigFile() : new FileInputStream(config)) { return om.readValue(stream, TypeFactory .defaultInstance() .constructMapLikeType(HashMap.class, String.class, JsonNode.class)); } catch (IOException e) { LOGGER.info("Could not load '{}'. Using empty config.", DEFAULT_CONFIG_FILE, e); return new HashMap<>(); } }
/** * List with Generic Map, Generic, i.e.: List<Map<String, Object>> */ public JavaType get(@SuppressWarnings("rawtypes") Class<? extends List> collectionClazz, Class<?> mapClazz, Class<?> keyClazz, Class<?> valueClazz) { JavaType clazzType = objectMapper.getTypeFactory().constructMapLikeType(mapClazz, keyClazz, valueClazz); return objectMapper.getTypeFactory().constructCollectionType(collectionClazz, clazzType); } }
private Map<String, JsonNode> readDefaultConfig(String configFileResource) { try { InputStream configResource = getClass().getResourceAsStream(configFileResource); if (configResource == null) { configResource = getClass().getResourceAsStream(CONFIG_DEFAULT_FILE); } Map<String, JsonNode> result = new ObjectMapper().readValue(configResource, TypeFactory .defaultInstance() .constructMapLikeType(HashMap.class, String.class, JsonNode.class)); configResource.close(); return result; } catch (IOException e) { LOG.error("Could not load files {}, {}. Using empty config.", configFileResource, CONFIG_DEFAULT_FILE, e); return new HashMap<>(); } }
private Map<String, JsonNode> readDefaultConfig(File config) { try (InputStream stream = config == null ? getDefaultConfigFile() : new FileInputStream(config)) { return OBJECT_MAPPER.readValue(stream, TypeFactory.defaultInstance() .constructMapLikeType(HashMap.class, String.class, JsonNode.class)); } catch (IOException e) { LOGGER.trace("Could not load '{}'", DEFAULT_CONFIG_FILE, e); LOGGER.info("Config could not be loaded (switch to TRACE to see details)."); return new HashMap<>(); } }
public static void main(String[] args) { ObjectMapper mapper = new ObjectMapper(); TypeFactory factory = mapper.getTypeFactory(); // type of key of response map JavaType stringType = factory.constructType(String.class); // type of value of response map JavaType listOfDtosType = factory.constructCollectionLikeType(ArrayList.class, SingleSummonerBasicDTO.class); // create type of map JavaType responseType = factory.constructMapLikeType(HashMap.class, stringType, listOfDtosType); try (InputStream is = new FileInputStream("C://Temp/xx.json")) { Map<String, List<SingleSummonerBasicDTO>> response = new ObjectMapper().readValue(is, responseType); System.out.println(response); } catch (IOException e) { e.printStackTrace(); } }
/** * Method for constructing a {@link MapLikeType} instance *<p> * NOTE: type modifiers are NOT called on constructed type itself; but are called * for contained types. */ public MapLikeType constructMapLikeType(Class<?> mapClass, Class<?> keyClass, Class<?> valueClass) { return constructMapLikeType(mapClass, _fromClass(null, keyClass, EMPTY_BINDINGS), _fromClass(null, valueClass, EMPTY_BINDINGS)); }
/** * Method for constructing a {@link MapLikeType} instance *<p> * NOTE: type modifiers are NOT called on constructed type itself; but are called * for contained types. */ public MapLikeType constructMapLikeType(Class<?> mapClass, Class<?> keyClass, Class<?> valueClass) { return constructMapLikeType(mapClass, _fromClass(null, keyClass, EMPTY_BINDINGS), _fromClass(null, valueClass, EMPTY_BINDINGS)); }
/** * Method that can be used to construct "raw" Map-like type; meaning that its * parameterization is unknown. * This is similar to using <code>Object.class</code> parameterization, * and is equivalent to calling: *<pre> * typeFactory.constructMapLikeType(collectionClass, typeFactory.unknownType(), typeFactory.unknownType()); *</pre> *<p> * This method should only be used if parameterization is completely unavailable. */ public MapLikeType constructRawMapLikeType(Class<?> mapClass) { return constructMapLikeType(mapClass, unknownType(), unknownType()); }
/** * Method that can be used to construct "raw" Map-like type; meaning that its * parameterization is unknown. * This is similar to using <code>Object.class</code> parameterization, * and is equivalent to calling: *<pre> * typeFactory.constructMapLikeType(collectionClass, typeFactory.unknownType(), typeFactory.unknownType()); *</pre> *<p> * This method should only be used if parameterization is completely unavailable. */ public MapLikeType constructRawMapLikeType(Class<?> mapClass) { return constructMapLikeType(mapClass, unknownType(), unknownType()); }
JavaType constructMapType(TypeFactory factory, EClass type) { EStructuralFeature key = type.getEStructuralFeature("key"); EStructuralFeature value = type.getEStructuralFeature("value"); if (key == null || value == null) { return null; } EClassifier keyType = key.getEType(); EClassifier valueType = value.getEType(); Class<?> keyClass = rawType(keyType); if (String.class.isAssignableFrom(keyClass)) { return factory.constructMapLikeType(EMap.class, keyClass, rawType(valueType)); } else { return factory.constructCollectionType(Collection.class, factory.constructType(EObject.class)); } }
JavaType constructMapType(TypeFactory factory, EClass type) { EStructuralFeature key = type.getEStructuralFeature("key"); EStructuralFeature value = type.getEStructuralFeature("value"); if (key == null || value == null) { return null; } EClassifier keyType = key.getEType(); EClassifier valueType = value.getEType(); Class<?> keyClass = rawType(keyType); if (String.class.isAssignableFrom(keyClass)) { return factory.constructMapLikeType(EMap.class, keyClass, rawType(valueType)); } else { return factory.constructCollectionType(Collection.class, factory.constructType(EObject.class)); } }
MapCodec(Codec<K> keyCodec, Codec<V> valueCodec) { super( typeFactory.constructMapLikeType( Map.class, keyCodec.getJavaType(), valueCodec.getJavaType()), new RawMap(keyCodec.getCqlType(), valueCodec.getCqlType())); this.keyCodec = keyCodec; this.valueCodec = valueCodec; }
private JavaType fromTypeHeader(MessageProperties properties, String typeIdHeader) { JavaType classType = getClassIdType(typeIdHeader); if (!classType.isContainerType() || classType.isArrayType()) { return classType; } JavaType contentClassType = getClassIdType(retrieveHeader(properties, getContentClassIdFieldName())); if (classType.getKeyType() == null) { return TypeFactory.defaultInstance() .constructCollectionLikeType(classType.getRawClass(), contentClassType); } JavaType keyClassType = getClassIdType(retrieveHeader(properties, getKeyClassIdFieldName())); return TypeFactory.defaultInstance() .constructMapLikeType(classType.getRawClass(), keyClassType, contentClassType); }