Only update the persistent copy of the binary data held within this Persistable.

@param tran The ObjectManager transaction under which the update of the data is carried out.

@exception ObjectManagerException
@throws SevereMessageStoreException
322625
public void updateDataOnly(Transaction tran, ObjectStore store) throws PersistenceException, ObjectManagerException, SevereMessageStoreException
    {
        updateDataOnly(tran, store, this);
    }
1041695
public void registerTransaction(TransactionImpl tran) {
        if (tc.isEntryEnabled())
            Tr.entry(tc, "registerTransaction", new Object[] { this, tran });

        _recoveringTransactions.add(tran);

        if (tc.isEntryEnabled())
            Tr.exit(tc, "registerTransaction", _recoveringTransactions.size());
    }
992540
public final void addItemStream(final ItemStream itemStream, long lockID, final Transaction transaction) throws MessageStoreException
    {
        // Defect 410652
        // Check the transaction being used is from the same MessageStore as
        // ours so that we don't get a mismatch and run the possibility of
        // hitting a DuplicateKeyException at persistence time. If the MS's
        // don't match then the unique key generator being used for this
        // add could be using a range that has already been used in the MS
        // that will be used to persist the transaction.
        final MessageStoreImpl messageStore = getMessageStoreImpl();
        final MessageStore     tranStore    = ((PersistentTransaction)transaction).getOwningMessageStore();
        // We only need to do a simple equality check as all that we really
        // care about is that the same MS instance in memory is being used.
        if (messageStore != tranStore)
        {
            MismatchedMessageStoreException mmse = new MismatchedMessageStoreException("Transaction supplied on add does not originate from this MessageStore! MS: "+messageStore+", Tran.MS: "+tranStore);
            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.event(this, tc, "Transaction supplied on add does not originate from this MessageStore! MS: "+messageStore+", Tran.MS: "+tranStore, mmse);
            throw mmse;
        }

        int strategy = itemStream.getStorageStrategy();
        final long itemID = messageStore.getUniqueValue(strategy);
        TupleTypeEnum type = TupleTypeEnum.ITEM_STREAM;
        Persistable childPersistable = getTuple().createPersistable(itemID, type);
        childPersistable.setStorageStrategy(strategy);
        final AbstractItemLink link = new ItemStreamLink(itemStream, this, childPersistable);
        // Defect 463642
        // Revert to using spill limits previously removed in SIB0112d.ms.2
        link.setParentWasSpillingAtAddTime(getListStatistics().isSpilling());
        messageStore.registerLink(link, itemStream);
        link.cmdAdd(this, lockID, (PersistentTransaction)transaction);
    }
290091
@Override
    public void add(ItemStream itemStream, Transaction transaction) throws MessageStoreException
    {
        add(itemStream, AbstractItem.NO_LOCK_ID, transaction);
    }
1068275
public final void requestUpdate(Transaction transaction) throws MessageStoreException
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "requestUpdate", transaction);

        Membership membership = _getMembership();
        if (null == membership)
        {
            throw new NotInMessageStore();
        }
        else
        {
            membership.requestUpdate(transaction);
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "requestUpdate");
    }
1046844
public final void preCommit(final PersistentTransaction transaction) throws SevereMessageStoreException
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "preCommit", transaction);

        getItem();  // try to cache item in case we havent got it yet....
        getLink().preCommitRemove(transaction);

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "preCommit");
    }
