+ * <h4>Change compatibility</h4>
+ * There are several sets of changes which could be considered incompatible between two transactions which are
+ * derived from same initial state. Rules for conflict detection applies recursively for each subtree level.
+ *
+ * <h4>Change compatibility of leafs, leaf-list items</h4>
+ * Following table shows state changes and failures between two concurrent transactions, which are based on same
+ * initial state, Tx 1 completes successfully before Tx 2 is committed.
+ *
+ * <table>
+ * <caption>Change compatibility of leaf values</caption>
+ * <tr>
+ * <th>Initial state</th>
+ * <th>Tx 1</th>
+ * <th>Tx 2</th>
+ * <th>Result</th>
+ * </tr>
+ * <tr>
+ * <td>Empty</td>
+ * <td>put(A,1)</td>
+ * <td>put(A,2)</td>
+ * <td>Tx 2 will fail, state is A=1</td>
+ * </tr>
+ * <tr>
+ * <td>Empty</td>
+ * <td>put(A,1)</td>
+ * <td>merge(A,2)</td>
+ * <td>A=2</td>
+ * </tr>
+ *
+ * <tr>
+ * <td>Empty</td>
+ * <td>merge(A,1)</td>
+ * <td>put(A,2)</td>
+ * <td>Tx 2 will fail, state is A=1</td>
+ * </tr>
+ * <tr>
+ * <td>Empty</td>
+ * <td>merge(A,1)</td>
+ * <td>merge(A,2)</td>
+ * <td>A=2</td>
+ * </tr>
+ *
+ *
+ * <tr>
+ * <td>A=0</td>
+ * <td>put(A,1)</td>
+ * <td>put(A,2)</td>
+ * <td>Tx 2 will fail, A=1</td>
+ * </tr>
+ * <tr>
+ * <td>A=0</td>
+ * <td>put(A,1)</td>
+ * <td>merge(A,2)</td>
+ * <td>A=2</td>
+ * </tr>
+ * <tr>
+ * <td>A=0</td>
+ * <td>merge(A,1)</td>
+ * <td>put(A,2)</td>
+ * <td>Tx 2 will fail, A=1</td>
+ * </tr>
+ * <tr>
+ * <td>A=0</td>
+ * <td>merge(A,1)</td>
+ * <td>merge(A,2)</td>
+ * <td>A=2</td>
+ * </tr>
+ *
+ * <tr>
+ * <td>A=0</td>
+ * <td>delete(A)</td>
+ * <td>put(A,2)</td>
+ * <td>Tx 2 will fail, A does not exists</td>
+ * </tr>
+ * <tr>
+ * <td>A=0</td>
+ * <td>delete(A)</td>
+ * <td>merge(A,2)</td>
+ * <td>A=2</td>
+ * </tr>
+ * </table>
+ *
+ * <h4>Change compatibility of subtrees</h4>
+ * Following table shows state changes and failures between two concurrent transactions, which are based on same
+ * initial state, Tx 1 completes successfully before Tx 2 is committed.
+ *
+ * <table>
+ * <caption>Change compatibility of containers</caption>
+ * <tr>
+ * <th>Initial state</th>
+ * <th>Tx 1</th>
+ * <th>Tx 2</th>
+ * <th>Result</th>
+ * </tr>
+ *
+ * <tr>
+ * <td>Empty</td>
+ * <td>put(TOP,[])</td>
+ * <td>put(TOP,[])</td>
+ * <td>Tx 2 will fail, state is TOP=[]</td>
+ * </tr>
+ * <tr>
+ * <td>Empty</td>
+ * <td>put(TOP,[])</td>
+ * <td>merge(TOP,[])</td>
+ * <td>TOP=[]</td>
+ * </tr>
+ *
+ * <tr>
+ * <td>Empty</td>
+ * <td>put(TOP,[FOO=1])</td>
+ * <td>put(TOP,[BAR=1])</td>
+ * <td>Tx 2 will fail, state is TOP=[FOO=1]</td>
+ * </tr>
+ * <tr>
+ * <td>Empty</td>
+ * <td>put(TOP,[FOO=1])</td>
+ * <td>merge(TOP,[BAR=1])</td>
+ * <td>TOP=[FOO=1,BAR=1]</td>
+ * </tr>
+ *
+ * <tr>
+ * <td>Empty</td>
+ * <td>merge(TOP,[FOO=1])</td>
+ * <td>put(TOP,[BAR=1])</td>
+ * <td>Tx 2 will fail, state is TOP=[FOO=1]</td>
+ * </tr>
+ * <tr>
+ * <td>Empty</td>
+ * <td>merge(TOP,[FOO=1])</td>
+ * <td>merge(TOP,[BAR=1])</td>
+ * <td>TOP=[FOO=1,BAR=1]</td>
+ * </tr>
+ *
+ * <tr>
+ * <td>TOP=[]</td>
+ * <td>put(TOP,[FOO=1])</td>
+ * <td>put(TOP,[BAR=1])</td>
+ * <td>Tx 2 will fail, state is TOP=[FOO=1]</td>
+ * </tr>
+ * <tr>
+ * <td>TOP=[]</td>
+ * <td>put(TOP,[FOO=1])</td>
+ * <td>merge(TOP,[BAR=1])</td>
+ * <td>state is TOP=[FOO=1,BAR=1]</td>
+ * </tr>
+ * <tr>
+ * <td>TOP=[]</td>
+ * <td>merge(TOP,[FOO=1])</td>
+ * <td>put(TOP,[BAR=1])</td>
+ * <td>Tx 2 will fail, state is TOP=[FOO=1]</td>
+ * </tr>
+ * <tr>
+ * <td>TOP=[]</td>
+ * <td>merge(TOP,[FOO=1])</td>
+ * <td>merge(TOP,[BAR=1])</td>
+ * <td>state is TOP=[FOO=1,BAR=1]</td>
+ * </tr>
+ * <tr>
+ * <td>TOP=[]</td>
+ * <td>delete(TOP)</td>
+ * <td>put(TOP,[BAR=1])</td>
+ * <td>Tx 2 will fail, state is empty store</td>
+ * </tr>
+ * <tr>
+ * <td>TOP=[]</td>
+ * <td>delete(TOP)</td>
+ * <td>merge(TOP,[BAR=1])</td>
+ * <td>state is TOP=[BAR=1]</td>
+ * </tr>
+ *
+ * <tr>
+ * <td>TOP=[]</td>
+ * <td>put(TOP/FOO,1)</td>
+ * <td>put(TOP/BAR,1])</td>
+ * <td>state is TOP=[FOO=1,BAR=1]</td>
+ * </tr>
+ * <tr>
+ * <td>TOP=[]</td>
+ * <td>put(TOP/FOO,1)</td>
+ * <td>merge(TOP/BAR,1)</td>
+ * <td>state is TOP=[FOO=1,BAR=1]</td>
+ * </tr>
+ * <tr>
+ * <td>TOP=[]</td>
+ * <td>merge(TOP/FOO,1)</td>
+ * <td>put(TOP/BAR,1)</td>
+ * <td>state is TOP=[FOO=1,BAR=1]</td>
+ * </tr>
+ * <tr>
+ * <td>TOP=[]</td>
+ * <td>merge(TOP/FOO,1)</td>
+ * <td>merge(TOP/BAR,1)</td>
+ * <td>state is TOP=[FOO=1,BAR=1]</td>
+ * </tr>
+ * <tr>
+ * <td>TOP=[]</td>
+ * <td>delete(TOP)</td>
+ * <td>put(TOP/BAR,1)</td>
+ * <td>Tx 2 will fail, state is empty store</td>
+ * </tr>
+ * <tr>
+ * <td>TOP=[]</td>
+ * <td>delete(TOP)</td>
+ * <td>merge(TOP/BAR,1]</td>
+ * <td>Tx 2 will fail, state is empty store</td>
+ * </tr>
+ *
+ * <tr>
+ * <td>TOP=[FOO=1]</td>
+ * <td>put(TOP/FOO,2)</td>
+ * <td>put(TOP/BAR,1)</td>
+ * <td>state is TOP=[FOO=2,BAR=1]</td>
+ * </tr>
+ * <tr>
+ * <td>TOP=[FOO=1]</td>
+ * <td>put(TOP/FOO,2)</td>
+ * <td>merge(TOP/BAR,1)</td>
+ * <td>state is TOP=[FOO=2,BAR=1]</td>
+ * </tr>
+ * <tr>
+ * <td>TOP=[FOO=1]</td>
+ * <td>merge(TOP/FOO,2)</td>
+ * <td>put(TOP/BAR,1)</td>
+ * <td>state is TOP=[FOO=2,BAR=1]</td>
+ * </tr>
+ * <tr>
+ * <td>TOP=[FOO=1]</td>
+ * <td>merge(TOP/FOO,2)</td>
+ * <td>merge(TOP/BAR,1)</td>
+ * <td>state is TOP=[FOO=2,BAR=1]</td>
+ * </tr>
+ * <tr>
+ * <td>TOP=[FOO=1]</td>
+ * <td>delete(TOP/FOO)</td>
+ * <td>put(TOP/BAR,1)</td>
+ * <td>state is TOP=[BAR=1]</td>
+ * </tr>
+ * <tr>
+ * <td>TOP=[FOO=1]</td>
+ * <td>delete(TOP/FOO)</td>
+ * <td>merge(TOP/BAR,1]</td>
+ * <td>state is TOP=[BAR=1]</td>
+ * </tr>
+ * </table>
+ *
+ *
+ * <h4>Examples of failure scenarios</h4>
+ *
+ * <h5>Conflict of two transactions</h5>
+ * This example illustrates two concurrent transactions, which derived from same initial state
+ * of data tree and proposes conflicting modifications.
+ *
+ * <pre>
+ * txA = broker.newWriteTransaction(); // allocates new transaction, data tree is empty
+ * txB = broker.newWriteTransaction(); // allocates new transaction, data tree is empty
+ * txA.put(CONFIGURATION, PATH, A); // writes to PATH value A
+ * txB.put(CONFIGURATION, PATH, B) // writes to PATH value B
+ * ListenableFuture futureA = txA.commit(); // transaction A is sealed and committed
+ * ListenebleFuture futureB = txB.commit(); // transaction B is sealed and committed
+ * </pre>
+ * Commit of transaction A will be processed asynchronously and data tree will be updated to
+ * contain value <code>A</code> for <code>PATH</code>. Returned {@link FluentFuture} will
+ * successfully complete once state is applied to data tree.
+ * Commit of Transaction B will fail, because previous transaction also modified path in a
+ * concurrent way. The state introduced by transaction B will not be applied. Returned
+ * {@link FluentFuture} object will fail with {@link OptimisticLockFailedException}
+ * exception, which indicates to client that concurrent transaction prevented the committed
+ * transaction from being applied. <br>