Simplified method form for invoking the SendMessageBatch operation.

@see #sendMessageBatchAsync(SendMessageBatchRequest)
15246
@Override
    public java.util.concurrent.Future<SendMessageBatchResult> sendMessageBatchAsync(String queueUrl, java.util.List<SendMessageBatchRequestEntry> entries) {

        return sendMessageBatchAsync(new SendMessageBatchRequest().withQueueUrl(queueUrl).withEntries(entries));
    }
1355798
public void send(String destName, String messageText)
            throws MessagingException {
        this.send(destName, (Serializable) messageText);
    }
818216
public void sendMessage(String text) throws NotConnectedException, InterruptedException {
        Message message = createMessage();
        message.setBody(text);
        connection.sendStanza(message);
    }
580070
private void doBatchMessage(final JsonObject message) {
    String batchID = message.getString("batch");
    if (currentBatch != null && currentBatch.id().equals(batchID)) {
      Object value = deserializer.deserialize(message);
      if (value != null) {
        if (log.isDebugEnabled()) {
          log.debug(String.format("%s - Batch received: Batch[batch=%s, id=%d, message=%s]", this, batchID, message.getLong("id"), value));
        }
        currentBatch.handleMessage(value);
      }
    }
  }
1216793
@Override
    public java.util.concurrent.Future<SendMessageResult> sendMessageAsync(String queueUrl, String messageBody,
            com.amazonaws.handlers.AsyncHandler<SendMessageRequest, SendMessageResult> asyncHandler) {

        return sendMessageAsync(new SendMessageRequest().withQueueUrl(queueUrl).withMessageBody(messageBody), asyncHandler);
    }
1286498
public void sendMessage(ISUPMessage msg, int dpc) throws ParameterException, IOException {
        if (!msg.hasAllMandatoryParameters()) {
            throw new ParameterException("Message does not have all required parameters!");
        }
        sendOnCircuit(getCircuit(msg, dpc), msg);
    }
107144
public static SendMessageBatchRequestEntry createSendMessageBatchRequestEntryFrom(String id,
                                                                                      SendMessageRequest sendMessageRequest) {
        return new SendMessageBatchRequestEntry()
                .withId(id)
                .withMessageBody(sendMessageRequest.getMessageBody())
                .withDelaySeconds(sendMessageRequest.getDelaySeconds())
                .withMessageAttributes(sendMessageRequest.getMessageAttributes())
                .withMessageDeduplicationId(sendMessageRequest.getMessageDeduplicationId())
                .withMessageGroupId(sendMessageRequest.getMessageGroupId());
    }
420614
public void send(MessageBuilder builder, SendMessageCallback cb, long timeout, TimeUnit unit) {
        Message msg = builder.build(this.messageBodyConverter);
        final String topic = msg.getTopic();
        MessageProducer producer = this.getOrCreateProducer(topic);
        producer.sendMessage(msg, cb, timeout, unit);
    }
1321249
public void sendMessage(final String message) {
        try {
            session.sendMessage(new TextMessage(message));
        }
        catch (IOException e) {
            logger.error("[sendTextMessage]", e);
        }
    }
735845
public ChangeMessageVisibilityResult changeMessageVisibilitySync(ChangeMessageVisibilityRequest request) {
        Future<ChangeMessageVisibilityResult> future = sendBuffer.changeMessageVisibility(request, null);
        return waitForFuture(future);
    }
