Remove deprecated JSONCodecFactory methods

These methods have been moved to JSONCodecFactorySupplier, remove
their deprecated definitions.

Change-Id: I78860c620155c80c02669e70b879ca30a75eb3a7
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>

diff --git a/yang/yang-data-codec-gson/src/main/java/org/opendaylight/yangtools/yang/data/codec/gson/JSONCodecFactory.java b/yang/yang-data-codec-gson/src/main/java/org/opendaylight/yangtools/yang/data/codec/gson/JSONCodecFactory.java
index 9097e7fcb9a3036b2ee8fb795c833029737f8b6d..6d80e7ab1530da65bd3045a41565ba14cdea2465 100644 (file)
--- a/yang/yang-data-codec-gson/src/main/java/org/opendaylight/yangtools/yang/data/codec/gson/JSONCodecFactory.java
+++ b/yang/yang-data-codec-gson/src/main/java/org/opendaylight/yangtools/yang/data/codec/gson/JSONCodecFactory.java
@@ -11,7 +11,6 @@ import static com.google.common.base.Verify.verifyNotNull;
 
 import com.google.common.annotations.Beta;
 import java.util.List;
-import java.util.Optional;
 import java.util.function.BiFunction;
 import org.opendaylight.yangtools.yang.common.QNameModule;
 import org.opendaylight.yangtools.yang.data.impl.codec.AbstractIntegerStringCodec;
@@ -47,11 +46,6 @@ import org.opendaylight.yangtools.yang.model.api.type.UnknownTypeDefinition;
 /**
  * Factory for creating JSON equivalents of codecs. Each instance of this object is bound to
  * a particular {@link SchemaContext}, but can be reused by multiple {@link JSONNormalizedNodeStreamWriter}s.
- *
- * <p>
- * There are multiple implementations available, each with distinct thread-safety, CPU/memory trade-offs and reuse
- * characteristics. See {@link #getShared(SchemaContext)}, {@link #getPrecomputed(SchemaContext)},
- * {@link #createLazy(SchemaContext)} and {@link #createSimple(SchemaContext)} for details.
  */
 @Beta
 public final class JSONCodecFactory extends AbstractCodecFactory<JSONCodec<?>> {
@@ -63,112 +57,6 @@ public final class JSONCodecFactory extends AbstractCodecFactory<JSONCodec<?>> {
         iidCodec = verifyNotNull(iidCodecSupplier.apply(context, this));
     }
 
-    /**
-     * Get a thread-safe, eagerly-caching {@link JSONCodecFactory} for a SchemaContext. This method can, and will,
-     * return the same instance as long as the associated SchemaContext is present. Returned object can be safely
-     * used by multiple threads concurrently. If the SchemaContext instance does not have a cached instance
-     * of {@link JSONCodecFactory}, it will be completely precomputed before this method will return.
-     *
-     * <p>
-     * 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(SchemaContext)}, this implementation is expected to offer higher performance and have lower
-     * peak memory footprint when most of the SchemaContext is actually in use.
-     *
-     * <p>
-     * 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(SchemaContext)}.
-     *
-     * @param context SchemaContext instance
-     * @return A sharable {@link JSONCodecFactory}
-     * @throws NullPointerException if context is null
-     *
-     * @deprecated Use {@link JSONCodecFactorySupplier#getPrecomputed(SchemaContext)} instead.
-     */
-    @Deprecated
-    public static JSONCodecFactory getPrecomputed(final SchemaContext context) {
-        return JSONCodecFactorySupplier.DRAFT_LHOTKA_NETMOD_YANG_JSON_02.getPrecomputed(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(SchemaContext)} 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
-     *
-     * @deprecated Use {@link JSONCodecFactorySupplier#getPrecomputedIfAvailable(SchemaContext)} instead.
-     */
-    @Deprecated
-    public static Optional<JSONCodecFactory> getPrecomputedIfAvailable(final SchemaContext context) {
-        return JSONCodecFactorySupplier.DRAFT_LHOTKA_NETMOD_YANG_JSON_02.getPrecomputedIfAvailable(context);
-    }
-
-    /**
-     * Get a thread-safe, lazily-caching {@link JSONCodecFactory} for a SchemaContext. This method can, and will,
-     * return the same instance as long as the associated SchemaContext is present or the factory is not invalidated
-     * by memory pressure. Returned object can be safely used by multiple threads concurrently.
-     *
-     * <p>
-     * 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
-     *
-     * @deprecated Use {@link JSONCodecFactorySupplier#getShared(SchemaContext)} instead.
-     */
-    @Deprecated
-    public static JSONCodecFactory getShared(final SchemaContext context) {
-        return JSONCodecFactorySupplier.DRAFT_LHOTKA_NETMOD_YANG_JSON_02.getShared(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.
-     *
-     * <p>
-     * 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
-     *
-     * @deprecated Use {@link JSONCodecFactorySupplier#createLazy(SchemaContext)} instead.
-     */
-    @Deprecated
-    public static JSONCodecFactory createLazy(final SchemaContext context) {
-        return JSONCodecFactorySupplier.DRAFT_LHOTKA_NETMOD_YANG_JSON_02.createLazy(context);
-    }
-
-    /**
-     * Create a simplistic, thread-safe {@link JSONCodecFactory} for a {@link SchemaContext}. This method will return
-     * distinct objects every time it is invoked. Returned object may be use from multiple threads concurrently.
-     *
-     * <p>
-     * 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.
-     *
-     * @deprecated Use {@link JSONCodecFactorySupplier#createSimple(SchemaContext)} instead.
-     */
-    @Deprecated
-    public static JSONCodecFactory createSimple(final SchemaContext context) {
-        return JSONCodecFactorySupplier.DRAFT_LHOTKA_NETMOD_YANG_JSON_02.createSimple(context);
-    }
-
     @Override
     protected JSONCodec<?> binaryCodec(final BinaryTypeDefinition type) {
         return new QuotedJSONCodec<>(BinaryStringCodec.from(type));