docs: public void addToStore(Transaction tran, ObjectStore store, Persistable persistable) throws PersistenceException, ObjectManagerException, SevereMessageStoreException
      {
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.entry(this, tc, "addToStore", new Object[] { "Tran=" + tran, "ObjectStore=" + store, "Persistable=" + persistable });
  
          // Defect 585163
          // Create our meta data object so that we can populate it 
          // ready for adding to the file store.
          PersistableMetaData metaData = new PersistableMetaData(_uniqueID, _streamID, _tupleType.toString());
  
          metaData.setLockID(persistable.getLockID());
          metaData.setReferredID(persistable.getReferredID());
          metaData.setSequence(persistable.getSequence());
          metaData.setExpiryTime(persistable.getExpiryTime());
          metaData.setStorageStrategy(persistable.getStorageStrategy());
          metaData.setPriority(persistable.getPriority());
          metaData.setPersistentSize(persistable.getPersistentSize());
          metaData.setCanExpireSilently(persistable.getCanExpireSilently());
          metaData.setClassName(persistable.getItemClassName());
          metaData.setRedeliveredCount(persistable.getRedeliveredCount());
          metaData.setDeliveryDelayTime(persistable.getDeliveryDelayTime());
  
          PersistentTranId tranId = persistable.getPersistentTranId();
          if (tranId != null)
          {
              metaData.setTransactionId(tranId.toByteArray());
          }
  
          // Defect 542362
          // We need to catch any object manager exceptions so that
          // we can reset our state if we know that our object
          // manager transaction is going to be rolled back.
          // 
          // This is to handle the case where this persistables
          // addToStore() hits a problem.
          try
          {
              // If we are a Stream then we need to create our persistent
              // lists to store our child Items and Streams in.
              if ((_tupleType == TupleTypeEnum.ITEM_STREAM) || (_tupleType == TupleTypeEnum.REFERENCE_STREAM) || (_tupleType == TupleTypeEnum.ROOT))
              {
                  // Defect 297550
                  // If we are a STORE_MAYBE ItemStream then we don't
                  // need a persistent structure for an ItemStream. 
                  // Otherwise we need to create our persistent lists.
                  if (_storageStrategy != AbstractItem.STORE_MAYBE)
                  {
                      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                          SibTr.debug(this, tc, "Persistent item is a stream. Building lists.");
  
                      // Defect 585163
                      ConcurrentLinkedList streamList = new ConcurrentLinkedList(tran, store, 64);
                      metaData.setStreamListToken(streamList.getToken());
  
                      ConcurrentLinkedList itemList = new ConcurrentLinkedList(tran, store, 64);
                      metaData.setItemListToken(itemList.getToken());
                  }
              }
  
              // Create our raw data managed object. At this
              // point we will update our copy of the persistent
              // data from the ItemLink.
              // FSIB0112b.ms.2
              // Make sure all new objects use the new DataSlice
              // based binary data object.
              PersistableSlicedData slicedData = new PersistableSlicedData();
  
              try
              {
                  // Get our data from the passed persistable. This will
                  // either be this object or a cached version.
                  slicedData.setData(persistable.getData());
              } catch (SevereMessageStoreException smse)
              {
                  com.ibm.ws.ffdc.FFDCFilter.processException(smse, "com.ibm.ws.sib.msgstore.persistence.objectManager.PersistableImpl.addToStore", "1:416:1.36", this);
                  if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled())
                      SibTr.event(tc, "Severe exception caught retrieving latest copy of binary data from Item!", smse);
                  if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                      SibTr.exit(tc, "addToStore");
                  throw smse;
              } catch (PersistentDataEncodingException pdee)
              {
                  com.ibm.ws.ffdc.FFDCFilter.processException(pdee, "com.ibm.ws.sib.msgstore.persistence.objectManager.PersistableImpl.addToStore", "1:423:1.36", this);
                  if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled())
                      SibTr.event(this, tc, "Encoding exception caught retrieving latest copy of binary data from Item!", pdee);
                  if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                      SibTr.exit(this, tc, "addToStore");
                  throw pdee;
              }
  
              // Allocate in ObjectStore
              Token rawDataToken = store.allocate(slicedData);
  
              // Add MO to transaction
              tran.add(slicedData);
  
              // Add token to metadata
              metaData.setRawDataToken(rawDataToken);
  
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                  SibTr.debug(this, tc, "Persistent data token added to transaction: " + rawDataToken);
  
              // Then we need to allocate the item in the object store
              _metaDataToken = store.allocate(metaData);
  
              // Defect 441208
              // If we are STORE_MAYBE then we do not need a persistent
              // representation in our containing stream as at start-up
              // all STORE_MAYBE Items/Streams will be deleted.
              if ((_containingStream != null) && (_storageStrategy != AbstractItem.STORE_MAYBE))
              {
                  // If we aren't the root then we need to keep our
                  // parents pointers up to date.
                  PersistableImpl parentStream = (PersistableImpl) _containingStream;
  
                  PersistableMetaData parentMetaData = parentStream.getMetaData();
  
                  // Are we expirable? If so then we need to mark 
                  // our stream so it can be pre-loaded at startup.
                  if ((getExpiryTime() > 0) && !parentMetaData.containsExpirables())
                  {
                      // Only need to update if our streams flag
                      // isn't already set. This flag will be reset 
                      // at startup time when the stream is read in 
                      // if it no longer contains any expirables.
                      tran.lock(parentMetaData);
                      parentMetaData.setContainsExpirables(true);
                      tran.replace(parentMetaData);
                  }
  
                  // Defect 297550
                  // We only need to update our persistent lists
                  // if we have any so only STORE_ALWAYS and
                  // STORE_EVENTUALLY lists are updated.
                  if (parentStream.getStorageStrategy() != AbstractItem.STORE_MAYBE)
                  {
                      // We have a persistent parent so we can 
                      // update it's item list
                      ConcurrentLinkedList list = (ConcurrentLinkedList) parentMetaData.getItemListToken().getManagedObject();
                      List.Entry itemListEntry = list.addEntry(_metaDataToken, tran);
  
                      // Add the item list entry token to the metadata
                      metaData.setItemListEntryToken(((ManagedObject) itemListEntry).getToken());
  
                      // Finally, if this is a stream, we need to add 
                      // this item to it's parent's list of streams
                      if ((_tupleType == TupleTypeEnum.ITEM_STREAM) || (_tupleType == TupleTypeEnum.REFERENCE_STREAM))
                      {
                          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                              SibTr.debug(this, tc, "Persistent item is a stream. Adding to parent.");
  
                          list = (ConcurrentLinkedList) parentMetaData.getStreamListToken().getManagedObject();
                          List.Entry streamListEntry = list.addEntry(_metaDataToken, tran);
  
                          // Add the stream list entry token to the metadata
                          metaData.setStreamListEntryToken(((ManagedObject) streamListEntry).getToken());
                      }
                  }
              }
  
              // Finally add it to the transaction
              tran.add(metaData);
          } catch (ObjectManagerException ome)
          {
              com.ibm.ws.ffdc.FFDCFilter.processException(ome, "com.ibm.ws.sib.msgstore.persistence.objectManager.PersistableImpl.addToStore", "1:502:1.36", this);
              if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled())
                  SibTr.event(this, tc, "Exception caught trying to add persistable to object manager!", ome);
  
              // Defect 542362
              // This exception is going to trigger a rollback
              // of our object manager transaction so we need to
              // rollback the state of our object manager objects.
              _metaDataToken = null; // Defect 585163
  
              if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                  SibTr.exit(this, tc, "addToStore");
              throw ome;
          }
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.exit(this, tc, "addToStore");
      }