Examples of begin()

• atg.dtm.TransactionDemarcation.begin()
• bitronix.tm.BitronixTransactionManager.begin()
  Start a new transaction and bind the context to the calling thread. @throws NotSupportedException if a transaction is already bound to the calling thread. @throws SystemException if the transaction manager is shutting down.
• br.gov.frameworkdemoiselle.transaction.Transaction.begin()
  Create a new transaction and associate it with the current thread.
• ch.qos.logback.core.joran.action.Action.begin()
  Called when the parser encounters an element matching a {@link ch.qos.logback.core.joran.spi.Pattern Pattern}.
• com.alu.e3.common.transaction.ITransaction.begin()
• com.arjuna.ats.arjuna.AtomicAction.begin()
  Start the transaction running. If the transaction is already running or has terminated, then an error code will be returned. No timeout is associated with the transaction. @return ActionStatus indicating outcome.
• com.arjuna.ats.internal.jta.transaction.arjunacore.TransactionManagerImple.begin()
• com.arjuna.ats.internal.jta.transaction.jts.TransactionManagerImple.begin()
• com.arjuna.ats.internal.jts.orbspecific.CurrentImple.begin()
• com.arjuna.ats.jts.extensions.AtomicTransaction.begin()
  Start the transaction. @exception org.omg.CosTransactions.SubtransactionsUnavailable if subtransactions have been disabled, and the invoking thread already has a transaction associated with it. @exception org.omg.CORBA.INVALID_TRANSACTION if the transaction has already begun or has completed.
• com.arjuna.mw.wscf.model.twophase.api.CoordinatorManager.begin()
• com.arjuna.mw.wscf.model.twophase.api.UserCoordinator.begin()
  Start a new activity. If there is already an activity associated with the thread then it will be nested. An implementation specific timeout will be associated with the activity (which may be no timeout). @exception WrongStateException Thrown if the any currently associatedactivity is in a state that does not allow a new activity to be enlisted. @exception SystemException Thrown in any other situation.
• com.arjuna.mw.wst.UserBusinessActivity.begin()
  Start a new business activity with atomic outcome. If one is already associated with this thread then the WrongStateException will be thrown. Upon success, this operation associates the newly created transaction with the current thread.
• com.arjuna.mw.wst.UserTransaction.begin()
  Start a new transaction. If one is already associated with this thread then the WrongStateException will be thrown. Upon success, this operation associates the newly created transaction with the current thread.
• com.arjuna.mw.wst11.UserBusinessActivity.begin()
  Start a new business activity with atomic outcome. If one is already associated with this thread then the WrongStateException will be thrown. Upon success, this operation associates the newly created transaction with the current thread.
• com.arjuna.mw.wst11.UserTransaction.begin()
  Start a new transaction. If one is already associated with this thread then the WrongStateException will be thrown. Upon success, this operation associates the newly created transaction with the current thread.
• com.arjuna.mw.wstx.UserTransaction.begin()
  Start a new transaction. If there is already a transaction associated with the thread then it will be nested. @exception WrongStateException Thrown if the any currently associatedtransaction is in a state that does not allow a new transaction to be enlisted. @exception SystemException Thrown in any other situation.
