docs: public boolean put(SIMPMessage msg, boolean isOnItemStream)
    {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        SibTr.entry(tc, "put", new Object[] { msg, Boolean.valueOf(isOnItemStream)});
  
      boolean returnValue = false;
      // chose small value for ArrayList initial size since typically not many new messages will be produced
      // during the short time this method is being executed
      ArrayList<AORequestedTick> satisfiedTicks = new ArrayList<AORequestedTick>(5);
  
      // We need to lock down the whole AOStream so that another thread can't jump in between
      // us satisfying the request and actually creating an AOValue and updating the AOStream.
      // Otherwise, the other thread may modify the latestTick value, based on their request,
      // and we'll put a 'future' tick as our 'previous' tick and end up with an inconsistent
      // stream.
      synchronized(parent) // AOStream
      {
        try
        {
          this.lock();
          try
          {
            if (closed)
            {
              if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                SibTr.exit(tc, "put", Boolean.FALSE);
              return false;
            }
            if (!isOnItemStream)
            {
              // this should not really occur. we ought to log this error
              SIErrorException e =
                new SIErrorException(
                  nls.getFormattedMessage(
                    "INTERNAL_MESSAGING_ERROR_CWSIP0001",
                    new Object[] {
                      "com.ibm.ws.sib.processor.impl.JSRemoteConsumerPoint",
                      "1:713:1.43.2.26" },
                    null));
              FFDCFilter.processException(
                e,
                "com.ibm.ws.sib.processor.impl.JSRemoteConsumerPoint.put",
                "1:718:1.43.2.26",
                this);
              SibTr.exception(tc, e);
              SibTr.error(tc, "INTERNAL_MESSAGING_ERROR_CWSIP0001",
                new Object[] {
                  "com.ibm.ws.sib.processor.impl.JSRemoteConsumerPoint",
                  "1:724:1.43.2.26" });
    
              if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                SibTr.exit(tc, "put", Boolean.valueOf(false));
    
              return false; // we only accept recoverable messages
            }
            if (!isready)
            {
              if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                SibTr.exit(tc, "put", Boolean.valueOf(false));
    
              return false; // no one is interested in a message
            }
    
            // set isready to false since ConsumerKey is no longer ready
            isready = false;
    
            // possibly someone interested in the message
            AORequestedTick rt = (AORequestedTick) listOfRequests.getFirst();
            if (rt == null)
            {
              // no request is waiting, so do nothing
            }
            else
            { // there is atleast one waiting request (which is !expired and !satisfied)
              boolean locked = false;
              try
              {
                locked = msg.lockItemIfAvailable(cks[0].getGetCursor(msg).getLockID());
              }
              catch(MessageStoreException e)
              {
                // FFDC
                FFDCFilter.processException(
                    e,
                    "com.ibm.ws.sib.processor.impl.JSRemoteConsumerPoint.put",
                    "1:761:1.43.2.26",
                    this);  
                            
                SibTr.exception(tc, e); 
                
                // TODO : We need a much wider handling of exception here and around this area. If anything
                // goes wrong we probably need to close off the consumerSession otherwise msgs could get "stuck"
                
              }
              // lock this particular message
              if (!locked)
                msg = null;
    
              if (msg != null)
              {
                AORequestedTick satTick = satisfyRequest(rt, msg);
                if (satTick != null)
                  satisfiedTicks.add(satTick);
    
                rt = null;
                msg = null;
                returnValue = true; // the message was accepted
              }
              // At this point there are 2 possibilities: (1) msg == null && rt == null, or
              // (2) msg == null && rt != null. Case #2 occurs if the msg was not successfully locked.
    
              // while the ConsumerKey was not ready, many messages may have been made available but they were missed
              // so loop till either there are no more waiting requests, or there are no more available messages
              satisfiedTicks.addAll(processQueuedMsgs(rt));
    
            } // end else
          } // end this.lock()
          finally
          {
            this.unlock();
          }
        }
        catch(SINotPossibleInCurrentConfigurationException e)
        {
          // No FFDC code needed
          notifyException(e);
        }
        
        // inform parent about satisfied ticks - outside lock
        int length = satisfiedTicks.size();
        for (int i = 0; i < length; i++)
        {
          AORequestedTick aotick = (AORequestedTick) satisfiedTicks.get(i);
          parent.satisfiedRequest(aotick.tick, aotick.getMessage());
        }
      } // synchronized(parent)
      
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        SibTr.exit(tc, "put", Boolean.valueOf(returnValue));
  
      return returnValue;
    }