Update the message in this Snackbar. This will overwrite the whole message that is currently shown.

@param message The new message.
@return This instance.
349708
@NonNull
  @SuppressWarnings("WeakerAccess")
  public SnackbarWrapper setText(@NonNull CharSequence message) {
    snackbar.setText(message);
    return this;
  }
2476
public void updateMessage(final Wave wave, final String message) {

        // Update the current task message
        JRebirth.runIntoJAT("Service Task Mesage => " + message,
                            () -> wave.get(JRebirthWaves.SERVICE_TASK).updateMessage(message));
    }
688888
public BType addBuilder(final MType message) {
    ensureMutableMessageList();
    ensureBuilders();
    final SingleFieldBuilder<MType, BType, IType> builder =
        newSingleFieldBuilder(message, this, isClean);
    messages.add(null);
    builders.add(builder);
    onChanged();
    incrementModCounts();
    return builder.getBuilder();
  }
854116
protected final void putMessage(Http2Stream stream, FullHttpMessage message) {
        FullHttpMessage previous = stream.setProperty(messageKey, message);
        if (previous != message && previous != null) {
            previous.release();
        }
    }
142946
public RepeatedFieldBuilder<MType, BType, IType> setMessage(
      int index, MType message) {
    if (message == null) {
      throw new NullPointerException();
    }
    ensureMutableMessageList();
    messages.set(index, message);
    if (builders != null) {
      SingleFieldBuilder<MType, BType, IType> entry =
          builders.set(index, null);
      if (entry != null) {
        entry.dispose();
      }
    }
    onChanged();
    incrementModCounts();
    return this;
  }
1052280
private Observable<Boolean> upsertTempMessage(ChatMessage message) {
        return persistenceController.updateStoreWithNewMessage(message, noConversationListener)
                .doOnError(t -> log.e("Error saving temp message " + t.getLocalizedMessage()))
                .onErrorReturn(t -> false);
    }
1372591
@SuppressWarnings("ConstantConditions")
    private void showResult(String message) {
        Snackbar.make(rootLayout, message, Snackbar.LENGTH_LONG).show();
    }
656291
private void copyCookies(final Message message) {
        if (message instanceof HttpMessage) {
            this.cookies.putAll(((HttpMessage) message).getCookiesMap());
        }
    }
253372
public void setMessage( Message message ) {
        Assert.notNull(message, "The message is required");
        Assert.hasText( message.getMessage(), "The message text is required" );
        this.message = message;
    }
1328785
public synchronized long sendMessage(AbstractRequestMessage message) {
    log.debug("Sending {} to {}", message, this);
    message.setTicketNumber(this.nextTicketNumber.getAndIncrement());
    this.outstandingRequests.put(Long.valueOf(message.getTicketNumber()),
        message);
    this.session.write(message);
    return message.getTicketNumber();
  }
786397
public static void addMessage(final HttpServletRequest request, final String message) {
		StringBuilder sb = (StringBuilder) request.getAttribute(MESSAGE_KEY);
		if (sb == null) {
			sb = new StringBuilder();
			request.setAttribute(MESSAGE_KEY, sb);
		}
		sb.append(message);
	}
