docs: public final AORequestedTick newRequest(long tick, long expiryTimeout)
      throws ClosedException, MessageStoreException, SINotPossibleInCurrentConfigurationException
    {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        SibTr.entry(
          tc,
          "newRequest",
          new Object[] { Long.valueOf(tick), Long.valueOf(expiryTimeout)});
  
      SIMPMessage msg = null;
      AORequestedTick aotick = null;
      try
      {
        this.lock();
        try
        {
          if (closed)
          {
            ClosedException e = new ClosedException();
            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.exit(tc, "newRequest", e);
    
            throw e;
          }
          // cancel the idle timer
          if (idleHandler != null)
          {
            idleHandler.cancel();
            idleHandler = null;
          }
  
          // try to satisfy it immediately
          if (!temporarilyStopped)
          {
            if (!isready)
            {
              // have not indicated isready, so listOfRequests must be empty prior to inserting this AORequestedTick
              ck.ready(Reliability.NONE);
              isready = true;
              msg = (SIMPMessage) cks[0].getMessageLocked();
              if (msg != null)
              {
                // no longer ready
                ck.notReady();
                isready = false;
              }
              if (msg == null || gatherMessages) // Drive any refills if we are gathering
              {            
                long timeout = cks[0].waiting(convertTimeoutSIMPtoLCP(expiryTimeout), false);
                if (msg == null && timeout != LocalConsumerPoint.NO_WAIT && timeout != LocalConsumerPoint.INFINITE_WAIT )
                  expiryTimeout = convertTimeoutLCPtoSIMP(timeout);
              }
            }             
          } // end if (!temporarilyStopped)    
               
          // create a new AORequestedTick and add it to listOfRequests, tableOfRequests
          aotick =
            new AORequestedTick(this, tick, Long.valueOf(tick), expiryTimeout, am);
        
          if (msg!=null)
          {
            // satisfy the tick
            boolean satisfied = aotick.satisfy(msg);
            if (!satisfied)
            {
              // unlock the msg and return null (dont increment unlock count)
              msg.unlockMsg(msg.getLockID(),null, false);
              msg = null;
              
              // The idle timeout is for periods of time when we have no requests. If a msg is
              // locked it must not be running. 
              // At this point we have no locked msg.
              if( idleTimeout > 0) 
                  this.idleHandler = am.create(idleTimeout, this);    
            }         
          }  
          else
          {
            listOfRequests.put(aotick);
            tableOfRequests.put(Long.valueOf(tick), aotick);
          }
        } // end this.lock
        finally
        {
          this.unlock();
        }
      }
      catch (MessageStoreException e)
      {
        // No FFDC code needed
        
        // Things have gone wrong with the message store, best to close down
        // this consumer, forcing a new one to be created for new requests.
        // The existing requests are in a bit of a funny state now, but hey,
        // it's not our fault, blame the message store.
        
        // notify the parent first to try to stop new requests using this one
        parent.removeConsumerKey(selectionCriteriasAsString, this);
        
        // close this and throw exception
        close(); //Never call close() from withing synchronized (this)!!
        
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
          SibTr.exit(tc, "newRequest", e);
        throw e;
      }
      catch (SINotPossibleInCurrentConfigurationException e)
      {
        // No FFDC code needed
  
        // close this and throw exception
        close(); //Never call close() from withing synchronized (this)!!
        // notify the parent since this is an asynchronous close
        parent.removeConsumerKey(selectionCriteriasAsString, this);
        
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
          SibTr.exit(tc, "newRequest", e);
        throw e;
      }
  
      /**
       * If the request had a 0 timeout and we couldnt find a message then we expire the 
       * request 
       */
      if (expiryTimeout == 0L && msg == null)
      {
        // Since we are not prepared to wait we will expire this request.
        // The aotick handles its own expiry timer when expiryTimeout > 0L
        expiryAlarm(aotick);
      }
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        SibTr.exit(tc, "newRequest", msg);
  
      return aotick;
    }