Processes (acks) an operation that has already been processed and would otherwise result in no change to the
underlying Storage.

@param operation The operation to handle.
439549
private void acknowledgeAlreadyProcessedOperation(SegmentOperation operation) throws DataCorruptionException {
        if (operation instanceof MergeSegmentOperation) {
            // Only MergeSegmentOperations need special handling. Others, such as StreamSegmentSealOperation, are not
            // needed since they're handled in the initialize() method. Ensure that the DataSource is aware of this
            // (since after recovery, it may not know that a merge has been properly completed).
            MergeSegmentOperation mergeOp = (MergeSegmentOperation) operation;
            try {
                updateMetadataForTransactionPostMerger(this.dataSource.getStreamSegmentMetadata(mergeOp.getSourceSegmentId()), mergeOp.getStreamSegmentId());
            } catch (Throwable ex) {
                // Something really weird must have happened if we ended up in here. To prevent any (further) damage, we need
                // to stop the Segment Container right away.
                throw new DataCorruptionException(String.format("Unable to acknowledge already processed operation '%s'.", operation), ex);
            }
        }
    }
809546
private void processRequestAcknowledgements(
            final AbstractBody req, final AbstractBody resp) {
        assertLocked();
        
        if (!cmParams.isAckingRequests()) {
            return;
        }

        // If a report or time attribute is set, we aren't acking anything
        if (resp.getAttribute(Attributes.REPORT) != null) {
            return;
        }

        // Figure out what the highest acked RID is
        String acked = resp.getAttribute(Attributes.ACK);
        Long ackUpTo;
        if (acked == null) {
            // Implicit ack of all prior requests up until RID
            ackUpTo = Long.parseLong(req.getAttribute(Attributes.RID));
        } else {
            ackUpTo = Long.parseLong(acked);
        }

        // Remove the acked requests from the list
        if (LOG.isLoggable(Level.FINEST)) {
            LOG.finest("Removing pending acks up to: " + ackUpTo);
        }
        Iterator<ComposableBody> iter = pendingRequestAcks.iterator();
        while (iter.hasNext()) {
            AbstractBody pending = iter.next();
            Long pendingRID = Long.parseLong(
                    pending.getAttribute(Attributes.RID));
            if (pendingRID.compareTo(ackUpTo) <= 0) {
                iter.remove();
            }
        }
    }
1032521
public void manage(final Ack ack) {
		
		if (logger.isDebugEnabled()) {
			logger.debug("Receiving ack : " + 
				     "  - id : " + ack.getId() + 
				     "  - type : " + ack.getType() + 
				     "  - count : " + ack.getCount());
		}
		
		if (SMText.EXPECTED_ACK_TYPE.equalsIgnoreCase(ack.getType())) {
			//
			
		} else {
			logger.error("Ack received is not and SMText ack : " + 
				     "  - id : " + ack.getId() + 
				     "  - type : " + ack.getType() + 
				     "  - count : " + ack.getCount() + 
				     "Ack not managed ");
		}
		
	 }
1156583
void checkSetupDone(String operation) {
        if (!setupSuccessful()) {
            String stateToString = setupStateToString(setupState);
            Logger.e("Illegal state for operation (", operation, "): ", stateToString);
            throw new IllegalStateException(stateToString + " Can't perform operation: " + operation);
        }
    }
174918
private static void pushOp(String operation, Stack<MetricExpression> expressions, Stack<String> operations) {
        if (operation.equals("(")) {
            operations.push(operation);
            return;
        }

        if (operation.equals(")")) {
            while (!operations.isEmpty()) {
                String op = operations.pop();
                if (op.equals("("))
                    return;
                doOperation(op, expressions, operations);
            }
        }


        if (operation.equals("*") || operation.equals("/")) {
            if (operations.isEmpty())
                operations.push(operation);
            else {
                String op1 = operations.peek();
                if (!op1.equals("(")) {
                    if (op1.equals("+") || op1.equals("-")) {
                        operations.push(operation);
                    } else {
                        doOperation(operations.pop(), expressions, operations);
                        operations.push(operation);
                    }
                } else {
                    operations.push(operation);
                }

            }
        }
        if (operation.equals("+") || operation.equals("-")) {
            if (operations.isEmpty())
                operations.push(operation);
            else {
                String op1 = operations.peek();
                if (!op1.equals("(")) {
                    doOperation(operations.pop(), expressions, operations);
                }
                operations.push(operation);
            }
        }
    }
389339
private void performAdj(int operation, int position, byte[] bytes, int offset, int length) {
		checkMutable();
		final int to = (bytes.length << 3) - offset;
		final int from = to - length;
		position += length;
		for (int i = from; i < to; i++) {
			boolean b = (bytes[i >> 3] & (128 >> (i & 7))) != 0;
			performAdj(operation, --position, b);
		}
	}
