Examples of commit()

• appeng.crafting.MECraftingInventory.commit()
• bitronix.tm.BitronixTransactionManager.commit()
• br.gov.frameworkdemoiselle.transaction.Transaction.commit()
  Complete the transaction associated with the current thread. When this method completes, the thread is no longer associated with a transaction.
• ch.ethz.prose.tools.RemoteAspectManager.commit()
• ch.inftec.ju.db.TxHandler.commit()
  Commits the transaction without beginning a new one.
• cirrus.hibernate.Transaction.commit()
• co.cask.tephra.TransactionManager.commit()
• co.paralleluniverse.galaxy.Store.commit()
  Ends a transaction, and makes all updates visible by all other nodes in the cluster. @param txn The current transaction, which we wish to complete.
• co.paralleluniverse.galaxy.quasar.Store.commit()
  Ends a transaction, and makes all updates visible by all other nodes in the cluster. @param txn The current transaction, which we wish to complete.
• com.activequant.archive.IArchiveWriter.commit()
  Can be an expensive call, handle with care. @throws IOException
• com.adito.jdbc.JDBCPreparedStatement.commit()
• com.alibaba.citrus.service.requestcontext.basic.impl.BasicRequestContextImpl.commit()
• com.alibaba.citrus.service.requestcontext.session.SessionStore.commit()
  ����ָ��session��attributes�� @param modifiedAttrs Ҫ�����attrs�����ֵΪnull��ʾɾ�� @param sessionID Ҫ�����sessionID @param storeContext ����ȡ��request��Ϣ�������store��ǰ��״̬
• com.alibaba.druid.pool.DruidPooledConnection.commit()
• com.alibaba.druid.pool.xa.JtdsXAResource.commit()
• com.alu.e3.common.transaction.ITransaction.commit()
• com.aptana.interactive_console.console.ScriptConsoleHistory.commit()
  Commits the currently added line (last called in update) to the history and keeps it there.
• com.aragost.javahg.merge.GraftContext.commit()
• com.arconsis.android.datarobot.manifest.AndroidManifestProcessor.ManifestBuilder.commit()
• com.arjuna.ats.arjuna.AtomicAction.commit()
  Commit the transaction, and have heuristic reporting. Heuristic reporting via the return code is enabled. @return ActionStatus indicating outcome.
• com.arjuna.ats.internal.jta.transaction.arjunacore.TransactionManagerImple.commit()
• com.arjuna.ats.internal.jta.transaction.arjunacore.jca.XATerminatorImple.commit()
  Commit the transaction identified and hence any inflow-associated work. @param xid the transaction to commit @param onePhase whether or not this is a one-phase commit (should onlybe true if there is a single resource associated with the transaction). @exception XAException thrown if there are any errors, including ifthe transaction cannot commit and has to roll back.
• com.arjuna.ats.internal.jts.orbspecific.CurrentImple.commit()
  It's not possible to commit/abort out of order using the current interface. Do we delete the control if the transaction gives an heuristic result? CurrentImplely we do. If another thread has already terminated the transaction then: (i) if it committed, we do nothing - could throw TransactionRequired of INVALID_TRANSACTION, or NoTransaction. Probably not NoTransaction, since it would be better to distinguish between the situation where the transaction has already been terminated and there really is no transaction for this thread. (ii) if it rolledback, we throw TRANSACTION_ROLLEDBACK.
• com.arjuna.ats.internal.jts.orbspecific.coordinator.ArjunaTransactionImple.commit()
  If the transaction has already been committed (by another thread, for example) then we do nothing - could throw TransactionRequired or INVALID_TRANSACTION. However, if it was rolledback then we throw TRANSACTION_ROLLEDBACK. Seems like an inconsistency. report_heuristics is ignored if we are a subtransaction.
• com.arjuna.ats.internal.jts.orbspecific.interposition.coordinator.ServerTransaction.commit()
• com.arjuna.ats.jts.extensions.AtomicTransaction.commit()
• com.arjuna.mw.wst.UserTransaction.commit()
  The transaction is committed by the commit method. This will execute the PhaseZero, 2PC and OutcomeNotification protocols prior to returning. If there is no transaction associated with the invoking thread then WrongStateException is thrown. If the coordinator is not aware of the current transaction UnknownTransactionException is thrown. If the transaction ultimately rolls back then the TransactionRolledBackException is thrown. If any other error occurs a SystemException is thrown. When complete, this operation disassociates the transaction from the current thread such that it becomes associated with no transaction.
• com.arjuna.mw.wst11.UserTransaction.commit()
  The transaction is committed by the commit method. This will execute the PhaseZero, 2PC and OutcomeNotification protocols prior to returning. If there is no transaction associated with the invoking thread then WrongStateException is thrown. If the coordinator is not aware of the current transaction UnknownTransactionException is thrown. If the transaction ultimately rolls back then the TransactionRolledBackException is thrown. If any other error occurs a SystemException is thrown. When complete, this operation disassociates the transaction from the current thread such that it becomes associated with no transaction.
• com.arjuna.mw.wstx.UserTransaction.commit()
  Commit the transaction. All participants that are still enlisted with the transaction are committed. @exception InvalidTransactionException Thrown if the current transaction is notknown about by the transaction system. @exception WrongStateException Thrown if the current transaction is not in astate that allows commit to be called. @exception HeuristicHazardException Thrown if the participants generated a hazardheuristic. @exception HeuristicMixedException Thrown if the participants generated a mixed heuristic. @exception NoTransactionException Thrown if there is no transactionassociated with the invoking thread. @exception SystemException Thrown if some other error occurred.
• com.arjuna.webservices.wsat.ParticipantInboundEvents.commit()
  Handle the commit event. @param commit The commit notification. @param addressingContext The addressing context. @param arjunaContext The arjuna context.
• com.arjuna.webservices11.wsat.ParticipantInboundEvents.commit()
  Handle the commit event. @param commit The commit notification. @param addressingProperties The addressing context. @param arjunaContext The arjuna context.
• com.arjuna.wst.CompletionCoordinatorParticipant.commit()
• com.arjuna.wst.stub.CompletionStub.commit()
• com.arjuna.wst11.CompletionCoordinatorParticipant.commit()
  Commit. @param commit The commit notification. @param addressingProperties The addressing context. @param arjunaContext The arjuna context.
• com.arjuna.wst11.stub.CompletionStub.commit()
• com.atomikos.icatch.CompositeTerminator.commit()
  Commit the composite transaction. @exception HeurRollbackException On heuristic rollback. @exception HeurMixedException On heuristic mixed outcome. @exception SysException For unexpected failures. @exception SecurityException If calling thread does not have right to commit. @exception HeurHazardException In case of heuristic hazard. @exception RollbackException If the transaction was rolled backbefore prepare.
• com.atomikos.icatch.Participant.commit()
  Commits the participant's work. NOTE: custom participant implementations should preferably be made for the server's local VM (e.g., it is better not to do this over RMI). Also, they should rely on the transaction manager for heuristic timeout (and NOT decide to terminate heuristically themselves). In that case, implementations never need to throw any of the heuristic exceptions of this method. @return HeuristicMessage[] An array of messages, null if none. @param onePhase If true, one-phase commit is being started.If the participant has received a prepare call earlier, then it should throw a SysException here. @exception HeuristicRollbackException If the participant has rolled back. @exception HeuristicMixedException If part of it was rolled back. @exception HeurHazardException On possible conflicts. @exception RollbackException In case of one-phase commit,and the transaction has been rolled back at the time commit is called. @exception SysException
• com.avaje.ebean.Transaction.commit()
  Commit the transaction.
• com.avaje.ebeaninternal.server.transaction.TransactionMap.State.commit()
• com.caucho.db.block.Block.commit()
  Handle any database writes necessary at commit time. If isFlushDirtyOnCommit() is true, this will write the data to the backing file.
• com.caucho.db.xa.DbTransaction.commit()
• com.caucho.db.xa.Transaction.commit()
• com.cetsoft.imcache.cache.heap.tx.Transaction.commit()
  Commit the transaction.
• com.cloud.utils.db.Transaction.commit()
• com.cloud.utils.db.TransactionLegacy.commit()
• com.complexible.stardog.api.Connection.commit()
• com.conexao.Transacao.commit()
• com.cosmo.data.DataAgent.commit()
  Envia els canvis a la base de dades. @throws SQLException
• com.db4o.ObjectContainer.commit()
  commits the running transaction.
  
  Transactions are back-to-back. A call to commit will starts a new transaction immedidately. @throws Db4oIOException I/O operation failed or was unexpectedly interrupted. @throws DatabaseClosedException db4o database file was closed or failed to open. @throws DatabaseReadOnlyException database was configured as read-only.
• com.dbxml.db.core.transaction.Transaction.commit()
  commit ends a transaction by commiting all data. This method, in turn, should call the commit methods of all participating Collections' Transaction Logs.
• com.dci.intellij.dbn.connection.ConnectionHandler.commit()
• com.dci.intellij.dbn.connection.transaction.DatabaseTransactionManager.commit()
• com.din.din.model.util.EntityCachingManager.commit()
• com.facebook.presto.metadata.ColumnFileHandle.commit()
• com.facebook.presto.spi.RecordSink.commit()
• com.github.maven_nar.cpptasks.TargetHistoryTable.commit()
• com.google.api.services.androidpublisher.AndroidPublisher.Edits.commit()
• com.google.api.services.datastore.client.Datastore.commit()
• com.google.appengine.api.datastore.Transaction.commit()
• com.google.gdt.eclipse.designer.model.module.GwtDocumentEditContext.commit()
• com.google.gdt.eclipse.designer.model.web.WebDocumentEditContext.commit()
• com.google.gerrit.server.git.CreateCodeReviewNotes.commit()
• com.google.gerrit.server.git.ProjectConfig.commit()
• com.google.gwt.dev.util.StringCopier.commit()
• com.google.gwt.user.rebind.SourceWriter.commit()
• com.google.walkaround.util.server.appengine.CheckedDatastore.CheckedTransaction.commit()
• com.hazelcast.core.Transaction.commit()
• com.hazelcast.transaction.impl.Transaction.commit()
• com.hp.hpl.jena.graph.TransactionHandler.commit()
  If transactions are supported and there is a tranaction in progress, commit it. If transactions are not supported, , or there is no transaction in progress, throw an UnsupportedOperationException.