965315
public int updateGridToMessage(BaseMessage message, boolean bReReadMessage, boolean bAddIfNotFound)
    {
        Record record = this.getRecord(); // Record changed
        int iHandleType = DBConstants.BOOKMARK_HANDLE;  // OBJECT_ID_HANDLE;
        if (this.getNextTable() instanceof org.jbundle.base.db.shared.MultiTable)
            iHandleType = DBConstants.FULL_OBJECT_HANDLE;
        Object bookmark = ((RecordMessageHeader)message.getMessageHeader()).getBookmark(iHandleType);
        int iRecordMessageType = ((RecordMessageHeader)message.getMessageHeader()).getRecordMessageType();
        // See if this record is currently displayed or buffered, if so, refresh and display.
        GridTable table = (GridTable)record.getTable();
        int iIndex = -1;
        if (iRecordMessageType == -1)
        {
            iIndex = table.bookmarkToIndex(bookmark, iHandleType);  // Find this bookmark in the table
        }
        else if (iRecordMessageType == DBConstants.CACHE_UPDATE_TYPE)
        {   // No need to update anything as this is just a notification that the cache has been updaed already.
            iIndex = table.bookmarkToIndex(bookmark, iHandleType);  // Find this bookmark in the table
        }
        else if (iRecordMessageType == DBConstants.SELECT_TYPE)
        {   // A secondary record was selected, update the secondary field to the new value.
            // Don't need to update the table for a select
        }
        else if (iRecordMessageType == DBConstants.AFTER_ADD_TYPE)
        {
            iIndex = table.refreshBookmark(bookmark, iHandleType, false);  // Double-check to see if it has already been added
            if (iIndex == -1)
            {
                if (bAddIfNotFound)
                {   // Note: It might be nice to check this filter in the message on the server, then I don't change to read and check it.
                    try {
                        record = record.setHandle(bookmark, iHandleType);
                        // Fake the handleCriteria to think this is a slave. NOTE: This is not cool in a multitasked environment.
                        int iDBMasterSlave = record.getTable().getCurrentTable().getDatabase().getMasterSlave();
                        record.getTable().getCurrentTable().getDatabase().setMasterSlave(RecordOwner.MASTER | RecordOwner.SLAVE);
                        boolean bMatch = record.handleRemoteCriteria(null, false, null);
                        record.getTable().getCurrentTable().getDatabase().setMasterSlave(iDBMasterSlave);
                        if (bMatch)
                        {
                            iHandleType = DBConstants.DATA_SOURCE_HANDLE;
                            bookmark = this.getDataRecord(m_bCacheRecordData, BaseBuffer.SELECTED_FIELDS);
                        }
                        else
                            bookmark = null;
                    } catch (DBException e) {
                        e.printStackTrace();
                    }
                    if (bookmark != null)
                        iIndex = table.addNewBookmark(bookmark, iHandleType);   // Add this new record to the table
                }
            }
        }
        else
        {
            iIndex = table.refreshBookmark(bookmark, iHandleType, bReReadMessage);  // Refresh the data for this bookmark
        }
        return iIndex;
    }
199201
protected void addMessage(String message)
    {
        messages.add(message);
        messageCount++;
        if (messageCount > messagesQueueMax)
        {
            messages.remove();
            messageCount--;
        }
    }
1223574
public R setMessage(String message) {
        mBodyMap.put(BoxComment.FIELD_MESSAGE, message);
        return (R) this;
    }
872968
public RepeatedFieldBuilder<MType, BType, IType> addMessage(
      MType message) {
    if (message == null) {
      throw new NullPointerException();
    }
    ensureMutableMessageList();
    messages.add(message);
    if (builders != null) {
      builders.add(null);
    }
    onChanged();
    incrementModCounts();
    return this;
  }
1134007
private void updateMessage(ClientSocket client, DataInputStream buffer, byte messageSystemId, byte from)
            throws IOException
    {
        switch (messageSystemId)
        {
            case NetworkMessageSystemId.CONNECTING:
                receiveConnecting(client, buffer, from, StateConnection.CONNECTING);
                break;
            case NetworkMessageSystemId.CONNECTED:
                receiveConnected(client, from, StateConnection.CONNECTED);
                break;
            case NetworkMessageSystemId.PING:
                client.getOut().writeByte(NetworkMessageSystemId.PING);
                client.getOut().flush();
                bandwidth += 1;
                break;
            case NetworkMessageSystemId.OTHER_CLIENT_DISCONNECTED:
                receiveDisconnected(client, from, StateConnection.CONNECTED);
                break;
            case NetworkMessageSystemId.OTHER_CLIENT_RENAMED:
                receiveRenamed(client, buffer, from, StateConnection.CONNECTED);
                break;
            case NetworkMessageSystemId.USER_MESSAGE:
                receiveMessage(client, buffer, from, StateConnection.CONNECTED);
                break;
            default:
                break;
        }
    }
183434
public void addMessageToCache(Message message) {
        messages.compute(message.getId(), (key, value) -> {
            if ((value == null) || (value.get() == null)) {
                WeakReference<Message> result = new WeakReference<>(message, messagesCleanupQueue);
                messageIdByRef.put(result, key);
                return result;
            }
            return value;
        });
    }