* Choosing this implementation is appropriate when the memory overhead of keeping a full codec tree is not as * great a concern as predictable performance. When compared to the implementation returned by * {@link #getShared(EffectiveModelContext)}, this implementation is expected to offer higher performance and have * lower peak memory footprint when most of the SchemaContext is actually in use. * *
* For call sites which do not want to pay the CPU cost of pre-computing this implementation, but still would like
* to use it if is available (by being populated by some other caller), you can use
* {@link #getPrecomputedIfAvailable(EffectiveModelContext)}.
*
* @param context SchemaContext instance
* @return A sharable {@link JSONCodecFactory}
* @throws NullPointerException if context is null
*/
public @NonNull JSONCodecFactory getPrecomputed(final @NonNull EffectiveModelContext context) {
return verifyNotNull(precomputed.getUnchecked(context));
}
/**
* Get a thread-safe, eagerly-caching {@link JSONCodecFactory} for a SchemaContext, if it is available. This
* method is a non-blocking equivalent of {@link #getPrecomputed(EffectiveModelContext)} for use in code paths where
* the potential of having to pre-compute the implementation is not acceptable. One such scenario is when the
* code base wants to opportunistically take advantage of pre-computed version, but is okay with a fallback to
* a different implementation.
*
* @param context SchemaContext instance
* @return A sharable {@link JSONCodecFactory}, or absent if such an implementation is not available.
* @throws NullPointerException if context is null
*/
public @NonNull Optional
* Choosing this implementation is a safe default, as it will not incur prohibitive blocking, nor will it tie up
* memory in face of pressure.
*
* @param context SchemaContext instance
* @return A sharable {@link JSONCodecFactory}
* @throws NullPointerException if context is null
*/
public @NonNull JSONCodecFactory getShared(final @NonNull EffectiveModelContext context) {
return verifyNotNull(shared.getUnchecked(context));
}
/**
* Create a new thread-unsafe, lazily-caching {@link JSONCodecFactory} for a SchemaContext. This method will
* return distinct objects every time it is invoked. Returned object may not be used from multiple threads
* concurrently.
*
*
* This implementation is appropriate for one-off serialization from a single thread. It will aggressively cache
* codecs for reuse and will tie them up in memory until the factory is freed.
*
* @param context SchemaContext instance
* @return A non-sharable {@link JSONCodecFactory}
* @throws NullPointerException if context is null
*/
public @NonNull JSONCodecFactory createLazy(final @NonNull EffectiveModelContext context) {
return createFactory(context, new LazyCodecCache<>());
}
/**
* Create a simplistic, thread-safe {@link JSONCodecFactory} for a {@link EffectiveModelContext}. This method will
* return distinct objects every time it is invoked. Returned object may be use from multiple threads concurrently.
*
*
* This implementation exists mostly for completeness only, as it does not perform any caching at all and each codec
* is computed every time it is requested. This may be useful in extremely constrained environments, where memory
* footprint is more critical than performance.
*
* @param context SchemaContext instance
* @return A non-sharable {@link JSONCodecFactory}
* @throws NullPointerException if context is null.
*/
public @NonNull JSONCodecFactory createSimple(final @NonNull EffectiveModelContext context) {
return createFactory(context, NoopCodecCache.getInstance());
}
abstract @NonNull JSONCodecFactory createFactory(EffectiveModelContext context, CodecCache