498076
private synchronized JsMessage[] getBatch(int batchSize, ConversationHelper convHelper)
      throws SIResourceException, SIConnectionDroppedException
   {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "getBatch",
                                           new Object[]{batchSize, convHelper});

      if (batchesReady == 0)
      {
         if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "No batches are ready!!");

         // We are getting a batch of messages from the queue but there are none ready. Oops.
         SIErrorException e = new SIErrorException(
            nls.getFormattedMessage("ASYNC_BATCH_NOT_READY_SICO1033", null, null)
         );

         FFDCFilter.processException(e, CLASS_NAME + ".getBatch",
                                     CommsConstants.ASYNCHPQ_GETBATCH_01, this);

         throw e;
      }

      int currentSessionId = 0;
      JsMessage[] msg = new JsMessage[batchSize];
      QueueData data = null;

      for (int i=0; i<msg.length; ++i)
      {
         data = queue.removeFirst();
         currentSessionId = data.getProxyQueue().getId();
         msg[i] = (JsMessage) data.getMessage();

         // Is this the last bit of data? If so - out we go
         if (data.isLastInBatch()) break;
      }
      batchesReady--;

      // Have a quick check and see if there is any data left on the queue. If there is, it is
      // probably for another session and we should therefore transistion that session into
      // delivery by calling batch()
      if (!isQueueEmpty())
      {
         QueueData qd = queue.get(0);
         AsynchConsumerProxyQueue pq = (AsynchConsumerProxyQueue)qd.getProxyQueue();

         if (pq.getId() != currentSessionId)
         {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Next data on the queue is for a different session:", pq);
            pq.nudge();
         }
      }

      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "getBatch", msg);
      return msg;
   }
1022847
public void send(String destination, Object body) {
        AsyncMessage message = this.defaultMessageCreator.createMessage();
        message.setDestination(destination);
        message.setBody(body);
        getMessageBroker().routeMessageToService(message, null);
    }
639399
public void send(final Command msg) throws HandlerSocketException {
		Session session = this.selectSession();
		session.write(msg);
	}
421948
public void sendMessage(
      @Nonnull final String to,
      @Nonnull final String from,
      @Nonnull final String body) {
    proxy.sendMessage(to, from, body);
  }
1324092
public void sendRequest(Message request, Message.Builder responseBuilder) {
    sendRequest(request, null, responseBuilder, Duration.ZERO);
  }
773751
public List<Message> receiveBatch(int batchSize) throws JmsException {

        Destination defaultDestination = getDefaultDestination();

        if (defaultDestination != null) {
            return receiveBatch(defaultDestination, batchSize);
        } else {
            return receiveBatch(getRequiredDefaultDestinationName(), batchSize);
        }
    }
1054892
private static void sendMessageBatchOperationMd5Check(SendMessageBatchRequest sendMessageBatchRequest,
                                                          SendMessageBatchResult sendMessageBatchResult) {
        Map<String, SendMessageBatchRequestEntry> idToRequestEntryMap = new HashMap<String, SendMessageBatchRequestEntry>();
        if (sendMessageBatchRequest.getEntries() != null) {
            for (SendMessageBatchRequestEntry entry : sendMessageBatchRequest.getEntries()) {
                idToRequestEntryMap.put(entry.getId(), entry);
            }
        }

        if (sendMessageBatchResult.getSuccessful() != null) {
            for (SendMessageBatchResultEntry entry : sendMessageBatchResult.getSuccessful()) {
                String messageBody = idToRequestEntryMap.get(entry.getId()).getMessageBody();
                String bodyMd5Returned = entry.getMD5OfMessageBody();
                String clientSideBodyMd5 = calculateMessageBodyMd5(messageBody);
                if (!clientSideBodyMd5.equals(bodyMd5Returned)) {
                    throw new AmazonClientException(String.format(MD5_MISMATCH_ERROR_MESSAGE_WITH_ID, MESSAGE_BODY,
                            entry.getId(), clientSideBodyMd5, bodyMd5Returned));
                }

                Map<String, MessageAttributeValue> messageAttr = idToRequestEntryMap.get(entry.getId())
                        .getMessageAttributes();
                if (messageAttr != null && !messageAttr.isEmpty()) {
                    String attrMd5Returned = entry.getMD5OfMessageAttributes();
                    String clientSideAttrMd5 = calculateMessageAttributesMd5(messageAttr);
                    if (!clientSideAttrMd5.equals(attrMd5Returned)) {
                        throw new AmazonClientException(String.format(MD5_MISMATCH_ERROR_MESSAGE_WITH_ID,
                                MESSAGE_ATTRIBUTES, entry.getId(), clientSideAttrMd5, attrMd5Returned));
                    }
                }
            }
        }
    }