/** * Factory method for constructing an instance. */ public static ReadOnlyClassToSerializerMap from(HashMap<TypeKey, JsonSerializer<Object>> src) { return new ReadOnlyClassToSerializerMap(src); }
private final synchronized ReadOnlyClassToSerializerMap _makeReadOnlyLookupMap() { // double-locking; safe, but is it really needed? Not doing that is only a perf problem, // not correctness ReadOnlyClassToSerializerMap m = _readOnlyMap.get(); if (m == null) { m = ReadOnlyClassToSerializerMap.from(_sharedMap); _readOnlyMap.set(m); } return m; }
JsonSerializer<Object> ser = _knownSerializers.typedValueSerializer(valueType); if (ser != null) { return ser;
/** * Method that will try to find a serializer, either from cache * or by constructing one; but will not return an "unknown" serializer * if this cannot be done but rather returns null. * * @return Serializer if one can be found, null if not. */ protected JsonSerializer<Object> _findExplicitUntypedSerializer(Class<?> runtimeType) throws JsonMappingException { // Fast lookup from local lookup thingy works? JsonSerializer<Object> ser = _knownSerializers.untypedValueSerializer(runtimeType); if (ser == null) { // If not, maybe shared map already has it? ser = _serializerCache.untypedValueSerializer(runtimeType); if (ser == null) { ser = _createAndCacheUntypedSerializer(runtimeType); } } /* 18-Sep-2014, tatu: This is unfortunate patch over related change * that pushes creation of "unknown type" serializer deeper down * in BeanSerializerFactory; as a result, we need to "undo" creation * here. */ if (isUnknownTypeSerializer(ser)) { return null; } return ser; }
/** * Method that can be called to get a read-only instance populated from the * most recent version of the shared lookup Map. */ public ReadOnlyClassToSerializerMap getReadOnlyLookupMap() { ReadOnlyClassToSerializerMap m; synchronized (this) { m = _readOnlyMap; if (m == null) { _readOnlyMap = m = ReadOnlyClassToSerializerMap.from(_sharedMap); } } return m.instance(); }
public ReadOnlyClassToSerializerMap(Map<TypeKey,JsonSerializer<Object>> serializers) { int size = findSize(serializers.size()); _size = size; _mask = (size-1); Bucket[] buckets = new Bucket[size]; for (Map.Entry<TypeKey,JsonSerializer<Object>> entry : serializers.entrySet()) { TypeKey key = entry.getKey(); int index = key.hashCode() & _mask; buckets[index] = new Bucket(buckets[index], key, entry.getValue()); } _buckets = buckets; }
/** * Method variant used when we do NOT want contextualization to happen; it will need * to be handled at a later point, but caller wants to be able to do that * as needed; sometimes to avoid infinite loops * * @since 2.5 */ public JsonSerializer<Object> findValueSerializer(JavaType valueType) throws JsonMappingException { // (see comments from above method) JsonSerializer<Object> ser = _knownSerializers.untypedValueSerializer(valueType); if (ser == null) { ser = _serializerCache.untypedValueSerializer(valueType); if (ser == null) { ser = _createAndCacheUntypedSerializer(valueType); if (ser == null) { ser = getUnknownTypeSerializer(valueType.getRawClass()); if (CACHE_UNKNOWN_MAPPINGS) { _serializerCache.addAndResolveNonTypedSerializer(valueType, ser, this); } } } } return ser; }
/** * Method that can be called to get a read-only instance populated from the * most recent version of the shared lookup Map. */ public ReadOnlyClassToSerializerMap getReadOnlyLookupMap() { ReadOnlyClassToSerializerMap m; synchronized (this) { m = _readOnlyMap; if (m == null) { _readOnlyMap = m = ReadOnlyClassToSerializerMap.from(_sharedMap); } } return m.instance(); }
public ReadOnlyClassToSerializerMap(Map<TypeKey,JsonSerializer<Object>> serializers) { int size = findSize(serializers.size()); _size = size; _mask = (size-1); Bucket[] buckets = new Bucket[size]; for (Map.Entry<TypeKey,JsonSerializer<Object>> entry : serializers.entrySet()) { TypeKey key = entry.getKey(); int index = key.hashCode() & _mask; buckets[index] = new Bucket(buckets[index], key, entry.getValue()); } _buckets = buckets; }
/** * Method variant used when we do NOT want contextualization to happen; it will need * to be handled at a later point, but caller wants to be able to do that * as needed; sometimes to avoid infinite loops * * @since 2.5 */ public JsonSerializer<Object> findValueSerializer(Class<?> valueType) throws JsonMappingException { // (see comments from above method) JsonSerializer<Object> ser = _knownSerializers.untypedValueSerializer(valueType); if (ser == null) { ser = _serializerCache.untypedValueSerializer(valueType); if (ser == null) { ser = _serializerCache.untypedValueSerializer(_config.constructType(valueType)); if (ser == null) { ser = _createAndCacheUntypedSerializer(valueType); if (ser == null) { ser = getUnknownTypeSerializer(valueType); if (CACHE_UNKNOWN_MAPPINGS) { _serializerCache.addAndResolveNonTypedSerializer(valueType, ser, this); } } } } } return ser; }
JsonSerializer<Object> ser = _knownSerializers.typedValueSerializer(valueType); if (ser != null) { return ser;
/** * Factory method for constructing an instance. */ public static ReadOnlyClassToSerializerMap from(HashMap<TypeKey, JsonSerializer<Object>> src) { return new ReadOnlyClassToSerializerMap(src); }
/** * Method that can be called to get a read-only instance populated from the * most recent version of the shared lookup Map. */ public ReadOnlyClassToSerializerMap getReadOnlyLookupMap() { ReadOnlyClassToSerializerMap m = _readOnlyMap; if(m == null) { synchronized (this) { m = _readOnlyMap; if (m == null) { _readOnlyMap = m = ReadOnlyClassToSerializerMap.from(_sharedMap); } } } return m.instance(); }
private final synchronized ReadOnlyClassToSerializerMap _makeReadOnlyLookupMap() { // double-locking; safe, but is it really needed? Not doing that is only a perf problem, // not correctness ReadOnlyClassToSerializerMap m = _readOnlyMap.get(); if (m == null) { m = ReadOnlyClassToSerializerMap.from(_sharedMap); _readOnlyMap.set(m); } return m; }
public ReadOnlyClassToSerializerMap(Map<TypeKey,JsonSerializer<Object>> serializers) { int size = findSize(serializers.size()); _size = size; _mask = (size-1); Bucket[] buckets = new Bucket[size]; for (Map.Entry<TypeKey,JsonSerializer<Object>> entry : serializers.entrySet()) { TypeKey key = entry.getKey(); int index = key.hashCode() & _mask; buckets[index] = new Bucket(buckets[index], key, entry.getValue()); } _buckets = buckets; }
throws JsonMappingException JsonSerializer<Object> ser = _knownSerializers.untypedValueSerializer(valueType); if (ser == null) { ser = _serializerCache.untypedValueSerializer(valueType);
JsonSerializer<Object> ser = _knownSerializers.typedValueSerializer(valueType); if (ser != null) { return ser;
/** * Factory method for constructing an instance. */ public static ReadOnlyClassToSerializerMap from(HashMap<TypeKey, JsonSerializer<Object>> src) { return new ReadOnlyClassToSerializerMap(src); }
/** * Method that can be called to get a read-only instance populated from the * most recent version of the shared lookup Map. */ public ReadOnlyClassToSerializerMap getReadOnlyLookupMap() { ReadOnlyClassToSerializerMap m = _readOnlyMap; if(m == null) { synchronized (this) { m = _readOnlyMap; if (m == null) { _readOnlyMap = m = ReadOnlyClassToSerializerMap.from(_sharedMap); } } } return m.instance(); }
private final synchronized ReadOnlyClassToSerializerMap _makeReadOnlyLookupMap() { // double-locking; safe, but is it really needed? Not doing that is only a perf problem, // not correctness ReadOnlyClassToSerializerMap m = _readOnlyMap.get(); if (m == null) { m = ReadOnlyClassToSerializerMap.from(_sharedMap); _readOnlyMap.set(m); } return m; }