• com.hp.hpl.jena.query.Dataset.commit()
  Commit a transaction - finish the transaction and make any changes permanent (if a "write" transaction)
• com.hp.hpl.jena.rdf.model.Model.commit()
  Commit the current transaction. @return this model to enable cascading.
• com.hp.hpl.jena.sparql.core.Transactional.commit()
  Commit a transaction - finish the transaction and make any changes permanent (if a "write" transaction)
• com.hp.hpl.jena.tdb.transaction.DatasetGraphTxn.commit()
• com.hp.mwtests.performance.products.TxWrapper.commit()
  Commit the current transaction @return one of the com.arjuna.ats.arjuna.coordinator.ActionStatus constants
• com.intellij.facet.ModifiableFacetModel.commit()
• com.intellij.openapi.module.ModifiableModuleModel.commit()
  Commits changes made in this model to the actual project structure. @throws ModuleCircularDependencyException never actually thrown (circular module dependency is not an error).
• com.intellij.openapi.roots.CompilerModuleExtension.commit()
• com.intellij.openapi.roots.ModifiableRootModel.commit()
  Commits changes to a {@link ModuleRootManager}. Should be invoked in a write action. After commit(), the model becomes read-only.
• com.j256.ormlite.support.DatabaseConnection.commit()
  Commit all changes since the savepoint was created. If savePoint is null then commit all outstanding changes. @param savePoint That was returned by setSavePoint or null if none.
• com.jbidwatcher.util.db.Database.commit()
• com.jboss.transaction.txinterop.webservices.atinterop.generated.ParticipantPortType.commit()
• com.jboss.transaction.wstf.webservices.sc007.generated.ParticipantPortType.commit()
• com.jengine.orm.db.DBConnection.commit()
• com.knowgate.datacopy.DataStruct.commit()
• com.knowgate.jdc.JDCConnection.commit()
• com.mobixess.jodb.core.JODBSessionContainer.commit()
• com.mysql.jdbc.ReplicationConnection.commit()
• com.onpositive.instrumentation.tasks.CallDictionary.commit()
• com.onpositive.semantic.model.binding.Binding.commit()
• com.orientechnologies.orient.core.db.document.ODatabaseDocument.commit()
• com.orientechnologies.orient.core.db.document.ODatabaseDocumentTx.commit()
• com.orientechnologies.orient.core.db.record.ODatabaseFlat.commit()
• com.orientechnologies.orient.core.db.record.ODatabaseRecord.commit()
• com.orientechnologies.orient.core.db.record.ODatabaseRecordTx.commit()
• com.orientechnologies.orient.core.index.OIndex.commit()
  Commit changes as atomic. @param oDocument Collection of entries to commit