1121515
public synchronized void cancelMessageRequest(boolean discard)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "cancelMessageRequest", new Boolean(discard));
      
    SIMPTransactionManager txManager = messageProcessor.getTXManager();
    LocalTransaction tran = null;
    
    try
    {
      MessageItem msg = (MessageItem)getSIMPMessage();
      
      
      if(discard)
      {
        if(msg!=null)
        {
          tran = txManager.createLocalTransaction(false);
          Transaction msTran = messageProcessor.resolveAndEnlistMsgStoreTransaction(tran);

          // Cleanup the AOValue and the Msg
          aoStream.syncRemoveValueTick(tick, msTran, msg);
          
          tran.commit();
        }
        else
        {
          //if the request was not in the value state, then we simply expire
          //the request
          aoStream.expiredRequest(tick, true);          
        }
      }
      else
      {  
        if(msg!=null) 
        {          
          tran = txManager.createLocalTransaction(false);
          Transaction msTran = messageProcessor.resolveAndEnlistMsgStoreTransaction(tran);
          
          // Cleanup the AOValue
          aoStream.syncRemoveValueTick(tick, msTran, null);
          
          if(msg.isInStore())
          {
            long lockID = msg.getLockID();
            if(lockID!=AbstractItem.NO_LOCK_ID)
            {
              //unlock the message for others to consume it etc
              msg.unlockMsg(lockID, msTran, true);
            }  
          }
          tran.commit();
        }
        else
          //if the request was not in the value state, then we simply expire
          //the request
          aoStream.expiredRequest(tick, true); 
      }
    }
    catch(MessageStoreException e)
    {
      FFDCFilter.processException(
        e,
        "com.ibm.ws.sib.processor.runtime.TransmitMessageRequest.cancelMessageRequest",
        "1:644:1.48",
        this); 
        
      SibTr.error(tc, "INTERNAL_MESSAGING_ERROR_CWSIP0002",
        new Object[] { "com.ibm.ws.sib.processor.runtime.TransmitMessageRequest.cancelMessageRequest", 
                       "1:649:1.48", 
                       SIMPUtils.getStackTrace(e) });
      SibTr.exception(tc, e);
      
      try
      {
        if (tran!=null)
          tran.rollback();
      }
      catch (SIException ee)
      {
        // No FFDC code needed
        SibTr.exception(tc, e);
      }
    }
    catch (SIException e)
    {
      FFDCFilter.processException(
          e,
          "com.ibm.ws.sib.processor.runtime.TransmitMessageRequest.cancelMessageRequest",
          "1:669:1.48",
          this); 
          
        SibTr.error(tc, "INTERNAL_MESSAGING_ERROR_CWSIP0002",
          new Object[] { "com.ibm.ws.sib.processor.runtime.TransmitMessageRequest.cancelMessageRequest", 
                         "1:674:1.48", 
                         SIMPUtils.getStackTrace(e) });
        SibTr.exception(tc, e); 
        
        try
        {
          if (tran!=null)
            tran.rollback();
        }
        catch (SIException ee)
        {
          // No FFDC code needed
          SibTr.exception(tc, e);
        }

    }  

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "cancelMessageRequest");
  }
413632
public final synchronized void incrementReferenceCount() throws SevereMessageStoreException
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "incrementReferenceCount");

        if (_referenceCountIsDecreasing)
        {
        	if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) SibTr.event(this, tc, "Cannot increment! Reference count has begun decreasing.");
        	if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "incrementReferenceCount");
            throw new SevereMessageStoreException("Cannot add more references to an item after one has been removed");
        }
        _referenceCount++;

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "incrementReferenceCount");
    }
266030
public void deleteCurrent(SITransaction transaction)
      throws SISessionUnavailableException, SISessionDroppedException,
             SIConnectionUnavailableException, SIConnectionDroppedException,
             SIResourceException, SIConnectionLostException, SILimitExceededException,
             SIIncorrectCallException, SIMessageNotLockedException, 
             SIErrorException
	{
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc,"deleteCurrent", transaction);
      
      synchronized(lmeOperationMonitor)
      {
         checkValid();
         
         // If nextIndex = 0 then we are pointing at the first item, therefore unlocking the current
         // is invalid. Also, if the message is null, then we must have deleted - therefore also
         // invalid.
         if ((nextIndex == 0) || (messages[nextIndex - 1] == null))
         {
            throw new SIIncorrectCallException(
               nls.getFormattedMessage("LME_DELETE_INVALID_MSG_SICO1018", null, null)
            );
         }
         
         JsMessage retMsg = messages[nextIndex - 1];
         
         // Only flow the delete if it would not have been done on the server already.
         // This will have been done if the message is determined to be 'unrecoverable'.
         if (CommsUtils.isRecoverable(retMsg, consumerSession.getUnrecoverableReliability()))
         {
            // Start d181719
            JsMessage[] msgs = new JsMessage[] {retMsg};         // f191114
            
            if (transaction != null)
            {
               synchronized (transaction)
               {
                  // Check transaction is in a valid state.
                  // Enlisted for an XA UOW and not rolledback or
                  // completed for a local transaction.
                  if (!((Transaction)transaction).isValid())
                  {
                     throw new SIIncorrectCallException(
                        nls.getFormattedMessage("TRANSACTION_COMPLETE_SICO1022", null, null)
                     );
                  }
                  
                  deleteMessages(msgs, transaction);             // f191114
               }
            }
            else
            {
               deleteMessages(msgs, null);                       // f191114
            }
            // End d181719
         }
         
         // Now remove it from the LME
         messages[nextIndex - 1] = null;
         
      }  
      
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc,"deleteCurrent");
	}
