Try to create a message filler if the given parameter is a message parameter.

@return created message filler, or null if the given parameter is not a message parameter
979166
static MessageFiller parseMessageParameter(String wrappedParameter, String trimmedParameter) {
    if (trimmedParameter.equals(PARAMETER_MESSAGE)) {
      return new MessageFiller(wrappedParameter, trimmedParameter);
    }
    return null;
  }
1040473
private final JsMessage createSpecialisedMessage(JsMsgObject jmo) {

    JsMessage message = null;

    /* For an API message, we need to return an instance of the appropriate   */
    /* specialisation.                                                        */
    if (jmo.getChoiceField(JsHdrAccess.API) == JsHdrAccess.IS_API_DATA) {

      /* If it is a JMS message, get the right specialisation                 */
      if (jmo.getField(JsHdrAccess.MESSAGETYPE).equals(MessageType.JMS.toByte())) {
        message = getJmsFactory().createInboundJmsMessage(jmo, ((Byte)jmo.getField(JsHdrAccess.SUBTYPE)).intValue());
      }      
    }

    /* If it isn't an API message, just return a JsMessageImpl                */
    else {
      message = new JsMessageImpl(jmo);
    }

    return message;
  }
8495
@Override
	public String getFormattedMessage() {
		String result = localizedMessage==null ? rawMessage : localizedMessage;
		if (parameters != null) {
			try {
				return MessageFormat.format(result, parameters);
			} catch (IllegalArgumentException iae) {
				// In case of problem with positional parameters fall through and
				// return unformatted string.
			}
		}
		return result;
	}
155152
private ISFSObject getMessage() {
        if(messageObject != null) {
            MessageParamsClass clazz = context.getMessageParamsClass(messageObject.getClass());
            if(clazz != null) 
                return new ResponseParamSerializer().object2params(clazz.getUnwrapper(), messageObject);
        }
        if(jsonMessage != null)
            return SFSObject.newFromJsonData(jsonMessage);
        if(messageString == null)
            return new SFSObject();
        ISFSObject answer = new SFSObject();
        answer.putUtfString(APIKey.MESSAGE, messageString);
        return answer;
            
    }
1026670
@Override
    public VoidMessage takeMessage() {
        if (threadingModel != ThreadingModel.SAME_THREAD) {
            try {
                return messages.take();
            } catch (InterruptedException e) {
                // probably we don't want to do anything here
                return null;
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        } else {
            /**
             * PLEASE NOTE: This branch is suitable for debugging only, should never be used in wild life
             */
            // we do inplace poll
            if (subscriptionForShards != null)
                subscriptionForShards.poll(messageHandlerForShards, 512);

            subscriptionForClients.poll(messageHandlerForClients, 512);

            return messages.poll();
        }
    }
356046
@Override
    public Message createMessage(Session session) throws JMSException {
        Message message = session.createTextMessage(requestMessage);
        if (correlationId != null)
            message.setJMSCorrelationID(correlationId);
        if (replyQueue != null) {
            message.setJMSReplyTo(replyQueue);
        }
        if (delaySeconds >0) {
            ApplicationContext.getJmsProvider().setMessageDelay(null, message, delaySeconds);
        }
        return message;
    }
1172573
public BaseMessageSender createMessageSender()
    {
        RemoteTask server = (RemoteTask)((App)this.getMessageManager().getApplication()).getRemoteTask(null);
        try   {
            return new RemoteMessageSender(server, this);
        } catch (RemoteException ex)    {
            ex.printStackTrace();
        }
        return null;
    }
1266428
public Message createMessage(ByteBuffer buffer) {

        if (!isHeaderReady) {
            int len = Math.min(MESSAGE_HEADER_SIZE - pos, buffer.remaining());
            buffer.get(header, pos, len);

            // update cursor postion in the header's buffer
            pos += len;

            // header completed?
            isHeaderReady = pos == header.length;

            if (!isHeaderReady) {
                // no more data available
                return null;
            }

            // obtain remaining length of the message and prepare buffer
            length = ((header[0] & 0xff) << 24);
            length += ((header[1] & 0xff) << 16);
            length += ((header[2] & 0xff) << 8);
            length += (header[3] & 0xff);

            length -= MESSAGE_HEADER_SIZE;

            params = new byte[length];

            // finally switch cursor position
            pos = 0;

            message = new Message();
        }

        // at this point we must recheck remainder of the input buffer
        // because possible case when input buffer fits exactly to the header
        if (length > 0 && !buffer.hasRemaining()) {
            return null;
        }

        // again, reading all parameters before parsing

        // compute available or required data
        int len = Math.min((params.length - pos), buffer.remaining());
        buffer.get(params, pos, len);

        // update cursor position
        pos += len;

        // end of message not reached
        if (pos < params.length) {
            return null;
        }

        // end of message reached and most probably some data remains in buffer
        // do not touch remainder of the input buffer, next call to this method
        // will proceed remainder

        // parsing params of this message
        message.decode(params);

        // switch factory for receiving new message
        this.isHeaderReady = false;
        this.pos = 0;

        // return
        return message;
    }
226014
public static <O extends Object> void notNull(O o, String message) {
		if(!validation) return;
		notNull(message);
		if(o == null)
			throw new ParameterException(ErrorCode.NULLPOINTER, message);
	}
806485
@Override
    public TextMessage createTextMessage() throws JMSRuntimeException {

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "createTextMessage");

        TextMessage textMessage = null;

        try {
            textMessage = jmsSession.createTextMessage();
        } catch (JMSException jmse) {
            throw (JMSRuntimeException) JmsErrorUtils.getJMS2Exception(jmse, JMSRuntimeException.class);
        } finally {
            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                SibTr.exit(this, tc, "createTextMessage", new Object[] { textMessage });
        }

        return textMessage;

    }
