Enable checkstyle on yang-data-codec-gson

[yangtools.git] / yang / yang-data-codec-gson / src / main / java / org / opendaylight / yangtools / yang / data / codec / gson / JSONCodecFactory.java

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 c24db7699414d8d762b6e4a78e70d77547e7df5e..7769eb1ed7da8a850946850f21881d43ef4a9a92 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
@@ -52,6 +52,7 @@ import org.slf4j.LoggerFactory;
  * 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.
@@ -129,11 +130,13 @@ public final class JSONCodecFactory extends AbstractCodecFactory<JSONCodec<?>> {
      * 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)}.
@@ -166,6 +169,7 @@ public final class JSONCodecFactory extends AbstractCodecFactory<JSONCodec<?>> {
      * 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.
      *
@@ -182,6 +186,7 @@ public final class JSONCodecFactory extends AbstractCodecFactory<JSONCodec<?>> {
      * 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.
      *
@@ -197,6 +202,7 @@ public final class JSONCodecFactory extends AbstractCodecFactory<JSONCodec<?>> {
      * 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.