711464
public final void releaseItem() throws SevereMessageStoreException
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "releaseItem");

        synchronized (this)
        {
            _strongReferenceToItem = NULL_STRONG_REF;
        }

        if (_softReferenceToItem != null)
        {
            _softReferenceToItem.clear();
        }

        // Defect 601995
        if (_isStorageManaged && (_itemCacheManagedReference != NULL_CACHE_REF))
        {
            _itemCache.unmanage(this);
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
            {
                SibTr.debug(this, tc, "release item(" + getID() + ":" + _inMemoryItemSize + ") new cacheSize = " + _itemCache.getCurrentSize());
            }
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "releaseItem");
    }
491980
@Override
    public void bind(TransactionResource resource)
    {
        // Not checking for type of TransactionRes
        if (resource != null && resource instanceof RedisTransaction)
        {
            this.resource = resource;
        }
        else
        {
            throw new KunderaTransactionException("Invalid transaction resource provided:" + resource
                    + " Should have been an instance of :" + RedisTransaction.class);
        }
    }
299602
public final void postAbort(final PersistentTransaction transaction) throws SevereMessageStoreException
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "postAbort", transaction);

        AbstractItem item = getItem();
        if (null == item)
        {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "null item");
        }
        else
        {
            item.eventPostRollbackRemove(transaction);
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "postAbort");
    }
991475
@SuppressWarnings("unchecked")
    public <T extends IEntity> T update(T entity) throws FMSException {

        IntuitMessage intuitMessage = prepareUpdate(entity);

        //execute interceptors
        executeInterceptors(intuitMessage);

        return (T) retrieveEntity(intuitMessage);
    }
494758
private void resumeTran(Transaction tran) {
        if (tran != null) {
            try {
                tranMgr.resume(tran);
            } catch (Exception e) {
                throw new BatchRuntimeException("Failed to resume transaction after JobOperator method", e);
            } 
        }
    }
203220
public void reconstitute(BaseDestinationHandler destinationHandler,
                           SIMPTransactionManager txManager)
    throws MessageStoreException
  {
    if (tc.isEntryEnabled())
      SibTr.entry(tc, "reconstitute", new Object[] {destinationHandler, txManager}); 
      
    initializeNonPersistent(destinationHandler, txManager);
        
    if (tc.isEntryEnabled())
      SibTr.exit(tc, "reconstitute");           
  }
307394
public void abortAdd(final PersistentTransaction transaction) throws SevereMessageStoreException
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "abortAdd", transaction);

        synchronized (this)
        {
            if ((_itemLinkState == ItemLinkState.STATE_ADDING_LOCKED)
                || (_itemLinkState == ItemLinkState.STATE_ADDING_UNLOCKED))
            {
                _assertCorrectTransaction(transaction);

                MessageStoreImpl msi = getMessageStoreImpl();
                Expirer expirer = msi._getExpirer();
                long expiryTime = getTuple().getExpiryTime();
                if (null != expirer && 0 != expiryTime)
                {
                    expirer.removeExpirable(this);
                }

                // Remove from the DeliveryDelayManager as well
                DeliveryDelayManager deliveryDelayManager = msi._getDeliveryDelayManager();
                long deliveryDelayTime = getTuple().getDeliveryDelayTime();
                if (null != deliveryDelayManager && 0 != deliveryDelayTime) {
                    deliveryDelayManager.removeDeliveryDelayable(this);
                }

                // going back to 'not stored' state requires a decrement in total count
                ListStatistics stats = getParentStatistics();

                // Defect 510343.1
                stats.decrementAdding(_inMemoryItemSize);

                _lockID = NO_LOCK_ID;
                _transactionId = null;
                _itemLinkState = ItemLinkState.STATE_NOT_STORED;

                msi.unregister(this);

                // Now, pay attention. This was added under defect 290610.
                // It looks it was omitted in changes for v6.0.2 and would result
                // in rolled back additions leaking into the linked lists.
                unlink();
            }
            else
            {
                if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled())
                    SibTr.event(this, tc, "Invalid Item state: " + _itemLinkState);
                if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                    SibTr.exit(this, tc, "abortAdd");
                throw new StateException(_itemLinkState.toString());
            }
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "abortAdd");
    }
1016652
protected void restore(ObjectInputStream ois, int dataVersion) throws SevereMessageStoreException
  
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "restore", new Object[] { dataVersion});
    checkPersistentVersionId(dataVersion);
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "restore");
  }