Fixed Checkstyle violation errors in mdsal-common-api

[mdsal.git] / common / mdsal-common-api / src / main / java / org / opendaylight / mdsal / common / api / TransactionChain.java

diff --git a/common/mdsal-common-api/src/main/java/org/opendaylight/mdsal/common/api/TransactionChain.java b/common/mdsal-common-api/src/main/java/org/opendaylight/mdsal/common/api/TransactionChain.java
index 8eb2e9c0d5b9951bf6bd4a22fb5c3d196331b9ea..d6ef81c7a70b1156fd48696763c96734d1b953a7 100644 (file)
--- a/common/mdsal-common-api/src/main/java/org/opendaylight/mdsal/common/api/TransactionChain.java
+++ b/common/mdsal-common-api/src/main/java/org/opendaylight/mdsal/common/api/TransactionChain.java
@@ -14,7 +14,6 @@ import org.opendaylight.yangtools.concepts.Path;
  * sequence and each transaction should see the effects of previous committed transactions
  * as they occurred. A chain makes no guarantees of atomicity across the chained transactions -
  * the transactions are committed as soon as possible in the order that they were submitted.
- *
  * This behaviour is different from the default AsyncDataBroker, where a
  * transaction is always created from the current global state, not taking into
  * account any transactions previously committed by the calling thread. Due to
@@ -29,13 +28,11 @@ import org.opendaylight.yangtools.concepts.Path;
  * AsyncReadTransaction t2 = broker.newReadOnlyTransaction();
  * Optional<?> maybeData = t2.read(id).get();
  * </code></pre>
- *
  * it may happen, that it sees maybeData.isPresent() == false, simply because
  * t1 has not completed the processes of being applied and t2 is actually
  * allocated from the previous state. This is obviously bad for users who create
  * incremental state in the datastore and actually read what they write in
  * subsequent transactions.
- *
  * Using a TransactionChain instead of a broker solves this particular problem,
  * and leads to expected behavior: t2 will always see the data written in t1
  * present.
@@ -50,6 +47,7 @@ public interface TransactionChain<P extends Path<P>, D> extends AutoCloseable,
      * The previous write transaction has to be either SUBMITTED
      * ({@link AsyncWriteTransaction#submit submit} was invoked) or CANCELLED
      * ({@link #close close} was invoked).
+     *
      * <p>
      * The returned read-only transaction presents an isolated view of the data if the previous
      * write transaction was successful - in other words, this read-only transaction will see the
@@ -64,34 +62,7 @@ public interface TransactionChain<P extends Path<P>, D> extends AutoCloseable,
      *             if the chain has been closed.
      */
     @Override
-    public AsyncReadOnlyTransaction<P, D> newReadOnlyTransaction();
-
-    /**
-     * Create a new read-write transaction which will continue the chain.
-     *
-     * <p>
-     * The previous write transaction has to be either SUBMITTED
-     * ({@link AsyncWriteTransaction#submit submit} was invoked) or CANCELLED
-     * ({@link #close close} was invoked).
-     * <p>
-     * The returned read-write transaction presents an isolated view of the data if the previous
-     * write transaction was successful - in other words, this read-write transaction will see the
-     * state changes made by the previous write transaction in the chain. However, state which
-     * was introduced by other transactions outside this transaction chain after creation of
-     * the previous transaction is not visible.
-     * <p>
-     * Committing this read-write transaction using {@link AsyncWriteTransaction#submit submit}
-     * will submit the state changes in this transaction to be visible to any subsequent
-     * transaction in this chain and also to any transaction outside this chain.
-     *
-     * @return New transaction in the chain.
-     * @throws IllegalStateException
-     *             if the previous transaction was not SUBMITTED or CANCELLED.
-     * @throws TransactionChainClosedException
-     *             if the chain has been closed.
-     */
-    @Override
-    public AsyncReadWriteTransaction<P, D> newReadWriteTransaction();
+    AsyncReadTransaction<P, D> newReadOnlyTransaction();
 
     /**
      * Create a new write-only transaction which will continue the chain.
@@ -99,13 +70,15 @@ public interface TransactionChain<P extends Path<P>, D> extends AutoCloseable,
      * <p>
      * The previous write transaction has to be either SUBMITTED
      * ({@link AsyncWriteTransaction#submit submit} was invoked) or CANCELLED
-     * ({@link #close close} was invoked).
+     * ({@link #close close} was invoked)
+     *
      * <p>
      * The returned write-only transaction presents an isolated view of the data if the previous
      * write transaction was successful - in other words, this write-only transaction will see the
      * state changes made by the previous write transaction in the chain. However, state which
      * was introduced by other transactions outside this transaction chain after creation of
-     * the previous transaction is not visible.
+     * the previous transaction is not visible
+     *
      * <p>
      * Committing this write-only transaction using {@link AsyncWriteTransaction#submit submit}
      * will submit the state changes in this transaction to be visible to any subsequent
@@ -118,7 +91,7 @@ public interface TransactionChain<P extends Path<P>, D> extends AutoCloseable,
      *             if the chain has been closed.
      */
     @Override
-    public AsyncWriteTransaction<P, D> newWriteOnlyTransaction();
+    AsyncWriteTransaction<P, D> newWriteOnlyTransaction();
 
     @Override
     void close();