How to use com.palantir.atlasdb.transaction.impl

@Override
public void put(TableReference tableRef, Map<Cell, byte[]> values) {
  super.put(tableRef, values);
  addToCache(tableRef, values);
}

@Override
public void put(TableReference tableRef, Map<Cell, byte[]> values) {
  validateWrites(tableRef, values);
  super.put(tableRef, values);
}

private <T, E extends Exception> TransactionTask<T, E> wrapTaskIfNecessary(
    TransactionTask<T, E> task, LockToken immutableTsLock) {
  if (taskWrappingIsNecessary()) {
    return new LockCheckingTransactionTask<>(task, timelockService, immutableTsLock);
  }
  return task;
}

@Override
public <T, E extends Exception> T runTaskWithLocksWithRetry(
    Iterable<HeldLocksToken> lockTokens,
    Supplier<LockRequest> lockSupplier,
    LockAwareTransactionTask<T, E> task) throws E, InterruptedException {
  checkOpen();
  Supplier<AdvisoryLocksCondition> conditionSupplier =
      AdvisoryLockConditionSuppliers.get(getLockService(), lockTokens, lockSupplier);
  return runTaskWithConditionWithRetry(conditionSupplier, (transaction, condition) ->
      task.execute(transaction, condition.getLocks()));
}

@Override
protected void throwIfReadWriteConflictForSerializable(long commitTimestamp) {
  Transaction ro = getReadOnlyTransaction(commitTimestamp);
  verifyRanges(ro);
  verifyColumnRanges(ro);
  verifyCells(ro);
  verifyRows(ro);
}

@Override
public void throwIfConditionInvalid(long timestamp) {
  externalLocksCondition.throwIfConditionInvalid(timestamp);
  transactionLocksCondition.throwIfConditionInvalid(timestamp);
}

@Override
public void cleanup() {
  // Both of these conditions don't throw internally
  externalLocksCondition.cleanup();
  transactionLocksCondition.cleanup();
}

@Override
public Transaction createNewTransaction() {
  return wrap(delegate.createNewTransaction());
}

@Override
ConflictDetectionManager getConflictDetectionManager() {
  return TestConflictDetectionManagers.createWithStaticConflictDetection(getConflictHandlerWithOverrides());
}

private void ensureUncommitted() {
  if (!isUncommitted()) {
    throw new CommittedTransactionException();
  }
}

@Override
public Transaction commitAndStartNewTransaction(Transaction txn) {
  return wrap(delegate.commitAndStartNewTransaction(txn));
}

public static SweepStrategyManager completelyConservative(KeyValueService kvs) {
  return new SweepStrategyManager(getConservativeManager(kvs));
}

public static ConflictDetectionManager createWithNoConflictDetection() {
  return new ConflictDetectionManager(
      new CacheLoader<TableReference, ConflictHandler>() {
        @Override
        public ConflictHandler load(TableReference tableReference) throws Exception {
          return ConflictHandler.IGNORE_ALL;
        }
      });
}

@Override
public boolean isInitialized() {
  assertOpen();
  return status == State.READY && isInitializedInternal();
}

public static SweepStrategyManager createDefault(KeyValueService kvs) {
  return new SweepStrategyManager(getSweepStrategySupplier(kvs));
}

private static RecomputingSupplier<Map<TableReference, SweepStrategy>> getSweepStrategySupplier(final KeyValueService keyValueService) {
  return RecomputingSupplier.create(() -> getSweepStrategies(keyValueService));
}

private void reachedEndOfRange(TableReference table, RangeRequest range) {
  if (!isSerializableTable(table)) {
    return;
  }
  setRangeEnd(table, range, PtBytes.EMPTY_BYTE_ARRAY);
}

private void reachedEndOfColumnRange(
    TableReference table,
    byte[] row,
    BatchColumnRangeSelection columnRangeSelection) {
  if (!isSerializableTable(table)) {
    return;
  }
  setColumnRangeEnd(table, row, columnRangeSelection, PtBytes.EMPTY_BYTE_ARRAY);
}

InitializeCheckingWrapper(TransactionManager manager,
    Supplier<Boolean> initializationPrerequisite,
    Callback<TransactionManager> callBack, ScheduledExecutorService initializer) {
  this.txManager = manager;
  this.initializationPrerequisite = initializationPrerequisite;
  this.callback = callBack;
  this.executorService = initializer;
  runCallbackIfInitializedOrScheduleForLater(this::attemptCallbackSynchronously);
}

@Override
protected TransactionManager getManager() {
  // create new transaction manager every time because some tests close it
  return createAndRegisterManager();
}