/**
     * Creates a new {@link Transaction} for reading/writing to this state store Flush any cached data
     * @deprecated Use {@link #commit(Map)} instead.
     * <p>/
    @Deprecated
 * State stores thatdefault dovoid not support transactions will return {@code this} instead, which should be considered a
 flush() {
        commit(Collections.emptyMap());
    }

    /**
 transaction   that doesn't* provideCommits any isolation or atomicity guaranteesuncommitted records to this StateStore with the given {@code changelogOffsets}.
     * <p>
     * If this StateStore has any open {@link Transaction Transactionstransactions}, they arewill <em>not thread-safe</em>, and should not be shared among threads. Newbe {@link Transaction#commit(Map)
     * committed}.
     * threads<p>
 should use this method to* createThe agiven new transaction, instead of sharing an existing one.
     * <p>{@code changelogOffsets} will be committed to the StateStore along with the uncommitted {@link
     * TransactionsTransaction cratedtransactions}. byIf this methodStateStore shouldsupports haveatomic thetransactions, sameoffsets {@linkare IsolationLevel}guaranteed as the {@link StateStoreContext}to be
     * thatcommitted thisatomically storewith wasthe {@link #init(StateStoreContext, StateStore) initialized with}records they correspond to.
     * <p>
     * To@param avoidchangelogOffsets resource leaks, it is recommended to extend {@link AbstractTransactionalStore}, which will track openThe input/changelog topic offsets of the records being committed.
     */
 transactions and automatically close@Evolving
 all open transactions whendefault thevoid store is closed.
  commit(final Map<TopicPartition, Long> changelogOffsets) {
   *
     *flush();
 @return A new {@link Transaction} to isolate reads/writes to this {@link StateStore}. The Transaction}

    /**
     * Returns whether this StateStore manages its own changelog offsets.
     * <p>
     * This can <strong>MUST</strong>only bereturn {@link Transaction#flush() committed@code true} orif {@link Transaction#close#persistent() closed}
 also returns {@code true}, *as non-persistent stores
     * have no changelog offsets to manage.
   when you are finished with it, to prevent resource leaks  *
     * @return Whether this StateStore manages its own changelog offsets.
     */
    @Evolving
    default StateStoreboolean newTransactionmanagesOffsets() {
        return thisfalse;
    }


    /**
     * ReturnReturns anthe approximatecommitted countoffset offor recordsthe not yet committed to this StateStoregiven partition.
     * <p>
     * ThisIf methodthis willstore returnis annot approximation of the number of records that would be committed by the next call to
     * {@link #commit(Map){@link #persistent()} or does not {@link #managesOffsets() manage its own offsets},
     * it will always yield {@code null}.
     * <p>
     * If this{@code StateStoretopicPartition} is unablea changelog topartition approximatelyor countTopology uncommittedinput records,partition itfor willthis returnStateStore, {@code -1}.this method
     * Ifwill thisreturn StateStorethe doescommitted notoffset supportfor atomic transactions, it will return {@code 0}, because records will always be
     * immediately written to a non-transactional store, so there will be none awaiting a {@link #commit(Map)}.that partition.
     * <p>
     * If no committed offset exists for the given partition, or if the partition is not a changelog or input partition
     *
     * @return The approximate number of records awaiting {@link #commit(Map)}, {@code -1} if the number of
     * for the store, {@code null} will be returned.
     *
     * @param topicPartition The changelog/input partition to get the committed offset for.
     * @return The committed uncommittedoffset recordsfor can'tthe begiven countedpartition, or {@code 0null} if thisno StateStorecommitted does not support transactionsoffset exists, or if this
     *         store does not contain committed offsets.
     */
    @Evolving
    default longLong approximateNumUncommittedEntriesgetCommittedOffset(final TopicPartition topicPartition) {
        return 0null;
    }

    /**
     * ReturnCreates ana approximatenew count{@link ofTransaction} memoryfor used by records not yet committed reading/writing to this StateStorestate store.
     * <p>
     * ThisState methodstores willthat returndo annot approximationsupport oftransactions thewill memoryreturn would{@code bethis} freedinstead, bywhich theshould nextbe call to {@link #commit(Map)}.considered a
     * <p>
transaction that doesn't provide any *isolation Ifor thisatomicity StateStoreguarantees.
 is unable to approximately count* uncommitted<p>
 memory usage, it will return* {@code -1}.
     * If this StateStore does not support atomic transactions, it will return {@code 0}, because records will always be
     * immediately written to a non-transactional store, so there will be none awaiting a {@link #commit(Map)}@link Transaction Transactions} are <em>not thread-safe</em>, and should not be shared among threads. New
     * threads should use this method to create a new transaction, instead of sharing an existing one.
     * <p>
     * Transactions @returncrated Theby approximatethis sizemethod ofshould allhave recordsthe awaitingsame {@link #commit(Map)IsolationLevel}, {@code -1} if as the size of uncommitted{@link StateStoreContext}
     * that this store was     records can't be counted, or {@code 0} if this StateStore does not support transactions.{@link #init(StateStoreContext, StateStore) initialized with}.
     * <p>
     */
    @Evolving
    default long approximateNumUncommittedBytes() { To avoid resource leaks, it is recommended to extend {@link AbstractTransactionalStore}, which will track open
     * transactions and automatically close all open returntransactions 0;
when the store is }