• com.orientechnologies.orient.core.index.OIndexMVRBTreeAbstract.commit()
• com.orientechnologies.orient.object.db.OObjectDatabaseTx.commit()
• com.persistit.Transaction.commit()

  Commit this transaction. This method flushes the journal entries created by the transaction to the journal buffer, optionally waits for those changes to be written durably to disk according to the default configured {@link CommitPolicy}, and marks the transaction as completed so that its effects are visible to other transactions.

  If executed within the scope of an outer transaction, this method simply sets a flag indicating that the current transaction level has committed without modifying any data. The commit for the outermost transaction scope is responsible for actually committing the changes.

  Once an application thread has called commit, no subsequent Persistit database operations are permitted until the end method has been called. An attempt to store, fetch or remove data after commit has been called throws an IllegalStateException.

  @throws PersistitIOException if the transaction could not be written to the journal due to an IOException. This exception also causes the transaction to be rolled back. @throws RollbackException if the {@link #rollback()} was previously called @throws PersistitInterruptedException if the thread was interrupted while waiting for I/O completion @throws IllegalStateException if no transaction scope is active or this transaction scope has already called commit @throws PersistitException if a PersistitException was caught by the JOURNAL_FLUSHER thread after this transaction began waiting for durability @see Persistit#getDefaultTransactionCommitPolicy()
• com.ponysdk.core.stm.Txn.commit()
• com.prodeagle.java.counters.BatchCounter.commit()
  Commit all the pending batch counters ProdEagle stats will be stored in the process.
• com.salesforce.phoenix.jdbc.PhoenixConnection.commit()
• com.sleepycat.db.Transaction.commit()
  End the transaction. If the environment is configured for synchronous commit, the transaction will be committed synchronously to stable storage before the call returns. This means the transaction will exhibit all of the ACID (atomicity, consistency, isolation, and durability) properties.

  If the environment is not configured for synchronous commit, the commit will not necessarily have been committed to stable storage before the call returns. This means the transaction will exhibit the ACI (atomicity, consistency, and isolation) properties, but not D (durability); that is, database integrity will be maintained, but it is possible this transaction may be undone during recovery.

  In the case of nested transactions, if the transaction is a parent transaction, committing the parent transaction causes all unresolved children of the parent to be committed. In the case of nested transactions, if the transaction is a child transaction, its locks are not released, but are acquired by its parent. Although the commit of the child transaction will succeed, the actual resolution of the child transaction is postponed until the parent transaction is committed or aborted; that is, if its parent transaction commits, it will be committed; and if its parent transaction aborts, it will be aborted.

  All cursors opened within the transaction must be closed before the transaction is committed.

  After this method returns the {@link com.sleepycat.db.Transaction Transaction} handle may not beaccessed again, regardless of the method's success or failure. If the method encounters an error, the transaction and all child transactions of the transaction will have been aborted when the call returns.

  @throws DatabaseException if a failure occurs.

• com.sleepycat.je.Transaction.commit()
  End the transaction. If the environment is configured for synchronous commit, the transaction will be committed synchronously to stable storage before the call returns. This means the transaction will exhibit all of the ACID (atomicity, consistency, isolation, and durability) properties.

  If the environment is not configured for synchronous commit, the commit will not necessarily have been committed to stable storage before the call returns. This means the transaction will exhibit the ACI (atomicity, consistency, and isolation) properties, but not D (durability); that is, database integrity will be maintained, but it is possible this transaction may be undone during recovery.

  All cursors opened within the transaction must be closed before the transaction is committed.

  If the method encounters an error, the transaction will have been aborted when the call returns.

  After this method has been called, regardless of its return, the {@link Transaction} handle may not be accessed again, with oneexception: the {@code abort} method may be called any number of timesto simplify error handling.

  @throws com.sleepycat.je.rep.InsufficientReplicasException if the masterin a replicated environment could not contact a quorum of replicas as determined by the {@link ReplicaAckPolicy}. @throws com.sleepycat.je.rep.InsufficientAcksException if the master ina replicated environment did not receive enough replica acknowledgments, although the commit succeeded locally. @throws com.sleepycat.je.rep.ReplicaWriteException if a write operationwas performed with this transaction, but this node is now a Replica. @throws OperationFailureException if this exception occurred earlier andcaused the transaction to be invalidated. @throws EnvironmentFailureException if an unexpected, internal orenvironment-wide failure occurs. @throws IllegalStateException if the transaction or environment has beenclosed, or cursors associated with the transaction are still open.
• com.sleepycat.je.XAEnvironment.commit()
• com.sleepycat.je.rep.txn.MasterTxn.commit()
• com.sleepycat.je.rep.txn.ReplayTxn.commit()
  Commits the txn being replayed. @param syncPolicy to be used for the commit. @param clientRepContext the replication context it encapsulates the VLSNassociated with the txn. @return the commit LSN @throws DatabaseException
• com.sleepycat.je.txn.Txn.commit()
• com.sun.enterprise.ee.admin.hadbmgmt.HADBConfigurePersistence.commit()
• com.sun.enterprise.ee.synchronization.store.SynchronizationMemento.commit()
  Commits the saved state to repository. @throws StoreException if an error while commiting the saved state
• com.sun.enterprise.transaction.api.JavaEETransaction.commit()
• com.sun.grid.jgdi.EventClient.commit()
  Commit the subscription @throws JGDIException if the commit has failed
• com.sun.grizzly.http.SocketChannelOutputBuffer.commit()
• com.sun.media.util.Registry.commit()
• com.sun.security.auth.module.KeyStoreLoginModule.commit()
  Abstract method to commit the authentication process (phase 2).

  This method is called if the LoginContext's overall authentication succeeded (the relevant REQUIRED, REQUISITE, SUFFICIENT and OPTIONAL LoginModules succeeded).

  If this LoginModule's own authentication attempt succeeded (checked by retrieving the private state saved by the login method), then this method associates a X500Principal for the subject distinguished name of the first certificate in the alias's credentials in the subject's principals,the alias's certificate path in the subject's public credentials, and aX500PrivateCredential whose certificate is the first certificate in the alias's certificate path and whose private key is the alias's private key in the subject's private credentials. If this LoginModule's own authentication attempted failed, then this method removes any state that was originally saved.

  @exception LoginException if the commit fails @return true if this LoginModule's own login and commitattempts succeeded, or false otherwise.

• com.sun.security.auth.module.Krb5LoginModule.commit()

  This method is called if the LoginContext's overall authentication succeeded (the relevant REQUIRED, REQUISITE, SUFFICIENT and OPTIONAL LoginModules succeeded).

  If this LoginModule's own authentication attempt succeeded (checked by retrieving the private state saved by the login method), then this method associates a Krb5Principal with the Subject located in the LoginModule. It adds Kerberos Credentials to the the Subject's private credentials set. If this LoginModule's own authentication attempted failed, then this method removes any state that was originally saved.

  @exception LoginException if the commit fails. @return true if this LoginModule's own login and commitattempts succeeded, or false otherwise.

• com.sun.sgs.impl.service.transaction.TransactionHandle.commit()
  Prepares and commits the transaction associated with this handle.

  If the transaction has been aborted, or when preparing a transaction participant or calling {@link TransactionListener#beforeCompletion beforeCompletion} on a transaction listener aborts the transactionwithout throwing an exception, then the exception thrown will have as its cause the value provided in the first call to {@link Transaction#abort abort} on the transaction, if any. If the causeimplements {@link ExceptionRetryStatus}, then the exception thrown will, too, and its {@link ExceptionRetryStatus#shouldRetry shouldRetry} methodwill return the value returned by calling that method on the cause. If no cause was supplied, then {@code shouldRetry} will either notimplement {@code ExceptionRetryStatus} or its {@code shouldRetry} methodwill return {@code false}. @throws TransactionNotActiveException if the transaction has beenaborted @throws TransactionAbortedException if a call to {@link TransactionParticipant#prepare prepare} on a transactionparticipant or to {@code beforeCompletion} on a transactionlistener aborts the transaction but does not throw an exception @throws IllegalStateException if {@code prepare} has been called on anytransaction participant and {@link Transaction#abort abort} hasnot been called on the transaction, or if called from a thread that is not the thread that created the transaction @throws Exception any exception thrown when calling {@code prepare} ona participant or {@code beforeCompletion} on a listener

• com.sun.sgs.service.TransactionParticipant.commit()
  Tells the participant to commit its state associated with the given transaction. @param txn the Transaction object @throws IllegalStateException if this participant was not previouslyprepared, or if this participant has already committed or aborted, or if this participant is not participating in the given transaction
• com.sun.sgs.service.store.db.DbTransaction.commit()
  Commits the transaction. This method should not be called if any cursors associated with this transaction are still open. No methods should be called on this transaction after this method is called. @throws DbDatabaseException if an unexpected database problem occurs
• com.sun.sgs.test.util.DummyTransaction.commit()
• com.sun.star.embed.XOLESimpleStorage.commit()
• com.sun.star.embed.XTransactedObject.commit()
• com.sun.star.form.XBoundComponent.commit()
• com.sun.xml.bind.v2.schemagen.xmlschema.ComplexType.commit()
• com.sun.xml.bind.v2.schemagen.xmlschema.ExplicitGroup.commit()
• com.sun.xml.bind.v2.schemagen.xmlschema.Schema.commit()
• com.sun.xml.bind.v2.schemagen.xmlschema.SimpleExtension.commit()
• com.sun.xml.bind.v2.schemagen.xmlschema.SimpleType.commit()
• com.sun.xml.bind.v2.schemagen.xmlschema.TopLevelElement.commit()
• com.sun.xml.internal.bind.v2.schemagen.xmlschema.ComplexType.commit()
• com.sun.xml.internal.bind.v2.schemagen.xmlschema.Schema.commit()
• com.sun.xml.internal.bind.v2.schemagen.xmlschema.SimpleExtension.commit()
• com.sun.xml.internal.bind.v2.schemagen.xmlschema.SimpleType.commit()
• com.sun.xml.internal.bind.v2.schemagen.xmlschema.TopLevelElement.commit()
• com.sun.xml.internal.txw2.TypedXmlWriter.commit()
  Commits this element (and all its descendants) to the output.

  Short for _commit(true).

• com.sun.xml.txw2.TypedXmlWriter.commit()
  Commits this element (and all its descendants) to the output.

  Short for _commit(true).

• com.sun.xml.ws.wsdl.writer.document.xsd.Schema.commit()
• com.taobao.metamorphosis.client.producer.MessageProducer.commit()
  �ύ��ǰ���񣬽������ڷ��͵���Ϣ�־û����˷���������beginTransaction֮����� @see #beginTransaction() @throws MetaClientException
• com.taobao.metamorphosis.client.transaction.TransactionContext.commit()
• com.taobao.metamorphosis.server.transaction.Transaction.commit()
• com.taobao.tdhs.client.statement.BatchStatement.commit()
  commit the batch statement @return TDHSResponse[] @throws TDHSException when has some error.
• com.thinkaurelius.titan.core.TitanTransaction.commit()
  Commits and closes the transaction.

  Will attempt to persist all modifications which may result in exceptions in case of persistence failures or lock contention.
  The call releases data structures if possible. All element references (e.g. vertex objects) retrieved through this transaction are stale after the transaction closes and should no longer be used. @throws com.thinkaurelius.titan.diskstorage.StorageException if an error arises during persistence

• com.thinkaurelius.titan.diskstorage.BackendTransaction.commit()
• com.thinkaurelius.titan.diskstorage.keycolumnvalue.StoreTransaction.commit()
• com.thinkaurelius.titan.graphdb.blueprints.TitanBlueprintsGraph.commit()
• com.thinkaurelius.titan.graphdb.database.StandardTitanGraph.commit()
• com.tinkerpop.blueprints.TransactionalGraph.commit()
  Stop the current transaction and successfully apply mutations to the graph.
• com.tinkerpop.blueprints.impls.orient.OrientBaseGraph.commit()
  Commits the current active transaction.
• com.tinkerpop.blueprints.impls.orient.OrientGraph.commit()
• com.tinkerpop.blueprints.util.wrappers.batch.BatchGraph.commit()
  Should only be invoked after loading is complete. Committing the transaction before will cause the loading to fail.
• com.totalchange.jizz.data.blobs.JizzBlobWriter.commit()
• com.totsp.gwittir.client.util.HistoryTokenizer.commit()
• com.vaadin.data.fieldgroup.FieldGroup.commit()
  Commits all changes done to the bound fields.

  Calls all {@link CommitHandler}s before and after committing the field changes to the item data source. The whole commit is aborted and state is restored to what it was before commit was called if any {@link CommitHandler} throws a CommitException or there is a problemcommitting the fields @throws CommitException If the commit was aborted

• com.vaadin.data.util.sqlcontainer.SQLContainer.commit()
  Commits all the changes, additions and removals made to the items of this container. @throws UnsupportedOperationException @throws SQLException
• com.vaadin.ui.ComboBox.commit()
• com.vaadin.ui.Form.commit()
• com.vaadin.ui.TextField.commit()
• com.xiaoleilu.hutool.db.Session.commit()
  提交事务 @throws SQLException
• com.yahoo.omid.tso.Bucket.commit()
• com.youtube.vitess.vtgate.VtGate.commit()
• de.fhg.igd.mongomvcc.VBranch.commit()
  Commit objects that have been added or changed in this branch to the database @return the new commit's ID (CID) @throws VException if the branch is named and the branch's headcould not be updated in the database, because it already has been updated somewhere else (most likely in another thread). If this happens, the commit has already been fully performed and {@link #getHead()} will return the new CID. The caller then has thechance to call {@link VDatabase#createBranch(String,long)} tocreate a new named branch based on this CID.
• de.mhus.lib.jpa.JpaEntityManager.commit()
• de.mhus.lib.sql.DbConnection.commit()
  Commit this connection changes. The system should not use the auto commit from jdbc. @throws Exception
• de.odysseus.calyxo.forms.FormProperties.commit()
  Commit form properties to form data. @throws Exception
• de.zib.scalaris.Transaction.commit()
  Commits the current transaction.

  The transaction's log is reset if the commit was successful, otherwise it still retains in the transaction which must be successfully committed, aborted or reset in order to be (re-)used for another request.

  @throws ConnectionException if the connection is not active or a communication error occurs or an exit signal was received or the remote node sends a message containing an invalid cookie @throws TimeoutException if a timeout occurred while trying to commit the transaction @throws AbortException if the commit failed @throws UnknownException If the commit fails or the returned value from erlang is of an unknown type/structure, this exception is thrown. Neither the transaction log nor the local operations buffer is emptied, so that the commit can be tried again. @see #abort()
• dovetaildb.api.ApiService.commit()
• dovetaildb.dbservice.BagIndexBridge.commit()
• edu.brown.hstore.estimators.TransactionEstimator.commit()
  The transaction with provided txn_id is finished @param txn_id finished transaction
• edu.isi.karma.semantictypes.tfIdf.Indexer.commit()
• edu.wpi.first.wpilibj.Dashboard.commit()
• es.ipsa.atril.sec.authentication.AtrilSession.commit()
• fitnesse.wiki.WikiPage.commit()
  Commit new content @param data @return version information about this new data version, may be null.
• fr.dyade.aaa.agent.ServerConfigHelper.commit()
• galena.addins.modules.database.DB.DBConnection.commit()
• helma.objectmodel.db.Transactor.commit()
  Commit the current transaction, persisting all changes to DB. @throws Exception ...
• hermes.Hermes.commit()
  Commit work on this thread since last commit or rollback.
• hudson.BulkChange.commit()
  Saves the accumulated changes.
• hudson.remoting.jnlp.MainMenu.commit()
  Reflects the changes made in the menu objects to GUI.
• hudson.util.AtomicFileWriter.commit()
• in.partake.model.dao.PartakeConnection.commit()
• io.crate.blob.DigestBlob.commit()
• io.druid.data.input.Firehose.commit()
• java.sql.Connection.commit()
  Commit makes all changes made since the previous commit/rollback permanent and releases any database locks currently held by the Connection. This method should only be used when auto commit has been disabled. @exception SQLException if a database-access error occurs. @see #setAutoCommit
• javax.jdo.Transaction.commit()
  Commit the current transaction. @throws JDOUserException if transactions are managed by a containerin the managed environment, or if the transaction is not active.
• javax.jms.QueueSession.commit()
• javax.jms.Session.commit()
• javax.jms.TopicSession.commit()
• javax.jms.XAQueueSession.commit()
• javax.jms.XASession.commit()
• javax.microedition.pim.Contact.commit()
• javax.microedition.pim.Event.commit()
• javax.persistence.EntityTransaction.commit()
  Commit the current transaction, writing any unflushed changes to the database. @throws IllegalStateException if isActive() is false. @throws RollbackException if the commit fails.
• javax.resource.cci.LocalTransaction.commit()
• javax.resource.spi.XATerminator.commit()
• javax.security.auth.spi.LoginModule.commit()
  Method to commit the authentication process (phase 2).

  This method is called if the LoginContext's overall authentication succeeded (the relevant REQUIRED, REQUISITE, SUFFICIENT and OPTIONAL LoginModules succeeded).

  If this LoginModule's own authentication attempt succeeded (checked by retrieving the private state saved by the {@code login} method), then this method associates relevantPrincipals and Credentials with the {@code Subject} located in the{@code LoginModule}. If this LoginModule's own authentication attempted failed, then this method removes/destroys any state that was originally saved.

  @exception LoginException if the commit fails @return true if this method succeeded, or false if this{@code LoginModule} should be ignored.

• javax.security.jacc.PolicyConfiguration.commit()
• javax.sql.rowset.CachedRowSet.commit()
  Each CachedRowSet object's SyncProvider contains a Connection object from the ResultSet or JDBC properties passed to it's constructors. This method wraps the Connection commit method to allow flexible auto commit or non auto commit transactional control support.

  Makes all changes that are performed by the acceptChanges() method since the previous commit/rollback permanent. This method should be used only when auto-commit mode has been disabled. @throws SQLException if a database access error occurs or thisConnection object within this CachedRowSet is in auto-commit mode @see java.sql.Connection#setAutoCommit

• javax.sql.rowset.JdbcRowSet.commit()
  Each JdbcRowSet contains a Connection object from the ResultSet or JDBC properties passed to it's constructors. This method wraps the Connection commit method to allow flexible auto commit or non auto commit transactional control support.

  Makes all changes made since the previous commit/rollback permanent and releases any database locks currently held by this Connection object. This method should be used only when auto-commit mode has been disabled. @throws SQLException if a database access error occurs or thisConnection object within this JdbcRowSet is in auto-commit mode @see java.sql.Connection#setAutoCommit

• javax.transaction.Transaction.commit()
• javax.transaction.TransactionManager.commit()
• javax.transaction.UserTransaction.commit()
  Commits the transaction
• javax.transaction.xa.XAResource.commit()
• jdbm.RecordManager.commit()
  Commit (make persistent) all changes since beginning of transaction.
• jdbm.recman.BaseRecordManager.commit()
  Commit (make persistent) all changes since beginning of transaction.
• jfix.search.FullTextIndex.commit()
• jodd.db.jtx.DbJtxTransaction.commit()
• jodd.jtx.JtxTransaction.commit()
  Commit and completes current transaction. Transaction is committed on all attached resources. After, resources are detached from the transaction. When this method completes,transaction is no longer associated with current thread.
• liquibase.database.Database.commit()
• liquibase.database.DatabaseConnection.commit()
• marauroa.server.db.TransactionPool.commit()
  commits this transaction and frees its reservation @param dbtransaction transaction @throws SQLException in case of an database error
• mireka.pop.store.MaildropAppender.commit()
  It closes the output stream, adds the mail to the maildrop and releases the appender. Even if it throws an exception, the appender is always released. @throws LocalMailSystemException if the mail couldn't be added to the maildrop for some reason.
• net.fortytwo.ripple.model.ModelConnection.commit()
  Commits the current transaction. @throws RippleException if the transaction cannot be committed
• net.fortytwo.twitlogic.persistence.TweetStoreConnection.commit()
• net.hasor.db.transaction.TransactionManager.commit()
  递交事务

  如果递交的事务并不处于事务堆栈顶端，会同时递交该事务的后面其它事务。

• net.jini.core.transaction.Transaction.commit()
  Commit the transaction. Commit asks the transaction manager to execute the voting process with the participants. Returns if the transaction successfully reaches either the NOTCHANGED or the COMMITTED state, without waiting for the transaction manager to notify all participants of the decision. If the transaction must be aborted (because one or more participants are unable to prepare), CannotCommitException is thrown without waiting for the transaction manager to notify all participants of the decision. @throws UnknownTransactionException if the transaction is unknown to the manager. This may be because the transaction ID was incorrect, or because the transaction has proceeded to cleanup due to an earlier commit or abort, and has been forgotten. @throws CannotCommitException if the transaction reaches the ABORTED state, or is known to have previously reached that state due to an earlier commit or abort. @throws RemoteException if a communication error occurs.
• net.jini.core.transaction.server.TransactionParticipant.commit()
  Requests that the participant make all of its PREPARED changes for the specified transaction visible outside of the transaction and unlock any resources locked by the transaction. All state associated with the transaction can then be discarded by the participant. @param mgr the manager of the transaction @param id the transaction ID @throws UnknownTransactionException if the transaction is unknown to the transaction manager, either because the transaction ID is incorrect or because the transaction is complete and its state has been discarded by the manager. @throws RemoteException if there is a communication error
• net.rim.blackberry.api.pdap.BlackBerryContact.commit()
• net.rim.blackberry.api.pdap.BlackBerryMemo.commit()
• net.rim.device.api.system.PersistentObject.commit()
• net.sf.collabreview.core.Repository.commit()
  Suggest to commit changes to the persistent store. This method does not have to do anything, but may for example be used to commit a database transaction.
• net.sf.collabreview.core.users.AuthorManager.commit()
  Commit the changes made to the AuthorManager.
• net.sf.ehcache.TransactionController.commit()
  Commit the transaction bound to the current thread
• net.sf.ehcache.transaction.local.LocalTransactionContext.commit()
  Commit all work done in the context and release all registered soft locks @param ignoreTimeout true if commit should proceed no matter the timeout
• net.sf.hibernate.Transaction.commit()
• net.sf.jabref.export.SaveSession.commit()
• net.sf.xbus.base.core.TAManager.commit()
  Commits all actions on the registered resources and closes the resources.
• net.sf.xbus.base.journal.Journal.commit()
  Commits the database.
• net.sf.xbus.technical.mq.MQConnection.commit()
  Commits all actions on the queues associated with this MQConnection (normally all queues of the current thread).
• net.sourceforge.ganttproject.gui.options.model.EnumerationOption.commit()
• net.sourceforge.ganttproject.gui.options.model.GPOption.commit()
• net.sourceforge.ganttproject.task.TaskMutator.commit()
• net.sourceforge.squirrel_sql.fw.sql.ISQLConnection.commit()
• net.sourceforge.wampum.system.data.DAOFactory.commit()
• net.timewalker.ffmq3.local.session.LocalSession.commit()
• nexj.core.runtime.UnitOfWork.commit()
  Commits the changes to the persistent storage. @param bEndTx True to commit also the distributed transaction.
• nexj.core.runtime.platform.generic.tx.GenericTransactionManager.commit()
  @see javax.transaction.TransactionManager#commit()
• oracle.AWXML.AW.Commit()
• oracle.toplink.sessions.UnitOfWork.commit()
• org.activemq.service.Transaction.commit()
• org.adbcj.Connection.commit()
• org.apache.accumulo.server.tabletserver.Tablet.CommitSession.commit()
• org.apache.accumulo.tserver.Tablet.CommitSession.commit()
• org.apache.ace.repository.Repository.commit()
  Commits data into the repository. @param data The data to be committed. @param fromVersion The version the data is based upon. @return True if the commit succeeded, false otherwise if the fromVersion is not the latest version. @throws java.io.IOException If there was a problem reading or writing the data. @throws IllegalArgumentException If the version is not greater than 0. @throws IllegalStateException If an attempt to commit was made on a non-master repository.
• org.apache.ace.repository.ext.CachedRepository.commit()
  Commits the most current version to the actual repository. @return true on success, false on failure (e.g. bad version number) @throws java.io.IOException Is thrown when the actual repository's commit does.
• org.apache.ace.repository.ext.impl.CachedRepositoryImpl.commit()
• org.apache.activemq.ActiveMQSession.commit()
  Commits all messages done in this transaction and releases any locks currently held. @throws JMSException if the JMS provider fails to commit the transactiondue to some internal error. @throws TransactionRolledBackException if the transaction is rolled backdue to some internal error during commit. @throws javax.jms.IllegalStateException if the method is not called by atransacted session.
• org.apache.activemq.store.kahadb.disk.page.Transaction.commit()
  Commits the transaction to the PageFile as a single 'Unit of Work'. Either all page updates associated with the transaction are written to disk or none will.
• org.apache.activemq.transaction.Transaction.commit()
• org.apache.activemq.transport.stomp.StompConnection.commit()
• org.apache.archiva.transaction.FileTransaction.commit()
• org.apache.aurora.scheduler.storage.log.LogManager.StreamManager.StreamTransaction.commit()
• org.apache.camel.component.file.strategy.FileProcessStrategy.commit()
  Releases any file locks and possibly deletes or moves the file
• org.apache.camel.impl.DefaultRouteContext.commit()
• org.apache.camel.impl.RouteContext.commit()
  Lets complete the route creation, creating a single event driven route for the current from endpoint with any processors required
• org.apache.camel.spi.RouteContext.commit()
  Lets complete the route creation, creating a single event driven route for the current from endpoint with any processors required
• org.apache.cayenne.access.Transaction.commit()
• org.apache.chemistry.opencmis.inmemory.storedobj.api.DocumentVersion.commit()
• org.apache.cocoon.acting.ModularDatabaseAccess.OutputHelper.commit()
  Signal that the database transaction completed successfully. See notes on @link{rollback}.
• org.apache.cocoon.components.modules.output.OutputModule.commit()
  Signal that the database transaction completed successfully. See notes on @link{rollback}.
• org.apache.curator.TimeTrace.commit()
  Record the elapsed time
• org.apache.curator.framework.api.transaction.CuratorTransactionFinal.commit()
  Commit all added operations as an atomic unit and return results for the operations. One result is returned for each operation added. Further, the ordering of the results matches the ordering that the operations were added. @return operation results @throws Exception errors
• org.apache.derby.iapi.store.access.TransactionController.commit()
  Commit this transaction. All savepoints within this transaction are released. All non-held conglomerates and scans are closed. @exception StandardException Only exceptions with severities greater thanExceptionSeverity.TRANSACTION_SEVERITY will be thrown. If an exception is thrown, the transaction will not (necessarily) have been aborted. The standard error handling mechanism is expected to do the appropriate cleanup. In other words, if commit() encounters an error, the exception is propagated up to the the standard exception handler, which initiates cleanupOnError() processing, which will eventually abort the transaction.
• org.apache.derby.iapi.store.access.conglomerate.TransactionManager.commit()
• org.apache.derby.iapi.store.access.xa.XAResourceManager.commit()
  This method is called to commit the global transaction specified by xid.

  RESOLVE - how do we map to the "right" XAExceptions.

  @return The identifier to be used to open the conglomerate later. @param cm The ContextManager returned from the find() call. @param xid A global transaction identifier. @param onePhase If true, the resource manager should use a one-phasecommit protocol to commit the work done on behalf of xid. @exception StandardException Standard exception policy.

• org.apache.derby.iapi.store.raw.xact.RawTransaction.commit()
• org.apache.excalibur.event.PreparedEnqueue.commit()
  Commit a previously prepared provisional enqueue operation (from the prepareEnqueue method). Causes the provisionally enqueued elements to appear on the queue for future dequeue operations. Note that once a prepareEnqueue has returned an enqueue key, the queue cannot reject the entries.
• org.apache.flume.Transaction.commit()
  Indicates that the transaction can be successfully committed. It is required that a transaction be in progress when this method is invoked.
• org.apache.geronimo.security.jacc.mappingprovider.PolicyConfigurationGeneric.commit()
• org.apache.geronimo.transaction.BeanTransactionContext.commit()
• org.apache.geronimo.transaction.ContainerTransactionContext.commit()
  TODO the exceptions thrown here are not all correct. Don't throw a RollbackException after a successful commit...?? @throws javax.transaction.HeuristicMixedException @throws javax.transaction.HeuristicRollbackException @throws javax.transaction.RollbackException @throws javax.transaction.SystemException
• org.apache.geronimo.transaction.context.BeanTransactionContext.commit()
• org.apache.geronimo.transaction.context.ContainerTransactionContext.commit()
• org.apache.geronimo.transaction.context.TransactionContext.commit()
• org.apache.geronimo.transaction.manager.TransactionManagerImpl.commit()
• org.apache.hadoop.hbase.HTable.commit()
  Finalize a row mutation When this method is specified, we pass the server a value that says use the 'latest' timestamp. If we are doing a put, on the server-side, cells will be given the servers's current timestamp. If the we are commiting deletes, then delete removes the most recently modified cell of stipulated column. @param lockid lock id returned from startUpdate @throws IOException
• org.apache.hadoop.hbase.client.HTable.commit()
  Commit a BatchUpdate to the table. If autoFlush is false, the update is buffered @param batchUpdate @throws IOException
• org.apache.hadoop.hbase.ipc.TransactionalRegionInterface.commit()
  Commit the transaction. @param regionName @param transactionId @throws IOException
• org.apache.harmony.auth.module.JndiLoginModule.commit()
• org.apache.harmony.auth.module.KeyStoreLoginModule.commit()
• org.apache.harmony.auth.module.LdapLoginModule.commit()
• org.apache.hcatalog.data.transfer.HCatWriter.commit()
  This method should be called at master node. Primary purpose of this is to do metadata commit. @throws {@link HCatException}
• org.apache.hive.hcatalog.data.transfer.HCatWriter.commit()
  This method should be called at master node. Primary purpose of this is to do metadata commit. @throws {@link HCatException}
• org.apache.hive.hcatalog.streaming.TransactionBatch.commit()
  Commit the currently open transaction @throws StreamingException if there are errors committing @throws InterruptedException if call in interrupted
• org.apache.ibatis.session.SqlSession.commit()
• org.apache.ibatis.transaction.Transaction.commit()
• org.apache.jackrabbit.core.UserTransactionImpl.commit()
  @see javax.transaction.UserTransaction#commit
• org.apache.jackrabbit.core.security.JahiaLoginModule.commit()
• org.apache.jackrabbit.data.core.TransactionContext.commit()
  Commit the transaction identified by this context. Commits changes on all resources. If some resource reports an error on commit, automatically rollback changes on all other resources. Throw exception at the end if some commit failed. @throws XAException if an error occurs
• org.apache.jackrabbit.mk.api.MicroKernel.commit()
  Applies the specified changes on the specified target node.

  If {@code path.length() == 0} the paths specified in the{@code jsonDiff} are expected to be absolute.

  The implementation tries to merge changes if the revision id of the commit is set accordingly. As an example, deleting a node is allowed if the node existed in the given revision, even if it was deleted in the meantime. @param path path denoting target node @param jsonDiff changes to be applied in JSON diff format. @param revisionId id of revision the changes are based on,if {@code null} the current head revision is assumed @param message commit message @return id of newly created revision @throws MicroKernelException if the specified revision doesn't exist or if another error occurs

• org.apache.jackrabbit.mk.core.MicroKernelImpl.commit()
• org.apache.jackrabbit.mk.simple.SimpleKernelImpl.commit()
• org.apache.jackrabbit.oak.api.Root.commit()
  Atomically persists all changes made to the tree attached to this root at the given {@code path}. An implementations may throw a {@code CommitFailedException} if there are changes outside of the subtreedesignated by {@code path} and the implementation does not supportsuch partial commits. However all implementation must handler the case where a {@code path} designates a subtree that contains allunpersisted changes.

  The message string (if given) is passed to the underlying storage as a part of the internal commit information attached to this commit. The commit information will be made available to local observers but will not be visible to observers on other cluster nodes.

  After a successful operation the root is automatically {@link #refresh() refreshed}, such that trees previously obtained through {@link #getTree(String)} may become non existing. @param message custom message to be associated with this commit @param path of the subtree to commit @throws CommitFailedException if the commit failed

• org.apache.jackrabbit.oak.core.RootImpl.commit()
• org.apache.jackrabbit.oak.core.SystemRoot.commit()
• org.apache.jackrabbit.oak.jcr.delegate.SessionDelegate.commit()
  Commits the changes currently in the transient space. TODO: Consolidate with save(). @throws CommitFailedException if the commit failed
• org.apache.jackrabbit.oak.plugins.document.DocumentMK.commit()
• org.apache.jackrabbit.ocm.transaction.jackrabbit.UserTransactionImpl.commit()
  @see javax.transaction.UserTransaction#commit
• org.apache.jackrabbit.vault.fs.api.VaultFsTransaction.commit()
  Commits the transaction and uploads all modifications to the repository. @return a list of modifications @throws IOException if an I/O error occurs @throws RepositoryException if a repository error occurs
• org.apache.jetspeed.components.persistence.store.Transaction.commit()
• org.apache.juddi.datastore.DataStore.commit()
  commit transaction
• org.apache.juddi.util.jdbc.Transaction.commit()
  commit on all connections. This is not XA, but it could be one day.
• org.apache.kahadb.page.Transaction.commit()
  Commits the transaction to the PageFile as a single 'Unit of Work'. Either all page updates associated with the transaction are written to disk or none will.
• org.apache.lenya.cms.repository.Session.commit()
  Commits the transaction. @throws RepositoryException if an error occurs. @throws ConcurrentModificationException if a transactionable has beenmodified by another session.
• org.apache.lucene.facet.taxonomy.TaxonomyWriter.commit()
  Calling commit() ensures that all the categories written so far are visible to a reader that is opened (or reopened) after that call. When the index is closed(), commit() is also implicitly done.
• org.apache.lucene.facet.taxonomy.directory.DirectoryTaxonomyWriter.commit()
• org.apache.lucene.facet.taxonomy.lucene.LuceneTaxonomyWriter.commit()
  Calling commit() ensures that all the categories written so far are visible to a reader that is opened (or reopened) after that call. When the index is closed(), commit() is also implicitly done. See {@link TaxonomyWriter#commit()}
• org.apache.lucene.index.BlurIndexWriter.commit()
• org.apache.lucene.index.IndexReader.commit()
  Commit changes resulting from delete, undeleteAll, or setNorm operations If an exception is hit, then either no changes or all changes will have been committed to the index (transactional semantics). @throws IOException if there is a low-level IO error
• org.apache.lucene.index.IndexWriter.commit()

  Commits all pending changes (added & deleted documents, segment merges, added indexes, etc.) to the index, and syncs all referenced index files, such that a reader will see the changes and the index updates will survive an OS or machine crash or power loss. Note that this does not wait for any running background merges to finish. This may be a costly operation, so you should test the cost in your application and do it only when really necessary.

  Note that this operation calls Directory.sync on the index files. That call should not return until the file contents & metadata are on stable storage. For FSDirectory, this calls the OS's fsync. But, beware: some hardware devices may in fact cache writes even during fsync, and return before the bits are actually on stable storage, to give the appearance of faster performance. If you have such a device, and it does not have a battery backup (for example) then on power loss it may still lose data. Lucene cannot guarantee consistency on such devices.

  NOTE: if this method hits an OutOfMemoryError you should immediately close the writer. See above for details.

  @see #prepareCommit @see #commit(Map)
• org.apache.lucene.index.RandomIndexWriter.commit()
• org.apache.lucene.replicator.IndexAndTaxonomyRevision.SnapshotDirectoryTaxonomyWriter.commit()
• org.apache.lucene.util.TwoPhaseCommitTool.TwoPhaseCommitWrapper.commit()
• org.apache.marmotta.kiwi.persistence.KiWiConnection.commit()
  Makes all changes made since the previous commit/rollback permanent and releases any database locks currently held by this Connection object. This method should be used only when auto-commit mode has been disabled. @exception java.sql.SQLException if a database access error occurs,this method is called while participating in a distributed transaction, if this method is called on a closed conection or this Connection object is in auto-commit mode @see #setAutoCommit
• org.apache.marmotta.kiwi.reasoner.persistence.KiWiReasoningConnection.commit()
• org.apache.marmotta.kiwi.versioning.persistence.KiWiVersioningConnection.commit()
• org.apache.marmotta.ldcache.api.LDCachingConnection.commit()
• org.apache.marmotta.ldcache.backend.kiwi.persistence.LDCachingKiWiPersistenceConnection.commit()
  Makes all changes made since the previous commit/rollback permanent and releases any database locks currently held by this Connection object. This method should be used only when auto-commit mode has been disabled. @exception java.sql.SQLException if a database access error occurs,this method is called while participating in a distributed transaction, if this method is called on a closed conection or this Connection object is in auto-commit mode
• org.apache.marmotta.ldcache.backend.kiwi.sail.LDCachingKiWiSailConnection.commit()
• org.apache.maven.archiva.converter.transaction.FileTransaction.commit()
• org.apache.maven.archiva.transaction.CopyFileEvent.commit()
• org.apache.maven.archiva.transaction.CreateFileEvent.commit()
• org.apache.maven.archiva.transaction.FileTransaction.commit()
• org.apache.maven.index.context.IndexingContext.commit()
  Commits changes to context, eventually refreshing readers/searchers too. @throws IOException
• org.apache.ode.store.ConfStoreConnection.commit()
• org.apache.ojb.odmg.TransactionExt.commit()
• org.apache.ojb.otm.core.Transaction.commit()
  Commit this transaction. A commit notifies all listeners of this transaction. It then initiates a two phase commit on connections. Since, connections cannot be associated to more than one transaction at any given point in time, there is no neccessity to identify transaction.
• org.apache.ojb.otm.states.State.commit()
  Describes the state transition on commit()
• org.apache.openejb.core.transaction.TransactionPolicy.commit()
  Commits or rolls back this TransactionPolicy. If there the actual transaction is completed or there is no actual transaction, the registered TransactionSynchronization are called. Otherwise, the registered TransactionSynchronization are called when the actual transaction is completed. @throws ApplicationException if recoverable exception is encountered @throws SystemException if an unrecoverable exception is encountered
• org.apache.openjpa.kernel.Broker.commit()
  Commit the current transaction.
• org.apache.openjpa.kernel.StoreManager.commit()
  Commit the current data store transaction.
• org.apache.openjpa.persistence.OpenJPAEntityManager.commit()
  @deprecated use {@link EntityTransaction#commit}instead: em.getTransaction().commit()
• org.apache.openjpa.persistence.OpenJPAEntityTransaction.commit()
• org.apache.phoenix.jdbc.PhoenixConnection.commit()
• org.apache.pig.CommittableStoreFunc.commit()
  This method is called when all mappers (when the storefunc is part of map) or reducers (when the storefunc is part of reduce) are finished. This allows the storeFunc to do any global commit actions - only called when all mappers/reducers successfully complete. If the StoreFunc needs to get hold of StoreConfig object for the store it can call {@link MapRedUtil#getStoreConfig(org.apache.hadoop.mapred.JobConf)} whereconf is the Configuration object passed in the commit() call. @param conf Configuration object for the job
• org.apache.qpid.jms.Session.commit()
• org.apache.qpid.server.AMQChannel.commit()
• org.apache.qpid.server.protocol.v0_8.AMQChannel.commit()
• org.apache.qpid.server.txn.DtxBranch.commit()
• org.apache.qpid.server.txn.LocalTransaction.commit()
• org.apache.qpid.server.txn.ServerTransaction.commit()
  Commit the transaction represented by this object. If the caller has registered one or more Actions, the postCommit() method on each will be executed immediately after the underlying transaction has committed.
• org.apache.sandesha2.storage.Transaction.commit()
• org.apache.slide.common.NamespaceAccessToken.commit()
• org.apache.sling.api.resource.ResourceResolver.commit()
  Persist all pending changes. @throws PersistenceException @since 2.2
• org.apache.sling.cassandra.resource.provider.CassandraResourceProvider.commit()
• org.apache.solr.client.solrj.SolrServer.commit()
  Performs an explicit commit, causing pending documents to be committed for indexing

  waitFlush=true and waitSearcher=true to be inline with the defaults for plain HTTP access @throws SolrServerException @throws IOException

• org.apache.solr.client.solrj.impl.CloudSolrServer.commit()
• org.apache.solr.client.solrj.impl.CommonsHttpSolrServer.commit()
• org.apache.solr.client.solrj.impl.HttpSolrServer.commit()
• org.apache.solr.update.UpdateHandler.commit()
• org.apache.sqoop.repository.RepositoryTransaction.commit()
• org.apache.tapestry5.hibernate.HibernateSessionManager.commit()
  Commits the current transaction (which will cause a flush of data to the database), then starts a new transaction to replace it.
• org.apache.tapestry5.internal.services.ajax.JavaScriptSupportImpl.commit()
• org.apache.tez.mapreduce.output.MROutput.commit()
  MROutput expects that a Processor call commit prior to the Processor's completion @throws IOException
• org.apache.tiles.freemarker.renderer.FreeMarkerAttributeRenderer.commit()
  Commits the parameters and makes this renderer ready for the use. @since 2.2.0
• org.apache.tiles.velocity.renderer.VelocityAttributeRenderer.commit()
  Commits the parameters and makes this renderer ready for the use. @since 2.2.0
• org.apache.uima.cas.admin.FSIndexRepositoryMgr.commit()
  Commit this repository instance. No more additions will be allowed.
• org.apache.uima.cas.admin.TypeSystemMgr.commit()
  Commit the type system. The type system will be locked and no longer writable. WARNING: Users should not call this, but instead call ((CASImpl) theAssociatedCAS).commitTypeSystem() in order to set up the parts of the CAS that should be set up when the type system is committed.
• org.apache.wookie.beans.util.IPersistenceManager.commit()
  Commit persistence manager transaction. @throws PersistenceCommitException
• org.apache.zookeeper.Transaction.commit()
• org.apache.zookeeper.server.persistence.FileTxnSnapLog.commit()
  commit the transaction of logs @throws IOException
• org.araneaframework.servlet.util.AtomicResponseHelper.commit()
• org.ardverk.dht.storage.message.Response.commit()
• org.axonframework.saga.AssociationValues.commit()
  Resets the tracked changes.
• org.axonframework.unitofwork.UnitOfWork.commit()
  Commits the UnitOfWork. All registered aggregates that have not been registered as stored are saved in their respective repositories, buffered events are sent to their respective event bus, and all registered UnitOfWorkListeners are notified.

  After the commit (successful or not), the UnitOfWork is unregistered from the CurrentUnitOfWork and has cleaned up all resources it occupied. This effectively means that a rollback is done if Unit Of Work failed to commit. @throws IllegalStateException if the UnitOfWork wasn't started

• org.b3log.latke.repository.Transaction.commit()
  Commits this transaction.

  Throws:
  {@link java.lang.IllegalStateException} - if the transaction has already been committed, rolled back

• org.castor.persist.TransactionContext.commit()
  Commits all changes and closes the transaction releasing all locks on all objects. All objects are now transient. Must be called after a call to {@link #prepare} has returned successfully. Throws an IllegalStateExceptionwhen called without calling {@link #prepare} first. @throws TransactionAbortedException The transaction has been aborted due toinconsistency, duplicate object identity, error with the persistence engine or any other reason.
• org.codehaus.activemq.service.Transaction.commit()
• org.compass.core.CompassSession.commit()
• org.compass.core.CompassTransaction.commit()
• org.compiere.util.Trx.commit()
• org.conserve.connection.ConnectionWrapper.commit()
  All transactions executed on this ConnectionWrapper's connection are committed, if they have not already been so. @throws SQLException
• org.cruxframework.crux.core.rebind.AbstractProxyCreator.SourcePrinter.commit()
• org.dcm4che3.media.DicomDirWriter.commit()
• org.deuce.transaction.Context.commit()
  Called on commit @return true on success
• org.drools.persistence.Transaction.commit()
• org.drools.persistence.TransactionManager.commit()
• org.drools.persistence.jta.JtaTransactionManager.commit()
• org.dspace.core.Context.commit()
  Commit any transaction that is currently in progress, but do not close the context. @exception SQLException if there was an error completing the database transaction or closing the connection
• org.eclipse.core.filebuffers.ITextFileBuffer.commit()
• org.eclipse.egit.ui.common.CommitDialogTester.commit()
• org.eclipse.egit.ui.common.StagingViewTester.commit()
• org.eclipse.egit.ui.internal.commit.CommitUI.commit()
  1 Performs a commit @return true if a commit operation was triggered
• org.eclipse.jgit.api.Git.commit()
  org/pub/software/scm/git/docs/git-commit.html" >Git documentation about Commit @return a {@link CommitCommand} used to collect all optional parametersand to finally execute the {@code Commit} command
• org.eclipse.jgit.dircache.DirCache.commit()
  Commit this change and release the lock.

  If this method fails (returns false) the lock is still released. @return true if the commit was successful and the file contains the newdata; false if the commit failed and the file remains with the old data. @throws IllegalStateException the lock is not held.

• org.eclipse.jgit.dircache.DirCacheBuilder.commit()
• org.eclipse.jgit.dircache.DirCacheEditor.commit()
• org.eclipse.jgit.internal.storage.file.LockFile.commit()
  Commit this change and release the lock.

  If this method fails (returns false) the lock is still released. @return true if the commit was successful and the file contains the newdata; false if the commit failed and the file remains with the old data. @throws IllegalStateException the lock is not held.

• org.eclipse.jgit.junit.TestRepository.commit()
  Create a new commit.

  See {@link #commit(int,RevTree,RevCommit)}. The tree is the empty tree (no files or subdirectories). @param parents zero or more parents of the commit. @return the new commit. @throws Exception

• org.eclipse.jgit.junit.TestRepository.BranchBuilder.commit()
• org.eclipse.jgit.lib.Commit.commit()
  Create an empty commit object. More information must be fed to this object to make it useful. @param db The repository with which to associate it.
• org.eclipse.jgit.storage.file.LockFile.commit()
  Commit this change and release the lock.

  If this method fails (returns false) the lock is still released. @return true if the commit was successful and the file contains the newdata; false if the commit failed and the file remains with the old data. @throws IllegalStateException the lock is not held.

• org.eclipse.nebula.widgets.nattable.edit.editor.ICellEditor.commit()
  Commits the current value of this editor. Will first try to convert and validate the current value, and if that succeeds and the value can be committed to the data model, the editor will be closed afterwards. @param direction The direction the selection within the NatTable should move after commit has finished. @return true if the commit operation succeeded,false if the current value could not be committed. A value might not be committed for example if the conversion or the validation failed.
• org.eclipse.persistence.sessions.UnitOfWork.commit()
  PUBLIC: Commit the unit of work to its parent. For a nested unit of work this will merge any changes to its objects with its parents. For a first level unit of work it will commit all changes to its objects to the database as a single transaction. If successful the changes to its objects will be merged to its parent's objects. If the commit fails the database transaction will be rolledback, and the unit of work will be released. If the commit is successful the unit of work is released, and a new unit of work must be acquired if further changes are desired. @see #commitAndResumeOnFailure() @see #commitAndResume() @see #release()
• org.eclipse.test.performance.PerformanceMeter.commit()
  Called exactly once after repeated measurements are done and before their analysis. Afterwards {@link PerformanceMeter#start()} and{@link PerformanceMeter#stop()} must not be called.
• org.eclipse.ui.forms.IDetailsPage.commit()
• org.eclipse.ui.forms.IManagedForm.commit()
  Commits the dirty form. All pending changes in the widgets are flushed into the model. @param onSave
• org.eclipse.wb.internal.css.parser.CssEditContext.commit()
• org.ethereum.facade.Repository.commit()
  Store all the temporary changes made to the repository in the actual database
• org.exist.fluent.Transaction.commit()
• org.exist.storage.txn.TransactionManager.commit()
  Commit a transaction. @param txn @throws TransactionException
• org.exist.versioning.svn.WorkingCopy.commit()
• org.exolab.castor.jdo.Database.commit()
  Commits and closes the transaction. All changes made to persistent objects during the transaction are made persistent; objects created during the transaction are made durable; and, objects removed during the transaction are removed from the database.

  In other words, any modifications to any data objects which are queried/loaded/created/update to this database is automatically stored to the database and visible to subsequence transactions. (ie. update is solely used for long transaction support and should not be called for any data object queried/loaded/created in the this transaction.)

  If the transaction cannot commit, the entire transaction rolls back and a {@link TransactionAbortedException} exception isthrown.

  After this method returns, the transaction is closed and all persistent objects are transient. Using {@link #begin} to open anew transaction will not restore objects to their persistent stage. @throws TransactionNotInProgressException Method called whiletransaction is not in progress @throws TransactionAbortedException The transaction cannotcommit and has been rolled back

• org.exoplatform.services.jcr.impl.backup.DataRestore.commit()
  Commit changes. @throws RestoreException if any exception is occurred
• org.exoplatform.services.jcr.impl.clean.rdbms.DBCleanerTool.commit()
  Executes SQL scripts for finishing clean operations if needed. It can be adding indexes, constraints, removing temporary objects etc (related to specific database) or does nothing.
  This method does not invoke commit or rollback on {@link Connection} butneeded autocommit mode can be set. @throws DBCleanException
• org.exoplatform.services.jcr.storage.WorkspaceStorageConnection.commit()
  Persist changes and closes connection. It can be database transaction commit for instance etc. @throws IllegalStateException if connection is already closed @throws RepositoryException if some exception occured
• org.fcrepo.server.storage.DOWriter.commit()
  Saves the changes thus far to the permanent copy of the digital object. @param logMessage An explanation of the change(s). @throws ServerException If any type of error occurred fulfilling the request.
• org.fedorahosted.cobbler.autogen.Distro.commit()
• org.freeplane.core.undo.IUndoHandler.commit()
• org.freeplane.features.mode.ModeController.commit()
• org.fto.jthink.jdbc.JDBCTransaction.commit()
• org.fusesource.hawtdb.api.Transaction.commit()
  @throws OptimisticUpdateException is thrown if the update would conflict with a concurrent updated performed by another thread.
• org.garret.perst.Storage.commit()
• org.geoserver.catalog.impl.ModificationProxy.commit()
• org.geotools.data.DefaultTransaction.commit()
  Commits all modifications against this Transaction.

  This implementation will call commit() on all State managed by this Transaction. This allows DataStores to provide their own implementation of commit().

  @throws IOException Encountered problem maintaining transaction state @throws DataSourceException See IOException @see org.geotools.data.Transaction#commit()
• org.geotools.data.Transaction.commit()
  Makes all transactions made since the previous commit/rollback permanent.

  FeatureSources will need to issue any changes notifications using a FeatureEvent.FEATURES_CHANGED to all FeatureSources with the same typeName and a different Transaction. FeatureSources with the same Transaction will of been notified of changes as the FeaureWriter made them.

  @throws DataSourceException if there are any datasource errors. @see #setAutoCommit(boolean)
• org.glassfish.hk2.api.DynamicConfiguration.commit()
  This causes the configuration to get committed. This method may only be called once @throws MultiException If errors were found in the commit process @throws IllegalStateException if this method was called more than once
• org.gridkit.coherence.txlite.TxSession.commit()
• org.grouplens.lenskit.util.io.StagedWrite.commit()
  Complete the staging write by replacing the target file with the staging file. Any streams or channels used to write the file must be closed and/or flushed prior to calling this method. @throws IOException if there is an error moving the file.
• org.h2.engine.Session.commit()
  Commit the current transaction. If the statement was not a data definition statement, and if there are temporary tables that should be dropped or truncated at commit, this is done as well. @param ddl if the statement was a data definition statement
• org.h2.index.Index.commit()
  Commit the operation for a row. This is only important for multi-version indexes. @param operation the operation type @param row the row
• org.h2.result.Row.commit()
  This record has been committed. The session id is reset.
• org.helidb.txn.Transaction.commit()
  Commit the transaction. This persists all changes made and ends it. Future calls to {@link #getCurrentTransactionOrNull()} by this threadwill return {@code null} until a new transaction is started. @throws IllegalStateException If this transaction has already beencommitted or rolled back. @throws UnableToCommitException If the transaction cannot be committedfor some reason. The exception message should contain the reason why.
• org.hibernate.Transaction.commit()
  Flush the associated Session and end the unit of work (unless we are in {@link FlushMode#MANUAL}.

  This method will commit the underlying transaction if and only if the underlying transaction was initiated by this object. @throws HibernateException
• org.hornetq.api.core.client.ClientSession.commit()
  Commits the current transaction. @throws HornetQException if an exception occurs while committing the transaction
• org.hornetq.core.client.impl.ClientSessionInternal.commit()
• org.hornetq.core.paging.PageTransactionInfo.commit()
• org.hornetq.core.persistence.impl.journal.JournalStorageManager.commit()
• org.hornetq.core.transaction.Transaction.commit()
• org.hornetq.core.transaction.impl.BindingsTransactionImpl.commit()
• org.hornetq.core.transaction.impl.TransactionImpl.commit()
• org.hsqldb.Session.commit()
  Commits any uncommited transaction this Session may have open @throws HsqlException
• org.hsqldb_voltpatches.Session.commit()
  Commits any uncommited transaction this Session may have open @throws HsqlException
• org.huihoo.workflow.store.persistent.UserTransaction.commit()
  Commits user transaction. @exception TransactionException If something unexpected happens.
• org.infinispan.atomic.AtomicHashMap.commit()
• org.infinispan.atomic.impl.AtomicHashMap.commit()
• org.infinispan.container.entries.CacheEntry.commit()
  Commits changes @param container data container to commit to
• org.infinispan.transaction.TransactionCoordinator.commit()
• org.infinispan.transaction.impl.TransactionCoordinator.commit()
• org.infinispan.transaction.tm.DummyTransactionManager.commit()
• org.infinispan.transaction.xa.TransactionXaAdapter.commit()
  Same comment as for {@link #prepare(javax.transaction.xa.Xid)} applies for commit.
• org.jaudiotagger.audio.AudioFile.commit()

  Write the tag contained in this AudioFile in the actual file on the disk, this is the same as calling the AudioFileIO.write(this) method.

  @throws CannotWriteException If the file could not be written/accessed, the extension wasn't recognized, or other IO error occured. @see AudioFileIO
• org.jaudiotagger.audio.mp3.MP3File.commit()
  Overriden for comptability with merged code @throws CannotWriteException
• org.jboss.as.controller.ControllerTransaction.commit()
• org.jboss.as.demos.ejb3.archive.BMTStatefulBean.commit()
• org.jboss.cache.loader.CacheLoader.commit()
  Commits the transaction. A DB-based CacheLoader would look up the local JDBC transaction asociated with tx and commit that transaction. Non-transactional CacheLoaders could simply write the data that was previously saved transiently under the given tx key, to (for example) a file system.

  Note this only holds if the previous prepare() did not define

  one_phase=true

  @param tx transaction to commit
• org.jboss.cache.transaction.DummyTransactionManager.commit()
• org.jboss.forge.addon.resource.transaction.ResourceTransaction.commit()
  Applies every change in the {@link Set} returned by {@link ResourceTransaction#getChangeSet()}
• org.jboss.jms.client.JBossSession.commit()
• org.jboss.jms.tx.MessagingXAResource.commit()
• org.jboss.messaging.core.impl.tx.Transaction.commit()
• org.jboss.messaging.core.tx.Transaction.commit()
• org.jboss.narayana.blacktie.jatmibroker.jab.JABTransaction.commit()
• org.jboss.narayana.blacktie.jatmibroker.jab.factory.Transaction.commit()
  Commit the work performed within the scope of this transaction @throws JABException In case the transaction cannot be committed
• org.jboss.security.authorization.AuthorizationModule.commit()
  Overall authorization process has succeeded. The module can commit any decisions it has made, with third party systems like a database. @return
• org.jboss.soa.esb.helpers.persist.JdbcCleanConn.commit()
• org.jboss.test.cluster.invokerha.InvokerHaTransactionalMockUtils.MockUserTransaction.commit()
• org.jboss.test.jca.adapter.TestConnection.commit()
• org.jfree.report.flow.EmptyReportTarget.commit()
• org.jfree.report.flow.LibLayoutReportTarget.commit()
• org.jfree.report.flow.ReportTarget.commit()
• org.jooq.TransactionProvider.commit()
  @param Configuration the configuration scoped to this transaction and itsnested transactions. @param transaction The user-defined transaction object returned from{@link #begin(TransactionContext)}. May be null. @throws DataAccessException Any exception issued by the underlyingdatabase.
• org.jooq.impl.DefaultConnectionProvider.commit()
  Convenience method to access {@link Connection#commit()}.
• org.jpokemon.item.Inventory.commit()
• org.jpokemon.item.Store.commit()
• org.jpokemon.trainer.Event.commit()
• org.jtester.module.database.environment.DBEnvironment.commit()
  Commit current transaction.
• org.jugile.demo.domain.Domain.commit()
• org.jugile.proto2.domain.Domain.commit()
• org.jugile.util.DBConnection.commit()
• org.jvnet.hk2.config.Transaction.commit()
  Commits all participants to this transaction @return list of PropertyChangeEvent for the changes that were applied to the participants during the transaction. @throws RetryableException if the transaction cannot commit at this time butcould succeed later. @throws TransactionFailure if the transaction commit failed.
• org.jvnet.hk2.internal.DynamicConfigurationImpl.commit()
• org.keycloak.models.KeycloakTransaction.commit()
• org.knopflerfish.service.log.LogConfig.commit()
• org.lab41.dendrite.metagraph.DendriteGraph.commit()
• org.lab41.dendrite.metagraph.DendriteGraphTx.commit()
• org.lab41.dendrite.metagraph.MetaGraphTx.commit()
• org.lealone.dbobject.index.Index.commit()
  Commit the operation for a row. This is only important for multi-version indexes. The method is only called if multi-version is enabled. @param operation the operation type @param row the row
• org.lealone.engine.Session.commit()
• org.lealone.hbase.transaction.Transaction.commit()
• org.lealone.result.Row.commit()
  This record has been committed. The session id is reset.
• org.locationtech.geogig.api.GeogigTransaction.commit()
• org.mapdb.DB.commit()
  Commit changes made on collections loaded by this DB @see org.mapdb.Engine#commit()
• org.modeshape.jcr.txn.Transactions.Transaction.commit()
• org.mortbay.http.HttpResponse.commit()
• org.mule.api.transaction.Transaction.commit()
  Commit the transaction @throws TransactionException
• org.mule.transaction.XaTransaction.commit()
• org.nasutekds.server.admin.TestChildCfgClient.commit()
• org.nasutekds.server.admin.TestParentCfgClient.commit()
• org.nasutekds.server.admin.std.client.ConnectionHandlerCfgClient.commit()
• org.nasutekds.server.admin.std.client.LDAPConnectionHandlerCfgClient.commit()
• org.nasutekds.server.admin.std.client.LocalDBBackendCfgClient.commit()
• org.nasutekds.server.admin.std.client.LocalDBIndexCfgClient.commit()
• org.nasutekds.server.admin.std.client.LocalDBVLVIndexCfgClient.commit()
• org.nasutekds.server.admin.std.client.ReplicationDomainCfgClient.commit()
• org.nasutekds.server.admin.std.client.ReplicationServerCfgClient.commit()
• org.nasutekds.server.admin.std.client.ReplicationSynchronizationProviderCfgClient.commit()
• org.neo4j.neoclipse.graphdb.GraphDbServiceManager.commit()
  Commit transaction. @return
• org.odmg.Transaction.commit()
  Commit and close the transaction. Calling commit commits to the database all persistent object modifications within the transaction and releases any locks held by the transaction. A persistent object modification is an update of any field of an existing persistent object, or an update or creation of a new named object in the database. If a persistent object modification results in a reference from an existing persistent object to a transient object, the transient object is moved to the database, and all references to it updated accordingly. Note that the act of moving a transient object to the database may create still more persistent references to transient objects, so its referents must be examined and moved as well. This process continues until the database contains no references to transient objects, a condition that is guaranteed as part of transaction commit. Committing a transaction does not remove from memory transient objects created during the transaction
• org.omg.CosTransactions.Current.commit()
• org.omg.CosTransactions.Resource.commit()
• org.ontoware.rdf2go.model.Model.commit()
• org.openbp.server.ProcessFacade.commit()
  Commits the transaction on the token context store.
• org.openbp.server.context.TokenContextService.commit()
  Commits the recent changes (if supported).
• org.openntf.domino.graph.DominoGraph.commit()
• org.openntf.domino.transactions.DatabaseTransaction.commit()
• org.openrdf.http.server.helpers.ServerConnection.commit()
• org.openrdf.repository.RepositoryConnection.commit()
  Commits the active transaction. @throws StoreException If the connection could not be committed, or if the connection does not have an active connection. @see #isAutoCommit() @see #begin()
• org.openrdf.repository.contextaware.ContextAwareConnection.commit()
• org.openrdf.repository.event.InterceptingRepositoryConnection.commit()
• org.openrdf.repository.event.base.InterceptingRepositoryConnectionWrapper.commit()
• org.openrdf.repository.sail.SailRepositoryConnection.commit()
• org.openrdf.sail.NotifyingSailConnection.commit()
• org.openrdf.sail.SailConnection.commit()
  Commits any updates that have been performed since the last time {@link #commit()} or {@link #rollback()} was called. @throws StoreException If the SailConnection could not be committed, or if the connection does not have an active connection.
• org.openrdf.sail.inferencer.InferencerConnection.commit()
• org.opensolaris.opengrok.jdbc.ConnectionResource.commit()
  Commit the transaction. @throws SQLException if a database error occurs
• org.openstreetmap.osmosis.pgsimple.common.DatabaseContext.commit()
  Commits any outstanding transaction.
• org.openxdas.client.XDasRecord.commit()
  Write a completed audit record to the audit stream.

  This method writes the audit record to the audit stream. If no prior call to the {@link org.openxdas.client.XDasRecord#setTimeStamp setTimeStamp}method has been made, this method will also set the timestamp for the record. The caller must have the XDAS_AUDIT_SUBMIT authority.

  If the event number, outcome, initiator information, target information, or event information has not been set, this method will throw an {@link org.openxdas.client.XDasException XDasException} and set the majorstatus code to XDas.MajorStatusCode.XDAS_S_INCOMPLETE_RECORD.

• org.orm.PersistentTransaction.commit()
• org.osgi.service.condpermadmin.ConditionalPermissionUpdate.commit()
  Commit this update. If no changes have been made to the Conditional Permission Table since this update was created, then this method will replace the Conditional Permission Table with this update's Conditional Permissions. This method may only be successfully called once on this object.

  If any of the {@link ConditionalPermissionInfo}s in the update list has null as a name it will be replaced with a new {@link ConditionalPermissionInfo} object that has a generated name whichis unique within the list.

  No two entries in this update's Conditional Permissions may have the same name. Other consistency checks may also be performed. If this update's Conditional Permissions are determined to be inconsistent in some way then an IllegalStateException will be thrown.

  This method returns false if the commit did not occur because the Conditional Permission Table has been modified since the creation of this update. @return true if the commit was successful.false if the commit did not occur because the Conditional Permission Table has been modified since the creation of this update. @throws SecurityException If the caller does not haveAllPermission. @throws IllegalStateException If this update's Conditional Permissionsare not valid or inconsistent. For example, this update has two Conditional Permissions in it with the same name.

• org.osgi.service.deploymentadmin.spi.ResourceProcessor.commit()
  Called when the processing of the current deployment package is finished. This method is called if the processing of the current deployment package was successful, and the changes must be made permanent.
• org.ozoneDB.ExternalTransaction.commit()
  Complete this transaction. When this method completes, the thread becomes associated with no transaction. This method can be called by a non-joined thread.
• org.pentaho.reporting.engine.classic.core.layout.process.util.OrphanContext.commit()
  Widow is the y/top boundary for the element after which the box becomes unbreakable. @return
• org.pentaho.reporting.engine.classic.core.layout.process.util.WidowContext.commit()
• org.pentaho.reporting.engine.classic.core.states.process.ProcessState.commit()
• org.persvr.data.Transaction.commit()
  Commit the transaction
• org.photovault.dbhelper.ODMGXAWrapper.commit()
• org.picketlink.identity.federation.core.wstrust.auth.STSIssuingLoginModule.commit()
• org.picketlink.identity.federation.core.wstrust.auth.STSValidatingLoginModule.commit()
• org.projectodd.stilts.stomp.client.ClientTransaction.commit()
• org.restlet.ext.sip.SipResponse.commit()
• org.sindice.siren.demo.SimpleIndexer.commit()
• org.sleuthkit.datamodel.SleuthkitCase.CaseDbTransaction.commit()
• org.sleuthkit.datamodel.SleuthkitJNI.CaseDbHandle.AddImageProcess.commit()
• org.sonar.core.persistence.DbSession.commit()
• org.springframework.binding.value.CommitTrigger.commit()
  Triggers a commit event.
• org.springframework.data.solr.core.SolrOperations.commit()
  Send commit command {@link SolrServer#commit()}
• org.springframework.jdbc.datasource.DataSourceTransactionManager.commit()
• org.springframework.orm.hibernate3.HibernateTransactionManager.commit()
• org.springframework.transaction.PlatformTransactionManager.commit()
  Commit the given transaction, with regard to its status. If the transaction has been marked rollback-only programmatically, perform a rollback.

  If the transaction wasn't a new one, omit the commit for proper participation in the surrounding transaction. If a previous transaction has been suspended to be able to create a new one, resume the previous transaction after committing the new one.

  Note that when the commit call completes, no matter if normally or throwing an exception, the transaction must be fully completed and cleaned up. No rollback call should be expected in such a case.

  If this method throws an exception other than a TransactionException, then some before-commit error caused the commit attempt to fail. For example, an O/R Mapping tool might have tried to flush changes to the database right before commit, with the resulting DataAccessException causing the transaction to fail. The original exception will be propagated to the caller of this commit method in such a case. @param status object returned by the getTransaction method @throws UnexpectedRollbackException in case of an unexpected rollbackthat the transaction coordinator initiated @throws HeuristicCompletionException in case of a transaction failurecaused by a heuristic decision on the side of the transaction coordinator @throws TransactionSystemException in case of commit or system errors(typically caused by fundamental resource failures) @throws IllegalTransactionStateException if the given transactionis already completed (that is, committed or rolled back) @see TransactionStatus#setRollbackOnly

• org.springframework.transaction.jta.JtaTransactionManager.commit()
• org.springframework.transaction.support.AbstractPlatformTransactionManager.commit()
  This implementation of commit handles participating in existing transactions and programmatic rollback requests. Delegates to isRollbackOnly, doCommit and rollback. @see org.springframework.transaction.TransactionStatus#isRollbackOnly() @see #doCommit @see #rollback
• org.switchyard.component.bpm.transaction.AS7TransactionHelper.commit()
  Commit. @throws HandlerException oops
• org.tmatesoft.hg.internal.CommitFacility.commit()
• org.tmatesoft.hg.internal.Transaction.commit()
  Complete the transaction
• org.tmatesoft.sqljet.core.table.SqlJetDb.commit()
  Commit transaction. @throws SqlJetException
• org.togglz.core.repository.file.ReloadablePropertiesFile.Editor.commit()
• org.vaadin.console.client.util.ClientCommUtils.Transcation.commit()
• org.w3c.cvs.CvsDirectory.commit()
  Commit pending actions on given file. @param names The name of the files to commit. @param msg The associated message. @param env The extra env to use during commit. @exception CvsException If some error occured during the CVS process.
• org.wso2.carbon.deployment.synchronizer.DeploymentSynchronizer.commit()
  Commit the artifacts in the file system repository to the registry @throws SynchronizationException If an error occurs while committing the artifacts
• org.xapian.WritableDatabase.commit()
• org.xmldb.api.modules.TransactionService.commit()
  Commit the transaction @exception XMLDBException with expected error codes.
  ErrorCodes.VENDOR_ERROR for any vendor specific errors that occur.
  
• proj.zoie.store.ZoieStore.commit()
• railo.runtime.db.DataSourceManager.commit()
  commit hanging transaction @throws DatabaseException
• realcix20.utils.DAO.commit()
• reportgen.prototype.queryresults.ResultsRowList.commit()
• rocket.generator.rebind.SourceWriter.commit()
• ru.snake.spritepacker.Configuration.commit()
• ru.yandex.strictweb.ajaxtools.orm.ORMManager.commit()
• se.unlogic.standardutils.dao.TransactionHandler.commit()
• smilehouse.gui.html.fieldbased.Field.commit()
  Sets the edit value from the editor as the modified object's value. Only valid values will be committed.
• sos.connection.SOSConnection.commit()
  commit transaction @throws Exception
• unibg.overencrypt.core.UploadManager.commit()
• webit.script.global.GlobalManager.commit()
• xbird.storage.tx.Transaction.commit()