package com.fasterxml.jackson.databind.introspect;

import java.util.HashMap;
import java.util.Map;

import com.fasterxml.jackson.databind.type.ClassKey;

Simple implementation of MixInResolver that just uses a Map for containing mapping from target to mix-in classes.

Implementation is only thread-safe after initialization (that is, when underlying Map is not modified but only read).

Since:2.6
/** * Simple implementation of {@link ClassIntrospector.MixInResolver} * that just uses a {@link java.util.Map} for containing mapping * from target to mix-in classes. *<p> * Implementation is only thread-safe after initialization (that is, * when underlying Map is not modified but only read). * * @since 2.6 */
public class SimpleMixInResolver implements ClassIntrospector.MixInResolver, java.io.Serializable { private static final long serialVersionUID = 1L;
External resolver that gets called before looking at any locally defined mix-in target classes.
/** * External resolver that gets called before looking at any locally defined * mix-in target classes. */
protected final ClassIntrospector.MixInResolver _overrides;
Simple mix-in targets defined locally.
/** * Simple mix-in targets defined locally. */
protected Map<ClassKey,Class<?>> _localMixIns; public SimpleMixInResolver(ClassIntrospector.MixInResolver overrides) { _overrides = overrides; } protected SimpleMixInResolver(ClassIntrospector.MixInResolver overrides, Map<ClassKey,Class<?>> mixins) { _overrides = overrides; _localMixIns = mixins; }
Mutant factory for constructor a new resolver instance with given mix-in resolver override.
/** * Mutant factory for constructor a new resolver instance with given * mix-in resolver override. */
public SimpleMixInResolver withOverrides(ClassIntrospector.MixInResolver overrides) { return new SimpleMixInResolver(overrides, _localMixIns); }
Mutant factory method that constructs a new instance that has no locally defined mix-in/target mappings.
/** * Mutant factory method that constructs a new instance that has no locally * defined mix-in/target mappings. */
public SimpleMixInResolver withoutLocalDefinitions() { return new SimpleMixInResolver(_overrides, null); } public void setLocalDefinitions(Map<Class<?>, Class<?>> sourceMixins) { if (sourceMixins == null || sourceMixins.isEmpty()) { _localMixIns = null; } else { Map<ClassKey,Class<?>> mixIns = new HashMap<ClassKey,Class<?>>(sourceMixins.size()); for (Map.Entry<Class<?>,Class<?>> en : sourceMixins.entrySet()) { mixIns.put(new ClassKey(en.getKey()), en.getValue()); } _localMixIns = mixIns; } } public void addLocalDefinition(Class<?> target, Class<?> mixinSource) { if (_localMixIns == null) { _localMixIns = new HashMap<ClassKey,Class<?>>(); } _localMixIns.put(new ClassKey(target), mixinSource); } @Override public SimpleMixInResolver copy() { ClassIntrospector.MixInResolver overrides = (_overrides == null) ? null : _overrides.copy(); Map<ClassKey,Class<?>> mixIns = (_localMixIns == null) ? null : new HashMap<ClassKey,Class<?>>(_localMixIns); return new SimpleMixInResolver(overrides, mixIns); } @Override public Class<?> findMixInClassFor(Class<?> cls) { Class<?> mixin = (_overrides == null) ? null : _overrides.findMixInClassFor(cls); if (mixin == null && (_localMixIns != null)) { mixin = _localMixIns.get(new ClassKey(cls)); } return mixin; } public int localSize() { return (_localMixIns == null) ? 0 : _localMixIns.size(); }
Method that may be called for optimization purposes, to see if calls to mix-in resolver may be avoided. Return value of true means that it is possible that a mix-in class will be found; false that no mix-in will ever be found. In latter case caller can avoid calls altogether.

Note that the reason for "empty" resolvers is to use "null object" for simplifying code.

Returns:True, if this resolver MAY have mix-ins to apply; false if not (it is "empty")
Since:2.10.1
/** * Method that may be called for optimization purposes, to see if calls to * mix-in resolver may be avoided. Return value of {@code true} means that * it is possible that a mix-in class will be found; {@code false} that no * mix-in will ever be found. In latter case caller can avoid calls altogether. *<p> * Note that the reason for "empty" resolvers is to use "null object" for simplifying * code. * * @return True, if this resolver MAY have mix-ins to apply; false if not (it * is "empty") * * @since 2.10.1 */
public boolean hasMixIns() { if (_localMixIns == null) { // if neither local mix-ins nor overrides, no mix-ins if (_overrides == null) { return false; } // or, if no local mix-ins and can delegate to resolver if (_overrides instanceof SimpleMixInResolver) { return ((SimpleMixInResolver) _overrides).hasMixIns(); } } // cannot rule out the possibility, so... return true; } }