/** * @since 1.8 */ public void addAndResolveNonTypedSerializer(JavaType type, JsonSerializer<Object> ser, SerializerProvider provider) throws JsonMappingException { synchronized (this) { if (_sharedMap.put(new TypeKey(type, false), ser) == null) { // let's invalidate the read-only copy, too, to get it updated _readOnlyMap = null; } /* Finally: some serializers want to do post-processing, after * getting registered (to handle cyclic deps). */ /* 14-May-2011, tatu: As per [JACKSON-570], resolving needs to be done * in synchronized manner; this because while we do need to register * instance first, we also must keep lock until resolution is complete */ if (ser instanceof ResolvableSerializer) { ((ResolvableSerializer) ser).resolve(provider); } } }
public JsonSerializerMap(Map<TypeKey,JsonSerializer<Object>> serializers) { int size = findSize(serializers.size()); _size = size; int hashMask = (size-1); Bucket[] buckets = new Bucket[size]; for (Map.Entry<TypeKey,JsonSerializer<Object>> entry : serializers.entrySet()) { TypeKey key = entry.getKey(); int index = key.hashCode() & hashMask; buckets[index] = new Bucket(buckets[index], key, entry.getValue()); } _buckets = buckets; }
/** * @since 1.8 */ public void addAndResolveNonTypedSerializer(JavaType type, JsonSerializer<Object> ser, SerializerProvider provider) throws JsonMappingException { synchronized (this) { if (_sharedMap.put(new TypeKey(type, false), ser) == null) { // let's invalidate the read-only copy, too, to get it updated _readOnlyMap = null; } /* Finally: some serializers want to do post-processing, after * getting registered (to handle cyclic deps). */ /* 14-May-2011, tatu: As per [JACKSON-570], resolving needs to be done * in synchronized manner; this because while we do need to register * instance first, we also must keep lock until resolution is complete */ if (ser instanceof ResolvableSerializer) { ((ResolvableSerializer) ser).resolve(provider); } } }
/** * @since 1.8 */ public void addAndResolveNonTypedSerializer(Class<?> type, JsonSerializer<Object> ser, SerializerProvider provider) throws JsonMappingException { synchronized (this) { if (_sharedMap.put(new TypeKey(type, false), ser) == null) { // let's invalidate the read-only copy, too, to get it updated _readOnlyMap = null; } /* Finally: some serializers want to do post-processing, after * getting registered (to handle cyclic deps). */ /* 14-May-2011, tatu: As per [JACKSON-570], resolving needs to be done * in synchronized manner; this because while we do need to register * instance first, we also must keep lock until resolution is complete */ if (ser instanceof ResolvableSerializer) { ((ResolvableSerializer) ser).resolve(provider); } } }
/** * @since 1.8 */ public void addAndResolveNonTypedSerializer(JavaType type, JsonSerializer<Object> ser, SerializerProvider provider) throws JsonMappingException { synchronized (this) { if (_sharedMap.put(new TypeKey(type, false), ser) == null) { // let's invalidate the read-only copy, too, to get it updated _readOnlyMap = null; } /* Finally: some serializers want to do post-processing, after * getting registered (to handle cyclic deps). */ /* 14-May-2011, tatu: As per [JACKSON-570], resolving needs to be done * in synchronized manner; this because while we do need to register * instance first, we also must keep lock until resolution is complete */ if (ser instanceof ResolvableSerializer) { ((ResolvableSerializer) ser).resolve(provider); } } }
/** * @since 1.8 */ public void addAndResolveNonTypedSerializer(Class<?> type, JsonSerializer<Object> ser, SerializerProvider provider) throws JsonMappingException { synchronized (this) { if (_sharedMap.put(new TypeKey(type, false), ser) == null) { // let's invalidate the read-only copy, too, to get it updated _readOnlyMap = null; } /* Finally: some serializers want to do post-processing, after * getting registered (to handle cyclic deps). */ /* 14-May-2011, tatu: As per [JACKSON-570], resolving needs to be done * in synchronized manner; this because while we do need to register * instance first, we also must keep lock until resolution is complete */ if (ser instanceof ResolvableSerializer) { ((ResolvableSerializer) ser).resolve(provider); } } }
public JsonSerializer<Object> find(TypeKey key) { int index = key.hashCode() & (_buckets.length-1); Bucket bucket = _buckets[index]; /* Ok let's actually try unrolling loop slightly as this shows up in profiler; * and also because in vast majority of cases first entry is either null * or matches. */ if (bucket == null) { return null; } if (key.equals(bucket.key)) { return bucket.value; } while ((bucket = bucket.next) != null) { if (key.equals(bucket.key)) { return bucket.value; } } return null; }
public JsonSerializer<Object> find(TypeKey key) { int index = key.hashCode() & (_buckets.length-1); Bucket bucket = _buckets[index]; /* Ok let's actually try unrolling loop slightly as this shows up in profiler; * and also because in vast majority of cases first entry is either null * or matches. */ if (bucket == null) { return null; } if (key.equals(bucket.key)) { return bucket.value; } while ((bucket = bucket.next) != null) { if (key.equals(bucket.key)) { return bucket.value; } } return null; }
/** * Method called if none of lookups succeeded, and caller had to construct * a serializer. If so, we will update the shared lookup map so that it * can be resolved via it next time. */ public void addTypedSerializer(JavaType type, JsonSerializer<Object> ser) { synchronized (this) { if (_sharedMap.put(new TypeKey(type, true), ser) == null) { // let's invalidate the read-only copy, too, to get it updated _readOnlyMap = null; } } }
/** * Method called if none of lookups succeeded, and caller had to construct * a serializer. If so, we will update the shared lookup map so that it * can be resolved via it next time. */ public void addTypedSerializer(JavaType type, JsonSerializer<Object> ser) { synchronized (this) { if (_sharedMap.put(new TypeKey(type, true), ser) == null) { // let's invalidate the read-only copy, too, to get it updated _readOnlyMap = null; } } }
public JsonSerializerMap(Map<TypeKey,JsonSerializer<Object>> serializers) { int size = findSize(serializers.size()); _size = size; int hashMask = (size-1); Bucket[] buckets = new Bucket[size]; for (Map.Entry<TypeKey,JsonSerializer<Object>> entry : serializers.entrySet()) { TypeKey key = entry.getKey(); int index = key.hashCode() & hashMask; buckets[index] = new Bucket(buckets[index], key, entry.getValue()); } _buckets = buckets; }
/** * Method that checks if the shared (and hence, synchronized) lookup Map might have * untyped serializer for given type. */ public JsonSerializer<Object> untypedValueSerializer(Class<?> type) { synchronized (this) { return _sharedMap.get(new TypeKey(type, false)); } }
public TypeKey(JavaType key, boolean typed) { _type = key; _class = null; _isTyped = typed; _hashCode = hash(key, typed); }
/** * @since 1.5 */ public JsonSerializer<Object> untypedValueSerializer(JavaType type) { synchronized (this) { return _sharedMap.get(new TypeKey(type, false)); } }
/** * Method that checks if the shared (and hence, synchronized) lookup Map might have * untyped serializer for given type. */ public JsonSerializer<Object> untypedValueSerializer(Class<?> type) { synchronized (this) { return _sharedMap.get(new TypeKey(type, false)); } }
public JsonSerializer<Object> untypedValueSerializer(JavaType type) { _cacheKey.resetUntyped(type); return _map.find(_cacheKey); } }
public TypeKey(JavaType key, boolean typed) { _type = key; _class = null; _isTyped = typed; _hashCode = hash(key, typed); }
public JsonSerializer<Object> typedValueSerializer(Class<?> cls) { _cacheKey.resetTyped(cls); return _map.find(_cacheKey); }
public JsonSerializerMap(Map<TypeKey,JsonSerializer<Object>> serializers) { int size = findSize(serializers.size()); _size = size; int hashMask = (size-1); Bucket[] buckets = new Bucket[size]; for (Map.Entry<TypeKey,JsonSerializer<Object>> entry : serializers.entrySet()) { TypeKey key = entry.getKey(); int index = key.hashCode() & hashMask; buckets[index] = new Bucket(buckets[index], key, entry.getValue()); } _buckets = buckets; }
public JsonSerializer<Object> typedValueSerializer(JavaType type) { synchronized (this) { return _sharedMap.get(new TypeKey(type, true)); } }