Computes the unique message id for the given MsgNode.

@param msgNode The message parsed from the Soy source.
@return The message id.
768266
private static long computeMsgId(MsgNode msgNode) {
    return SoyMsgIdComputer.computeMsgId(
        buildMsgParts(msgNode), msgNode.getMeaning(), msgNode.getContentType());
  }
922940
@FFDCIgnore({ EntityNotFoundException.class, Exception.class })
    private String getUniqueNameByUniqueId(String uniqueId, boolean isAllowOperationIfReposDown, Set<String> failureRepositoryIds) throws WIMException {
        final String METHODNAME = "getUniqueNameByUniqueId";
        String uniqueName = null;

        boolean found = false;
        int i = 0;
        Root temp = new Root();
        Entity entity = new Entity();
        IdentifierType id = new IdentifierType();
        id.setExternalId(uniqueId);
        entity.setIdentifier(id);
        temp.getEntities().add(entity);

        List<String> repositoryIds = repositoryManager.getRepoIds();
        while (i < repositoryIds.size() && !found) {
            try {
                Root returnedRoot = repositoryManager.getRepository(repositoryIds.get(i)).get(temp);
                if (returnedRoot != null) {
                    List<Entity> pes = returnedRoot.getEntities();
                    if (pes != null) {
                        Entity ent = pes.get(0);
                        if (ent != null) {
                            IdentifierType entityId = ent.getIdentifier();
                            if (entityId != null) {
                                uniqueName = entityId.getUniqueName();
                                found = true;
                            }
                        }
                    }
                }
            } catch (EntityNotFoundException e) {
                // Move on to the next repository
                i++;
            } catch (Exception e) {
                if (!isAllowOperationIfReposDown) {
                    if (e instanceof WIMException) {
                        throw (WIMException) e;
                    }
                    throw new WIMException(e);
                } else {
                    if (tc.isDebugEnabled())
                        Tr.debug(tc, METHODNAME + " IGNORE: exception [" + e.getMessage()
                                     + "] on repository [" + repositoryIds.get(i) + "]");
                    failureRepositoryIds.add(repositoryIds.get(i));

                    // Move on to the next repository
                    i++;
                }
            }
        }
        return uniqueName;
    }
62674
@Override
  protected void visitMsgNode(MsgNode node) {
    MsgPartsAndIds msgPartsAndIds = MsgUtils.buildMsgPartsAndComputeMsgIdForDualFormat(node);
    SoyMsg.Builder builder = SoyMsg.builder().setId(msgPartsAndIds.id);
    if (node.getMeaning() != null) {
      builder.setMeaning(node.getMeaning());
    }
    SoyMsg msg =
        builder
            .setDesc(node.getDesc())
            .setIsHidden(node.isHidden())
            .setContentType(node.getContentType())
            .addSourceLocation(node.getSourceLocation())
            .setIsPlrselMsg(node.isPlrselMsg())
            .setParts(msgPartsAndIds.parts)
            .build();
    msgs.add(msg);
  }
231910
public String getId()
  {
    try
    {
      if(id == null) 
        id = destinationHandler.getUuid()+
             RuntimeControlConstants.QUEUE_ID_INSERT+
             itemStream.getID();
    }
    catch (MessageStoreException e)
    {
      FFDCFilter.processException(
          e,
          "com.ibm.ws.sib.processor.runtime.LocalQueuePoint.getId",
          "1:471:1.58", 
          this);
      SibTr.exception(tc, e);
    }
    
    return id;
  }
1097937
private String getSecNameFromUniqueID(String uniqueId) throws WIMException {
        String METHODNAME = "getSecNameFromUniqueID";
        String secName = null;
        try {
            secName = getUserSecurityName(uniqueId);
        } catch (EntryNotFoundException e) {
            try {
                secName = getGroupSecurityName(uniqueId);
            } catch (com.ibm.ws.security.registry.EntryNotFoundException renf) {
                throw new EntityNotFoundException(WIMMessageKey.ENTITY_NOT_FOUND, Tr.formatMessage(tc, WIMMessageKey.ENTITY_NOT_FOUND,
                                                                                                   WIMMessageHelper.generateMsgParms(uniqueId)));
            } catch (RegistryException re) {
                throw new EntityNotFoundException(WIMMessageKey.ENTITY_NOT_FOUND, Tr.formatMessage(tc, WIMMessageKey.ENTITY_NOT_FOUND,
                                                                                                   WIMMessageHelper.generateMsgParms(uniqueId)));
            }
        } catch (RegistryException e) {
            throw new EntityNotFoundException(WIMMessageKey.ENTITY_NOT_FOUND, Tr.formatMessage(tc, WIMMessageKey.ENTITY_NOT_FOUND,
                                                                                               WIMMessageHelper.generateMsgParms(uniqueId)));
        }

        if (tc.isDebugEnabled()) {
            Tr.debug(tc, METHODNAME + " The Security Name for " + uniqueId + " is " + secName);
        }

        return secName;
    }
214804
public long getPreviousSequenceID()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "getPreviousSequenceID");
    long previousSequenceID=0;
    previousSequenceID = msgItem.getMessage().getGuaranteedValueStartTick()-1;

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "getPreviousSequenceID", new Long(previousSequenceID));
    return previousSequenceID;
  }
