@SneakyThrows private void updateTenants(String key, String config) { log.info("Tenants list was updated"); if (!TENANTS_LIST_CONFIG_KEY.equals(key)) { throw new IllegalArgumentException("Wrong config key to update " + key); } assertExistsTenantsListConfig(config); CollectionType setType = defaultInstance().constructCollectionType(HashSet.class, TenantState.class); MapType type = defaultInstance().constructMapType(HashMap.class, defaultInstance().constructType(String.class), setType); Map<String, Set<TenantState>> tenantsByServiceMap = objectMapper.readValue(config, type); Set<TenantState> tenantKeys = tenantsByServiceMap.get(applicationName); assertExistTenants(tenantKeys); this.tenants = tenantKeys; this.suspendedTenants = tenantKeys.stream().filter(tenant -> SUSPENDED_STATE.equals(tenant.getState())) .map(TenantState::getName).collect(Collectors.toSet()); }
@SneakyThrows private void updateTenants(String config) { log.info("Tenants list was updated"); CollectionType setType = defaultInstance().constructCollectionType(HashSet.class, TenantState.class); MapType type = defaultInstance().constructMapType(HashMap.class, defaultInstance().constructType(String.class), setType); Map<String, Set<TenantState>> tenantsByServiceMap = objectMapper.readValue(config, type); final Map<String, String> tenants = new HashMap<>(); for (TenantState tenant: tenantsByServiceMap.getOrDefault(applicationName, emptySet())) { for (String host : hosts) { tenants.put(tenant.getName() + "." + host, tenant.getName().toUpperCase()); } } this.tenants = tenants; }
@Override public ListResult<T> fetchAll() { try { // get the data out.. byte[] json = jsondb.getAsByteArray(getCollectionPath()); if( json!=null && json.length > 0 ) { // Lets use jackson to parse the map of keys to our model instances ObjectMapper mapper = Json.mapper(); TypeFactory typeFactory = mapper.getTypeFactory(); MapType mapType = typeFactory.constructMapType(LinkedHashMap.class, String.class, getType()); LinkedHashMap<String, T> map = mapper.readValue(json, mapType); return ListResult.of(map.values()); } return ListResult.of(Collections.<T>emptyList()); } catch (@SuppressWarnings("PMD.AvoidCatchingGenericException") RuntimeException|IOException e) { throw SyndesisServerException.launderThrowable(e); } }
/** * Helper method for deserializing a chat JSON response to a collection of objects. * * @param jsonStr * The chat JSON response. * @param mapElement * Chat JSON responses are actually maps with a single element. This argument is * the value of the element to pull out from the map. * @param colClassElements * The types of objects that the collection object will contain. * @param objMapper * The JSON object mapper used to deserialize the JSON string. * @return A collection of elements of type <code>colClassElements</code>. */ private <T> Collection<T> deserializeJsonStr(String jsonStr, String mapElement, Class<T> colClassElements, ObjectMapper objMapper) { Map<String, Collection<T>> re; try { TypeFactory typeFactory = objMapper.getTypeFactory(); CollectionType type = typeFactory.constructCollectionType(List.class, colClassElements); MapType thetype = typeFactory.constructMapType(HashMap.class, typeFactory.constructType(String.class), type); re = objMapper.readValue(jsonStr, thetype); } catch (IOException e) { LOG.error("Got exception when trying to deserialize list of {}", colClassElements, e); return Lists.newArrayListWithExpectedSize(0); } return re.get(mapElement); }
@Override public JsonDeserializer<?> modifyMapDeserializer( DeserializationConfig config, MapType type, BeanDescription beanDesc, JsonDeserializer<?> deserializer) { // statements if (isMapOfStringAndListOfStatements(type)) { return new ModifiedMapDeserializer<String, List<JacksonStatement>>(deserializer); } // labels and descriptions else if (isMapOfStringAndMonolingualTextValue(type)) { return new ModifiedMapDeserializer<String, JacksonMonolingualTextValue>(deserializer); } // sitelinks else if (isMapOfStringAndSitelink(type)) { return new ModifiedMapDeserializer<String, JacksonSiteLink>(deserializer); } // aliases and miscallaneous that does not need this workaround else { return deserializer; } }
public static JsonValueMap fromBundle(BundleName bundle, Locale locale) { JsonValueMap jvm = new JsonValueMap(); jvm.setMapId(bundle.getValueMapId()); URL resource = findResource(bundle.toString(), CONTROL, locale); if (resource == null) { return jvm; } ObjectMapper om = JsonUtils.defaultObjectMapper(); try { TypeFactory typeFactory = om.getTypeFactory(); MapType jsonType = typeFactory.constructMapType(Map.class, String.class, Object.class); Map<String, Object> jsonMap = om.readValue(resource, jsonType); if (LOG.isLoggable(Level.FINE)) { LOG.fine(String.valueOf(jsonMap)); } Object data = jsonMap.get("data"); jvm.setValues((List<Map<String, Object>>) data); } catch (Exception ex) { LOG.log(Level.WARNING, "Cannot read resource " + resource, ex); } return jvm; }
@Bean public ObjectMapper jsonObjectMapper() { final ObjectMapper jsonMapper = new ObjectMapper(); jsonMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false); jsonMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); jsonMapper.configure(Feature.ALLOW_UNQUOTED_FIELD_NAMES, true); jsonMapper.configure(Feature.ALLOW_SINGLE_QUOTES, true); jsonMapper.configure(MapperFeature.DEFAULT_VIEW_INCLUSION, false); final SimpleModule module = new SimpleModule("FieldsMapping", Version.unknownVersion()); module.setSerializerModifier(new BeanSerializerModifier() { @Override public JsonSerializer<?> modifyMapSerializer(final SerializationConfig config, final MapType valueType, final BeanDescription beanDesc, final JsonSerializer<?> serializer) { if (FieldsMap.class.isAssignableFrom(valueType.getRawClass())) { return new FieldsMapMixInLikeSerializer(); } else { return super.modifyMapSerializer(config, valueType, beanDesc, serializer); } } }); jsonMapper.registerModule(module); return jsonMapper; }
@Override public JavaType typeFromId(DatabindContext context, String id) { DeserializationContext ctx = (DeserializationContext) context; Map<String, Class> map = (Map) ctx.getAttribute("secucardobjectmap"); Class type = map.get(id); JavaType javatype; if (type == null) { javatype = MapType.construct(HashMap.class, SimpleType.construct(String.class), SimpleType.construct(Object.class)); } else { javatype = SimpleType.construct(type); } if (JsonToken.END_ARRAY.equals(ctx.getParser().getCurrentToken())) { // it is expected to get called here when reading the last token. javatype = CollectionType.construct(ArrayList.class, javatype); } return javatype; }
public static Map<String, Object> readJsonFromClasspathAsMap(String fileName) { InputStream inputStream = null; try { inputStream = IoUtil.getResourceAsStream(fileName); if (inputStream == null) { throw new RuntimeException("File '" + fileName + "' not found!"); } MapType type = TypeFactory.defaultInstance().constructMapType(HashMap.class, String.class, Object.class); HashMap<String, Object> mapping = objectMapper.readValue(inputStream, type); return mapping; } catch (IOException e) { throw new RuntimeException("Unable to load json [" + fileName + "] from classpath", e); } finally { IoUtil.closeSilently(inputStream); } }
public static Map<String, Object> bodyFromRequest(RecordedRequest request) throws IOException { ObjectMapper mapper = new ObjectMapper(); MapType mapType = mapper.getTypeFactory().constructMapType(HashMap.class, String.class, Object.class); Buffer body = request.getBody(); try { return mapper.readValue(body.inputStream(), mapType); } catch (IOException e) { throw e; } finally { body.close(); } }
@JmsListener(destination = INDEXING_QUEUE) public void receiveIndexingQueue(TurSNJob turSNJob) { logger.debug("Received job - " + INDEXING_QUEUE); JSONArray jsonRows = new JSONArray(turSNJob.getJson()); TurSNSite turSNSite = this.turSNSiteRepository.findById(Integer.parseInt(turSNJob.getSiteId())); try { for (int i = 0; i < jsonRows.length(); i++) { JSONObject jsonRow = jsonRows.getJSONObject(i); logger.debug("receiveQueue JsonObject: " + jsonRow.toString()); ObjectMapper mapper = new ObjectMapper(); TypeFactory typeFactory = mapper.getTypeFactory(); MapType mapType = typeFactory.constructMapType(HashMap.class, String.class, Object.class); HashMap<String, Object> attributes = mapper.readValue(new StringReader(jsonRow.toString()), mapType); Map<String, Object> consolidateResults = new HashMap<String, Object>(); // SE for (Entry<String, Object> attribute : attributes.entrySet()) { logger.debug("SE Consolidate Value: " + attribute.getValue()); logger.debug("SE Consolidate Class: " + attribute.getValue().getClass().getName()); consolidateResults.put(attribute.getKey(), attribute.getValue()); } // Remove Duplicate Terms Map<String, Object> attributesWithUniqueTerms = this.removeDuplicateTerms(consolidateResults); // SE turSolr.init(turSNSite, attributesWithUniqueTerms); turSolr.indexing(); } logger.debug("Sent job - " + NLP_QUEUE); this.jmsMessagingTemplate.convertAndSend(NLP_QUEUE, turSNJob); } catch (Exception e) { e.printStackTrace(); } }
/** * A map of emojis to unicode * * @return A map of emoji names to unicode * @throws RuntimeException * When the emoji file can't be found, read or parsed */ public static Map<String, String> getUnicodeEmojis(ObjectMapper objectMapper) { MapType mapType = TypeFactory.defaultInstance() .constructMapType(Map.class, String.class, String.class); try { return objectMapper.readValue(Resources.getResource(Constants.EMOJI_RESOURCE), mapType); } catch (IOException e) { throw new RuntimeException("Can't read emojis", e); } }
@Override public JsonDeserializer<?> findMapDeserializer(MapType type, DeserializationConfig config, BeanDescription beanDesc, KeyDeserializer keyDeserializer, TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer) { return forJavaType(type); }
@Override public JsonSerializer<?> modifyMapSerializer(SerializationConfig config, MapType valueType, BeanDescription beanDesc, JsonSerializer<?> serializer) { if (serializer instanceof MapSerializer) { // TODO: We should probably be propagating the NON_EMPTY inclusion here, but it's breaking // discovery. return new DeepEmptyCheckingSerializer<>(serializer); } return serializer; }
@Override public void setupModule(SetupContext context) { // Modify the Map serializer to the delegate if it matches Map<String, ?> context.addBeanSerializerModifier(new BeanSerializerModifier() { @Override public JsonSerializer<?> modifyMapSerializer(SerializationConfig config, MapType valueType, BeanDescription beanDesc, JsonSerializer<?> serializer) { if (valueType.getKeyType().equals(SimpleType.construct(String.class))) { return new DelegatingMapSerializer(serializer); } return serializer; } }); }
@Override public JsonDeserializer<?> findMapDeserializer(MapType type, DeserializationConfig config, BeanDescription beanDesc, KeyDeserializer keyDeserializer, TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer) throws JsonMappingException { return null; }
public void enterComponent_terminologies_section(AdlParser.Component_terminologies_sectionContext ctx) { if(archetype instanceof OperationalTemplate) { OperationalTemplate template = (OperationalTemplate) archetype; TypeFactory typeFactory = OdinToJsonConverter.getObjectMapper().getTypeFactory(); MapType mapType = typeFactory.constructMapType(ConcurrentHashMap.class, String.class, ArchetypeTerminology.class); template.setComponentTerminologies(OdinObjectParser.convert(ctx.odin_text(), mapType)); } else { throw new IllegalArgumentException("cannot add component terminologies to anything but an operational template"); } }
@Theory public void objectMapperWithTTKeyDeserializerInstalledYieldsExpectedDeserializationsForTTs(Pair<String, Object> serializedAndExpectedDeserialization) throws IOException { final ObjectMapper om = new ObjectMapper(); om.registerModule(new KeyDeserializersOnlyModule()); final String serialzied = serializedAndExpectedDeserialization.fst; final Object expected = serializedAndExpectedDeserialization.snd; final JavaType mapType = MapType.construct(HashMap.class, SimpleType.construct(serializedAndExpectedDeserialization.snd.getClass()), SimpleType.construct(Void.class)); final Object got = ((Map)om.readValue(asJsonMapKey(serialzied), mapType)).keySet().iterator().next(); Assert.assertEquals(got, expected); }
protected Map<String, Object> mappingAsJsonToMap(String mappingAsJson) { ObjectMapper objectMapper = new ObjectMapper(); MapType mapType = objectMapper.getTypeFactory().constructMapType(HashMap.class, String.class, Object.class); try { return new ObjectMapper().readValue(mappingAsJson, mapType); } catch (IOException e) { throw new RuntimeException(e); } }
protected static <T extends JavaType> T modifySecondaryTypesByAnnotation(SerializationConfig paramSerializationConfig, Annotated paramAnnotated, T paramT) { AnnotationIntrospector localAnnotationIntrospector = paramSerializationConfig.getAnnotationIntrospector(); if (paramT.isContainerType()) { Class localClass1 = localAnnotationIntrospector.findSerializationKeyType(paramAnnotated, paramT.getKeyType()); if (localClass1 != null) { if (!(paramT instanceof MapType)) throw new IllegalArgumentException("Illegal key-type annotation: type " + paramT + " is not a Map type"); try { paramT = ((MapType)paramT).widenKey(localClass1); } catch (IllegalArgumentException localIllegalArgumentException2) { throw new IllegalArgumentException("Failed to narrow key type " + paramT + " with key-type annotation (" + localClass1.getName() + "): " + localIllegalArgumentException2.getMessage()); } } Class localClass2 = localAnnotationIntrospector.findSerializationContentType(paramAnnotated, paramT.getContentType()); if (localClass2 != null) try { JavaType localJavaType = paramT.widenContentsBy(localClass2); return localJavaType; } catch (IllegalArgumentException localIllegalArgumentException1) { throw new IllegalArgumentException("Failed to narrow content type " + paramT + " with content-type annotation (" + localClass2.getName() + "): " + localIllegalArgumentException1.getMessage()); } } return paramT; }
protected JsonSerializer<?> buildMapSerializer(SerializationConfig paramSerializationConfig, MapType paramMapType, BeanDescription paramBeanDescription, boolean paramBoolean, JsonSerializer<Object> paramJsonSerializer1, TypeSerializer paramTypeSerializer, JsonSerializer<Object> paramJsonSerializer2) { Object localObject = null; Iterator localIterator1 = customSerializers().iterator(); JsonSerializer localJsonSerializer; do { if (!localIterator1.hasNext()) break; localJsonSerializer = ((Serializers)localIterator1.next()).findMapSerializer(paramSerializationConfig, paramMapType, paramBeanDescription, paramJsonSerializer1, paramTypeSerializer, paramJsonSerializer2); localObject = localJsonSerializer; } while (localJsonSerializer == null); if (localObject == null) if (EnumMap.class.isAssignableFrom(paramMapType.getRawClass())) { JavaType localJavaType = paramMapType.getKeyType(); boolean bool = localJavaType.isEnumType(); EnumValues localEnumValues = null; if (bool) localEnumValues = EnumValues.construct(localJavaType.getRawClass(), paramSerializationConfig.getAnnotationIntrospector()); localObject = new EnumMapSerializer(paramMapType.getContentType(), paramBoolean, localEnumValues, paramTypeSerializer, paramJsonSerializer2); } else { localObject = MapSerializer.construct(paramSerializationConfig.getAnnotationIntrospector().findPropertiesToIgnore(paramBeanDescription.getClassInfo()), paramMapType, paramBoolean, paramTypeSerializer, paramJsonSerializer1, paramJsonSerializer2); } if (this._factoryConfig.hasSerializerModifiers()) { Iterator localIterator2 = this._factoryConfig.serializerModifiers().iterator(); while (localIterator2.hasNext()) localObject = ((BeanSerializerModifier)localIterator2.next()).modifyMapSerializer(paramSerializationConfig, paramMapType, paramBeanDescription, (JsonSerializer)localObject); } return localObject; }
protected JsonDeserializer<?> _findCustomMapDeserializer(MapType paramMapType, DeserializationConfig paramDeserializationConfig, BeanDescription paramBeanDescription, KeyDeserializer paramKeyDeserializer, TypeDeserializer paramTypeDeserializer, JsonDeserializer<?> paramJsonDeserializer) { Iterator localIterator = this._factoryConfig.deserializers().iterator(); while (localIterator.hasNext()) { JsonDeserializer localJsonDeserializer = ((Deserializers)localIterator.next()).findMapDeserializer(paramMapType, paramDeserializationConfig, paramBeanDescription, paramKeyDeserializer, paramTypeDeserializer, paramJsonDeserializer); if (localJsonDeserializer != null) return localJsonDeserializer; } return null; }
protected final JsonDeserializer<?> _createDeserializer2(DeserializationContext paramDeserializationContext, DeserializerFactory paramDeserializerFactory, JavaType paramJavaType, BeanDescription paramBeanDescription) { DeserializationConfig localDeserializationConfig = paramDeserializationContext.getConfig(); if (paramJavaType.isEnumType()) return paramDeserializerFactory.createEnumDeserializer(paramDeserializationContext, paramJavaType, paramBeanDescription); if (paramJavaType.isContainerType()) { if (paramJavaType.isArrayType()) return paramDeserializerFactory.createArrayDeserializer(paramDeserializationContext, (ArrayType)paramJavaType, paramBeanDescription); if (paramJavaType.isMapLikeType()) { MapLikeType localMapLikeType = (MapLikeType)paramJavaType; if (localMapLikeType.isTrueMapType()) return paramDeserializerFactory.createMapDeserializer(paramDeserializationContext, (MapType)localMapLikeType, paramBeanDescription); return paramDeserializerFactory.createMapLikeDeserializer(paramDeserializationContext, localMapLikeType, paramBeanDescription); } if (paramJavaType.isCollectionLikeType()) { JsonFormat.Value localValue = paramBeanDescription.findExpectedFormat(null); if ((localValue == null) || (localValue.getShape() != JsonFormat.Shape.OBJECT)) { CollectionLikeType localCollectionLikeType = (CollectionLikeType)paramJavaType; if (localCollectionLikeType.isTrueCollectionType()) return paramDeserializerFactory.createCollectionDeserializer(paramDeserializationContext, (CollectionType)localCollectionLikeType, paramBeanDescription); return paramDeserializerFactory.createCollectionLikeDeserializer(paramDeserializationContext, localCollectionLikeType, paramBeanDescription); } } } if (JsonNode.class.isAssignableFrom(paramJavaType.getRawClass())) return paramDeserializerFactory.createTreeDeserializer(localDeserializationConfig, paramJavaType, paramBeanDescription); return paramDeserializerFactory.createBeanDeserializer(paramDeserializationContext, paramJavaType, paramBeanDescription); }
@SuppressWarnings("unchecked") <T, U> Map<T, U> deserializeMapResult(String rawResponse, JsonNode node, Class<T> keyClass, Class<T> valueClass) { String json = node.toString(); try { MapType mapType = TypeFactory.defaultInstance().constructMapType(HashMap.class, keyClass, valueClass); return (Map<T, U>) objectMapper.readerFor(mapType).readValue(node); } catch (IOException e) { throw new InternalViSearchException(ResponseMessages.PARSE_RESPONSE_ERROR, e, rawResponse); } }
@Override public JsonDeserializer<?> findMapDeserializer(MapType type, DeserializationConfig config, BeanDescription beanDesc, KeyDeserializer keyDeserializer, TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer) throws JsonMappingException { if (MapF.class.isAssignableFrom(type.getRawClass())) { return new MapFDeserializer(type, keyDeserializer, elementTypeDeserializer, elementDeserializer); } return null; }
protected MapDeserializer(MapType type, KeyDeserializer keyDeser, TypeDeserializer typeDeser, JsonDeserializer<?> deser) { mapType = type; keyDeserializer = keyDeser; typeDeserializerForValue = typeDeser; valueDeserializer = deser; }
@BeforeClass public static void init() throws Exception { userMapper.registerModule(new GuavaModule()); testData = new ObjectMapper().readValue( Resources.toString(JsonRpcServiceTest.class.getResource("/test_data.json"), Charsets.UTF_8), MapType.construct(Map.class, SimpleType.construct(String.class), SimpleType.construct(RequestResponse.class))); }
@Override public JsonSerializer<?> findMapSerializer(SerializationConfig config, MapType type, BeanDescription beanDesc, JsonSerializer<Object> keySerializer, TypeSerializer elementTypeSerializer, JsonSerializer<Object> elementValueSerializer) { return findSerializer(config, type, beanDesc); }
/** * <p> * Parses the given JSON string and converts it into an ObjectElement object * that represents the structure of the JSON object. * </p> * * @param json The JSON object to parse and convert into an ObjectElement. * @return The JSON string converted into an ObjectElement representation. */ public ObjectElement parse(String json) { ObjectMapper mapper = new ObjectMapper(); MapType type = mapper.getTypeFactory().constructMapType(Map.class, String.class, Object.class); Map<String, Object> datamap = null; try { datamap = mapper.readValue(json, type); } catch (Exception e) { logger.error("An error occurred while parsing the JSON string below:\n" + json, e); } return asElement(this.rootName, datamap); }
@SneakyThrows private String convertToJson(String yml) { MapType type = defaultInstance().constructMapType(HashMap.class, String.class, Object.class); Map<String, Object> properties = this.ymlmapper.readValue(yml, type); return this.jsonMapper.writeValueAsString(properties); }
private MapType constructMapType(Ctx pc, TypeFactory typeFactory) { return typeFactory.constructMapType(LinkedHashMap.class, typeFactory.constructType(String.class), pc.getType().getContentType()); }
public JsonSerializer<?> modifyMapSerializer(SerializationConfig paramSerializationConfig, MapType paramMapType, BeanDescription paramBeanDescription, JsonSerializer<?> paramJsonSerializer) { return paramJsonSerializer; }
protected JsonSerializer<?> buildContainerSerializer(SerializerProvider paramSerializerProvider, JavaType paramJavaType, BeanDescription paramBeanDescription, boolean paramBoolean) { SerializationConfig localSerializationConfig = paramSerializerProvider.getConfig(); if ((!paramBoolean) && (paramJavaType.useStaticType()) && ((!paramJavaType.isContainerType()) || (paramJavaType.getContentType().getRawClass() != Object.class))) paramBoolean = true; TypeSerializer localTypeSerializer = createTypeSerializer(localSerializationConfig, paramJavaType.getContentType()); if (localTypeSerializer != null) paramBoolean = false; JsonSerializer localJsonSerializer1 = _findContentSerializer(paramSerializerProvider, paramBeanDescription.getClassInfo()); if (paramJavaType.isMapLikeType()) { MapLikeType localMapLikeType1 = (MapLikeType)paramJavaType; JsonSerializer localJsonSerializer4 = _findKeySerializer(paramSerializerProvider, paramBeanDescription.getClassInfo()); if (localMapLikeType1.isTrueMapType()) return buildMapSerializer(localSerializationConfig, (MapType)localMapLikeType1, paramBeanDescription, paramBoolean, localJsonSerializer4, localTypeSerializer, localJsonSerializer1); Iterator localIterator3 = customSerializers().iterator(); while (localIterator3.hasNext()) { Serializers localSerializers = (Serializers)localIterator3.next(); MapLikeType localMapLikeType2 = (MapLikeType)paramJavaType; JsonSerializer localJsonSerializer5 = localSerializers.findMapLikeSerializer(localSerializationConfig, localMapLikeType2, paramBeanDescription, localJsonSerializer4, localTypeSerializer, localJsonSerializer1); JsonSerializer localJsonSerializer6 = localJsonSerializer5; if (localJsonSerializer5 != null) { if (this._factoryConfig.hasSerializerModifiers()) { Iterator localIterator4 = this._factoryConfig.serializerModifiers().iterator(); while (localIterator4.hasNext()) localJsonSerializer6 = ((BeanSerializerModifier)localIterator4.next()).modifyMapLikeSerializer(localSerializationConfig, localMapLikeType2, paramBeanDescription, localJsonSerializer6); } return localJsonSerializer6; } } return null; } if (paramJavaType.isCollectionLikeType()) { CollectionLikeType localCollectionLikeType1 = (CollectionLikeType)paramJavaType; if (localCollectionLikeType1.isTrueCollectionType()) return buildCollectionSerializer(localSerializationConfig, (CollectionType)localCollectionLikeType1, paramBeanDescription, paramBoolean, localTypeSerializer, localJsonSerializer1); CollectionLikeType localCollectionLikeType2 = (CollectionLikeType)paramJavaType; Iterator localIterator1 = customSerializers().iterator(); while (localIterator1.hasNext()) { JsonSerializer localJsonSerializer2 = ((Serializers)localIterator1.next()).findCollectionLikeSerializer(localSerializationConfig, localCollectionLikeType2, paramBeanDescription, localTypeSerializer, localJsonSerializer1); JsonSerializer localJsonSerializer3 = localJsonSerializer2; if (localJsonSerializer2 != null) { if (this._factoryConfig.hasSerializerModifiers()) { Iterator localIterator2 = this._factoryConfig.serializerModifiers().iterator(); while (localIterator2.hasNext()) localJsonSerializer3 = ((BeanSerializerModifier)localIterator2.next()).modifyCollectionLikeSerializer(localSerializationConfig, localCollectionLikeType2, paramBeanDescription, localJsonSerializer3); } return localJsonSerializer3; } } return null; } if (paramJavaType.isArrayType()) return buildArraySerializer(localSerializationConfig, (ArrayType)paramJavaType, paramBeanDescription, paramBoolean, localTypeSerializer, localJsonSerializer1); return null; }
public JsonSerializer<?> findMapSerializer(SerializationConfig paramSerializationConfig, MapType paramMapType, BeanDescription paramBeanDescription, JsonSerializer<Object> paramJsonSerializer1, TypeSerializer paramTypeSerializer, JsonSerializer<Object> paramJsonSerializer2) { return null; }
public JsonSerializer<?> findMapSerializer(SerializationConfig paramSerializationConfig, MapType paramMapType, BeanDescription paramBeanDescription, JsonSerializer<Object> paramJsonSerializer1, TypeSerializer paramTypeSerializer, JsonSerializer<Object> paramJsonSerializer2) { return findSerializer(paramSerializationConfig, paramMapType, paramBeanDescription); }
public JsonDeserializer<?> findMapDeserializer(MapType paramMapType, DeserializationConfig paramDeserializationConfig, BeanDescription paramBeanDescription, KeyDeserializer paramKeyDeserializer, TypeDeserializer paramTypeDeserializer, JsonDeserializer<?> paramJsonDeserializer) { if (this._classMappings == null) return null; return (JsonDeserializer)this._classMappings.get(new ClassKey(paramMapType.getRawClass())); }
public JsonDeserializer<?> findMapDeserializer(MapType paramMapType, DeserializationConfig paramDeserializationConfig, BeanDescription paramBeanDescription, KeyDeserializer paramKeyDeserializer, TypeDeserializer paramTypeDeserializer, JsonDeserializer<?> paramJsonDeserializer) { return null; }
public JsonDeserializer<?> modifyMapDeserializer(DeserializationConfig paramDeserializationConfig, MapType paramMapType, BeanDescription paramBeanDescription, JsonDeserializer<?> paramJsonDeserializer) { return paramJsonDeserializer; }