62443
@Nonnull
    public static <T> T checkNotNull(T value, @Nonnull String errorMessage) {
        if (value == null) {
            throw new NullPointerException(errorMessage);
        }
        return value;
    }
789390
private String getCreationErrorMessage() {

        String message = new String();
        if (!m_resourcesCreated.isEmpty()) {
            // some resources have been created, tell the user which resources were created successfully
            StringBuffer buf = new StringBuffer(64);
            for (String name : m_resourcesCreated.values()) {
                buf.append("<br />");
                buf.append(name);
            }
            message = m_bundle.key(org.opencms.ade.upload.Messages.ERR_UPLOAD_CREATING_1, buf.toString());
        } else {
            // no resources have been created on the VFS
            message = m_bundle.key(org.opencms.ade.upload.Messages.ERR_UPLOAD_CREATING_0);
        }
        return message;
    }
385170
public MessageRecordDesc createNewMessage(BaseMessage message, String strKey)
    {
        MessageRecordDesc messageData = null;
        String strClassName = this.getField(MessageInfo.MESSAGE_CLASS).toString();
        messageData = (MessageRecordDesc)ClassServiceUtility.getClassService().makeObjectFromClassName(strClassName);
        if (messageData != null)
               messageData.init(message, strKey);
        return messageData;
    }
1178912
@Override
    public Message newMessage(final String message, final Object... params) {
        return new FormattedMessage(message, params);
    }
974998
private MessageType checkMessageInitialized(MessageType message)
      throws InvalidProtocolBufferException {
    if (message != null && !message.isInitialized()) {
      throw newUninitializedMessageException(message)
          .asInvalidProtocolBufferException()
          .setUnfinishedMessage(message);
    }
    return message;
  }
7353
public MessageToSend prepareMessageToSend() {
        originalMessage.getParts().clear();
        originalMessage.getParts().addAll(publicParts);
        return originalMessage;
    }
609157
protected JLabel createMessageLabel() {
        JLabel messageLabel = new JLabel(" ");
        messageLabel.setName("message");
        Border bevelBorder = BorderFactory.createBevelBorder(BevelBorder.LOWERED, UIManager
                .getColor("controlHighlight"), UIManager.getColor("controlShadow"));
        Border emptyBorder = BorderFactory.createEmptyBorder(1, 3, 1, 3);
        messageLabel.setBorder(BorderFactory.createCompoundBorder(bevelBorder, emptyBorder));

        return messageLabel;
    }