42737
public void performWithLock (final NodeObject.Lock lock, final LockedOperation operation)
    {
        acquireLock(lock, new ResultListener<String>() {
            public void requestCompleted (String nodeName) {
                if (getNodeObject().nodeName.equals(nodeName)) {
                    // lock acquired successfully - perform the operation, and release the lock.
                    try {
                        operation.run();
                    } finally {
                        releaseLock(lock, new ResultListener.NOOP<String>());
                    }
                } else {
                    // some other peer beat us to it
                    operation.fail(nodeName);
                    if (nodeName == null) {
                        log.warning("Lock acquired by null?", "lock", lock);
                    }
                }
            }
            public void requestFailed (Exception cause) {
                log.warning("Lock acquisition failed", "lock", lock, cause);
                operation.fail(null);
            }
        });
    }
705443
public void each(Consumer<T> operation) {
		for (T component : components) {
			operation.accept(component);
		}
	}
12916
void performRun(IntegrationOperation operation) {
    for (Map.Entry<String, Integration<?>> entry : integrations.entrySet()) {
      String key = entry.getKey();
      long startTime = System.nanoTime();
      operation.run(key, entry.getValue(), projectSettings);
      long endTime = System.nanoTime();
      long durationInMillis = TimeUnit.NANOSECONDS.toMillis(endTime - startTime);
      stats.dispatchIntegrationOperation(key, durationInMillis);
      logger.debug("Ran %s on integration %s in %d ns.", operation, key, endTime - startTime);
    }
  }
880072
public void setOperations(java.util.Collection<BatchWriteOperation> operations) {
        if (operations == null) {
            this.operations = null;
            return;
        }

        this.operations = new java.util.ArrayList<BatchWriteOperation>(operations);
    }
1178511
@Override
    public void execute(OperationContext context, ModelNode operation) throws OperationFailedException {

        nameValidator.validate(operation);
        final String newAlias = operation.require(NAME).asString();
        final ModelNode submodel = context.readResourceForUpdate(PathAddress.EMPTY_ADDRESS).getModel();
        final ModelNode currentValue = submodel.get(CacheContainerResource.ALIASES.getName()).clone();

        ModelNode newValue = addNewAliasToList(currentValue, newAlias) ;

        // now set the new ALIAS attribute
        final ModelNode syntheticOp = new ModelNode();
        syntheticOp.get(CacheContainerResource.ALIASES.getName()).set(newValue);
        CacheContainerResource.ALIASES.validateAndSet(syntheticOp, submodel);

        // since we modified the model, set reload required
        if (requiresRuntime(context)) {
            context.addStep((context1, operation1) -> {
                context1.reloadRequired();
                context1.completeStep(OperationContext.RollbackHandler.REVERT_RELOAD_REQUIRED_ROLLBACK_HANDLER);
            }, OperationContext.Stage.RUNTIME);
        }
    }
181890
protected function processOperation()
    {
        if ($this->_operation!==null) {
            $value = $this->_operationArgument ? $this->_operationArgument : null;
            if ($value instanceof TmpFile) {
                $value = (string) $value;
            }
            $this->addArg($this->_operation, $value, $this->_escapeOperationArgument);
        }
    }
984462
@Override
    public void add(SegmentOperation operation) throws DataCorruptionException {
        Exceptions.checkNotClosed(this.closed.get(), this);
        Preconditions.checkArgument(operation.getStreamSegmentId() == this.connector.getMetadata().getId(),
                "Operation '%s' refers to a different Segment than this one (%s).", operation, this.connector.getMetadata().getId());
        Preconditions.checkArgument(operation.getSequenceNumber() != Operation.NO_SEQUENCE_NUMBER,
                "Operation '%s' does not have a Sequence Number assigned.", operation);
        if (this.connector.getMetadata().isDeleted() || !(operation instanceof CachedStreamSegmentAppendOperation)) {
            // Segment is either deleted or this is not an append operation. Nothing for us to do here.
            return;
        }

        CachedStreamSegmentAppendOperation append = (CachedStreamSegmentAppendOperation) operation;
        if (this.lastAddedOffset.get() >= 0) {
            // We have processed at least one operation so far. Verify operations are contiguous.
            if (this.lastAddedOffset.get() != append.getStreamSegmentOffset()) {
                throw new DataCorruptionException(String.format("Wrong offset for Operation '%s'. Expected: %s, actual: %d.",
                        operation, this.lastAddedOffset, append.getStreamSegmentOffset()));
            }
        } else {
            // We haven't processed any operation so far (this is the first). Verify that we are resuming from an expected
            // offset and not skipping any updates.
            if (this.aggregator.getLastIndexedOffset() < append.getStreamSegmentOffset()) {
                throw new DataCorruptionException(String.format("Operation '%s' begins after TABLE_INDEXED_OFFSET. Expected: %s, actual: %d.",
                        operation, this.aggregator.getLastIndexedOffset(), append.getStreamSegmentOffset()));
            }
        }

        if (append.getStreamSegmentOffset() >= this.aggregator.getLastIndexedOffset()) {
            // Operation has not been indexed yet; add it to the internal list so we can process it.
            // NOTE: appends that contain more than one TableEntry (for batch updates) will be indexed atomically (either
            // all Table Entries are indexed or none), so it is safe to compare this with the first offset of the append.
            this.aggregator.add(append);
            this.lastAddedOffset.set(append.getLastStreamSegmentOffset());
            log.debug("{}: Add {} (State={}).", this.traceObjectId, operation, this.aggregator);
        } else {
            log.debug("{}: Skipped {} (State={}).", this.traceObjectId, operation, this.aggregator);
        }
    }