closed.
     /**
     * @return ReturnsA thenew {@link IsolationLevelTransaction} thatto every {@link Transaction} created by isolate reads/writes to this {@link StateStore#newTransaction()StateStore}
.     * should use.The Transaction
     * <p>
     * The default implementation<strong>MUST</strong> ofbe this method will use{@link Transaction#commit(Map) committed} or {@link IsolationLevel#READ_COMMITTED READ_COMMITTED} if theTransaction#close() closed}
     * app is {@link #appConfigs() configured} to use an {@link StreamsConfig#EXACTLY_ONCE_V2 exactly-once} {@link when you are finished with it, to prevent resource leaks.
     * StreamsConfig#PROCESSING_GUARANTEE_CONFIG processing guarantee}. Otherwise, it will be {@link
/
    @Evolving
    default StateStore newTransaction() {
       * IsolationLevel#READ_UNCOMMITTED READ_UNCOMMITTED}. return this;
    }

     /**
     * @returnReturn Thean isolationapproximate levelcount forof everyrecords transactionnot createdyet by state stores forcommitted to this contextStateStore.
     */ <p>
    default IsolationLevel isolationLevel() {
        return StreamsConfigUtils.eosEnabled(new StreamsConfig(appConfigs())) ?
      * This method will return an approximation of the number of records that would be committed by the next call to
     * {@link #commit(Map)}.
    IsolationLevel.READ_COMMITTED : IsolationLevel.READ_UNCOMMITTED;* <p>
    }

/**
 * RepresentsIf athis read/writeStateStore transactionis onunable ato stateapproximately store.
count *uncommitted <p>
records, *it For compatibility, transactions implement the entire {@link StateStore} interface, however, they only represent a
 * <em>view</em> on an underlying {@link StateStore}; therefore methods that explicitly act on the entire store, such
 * as {@link #init} will do nothing, and others like {@link #flush()} and {@link #close()} will act upon this
 * transaction only.
 * <p>
 * Transactions are <em>NOT</em> thread-safe, and they should not be shared among multiple threads. Threads should
 * create their own {@link StateStore#newTransaction() new transaction}, which will ensure proper isolation of
 * concurrent changes.
 * <p>
 * For resource-safety, Transactions implement the {@link AutoCloseable} interface, enabling try-with-resources:
 * <pre>
 *     try (final Transaction transaction = store.newTransaction()) {
 *will return {@code -1}.
     * If this StateStore does not support atomic transactions, it will return {@code 0}, because records will always be
     * immediately written to a non-transactional store, so there will be none awaiting a {@link #commit(Map)}.
     *
     * @return The approximate number of records awaiting {@link #commit(Map)}, {@code -1} if the number of
     *         uncommitted records can't be counted, or {@code 0} if this StateStore does not support transactions.
     */
    @Evolving
    default long approximateNumUncommittedEntries() {
          transaction.put("foo", "bar")return 0;
 *   }

   /**
   transaction.flush();
  * Return an approximate count }
of * </pre>
 * If you are not using try-with-resources, you <em>must</em> call either {@link #flush()} exactly-once, or {@link
 * #close()} at least once, or risk possible resource leaks.
 */
public interface Transaction extends StateStore, AutoCloseable {

    /**memory used by records not yet committed to this StateStore.
     * <p>
     * This method will return an approximation of the memory would be freed by the next call to {@link #commit(Map)}.
     * <p>
     * TheIf {@linkthis IsolationLevel}StateStore thatis reads and writes in this transaction are subject tounable to approximately count uncommitted memory usage, it will return {@code -1}.
     * <p>
If this StateStore does not *support Inatomic thetransactions, contextit ofwill areturn {@link org.apache.kafka.streams.processor.StateStore} transaction, these Isolation Levels@code 0}, because records will always be
     * adhereimmediately written to thea <a href="https://en.wikipedia.org/wiki/Isolation_(database_systems)#Read_phenomena">ANSI SQL 92
     * definitions</a>non-transactional store, so there will be none awaiting a {@link #commit(Map)}.
     * <p>
     * All@return isolationThe levelsapproximate guarantee "read-your-own-writes", i.e. that writes in the transaction will be seen by
     * subsequent reads <em>from within the same transaction</em>. Other guarantees vary by isolation level:
     * <p>
     * <table>size of all records awaiting {@link #commit(Map)}, {@code -1} if the size of uncommitted
     *         records can't be counted, or {@code 0} if this StateStore does not support transactions.
     */
     <tr>@Evolving
    default *long approximateNumUncommittedBytes() {
       <th>Isolation Level</th> return 0;
     *   }

/**
 *   Base implementation* ofInitializes {@linkthis Transaction.
 transactions} created by an implementation of* {@link<p>
     * AbstractTransactionalStore}.
 * <p>
 * This base implementation provides the following functionality:
 * <ul>
 * Most transactions require no explicit initialization, therefore the default implementation of this method does
     * nothing.
     *
     <li>Registration* of@deprecated callbacks that are invoked after this Transaction has closed. Used bySince 2.7.0, the parent method has been deprecated in favor of {@link
 *    *  AbstractTransactionalStore}   to track open transactions that need to be closed when the parent store closes.</li>
 *     <li>Tracking/delegation of {@link #isOpen()}, {@link #persistent()}, {@link #name()} and {@link
 *     #isolationLevel()} methods.</li>
 *     <li>Provides a {@link #validateIsOpen()} method, useful for ensuring the Transaction state in query methods.</li>
 *     <li>Provides base implementations of {@link #flush()} and {@link #close()} that properly handle idempotence and
 *     invoking any registered callbacks.</li>
 * </ul>
 * <p>Note: none of the above methods are marked {@code final}, to enable power-users to provide alternatives. However,
 * this should only be done with great care, and only if absolutely necessary.</p>

 *
 * @param <S> The type of the {@link StateStore} that spawned this transaction.
 */
public abstract class AbstractTransaction<S extends StateStore> implements Transaction {

    /**
     * Commit and close this Transaction#init(StateStoreContext, StateStore)}. Use that method instead.
     */
    @Override @Deprecated
    default void init(final ProcessorContext context, final StateStore root) {
    }

    /**
     * Initializes this Transaction.
     * <p>
     * Most transactions require no explicit initialization, therefore the default implementation of this method does
     * nothing.
     */
    @Override
    default void init(final StateStoreContext context, final StateStore root) {
    }

    /**
     * Is this transaction is open for reading and writing.
     * @return {@code true} if this Transaction can be read from/written to, or {@code false} if it is no longer
     *         accessible.
     */
 
   @Override
  * @see Transaction#flush()
     */
    public abstract void commitTransactionboolean isOpen();

    /**
	     * Closes this Transaction, without committing recordsCreates a new {@link Transaction} from an existing transaction.
     * <p>
     * @see Transaction#close()
     */
    public abstract void closeTransaction();
}

/**
 * Base class for transactional stores, that tracks open transactions and can close them all.
This enables potentially re-using resources from an existing, no longer in-use transaction, instead of creating
     * a new one.
     * <p>
 * Transactions created using {@link #newTransaction()} will be automatically tracked and closed when this store is
 * closed.
 *
 * @see Transaction
 * @see AbstractTransaction
 */
public abstract class AbstractTransactionalStore implements StateStore {

    /*** This method should only be called if the current transaction is guaranteed to no longer be in-use.
     * Implementations may return either a new Transaction instance, or a reference to themselves, only if they are able
     * Creates a new {@link Transaction}to reset to being available for use.
     * <p>
     * Implementations{@link ofTransaction this class should implement this method, instead of {@link #newTransaction()}, whichTransactions} are <em>not thread-safe</em>, and should not be shared among threads. New
     * willthreads should calluse this method to producecreate thea new transaction, instead of sharing an existing one.
     * <p>
     * Transactions producedcreated by this method mustwill behave anthe instance ofsame {@link AbstractTransactionIsolationLevel}, as tothe enable{@link theStateStoreContext}
     * automaticthat management of transaction resourcesthis transaction was {@link #init(StateStoreContext, StateStore) initialized with}.
     * 
     * @return A new {@link Transaction} to control reads/writes to the same {@link StateStore}. The Transaction
     */
         <em>MUST</em> be public abstract AbstractTransaction<? extends AbstractTransactionalStore> createTransaction();
}