catch(Throwable t)
if (deliveries.isEmpty())
   private Delivery handleNoTx(DeliveryObserver sender, Receiver receiver, Routable r)   {      checkClosed();      if (r == null)      {         return null;      }      // don't even attempt synchronous delivery for a reliable message when we have an      // non-recoverable state that doesn't accept reliable messages. If we do, we may get into the      // situation where we need to reliably store an active delivery of a reliable message, which      // in these conditions cannot be done.      if (r.isReliable() && !state.acceptReliableMessages())      {         log.error("Cannot handle reliable message " + r +                   " because the channel has a non-recoverable state!");         return null;      }      if (log.isTraceEnabled()){ log.trace(this + " handling non-transactionally " + r); }      MessageReference ref = ref(r);      Set deliveries = Collections.EMPTY_SET;      if (receiver == null)      {         deliveries = router.handle(this, ref, null);      }      else      {         try         {            Delivery d = receiver.handle(this, ref, null);            if (d != null && !d.isCancelled())            {               deliveries = new HashSet(1);               deliveries.add(d);            }         }         catch(Throwable t)         {            // broken receiver - log the exception and ignore it            log.error("The receiver " + receiver + " is broken", t);         }      }      if (deliveries.isEmpty())      {         // no receivers, receivers that don't accept the message or broken receivers                  if (log.isTraceEnabled()){ log.trace("No deliveries returned for message; there are no receivers"); }                  try         {            state.add(ref, null);            if (log.isTraceEnabled()){ log.trace("adding reference to state successfully"); }         }         catch(Throwable t)         {            // this channel cannot safely hold the message, so it doesn't accept it            log.error("Cannot handle the message", t);            return null;         }      }      else      {         // there are receivers         try         {                        for (Iterator i = deliveries.iterator(); i.hasNext(); )            {               Delivery d = (Delivery)i.next();               if (!d.isDone())               {                  state.add(d);               }            }                   }         catch(Throwable t)         {            log.error(this + " cannot manage delivery, passing responsibility to the sender", t);            // cannot manage this delivery, pass the responsibility to the sender            // cannot split delivery, because in case of crash, the message must be recoverable            // from one and only one channel            // TODO this is untested            return new CompositeDelivery(sender, deliveries);         }               }      // the channel can safely assume responsibility for delivery      return new SimpleDelivery(true);   }