Adds TransactionQueueData to another.
765090
public TransactionQueueData add(TransactionQueueData data) {
        return new TransactionQueueData
            (null,
             Math.min(mSnapshotStart, data.mSnapshotStart),
             Math.max(mSnapshotEnd, data.mSnapshotEnd),
             mQueueSize + data.mQueueSize,
             mThreadCount + data.mThreadCount,
             mServicingCount + data.mServicingCount,
             Math.max(mPeakQueueSize, data.mPeakQueueSize),
             Math.max(mPeakThreadCount, data.mPeakThreadCount),
             Math.max(mPeakServicingCount, data.mPeakServicingCount),
             mTotalEnqueueAttempts + data.mTotalEnqueueAttempts,
             mTotalEnqueued + data.mTotalEnqueued,
             mTotalServiced + data.mTotalServiced,
             mTotalExpired + data.mTotalExpired,
             mTotalServiceExceptions + data.mTotalServiceExceptions,
             mTotalUncaughtExceptions + data.mTotalUncaughtExceptions,
             mTotalQueueDuration + data.mTotalQueueDuration,
             mTotalServiceDuration + data.mTotalServiceDuration
             );
    }
855752
public void commitTransaction()
   {
      CompressedISPNChangesBuffer changesContainer = getChangesBufferSafe();
      final TransactionManager tm = getTransactionManager();
      try
      {
         final List<ChangesContainer> containers = changesContainer.getSortedList();
         commitChanges(tm, containers);
      }
      finally
      {
         changesList.set(null);
         changesContainer = null;
      }
   }
388891
void addToCommittedQueue(Session session, Object[] list) {

        synchronized (committedTransactionTimestamps) {

            // add the txList according to commit timestamp
            committedTransactions.addLast(list);

            // get session commit timestamp
            committedTransactionTimestamps.addLast(session.actionTimestamp);
/* debug 190
            if (committedTransactions.size() > 64) {
                System.out.println("******* excessive transaction queue");
            }
// debug 190 */
        }
    }
1187361
public boolean addTransactionAware(TransactionAware txAware) {
    // If the txAware is newly added, call startTx as well if there is an active transaction
    boolean added = txAwares.add(txAware);
    if (added && currentTx != null) {
      txAware.startTx(currentTx);
    }
    return added;
  }
1360306
def append_waiting_queue(self, transfer_coordinator):
        '''  '''
        logger.debug("Add to waiting queue count=%d" % self.waiting_coordinator_count())
        with self._lockw:
            self._waiting_transfer_coordinators.append(transfer_coordinator)
1231829
public static void addTxn(TransactionImpl txn)
    {
        if (tc.isEntryEnabled()) Tr.entry(tc, "addTxn", txn);

        final ByteArray key = new ByteArray(txn.getXid().getGlobalTransactionId());

        synchronized (txnTable)
        {
            if (!txnTable.containsKey(key))
            {
                txnTable.put(key, new JCATranWrapperImpl(txn, true, false)); // @LIDB2110C
            }
        }

        if (tc.isEntryEnabled()) Tr.exit(tc, "addTxn");
    }
201436
def add(self, item, safe=None):
		''' '''
		item._set_session(self)
		if safe is None:
			safe = self.safe
		self.queue.append(SaveOp(self.transaction_id, self, item, safe))
		# after the save op is recorded, the document has an _id and can be
		# cached
		self.cache_write(item)
		if self.autoflush:
			return self.flush()
14357
private void executeUpdatesSynchronous(DBTransaction transaction) {
        BatchStatement batchState = new BatchStatement(Type.UNLOGGED);
        batchState.addAll(getMutations(transaction));
        executeBatch(batchState);
    }
28391
public void putAll(Map otherMap,
                       Transaction transaction)
                    throws ObjectManagerException
    {
        for (Iterator iterator = otherMap.entrySet()
                        .iterator(); iterator.hasNext(transaction);) {
            Entry entry = (Entry) iterator.next(transaction);
            put(entry.getKey(),
                entry.getValue(),
                transaction);
        } // for...
    }
422913
public Dispatchable addDispatchableForOptimizedLocalTransaction(int transactionId) {
        if (tc.isEntryEnabled())
            SibTr.entry(this, tc, "addDispatchableForOptimizedLocalTransaction", "" + transactionId);
        final Dispatchable result = addDispatchableForLocalTransaction(transactionId);
        if (tc.isEntryEnabled())
            SibTr.exit(this, tc, "addDispatchableForOptimizedLocalTransaction", result);
        return result;
    }
342148
def _merge_data_trace_events(self, event):
        """"""
        if isinstance(event, events.TraceDataTraceEvent):
            # Record the first data trace event.
            if self._pending_data_trace is None:
                self._pending_data_trace = event
            else:
                # We've got the second in a pair. If the comparator numbers are the same, then
                # we can merge the two events. Otherwise we just add them to the pending event
                # queue separately.
                if event.comparator == self._pending_data_trace.comparator:
                    # Merge the two data trace events.
                    ev = events.TraceDataTraceEvent(cmpn=event.comparator,
                        pc=(event.pc or self._pending_data_trace.pc),
                        addr=(event.address or self._pending_data_trace.address),
                        value=(event.value or self._pending_data_trace.value),
                        rnw=(event.is_read or self._pending_data_trace.is_read),
                        sz=(event.transfer_size or self._pending_data_trace.transfer_size),
                        ts=self._pending_data_trace.timestamp)
                else:
                    ev = self._pending_data_trace
                self._pending_events.append(ev)
                self._pending_data_trace = None
            return True
        # If we get a non-data-trace event while waiting for a second data trace event, then
        # just place the pending data trace event in the pending event queue.
        elif self._pending_data_trace is not None:
            self._pending_events.append(self._pending_data_trace)
            self._pending_data_trace = None
        return False
886757
public TransactionLoadRequest addLoad(Object key, DynamoDBTransactionLoadExpression transactLoadExpression) {
        objectsToLoad.add(key);
        objectLoadExpressions.add(transactLoadExpression);
        return this;
    }
1046845
public void add(Item item, TransactionCommon transaction)
                    throws MessageStoreException, SIResourceException {
        if (TraceComponent.isAnyTracingEnabled()
            && tc.isEntryEnabled())
            SibTr.entry(tc, "add", new Object[] { item, transaction });

        Transaction msTran = resolveAndEnlistMsgStoreTransaction(transaction);
        _persistentStore.addItem(item, msTran);

        if (TraceComponent.isAnyTracingEnabled()
            && tc.isEntryEnabled())
            SibTr.exit(tc, "add");
    }
986515
def append(self, *other):
    
    self._data = it.chain(self._data, Stream(*other)._data)
    return self
379056
public void add( T value ) {
		// see if it needs to grow the queue
		if( size >= data.length) {
			growInnerArray();
		}
		data[(start+size)%data.length] = value;
		size++;
	}
37614
public boolean addAll(Collection otherCollection,
                          Transaction transaction)
                    throws ObjectManagerException
    {
        boolean modified = false;
        try {
            for (Iterator iterator = otherCollection.iterator();;)
                modified = add((Token) iterator.next(transaction), transaction);
        } catch (java.util.NoSuchElementException exception) {
            // No FFDC code needed.
            // We have run off the end of the other collection.
        } // try.   
        return modified;
    }
296050
protected void modify(Transaction t) {
        try {
            this.lock.writeLock().lock();
            t.perform();
        } finally {
            this.lock.writeLock().unlock();
        }
    }