336903
private void verifyOperation(UpdateOperation operation) {
        if (this.operation == null) {
            this.operation = operation;
        } else if (this.operation != operation) {
            throw new JeppettoException("Can't switch operation type to '" + operation + "'.  '"
                                        + this.operation + "' is already in use.");
        }
    }
257463
void processAck(ControlAck ackMsg) 
  throws SIRollbackException, 
         SIConnectionLostException, 
         SIResourceException, 
         SIErrorException
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "processAck",
        new Object[] { ackMsg });

    List indexList = null;
    SourceStream batchListener = null;
    synchronized(sourceStreamManager)
    {
      indexList = sourceStreamManager.processAck(ackMsg);
      batchListener = sourceStreamManager.getBatchListener(ackMsg);
    }
    long index = 0;
    MessageItem msgItem = null;

    if(indexList != null)
    {         
      TransactionCommon tran = sourceBatchHandler.registerInBatch();
      // A marker to indicate how far through the method we get. 
      boolean messageAddCall = false;      
      
      try
      {      
        TickRange tr = null;
        for (int i = 0; i < indexList.size(); i++)
        {
          tr = (TickRange)indexList.get(i);
          batchListener.addToBatchList(tr);
          
          index = tr.itemStreamIndex;
          try
          {
            msgItem =
              (MessageItem)transmissionItemStream.findById(index);
            
            //it is possible that this is null in the case of a message
            //deleted via the Admin panels 
            if( msgItem != null)
            {  
              Transaction msTran = messageProcessor.resolveAndEnlistMsgStoreTransaction(tran);
              msgItem.remove(msTran, msgItem.getLockID());
            }  
          }
          catch (MessageStoreException e)
          {
            // MessageStoreException shouldn't occur so FFDC.
            FFDCFilter.processException(
              e,
              "com.ibm.ws.sib.processor.impl.PtoPOutputHandler.processAck",
              "1:1191:1.241",
              this);

            SibTr.exception(tc, e);
            SibTr.error(tc, "INTERNAL_MESSAGING_ERROR_CWSIP0002",
              new Object[] {
                "com.ibm.ws.sib.processor.impl.PtoPOutputHandler",
                "1:1198:1.241",
                e });

            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.exit(tc, "processAck", e);

            throw new SIResourceException(
              nls.getFormattedMessage(
                "INTERNAL_MESSAGING_ERROR_CWSIP0002",
                new Object[] {
                  "com.ibm.ws.sib.processor.impl.PtoPOutputHandler",
                  "1:1209:1.241",
                  e },
                null),
              e);
          }
        }
        
        // Indicate that we are about to unlock using messagesAdded.
        messageAddCall = true;
        sourceBatchHandler.messagesAdded(indexList.size(), batchListener);      
      }
      finally
      {
        // Before exiting this method, need to unlock the batch handler if it was locked.
        if (!messageAddCall)
        try
        {      
          sourceBatchHandler.messagesAdded(0);
        }
        catch (SIResourceException e)
        {
          // No FFDC code needed, This will allow for any exceptions that were thrown to
          // be rethrown instead of overiding with a batch handler error.
          if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled())
            SibTr.exception(tc, e);               
        }
        
      }
    }
    
    // Before we exit, let the source stream manager take care of any pending flushes
    sourceStreamManager.attemptFlushIfNecessary();

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "processAck");
  }
945546
function doOperation(operation) {
        if (operation.ops.length > 0) {
            try {
                $(exports).triggerHandler('beforeExecuteOperation', [operation]);
                _applyOperation(operation);
                if (operation.bypass !== true) {
                    _undoStack.push(operation);
                    _redoStack.clear();
                    $(exports).triggerHandler('operationExecuted', [operation]);
                }
            } catch (err) {
                console.error(err);
            }
        }
    }
75285
void processOperation(HierarchyWrapperOperation operation) {
        // Hook for start
        operation.startOfProcess();

        // Hook to process other content (newlines and comments)
        otherContentList.forEach(operation::processOtherContent);

        if (elementContent != null && elementContent.isContentElement()) {
            // Hook to process element
            operation.processElement(elementContent);
        }

        // Hook to manipulate the order of the children
        operation.manipulateChildElements(children);

        // Hook to modify the operation before traversing sub levels
        HierarchyWrapperOperation subOperation = operation.createSubOperation();

        for (HierarchyWrapper child : children) {
            child.processOperation(subOperation);
        }

        // Hook for end of process
        operation.endOfProcess();
    }