323380
public static String getMessageId(String msg) {
        if (msg == null) {
            return null;
        }
        // check for IBM SWG pattern - "AAAAANNNNS:"
        // 5 chars followed by 4 numbers, followed by one of E/W/I, followed by a colon
        if (msg.length() >= 10) { // 10 chars in pattern 

            // copy first 9 characters into an array
            char[] lm = new char[9];
            msg.getChars(0, 9, lm, 0);

            // match characters in array against AAAAANNNNS: pattern

            if ((lm[8] >= '0') && (lm[8] <= '9')
                && (lm[7] >= '0') && (lm[7] <= '9')
                && (lm[6] >= '0') && (lm[6] <= '9')
                && (lm[5] >= '0') && (lm[5] <= '9')
                && ((lm[4] >= 'A') && (lm[4] <= 'Z') || (lm[4] >= '0') && (lm[4] <= '9'))
                && ((lm[3] >= 'A') && (lm[3] <= 'Z') || (lm[3] >= '0') && (lm[3] <= '9'))
                && ((lm[2] >= 'A') && (lm[2] <= 'Z') || (lm[2] >= '0') && (lm[2] <= '9'))
                && ((lm[1] >= 'A') && (lm[1] <= 'Z') || (lm[1] >= '0') && (lm[1] <= '9'))
                && ((lm[0] >= 'A') && (lm[0] <= 'Z') || (lm[0] >= '0') && (lm[0] <= '9'))) {
                return msg.substring(0, 10);
            }

        }

        // Check for IBM4.4.1 pattern - "AAAANNNNS:"
        // 4 chars followed by 4 numbers, followed by one of E/W/I, followed by a colon
        if (msg.length() >= 9) { // 9 chars in pattern

            // copy first 8 characters into an array
            char[] lm = new char[8];
            msg.getChars(0, 8, lm, 0);

            // match characters in array against AAAAANNNNS: pattern
            if ((lm[7] >= '0') && (lm[7] <= '9')
                && (lm[6] >= '0') && (lm[6] <= '9')
                && (lm[5] >= '0') && (lm[5] <= '9')
                && (lm[4] >= '0') && (lm[4] <= '9')
                && ((lm[3] >= 'A') && (lm[3] <= 'Z') || (lm[3] >= '0') && (lm[3] <= '9'))
                && ((lm[2] >= 'A') && (lm[2] <= 'Z') || (lm[2] >= '0') && (lm[2] <= '9'))
                && ((lm[1] >= 'A') && (lm[1] <= 'Z') || (lm[1] >= '0') && (lm[1] <= '9'))
                && ((lm[0] >= 'A') && (lm[0] <= 'Z') || (lm[0] >= '0') && (lm[0] <= '9'))) {

                // v5
                return msg.substring(0, 9);
            }
        }
        return null;
    }
1179731
private void handleNewStreamID(MessageItem msgItem) throws SIResourceException
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "handleNewStreamID", new Object[] { msgItem });

    JsMessage jsMsg = msgItem.getMessage();

    handleNewStreamID(jsMsg, msgItem);

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "handleNewStreamID");
  }
521249
public boolean markSent(MessageID messageID) {
        MessageInfo messageInfo =  sentMessages.remove(messageID);
        return messageInfo != null && messageInfo.toSelfDeliver;
    }
1162904
def _msg_id_for_name(self, msg_name):
        
        if msg_name in self._async_id_stack and self._async_id_stack[msg_name]:
            return self._async_id_stack[msg_name][0]
764064
@Override
    public String getClientID() throws JMSRuntimeException {

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

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

        return clientId;
    }
1227953
private Expression generateSingleMsgVariable(MsgNode msgNode, String tmpVarName) {
    String googMsgVarName = buildGoogMsgVarNameHelper(msgNode);

    // Generate the goog.getMsg call.
    GoogMsgCodeGenInfo googMsgCodeGenInfo = genGoogGetMsgCallHelper(googMsgVarName, msgNode);

    if (!msgNode.isPlrselMsg()) {
      // No postprocessing is needed. Simply use the original goog.getMsg var.
      return googMsgCodeGenInfo.googMsgVar;
    }
    // For plural/select messages, generate the goog.i18n.MessageFormat call.
    // We don't want to output the result of goog.getMsg() directly. Instead, we send that
    // string to goog.i18n.MessageFormat for postprocessing. This postprocessing is where we're
    // handling all placeholder replacements, even ones that have nothing to do with
    // plural/select.
    return VariableDeclaration.builder(tmpVarName)
        .setRhs(getMessageFormatCall(googMsgCodeGenInfo))
        .build()
        .ref();
  }
1103345
public static void d(String msg) {
		if (!debug) {
			return;
		}
		if (messager == null) {
			return;
		}
		messager.printMessage(Diagnostic.Kind.NOTE, msg);
	}
1293947
private JsMessage getTrackedMessage(NodeTraversal t, String msgName) {
    boolean isUnnamedMessage = isUnnamedMessageName(msgName);
    if (!isUnnamedMessage) {
      MessageLocation location = messageNames.get(msgName);
      return location == null ? null : location.message;
    } else {
      Var var = t.getScope().getVar(msgName);
      if (var != null) {
        return unnamedMessages.get(var);
      }
    }
    return null;
  }
833692
public String getMsgPhrase(final UUID _msgPhrase)
        throws EFapsException
    {
        return getMsgPhrase(null, MsgPhrase.get(_msgPhrase));
    }
1163563
public static boolean isKnownById(int id) {
        final String hexId = Utils.supplyZero(Integer.toHexString(id).toUpperCase(), 4);
        
        String code = messageResolver.getMessage(String.format("locale.%s.code", hexId));
        return Utils.isNotEmpty(code);
    }
1057244
public int getJvmPid() {
        int pid = -1;
        if (strPID !=null) {
            try {
                pid = Integer.parseInt(strPID);
            }
            catch (NumberFormatException e) {/* */  }
        }
        return pid;
    }