• com.badlogic.gdx.graphics.g2d.Batch.begin()
  Sets up the Batch for drawing. This will disable depth buffer writing. It enables blending and texturing. If you have more texture units enabled than the first one you have to disable them before calling this. Uses a screen coordinate system by default where everything is given in pixels. You can specify your own projection and modelview matrices via {@link #setProjectionMatrix(Matrix4)} and {@link #setTransformMatrix(Matrix4)}.
• com.badlogic.gdx.graphics.glutils.ShaderProgram.begin()
  Makes OpenGL ES 2.0 use this vertex and fragment shader pair. When you are done with this shader you have to call {@link ShaderProgram#end()}.
• com.badlogic.gdx.graphics.glutils.ShapeRenderer.begin()
  Starts a new batch of shapes. All shapes within the batch have to have the type specified. E.g. if {@link ShapeType#Point}is specified, only call #point(). The call to this method must be paired with a call to {@link #end()}. In case OpenGL ES 1.x is used, the projection and modelview matrix will be modified. @param type the {@link ShapeType}.
• com.bradmcevoy.http.XmlWriter.begin()
• com.bradmcevoy.http.XmlWriter.Element.begin()
• com.caucho.jca.ra.BeginResource.begin()
  Callback when the transaction starts.
• com.cetsoft.imcache.cache.heap.tx.Transaction.begin()
  Begin the transaction.
• com.complexible.stardog.api.Connection.begin()
• com.conexao.Transacao.begin()
• com.dotcms.repackage.org.apache.oro.text.regex.MatchResult.begin()
• com.esri.gpt.control.rest.writer.ResultSetWriter.begin()
• com.exedosoft.plat.Transaction.begin()
• com.google.collide.client.documentparser.DocumentParser.begin()
  Schedules the parsing of the document from the last parsed position, or the beginning of the document if this is the first time parsing.
• com.googlecode.objectify.ObjectifyFactory.begin()
  This is the beginning of any Objectify session. It creates an Objectify instance with the default options, unless you override this method to alter the options. You can also override this method to produce a wholly different Objectify implementation (possibly using ObjectifyWrapper).

  The default options are:

  • Do NOT begin a transaction.
  • DO use a global cache.
  • Use STRONG consistency.
  • Apply no deadline to calls.

  Note that when using Objectify you will almost never directly call this method. Instead you should call the static ofy() method on ObjectifyService.

  @return a new Objectify instance
• com.googlecode.objectify.test.util.TestObjectifyFactory.begin()
• com.hazelcast.core.Transaction.begin()
• com.hp.hpl.jena.db.ModelRDB.begin()
• com.hp.hpl.jena.eyeball.inspectors.SparqlDrivenInspector.begin()
• com.hp.hpl.jena.eyeball.inspectors.VocabularyInspector.begin()
• com.hp.hpl.jena.graph.TransactionHandler.begin()
  If transactions are supported, begin a new transaction. If tranactions are not supported, or they are but this tranaction is nested and nested transactions are not supported, throw an UnsupportedOperationException.
• com.hp.hpl.jena.query.Dataset.begin()
  Start either a READ or WRITE transaction
• com.hp.hpl.jena.rdf.model.Model.begin()
  Begin a new transation.

  All changes made to a model within a transaction, will either be made, or none of them will be made.

  @return this model to enable cascading.
• com.hp.hpl.jena.sparql.core.Transactional.begin()
  Start either a READ or WRITE transaction
• com.hp.hpl.jena.tdb.StoreConnection.begin()
  Begin a transaction. Terminate a write transaction with {@link Transaction#commit()} or {@link Transaction#abort()}. Terminate a write transaction with {@link Transaction#close()}.
• com.hp.hpl.jena.tdb.transaction.DatasetGraphTransaction.begin()
• com.hp.mwtests.performance.products.TxWrapper.begin()
  Start a new transaction @return one of the com.arjuna.ats.arjuna.coordinator.ActionStatus constants
• com.mojang.minecraft.render.ShapeRenderer.begin()
• com.mysql.clusterj.core.store.ScanFilter.begin()
• com.orientechnologies.orient.core.db.document.ODatabaseDocument.begin()
• com.orientechnologies.orient.core.db.document.ODatabaseDocumentTx.begin()
• com.orientechnologies.orient.core.db.record.ODatabaseFlat.begin()
• com.orientechnologies.orient.core.db.record.ODatabaseRecord.begin()
• com.orientechnologies.orient.core.db.record.ODatabaseRecordTx.begin()
• com.orientechnologies.orient.core.storage.impl.local.paginated.wal.ODiskWriteAheadLog.begin()
• com.orientechnologies.orient.object.db.OObjectDatabaseTx.begin()
• com.persistit.Transaction.begin()
  Start a transaction. If there already is an active transaction then this method merely increments a counter that indicates how many times begin has been called. Application code should ensure that every method that calls begin also invokes end using a try/finally pattern described above. @throws IllegalStateException if the current transaction scope has already been committed.
• com.ponysdk.core.stm.Txn.begin()
• com.sun.enterprise.ee.synchronization.tx.TransactionManager.begin()
  Starts a new transaction @return returns the new created transaction object
• com.sun.jts.jta.TransactionManagerImpl.begin()
  Create a new transaction and associate it with the current thread. @exception NotSupportedException Thrown if the thread is alreadyassociated with a transaction.
• com.sun.speech.freetts.audio.AudioPlayer.begin()
  Starts the output of a set of data. Audio data for a single utterance should be grouped between begin/end pairs. @param size the size of data in bytes to be output beforeend is called.
• com.sun.tools.javadoc.Start.begin()
  Main program - external wrapper
• com.taobao.metamorphosis.client.transaction.TransactionContext.begin()
  ���з���Ϊ��������ʵ�֣�begin,commit��rollback
• com.totsp.gwittir.client.util.HistoryTokenizer.begin()
• com.youtube.vitess.vtgate.VtGate.begin()
• dclong.util.Timer.begin()
• de.mhus.lib.jpa.JpaEntityManager.begin()
• de.willuhn.datasource.GenericIterator.begin()
• de.willuhn.datasource.rmi.DBIterator.begin()
• helma.objectmodel.db.Transactor.begin()
  Start a new transaction with the given name. @param name The name of the transaction. This is usually the requestpath for the underlying HTTP request. @throws Exception ...
• javassist.bytecode.CodeIterator.begin()
  Moves to the first instruction.
• javax.enterprise.context.Conversation.begin()
• javax.jdo.Transaction.begin()
  Begin a transaction. The type of transaction is determined by the setting of the Optimistic flag. @see #setOptimistic @see #getOptimistic @throws JDOUserException if transactions are managed by a containerin the managed environment, or if the transaction is already active.
• javax.persistence.EntityTransaction.begin()
  Start a resource transaction. @throws IllegalStateException if isActive() is true.
• javax.resource.cci.LocalTransaction.begin()
• javax.transaction.TransactionManager.begin()
• javax.transaction.UserTransaction.begin()
  Start the transaction.
• l2p.gameserver.model.entity.vehicle.L2AirShip.begin()
• net.sf.ehcache.TransactionController.begin()
  Begin a new transaction and bind its context to the current thread
• net.sf.xbus.base.core.TAManager.begin()
  Initializes a transaction. All registered resources will be opened. @throws XException if opening one ressource throws an XException.
• nexj.core.runtime.platform.generic.tx.GenericTransactionManager.begin()
  @see javax.transaction.TransactionManager#begin()
• oracle.adf.share.logging.ADFLogger.begin()
• org.amplafi.flow.impl.FlowStateImpl.begin()
• org.apache.activemq.transport.stomp.StompConnection.begin()
• org.apache.ambari.server.controller.utilities.PredicateBuilder.begin()
• org.apache.camel.component.file.strategy.FileProcessStrategy.begin()
  Called when work is about to begin on this file. This method may attempt to acquire some file lock before returning true; returning false if the file lock could not be obtained so that the file should be ignored. @return true if the file can be processed (such as if a file lock could be obtained)
• org.apache.commons.digester.Rule.begin()
  This method is called when the beginning of a matching XML element is encountered. @param attributes The attribute list of this element @deprecated Use the {@link #begin(String,String,Attributes) begin}method with namespace and name parameters instead.
• org.apache.derby.iapi.sql.compile.ASTVisitor.begin()
  The compiler calls this method just before walking a query tree. @param statementText Text used to create the tree. @param phase of compilation (AFTER_PARSE, AFTER_BIND, or AFTER_OPTIMIZE).
• org.apache.flume.Transaction.begin()

  Starts a transaction boundary for the current channel operation. If a transaction is already in progress, this method will join that transaction using reference counting.

  Note: For every invocation of this method there must be a corresponding invocation of {@linkplain #close()} method. Failureto ensure this can lead to dangling transactions and unpredictable results.

• org.apache.flume.channel.file.FileChannel.FileBackedTransaction.begin()
• org.apache.geronimo.transaction.BeanTransactionContext.begin()
• org.apache.geronimo.transaction.ContainerTransactionContext.begin()
• org.apache.geronimo.transaction.context.ContainerTransactionContext.begin()
• org.apache.hive.beeline.BeeLine.begin()
  Start accepting input from stdin, and dispatch it to the appropriate {@link CommandHandler} until theglobal variable exit is true.
• org.apache.hivemind.schema.Rule.begin()
  Begin rules are fired first, in order. All rules are invoked, and then the SchemaProcessor recurses into the elements contained within the element.
• org.apache.hivemind.schema.rules.CreateObjectRule.begin()
  Creates the new object and pushes it onto the processor's stack. If the object implement {@link org.apache.hivemind.LocationHolder} then the {@link org.apache.hivemind.Location} ofthe element is assigned to the object.
• org.apache.hivemind.schema.rules.InvokeParentRule.begin()
  Invokes the named method on the parent object (using reflection).
• org.apache.hivemind.schema.rules.PushAttributeRule.begin()
  Uses the translator to convert the specified attribute into an object and pushes that object onto the processor stack.
• org.apache.hivemind.schema.rules.PushContentRule.begin()
  Uses the content translator to convert the element content into an object and pushes that object onto the processor stack.
• org.apache.hivemind.schema.rules.ReadAttributeRule.begin()
• org.apache.hivemind.schema.rules.SetModuleRule.begin()
• org.apache.hivemind.service.BodyBuilder.begin()
  Begins a new block. Emits a "{", properly indented, on a new line.
• org.apache.jackrabbit.core.UserTransactionImpl.begin()
  @see javax.transaction.UserTransaction#begin
• org.apache.jackrabbit.ocm.transaction.jackrabbit.UserTransactionImpl.begin()
  @see javax.transaction.UserTransaction#begin
• org.apache.jetspeed.components.persistence.store.Transaction.begin()
• org.apache.juddi.util.jdbc.Transaction.begin()
  If the connection is known then do nothing. If the connection is new then issue a SQL begin work and hold onto it for later. Actually the begin work is implicit and autocommit drives whether a transaction is progressed.
• org.apache.log4j.joran.action.Action.begin()
  Called when the parser first encounters an element. The return value indicates whether child elements should be processed. If the returned value is 'false', then child elements are ignored.
• org.apache.marmotta.ldcache.api.LDCachingConnection.begin()
• org.apache.marmotta.ldcache.backend.kiwi.sail.LDCachingKiWiSailConnection.begin()
• org.apache.niolex.commons.test.StopWatch.begin()
  Begin the time calculation. @param printDirectly whether we print the RPS directly into the console
• org.apache.ode.store.ConfStoreConnection.begin()
• org.apache.ojb.odmg.TransactionExt.begin()
• org.apache.ojb.otm.core.Transaction.begin()
• org.apache.openjpa.kernel.Broker.begin()
  Begin a transaction.
• org.apache.openjpa.kernel.StoreManager.begin()
  Begin a data store transaction. After this method is called, it is assumed that all further operations are operating in a single transaction that can be committed or rolled back. If optimistic transactions are in use, this method will only be called when the system requires a transactionally consistent connection due to a user request to flush or commit the transaction. In this case, it is possible that the optimistic transaction does not have the latest versions of all instances (i.e. another transaction has modified the same instances and committed since the optimistic transaction started). On commit, an exception must be thrown on any attempt to overwrite data for an instance with an older version. @since 0.2.5
• org.apache.openjpa.persistence.OpenJPAEntityManager.begin()
  @deprecated use {@link EntityTransaction#begin}instead: em.getTransaction().begin()
• org.apache.openjpa.persistence.OpenJPAEntityTransaction.begin()
• org.apache.qpid.server.store.handler.ConfiguredObjectRecordHandler.begin()
• org.apache.servicemix.jbi.cluster.requestor.JmsRequestor.begin()
• org.apache.slide.common.NamespaceAccessToken.begin()
• org.apache.sqoop.repository.RepositoryTransaction.begin()
• org.apache.tapestry.IMarkupWriter.begin()
  Closes any existing tag then starts a new element. The new element is pushed onto the active element stack.
• org.apache.tapestry.NestedMarkupWriter.begin()
• org.apache.tapestry.internal.services.HeartbeatImpl.begin()
• org.apache.tapestry.ioc.util.BodyBuilder.begin()
  Begins a new block. Emits a "{", properly indented, on a new line.
• org.apache.tapestry.services.Heartbeat.begin()
  Begins a new Heartbeat. Heartbeats nest. Every call to begin() should be matched by a call to {@link #end()}.
• org.apache.tapestry5.internal.services.HeartbeatImpl.begin()
• org.apache.tapestry5.ioc.util.BodyBuilder.begin()
  Begins a new block. Emits a "{", properly indented, on a new line.
• org.apache.tapestry5.services.Heartbeat.begin()
  Begins a new Heartbeat. Heartbeats nest. Every call to begin() should be matched by a call to {@link #end()}.
• org.apache.webbeans.conversation.ConversationImpl.begin()
  {@inheritDoc}
• org.apache.wookie.beans.util.IPersistenceManager.begin()
  Begin persistence manager transaction.
• org.archive.cdxserver.processor.BaseProcessor.begin()
• org.bukkit.conversations.Conversation.begin()
  Displays the first prompt of this conversation and begins redirecting the user's chat responses.
• org.datanucleus.Transaction.begin()
  Begin a transaction. The type of transaction (datastore/optimistic) is determined by the setting of the Optimistic flag. @throws NucleusUserException if transactions are managed by a containerin the managed environment, or if the transaction is already active.
• org.drools.persistence.TransactionManager.begin()
• org.drools.persistence.jta.JtaTransactionManager.begin()
• org.dru.clay.resolver.DependencyResolver.begin()
• org.dru.clay.resolver.DependencyResolverImpl.begin()
• org.eclipse.wb.draw2d.geometry.Interval.begin()
• org.exolab.castor.jdo.Database.begin()
  Begin a new transaction. A transaction must be open in order to query and persist objects. @throws PersistenceException A transaction is already open onthis database, or an error reported by the persistence engine
• org.exoplatform.services.jcr.statistics.Statistics.begin()
  Start recording
• org.fto.jthink.jdbc.JDBCTransaction.begin()
• org.graphstream.stream.file.FileSinkDGS.begin()
• org.graphstream.stream.file.FileSinkDynamicGML.begin()
• org.graphstream.stream.file.FileSinkGML.begin()
• org.graphstream.stream.file.FileSource.begin()
  Begin reading the file stopping as soon as possible. Next graph events stored in the file will be sent by calling {@link #nextEvents()} or{@link #nextStep()}. Once begin() has been called, you must finish the reading process using {@link #end()}. You cannot call begin() twice without having called {@link #end()} in between. @param fileName Name of the file to read. @throws IOException If an I/O error occurs while reading.
• org.graphstream.stream.file.FileSourceDGS.begin()
• org.graphstream.stream.file.FileSourceGML.begin()
• org.hibernate.Transaction.begin()
  Begin a new transaction.
• org.infinispan.transaction.tm.DummyTransactionManager.begin()
• org.jboss.cache.transaction.DummyTransactionManager.begin()
• org.jboss.capedwarf.jpa.ProxyingEnum.begin()
• org.jboss.forge.addon.resource.transaction.ResourceTransaction.begin()
  Starts a transaction. Throws {@link ResourceTransactionException} if the transaction is already started
• org.jboss.test.cluster.invokerha.InvokerHaTransactionalMockUtils.MockUserTransaction.begin()
• org.jboss.test.jca.adapter.TestConnection.begin()
• org.jboss.tm.usertx.interfaces.UserTransactionSession.begin()
  Start a new transaction, and return its TPC. @param timeout The timeout value for the new transaction, in seconds. @return The transaction propagation context for the new transaction.
• org.jooq.TransactionProvider.begin()
  Begin a new transaction.

  This method begins a new transaction with a {@link Configuration} scopedfor this transaction. The resulting {@link Transaction} object may beused by implementors to identify the transaction when {@link #commit(TransactionContext)} or{@link #rollback(TransactionContext)} is called. @param Configuration the configuration scoped to this transaction and itsnested transactions. @throws DataAccessException Any exception issued by the underlyingdatabase.

• org.jquantlib.math.matrixutilities.Array.begin()
• org.jruby.util.ByteList.begin()
• org.keycloak.models.KeycloakTransaction.begin()
• org.modeshape.jcr.txn.Transactions.begin()
  Starts a new transaction if one does not already exist, and associate it with the calling thread. @return the ModeShape transaction @throws NotSupportedException If the calling thread is already associated with a transaction, and nested transactions arenot supported. @throws SystemException If the transaction service fails in an unexpected way.
• org.mule.api.transaction.Transaction.begin()
  Begin the transaction. @throws TransactionException
• org.mule.transaction.XaTransaction.begin()
• org.objectweb.speedo.workingset.api.TransactionItf.begin()
  Starts the transaction. @throws SpeedoRuntimeException If the transaction is already started
• org.odmg.Transaction.begin()
  Start a transaction. Calling begin multiple times on the same transaction object, without an intervening call to commit or abort, causes the exception TransactionInProgressException to be thrown on the second and subsequent calls. Operations executed before a transaction has been opened, or before reopening after a transaction is aborted or committed, have undefined results; these may throw a TransactionNotInProgressException exception.
• org.omg.CosTransactions.Current.begin()
• org.openbp.server.ProcessFacade.begin()
  Begins a transaction on the token context store.
• org.openrdf.http.server.helpers.ServerConnection.begin()
• org.openrdf.repository.RepositoryConnection.begin()
  Begins a transaction requiring {@link #commit()} or {@link #rollback()} tobe called to close the transaction. @throws StoreException If the connection could not start a transaction, or if it already has an active transaction. @see #isAutoCommit()
• org.openrdf.repository.event.InterceptingRepositoryConnection.begin()
• org.openrdf.repository.event.base.InterceptingRepositoryConnectionWrapper.begin()
• org.openrdf.repository.sail.SailRepositoryConnection.begin()
• org.openrdf.sail.NotifyingSailConnection.begin()
• org.openrdf.sail.SailConnection.begin()
  Begins a transaction requiring {@link #commit()} or {@link #rollback()} tobe called to close the transaction. @throws StoreException If the connection could not start a transaction, or if it already has an active transaction. @see #isAutoCommit()
• org.openrdf.sail.inferencer.InferencerConnection.begin()
• org.osgi.framework.hooks.resolver.ResolverHookFactory.begin()
  This method is called by the framework each time a resolve process begins to obtain a {@link ResolverHook resolver hook} instance. This resolverhook instance will be used for the duration of the resolve process. At the end of the resolve process the method {@link ResolverHook#end()} mustbe called by the framework and the framework must not hold any references of the resolver hook instance.

  The triggers represent the collection of bundles which triggered the resolve process. This collection may be empty if the triggers cannot be determined by the framework. In most cases the triggers can easily be determined. Calling certain methods on {@link Bundle bundle} when abundle is in the {@link Bundle#INSTALLED INSTALLED} state will cause theframework to begin a resolve process in order to resolve the bundle. The following methods will start a resolve process in this case:

  • {@link Bundle#start() start}
  • {@link Bundle#loadClass(String) loadClass}
  • {@link Bundle#findEntries(String,String,boolean) findEntries}
  • {@link Bundle#getResource(String) getResource}
  • {@link Bundle#getResources(String) getResources}

  In such cases the collection will contain the single bundle which the framework is trying to resolve. Other cases will cause multiple bundles to be included in the trigger bundles collection. When {@link FrameworkWiring#resolveBundles(Collection) resolveBundles} iscalled the collection of triggers must include all the current bundle revisions for bundles passed to resolveBundles which are in the {@link Bundle#INSTALLED INSTALLED} state.

  When {@link FrameworkWiring#refreshBundles(Collection,org.osgi.framework.FrameworkListener)}is called the collection of triggers is determined with the following steps:

  • If the collection of bundles passed is null then {@link FrameworkWiring#getRemovalPendingBundles()} is called to get theinitial collection of bundles.
  • The equivalent of calling {@link FrameworkWiring#getDependencyClosure(Collection)} is called withthe initial collection of bundles to get the dependency closure collection of the bundles being refreshed.
  • Remove any non-active bundles from the dependency closure collection.
  • For each bundle remaining in the dependency closure collection get the current bundle revision and add it to the collection of triggers.

  As described above, a resolve process is typically initiated as a result of calling API that causes the framework to attempt to resolve one or more bundles. The framework is free to start a resolve process at any time for reasons other than calls to framework API. For example, a resolve process may be used by the framework for diagnostic purposes and result in no bundles actually becoming resolved at the end of the process. Resolver hook implementations must be prepared for resolve processes that are initiated for other reasons besides calls to framework API. @param triggers an unmodifiable collection of bundles which triggered theresolve process. This collection may be empty if the collection of trigger bundles cannot be determined. @return a resolver hook instance to be used for the duration of theresolve process. A {@code null} value may be returned whichindicates this resolver hook factory abstains from the resolve process.

• org.osgi.service.coordinator.Coordinator.begin()
  Create a new Coordination and make it the {@link #peek() currentCoordination}.

  This method does that same thing as calling {@link #create(String,long) create(name, timeMillis)}. {@link Coordination#push() push()} @param name The name of this coordination. The name does not have to beunique but must follow the {@code symbolic-name} syntax from theCore specification. @param timeMillis Timeout in milliseconds. A value of 0 means no timeoutis required. If the Coordination is not terminated within the timeout, the Coordinator service will {@link Coordination#fail(Throwable) fail} the Coordination with a{@link Coordination#TIMEOUT TIMEOUT} exception. @return A new Coordination object @throws IllegalArgumentException If the specified name does not followthe {@code symbolic-name} syntax or the specified time isnegative. @throws SecurityException If the caller does not have{@code CoordinationPermission[INITIATE]} for the specified nameand creating bundle.

• org.osgi.service.deploymentadmin.spi.ResourceProcessor.begin()
  Called when the Deployment Admin starts a new operation on the given deployment package, and the resource processor is associated a resource within the package. Only one deployment package can be processed at a time. @param session object that represents the current session to the resourceprocessor @see DeploymentSession
• org.ozoneDB.ExternalTransaction.begin()
  Start work on behalf of this transaction and associate it with the current thread. @throws TransactionExc If the thread is already associated with atransaction. @throws IOException If the server is not reachable.
• org.pdfclown.documents.contents.composition.BlockComposer.begin()
  Begins a content block. @param frame Block boundaries. @param alignmentX Horizontal alignment. @param alignmentY Vertical alignment.
• org.projectodd.stilts.stomp.client.StompClient.begin()
• org.rythmengine.internal.IDialect.begin()
• org.sonar.api.utils.text.XmlWriter.begin()
• org.squirrelframework.foundation.component.Heartbeat.begin()
  Begins a new Heartbeat. Heartbeats nest. Every call to begin() should be matched by a call to {@link #execute()}.
• org.switchyard.component.bpm.transaction.AS7TransactionHelper.begin()
  Begin. @throws HandlerException oops
• org.teiid.client.DQP.begin()
• org.terasology.engine.modes.loadProcesses.LoadPrefabs.begin()
• org.tmatesoft.hg.internal.ManifestRevision.begin()
• org.xmldb.api.modules.TransactionService.begin()
  Begin the transaction @exception XMLDBException with expected error codes.
  ErrorCodes.VENDOR_ERROR for any vendor specific errors that occur.
  
• prefuse.util.io.XMLWriter.begin()
  Begin the XML document. This must be called before any other formatting methods. This method prints an XML header into the top of the output stream.
• railo.runtime.db.DataSourceManager.begin()
  set state of transaction to begin
• ru.yandex.strictweb.ajaxtools.orm.ORMManager.begin()
• vrampal.connectfour.core.Game.begin()
  Change the status of a game from INIT to ONGOING. Only available in status INIT.

Examples of org.apache.tapestry.ioc.util.BodyBuilder.begin()

Examples of org.apache.tapestry.services.Heartbeat.begin()

Examples of org.apache.tapestry5.internal.services.HeartbeatImpl.begin()

Examples of org.apache.tapestry5.ioc.util.BodyBuilder.begin()

Examples of org.apache.tapestry5.services.Heartbeat.begin()

Examples of org.apache.webbeans.conversation.ConversationImpl.begin()

Examples of org.apache.wookie.beans.util.IPersistenceManager.begin()

Examples of org.archive.cdxserver.processor.BaseProcessor.begin()

Examples of org.bukkit.conversations.Conversation.begin()

Examples of org.datanucleus.Transaction.begin()