| /******************************************************************************* |
| * Copyright (c) 2010 BSI Business Systems Integration AG. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * BSI Business Systems Integration AG - initial API and implementation |
| ******************************************************************************/ |
| package org.eclipse.scout.sdk.workspace.type.config; |
| |
| import java.math.BigDecimal; |
| import java.math.BigInteger; |
| import java.math.RoundingMode; |
| import java.text.DecimalFormat; |
| import java.text.ParseException; |
| import java.util.Locale; |
| import java.util.regex.Matcher; |
| import java.util.regex.Pattern; |
| |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.jdt.core.IField; |
| import org.eclipse.jdt.core.IMethod; |
| import org.eclipse.jdt.core.IType; |
| import org.eclipse.jdt.core.JavaModelException; |
| import org.eclipse.scout.commons.StringUtility; |
| import org.eclipse.scout.nls.sdk.model.INlsEntry; |
| import org.eclipse.scout.nls.sdk.model.workspace.project.INlsProject; |
| import org.eclipse.scout.sdk.Texts; |
| import org.eclipse.scout.sdk.internal.ScoutSdk; |
| import org.eclipse.scout.sdk.util.NoSourceException; |
| import org.eclipse.scout.sdk.util.ScoutUtility; |
| import org.eclipse.scout.sdk.util.jdt.JdtUtility; |
| import org.eclipse.scout.sdk.util.log.ScoutStatus; |
| import org.eclipse.scout.sdk.util.type.TypeUtility; |
| import org.eclipse.scout.sdk.util.typecache.ITypeHierarchy; |
| import org.eclipse.scout.sdk.workspace.type.ScoutTypeUtility; |
| |
| public final class PropertyMethodSourceUtility { |
| private static final Pattern REGEX_REFERENCED_VALUE = Pattern.compile("\\b(([A-Za-z][a-zA-Z0-9_]*\\.)*)?([A-Za-z][a-zA-Z0-9_]*)\\b"); |
| private static final Pattern REGEX_NUMBER_PREFIX = Pattern.compile("^(\\+|\\-)?([A-Za-z0-9_\\.]*)$"); |
| private static final Pattern REGEX_NUMBER_INFINITY = Pattern.compile("^(\\-)?(inf)$"); |
| private static final Pattern REGEX_SIMPLE_DOUBLE = Pattern.compile("^[\\+\\-0-9eE\\.']*[DdfF]?$"); |
| private static final Pattern REGEX_SIMPLE_INTEGER = Pattern.compile("^[\\+\\-0-9eE']*$"); |
| private static final Pattern REGEX_SIMPLE_BIG_INTEGER = Pattern.compile("^(new (java\\.math\\.)?BigInteger\\(\\\")?([\\+\\-0-9]*)(\\\"\\))?$"); |
| private static final Pattern REGEX_SIMPLE_BIG_DECIMAL = Pattern.compile("^(new (java\\.math\\.)?BigDecimal\\(\\\")?([\\+\\-0-9eE\\.]*)(\\\"\\))?$"); |
| private static final Pattern REGEX_SIMPLE_LONG = Pattern.compile("^[\\+\\-0-9eE']*[lL]?$"); |
| private static final Pattern REGEX_SIMPLE_BOOLEAN = Pattern.compile("^(false|true)$"); |
| private static final Pattern REGEX_FIELD_VALUE = Pattern.compile("=\\s*(.*)\\s*\\;", Pattern.DOTALL); |
| private static final Pattern REGEX_CLASS_REFERENCE = Pattern.compile("\\b(([A-Za-z][a-zA-Z0-9_]*\\.)*)?(class)\\b"); |
| private static final Pattern REGEX_NULL = Pattern.compile("\\bnull\\b"); |
| private static final Pattern REGEX_METHOD_RETURN_NON_NLS_TEXT = Pattern.compile("\\s*\"(.*)\"\\s*"); |
| private static final Pattern REGEX_METHOD_RETURN_NLS_TEXT = Pattern.compile("[A-Za-z0-9_-]*\\.get\\(\\s*\\\"([^\\\"]*)\\\"\\s*\\)\\s*"); |
| |
| private PropertyMethodSourceUtility() { |
| } |
| |
| public static class CustomImplementationException extends CoreException { |
| private static final long serialVersionUID = -2524492192516521856L; |
| |
| public CustomImplementationException() { |
| super(new ScoutStatus(Status.INFO, Texts.get("CustomImplementation"), null)); |
| } |
| } |
| |
| /** |
| * <xmp> |
| * String methodA(){ |
| * return "a string"; |
| * } // result: a string |
| * int methodB(){ |
| * return Integer.MAX_VALUE; |
| * } // result: Integer.MAX_VALUE; |
| * </xmp> |
| * |
| * @param method |
| * @return |
| * @throws CoreException |
| */ |
| public static String getMethodReturnValue(IMethod method) throws CoreException { |
| String methodReturnValue = ScoutUtility.getMethodReturnValue(method); |
| if (methodReturnValue != null) { |
| return methodReturnValue; |
| } |
| else { |
| ScoutSdk.logInfo("could not find return value of method: " + method.getElementName()); |
| throw new CustomImplementationException(); |
| } |
| } |
| |
| private static IMethod findMethodInHierarchy(IType type, String methodName) { |
| IMethod method = TypeUtility.getMethod(type, methodName); |
| if (TypeUtility.exists(method)) { |
| return method; |
| } |
| ITypeHierarchy superTypeHierarchy = TypeUtility.getSupertypeHierarchy(type); |
| IType declaringType = superTypeHierarchy.getSuperclass(type); |
| while (declaringType != null) { |
| method = TypeUtility.getMethod(declaringType, methodName); |
| if (TypeUtility.exists(method)) { |
| return method; |
| } |
| declaringType = superTypeHierarchy.getSuperclass(declaringType); |
| } |
| return null; |
| } |
| |
| /** |
| * @param type |
| * @param methodName |
| * @return simpleName (translatedName) |
| */ |
| public static String getTranslatedMethodStringValue(IType type, String methodName) { |
| String name = type.getElementName(); |
| if (StringUtility.hasText(methodName)) { |
| IMethod method = findMethodInHierarchy(type, methodName); |
| if (TypeUtility.exists(method)) { |
| String retValue = ScoutUtility.getMethodReturnValue(method); |
| if (StringUtility.hasText(retValue) && !"null".equals(retValue)) { |
| String nlsKey = null; |
| try { |
| nlsKey = PropertyMethodSourceUtility.parseReturnParameterNlsKey(retValue); |
| } |
| catch (CustomImplementationException e) { |
| // ignore |
| } |
| if (nlsKey == null) { |
| return name + " (" + retValue + ")"; |
| } |
| else { |
| INlsProject nlsProject = ScoutTypeUtility.findNlsProject(type); |
| if (nlsProject != null) { |
| INlsEntry entry = nlsProject.getEntry(nlsKey); |
| String translation = nlsKey; |
| if (entry != null) { |
| translation = entry.getTranslation(nlsProject.getDevelopmentLanguage(), true); |
| } |
| return name + " (" + translation + ")"; |
| } |
| } |
| } |
| } |
| } |
| |
| return name; |
| } |
| |
| /** |
| * <xmp> |
| * input: "AString" output: AString |
| * input: IConstants.A output: the value of A |
| * input: null output: null |
| * </xmp> |
| * |
| * @param parameter |
| * @param method |
| * @return |
| * @throws CoreException |
| */ |
| public static String parseReturnParameterString(String parameter, IMethod method, ITypeHierarchy superTypeHierarchy) throws CoreException { |
| if (REGEX_NULL.matcher(parameter).matches()) { |
| return null; |
| } |
| String val = JdtUtility.fromStringLiteral(parameter); |
| if (val != null) { |
| return val; |
| } |
| else { |
| String referencedValue = findReferencedValue(parameter, method, superTypeHierarchy); |
| if (referencedValue != null) { |
| val = JdtUtility.fromStringLiteral(referencedValue); |
| if (val != null) { |
| return val; |
| } |
| } |
| } |
| throw new CustomImplementationException(); |
| } |
| |
| /** |
| * <xmp> |
| * input: "AString" output: AString |
| * input: IConstants.A output: the value of A |
| * </xmp> |
| * |
| * @param parameter |
| * @param method |
| * @return |
| * @throws CoreException |
| */ |
| public static Double parseReturnParameterDouble(String parameter, IMethod method, ITypeHierarchy superTypeHierarchy) throws CoreException { |
| if (parameter == null || REGEX_NULL.matcher(parameter).matches() || "".equals(parameter)) { |
| return null; |
| } |
| if ("Double.MAX_VALUE".equals(parameter)) { |
| return Double.MAX_VALUE; |
| } |
| if ("-Double.MAX_VALUE".equals(parameter)) { |
| return -Double.MAX_VALUE; |
| } |
| Matcher infMatcher = REGEX_NUMBER_INFINITY.matcher(parameter); |
| if (infMatcher.find()) { |
| if (infMatcher.group(1) != null) { |
| return -Double.MAX_VALUE; |
| } |
| else { |
| return Double.MAX_VALUE; |
| } |
| } |
| if (REGEX_SIMPLE_DOUBLE.matcher(parameter).matches()) { |
| parameter = parameter.replace('e', 'E'); |
| parameter = parameter.replace("E+", "E"); |
| try { |
| return DecimalFormat.getInstance(Locale.ENGLISH).parse(parameter).doubleValue(); |
| } |
| catch (ParseException e) { |
| throw new CoreException(new ScoutStatus("Error parsing parameter '" + parameter + "' to a decimal.", e)); |
| } |
| } |
| String prefix = ""; |
| Matcher matcher = REGEX_NUMBER_PREFIX.matcher(parameter); |
| if (matcher.find()) { |
| if (matcher.group(1) != null) { |
| prefix = matcher.group(1); |
| } |
| parameter = matcher.group(2); |
| String referencedValue = findReferencedValue(parameter, method, superTypeHierarchy); |
| if (referencedValue != null) { |
| Double val = parseReturnParameterDouble(prefix + referencedValue, method, superTypeHierarchy); |
| if (val != null) { |
| return val; |
| } |
| } |
| } |
| throw new CustomImplementationException(); |
| } |
| |
| /** |
| * @param parameter |
| * @param method |
| * @return |
| * @throws CoreException |
| */ |
| public static Integer parseReturnParameterInteger(String parameter, IMethod method, ITypeHierarchy superTypeHierarchy) throws CoreException { |
| try { |
| return parseReturnParameterInteger(parameter); |
| } |
| catch (CoreException e) { |
| // void try to find referenced value |
| } |
| String prefix = ""; |
| Matcher matcher = REGEX_NUMBER_PREFIX.matcher(parameter); |
| if (matcher.find()) { |
| if (matcher.group(1) != null) { |
| prefix = matcher.group(1); |
| } |
| parameter = matcher.group(2); |
| String referencedValue = findReferencedValue(parameter, method, superTypeHierarchy); |
| if (referencedValue != null) { |
| referencedValue = referencedValue.replace('e', 'E'); |
| referencedValue = referencedValue.replace("E+", "E"); |
| try { |
| return DecimalFormat.getInstance(Locale.ENGLISH).parse(prefix + referencedValue).intValue(); |
| } |
| catch (ParseException e) { |
| throw new CoreException(new ScoutStatus("Error parsing parameter '" + prefix + referencedValue + "' to a decimal.", e)); |
| } |
| } |
| } |
| throw new CustomImplementationException(); |
| } |
| |
| public static Integer parseReturnParameterInteger(String parameter) throws CoreException { |
| if (parameter == null || REGEX_NULL.matcher(parameter).matches() || "".equals(parameter)) { |
| return null; |
| } |
| // handle MIN_VAL / MAX_VAL |
| if ("Integer.MAX_VALUE".equals(parameter)) { |
| return Integer.MAX_VALUE; |
| } |
| if ("Integer.MIN_VALUE".equals(parameter)) { |
| return Integer.MIN_VALUE; |
| } |
| Matcher infMatcher = REGEX_NUMBER_INFINITY.matcher(parameter); |
| if (infMatcher.find()) { |
| if (infMatcher.group(1) != null) { |
| return Integer.MIN_VALUE; |
| } |
| else { |
| return Integer.MAX_VALUE; |
| } |
| } |
| if (REGEX_SIMPLE_INTEGER.matcher(parameter).matches()) { |
| parameter = parameter.replace('e', 'E'); |
| parameter = parameter.replace("E+", "E"); |
| try { |
| return DecimalFormat.getIntegerInstance().parse(parameter).intValue(); |
| } |
| catch (ParseException e) { |
| throw new CoreException(new ScoutStatus("Error parsing parameter '" + parameter + "' to a decimal.", e)); |
| } |
| } |
| throw new CustomImplementationException(); |
| } |
| |
| /** |
| * @param parameter |
| * @param method |
| * @return |
| * @throws CoreException |
| */ |
| public static Long parseReturnParameterLong(String parameter, IMethod method, ITypeHierarchy superTypeHierarchy) throws CoreException { |
| try { |
| return parseReturnParameterLong(parameter); |
| } |
| catch (CoreException e) { |
| // void work on with referenced values |
| } |
| String prefix = ""; |
| Matcher matcher = REGEX_NUMBER_PREFIX.matcher(parameter); |
| if (matcher.find()) { |
| if (matcher.group(1) != null) { |
| prefix = matcher.group(1); |
| } |
| parameter = matcher.group(2); |
| String referencedValue = findReferencedValue(parameter, method, superTypeHierarchy); |
| if (referencedValue != null) { |
| referencedValue = referencedValue.replace('e', 'E'); |
| referencedValue = referencedValue.replace('x', 'X'); |
| referencedValue = referencedValue.replace("E+", "E"); |
| try { |
| return DecimalFormat.getNumberInstance(Locale.ENGLISH).parse(prefix + referencedValue).longValue(); |
| } |
| catch (ParseException e) { |
| throw new CoreException(new ScoutStatus("Error parsing parameter '" + prefix + referencedValue + "' to a decimal.", e)); |
| } |
| } |
| } |
| throw new CustomImplementationException(); |
| } |
| |
| /** |
| * parses the given return clause input string into a big decimal.<br> |
| * <br> |
| * Example:<br> |
| * Input: new BigDecimal("-999999999999999999999999999999999999999999999999999999999999.056978")<br> |
| * Output: -999999999999999999999999999999999999999999999999999999999999.056978<br> |
| * <br> |
| * Input: 2358.2357<br> |
| * Output: 2358.2357 |
| * |
| * @param parameter |
| * @return |
| * @throws CoreException |
| */ |
| public static BigDecimal parseReturnParameterBigDecimal(String parameter) throws CoreException { |
| if (parameter == null || REGEX_NULL.matcher(parameter).matches() || "".equals(parameter)) { |
| return null; |
| } |
| Matcher m = REGEX_SIMPLE_BIG_DECIMAL.matcher(parameter); |
| if (m.find()) { |
| return new BigDecimal(m.group(3)); |
| } |
| throw new CustomImplementationException(); |
| } |
| |
| /** |
| * parses the given return clause input string into the corresponding rounding mode enum value. |
| * |
| * @param parameter |
| * The return clause |
| * @return The bigdecimal value of the return clause. |
| * @throws CoreException |
| * In case the value could not be parsed. |
| */ |
| public static RoundingMode parseReturnParameterRoundingMode(String parameter) throws CoreException { |
| if (parameter == null || REGEX_NULL.matcher(parameter).matches() || "".equals(parameter)) { |
| return null; |
| } |
| if (parameter.startsWith(RoundingMode.class.getName()) && parameter.length() > RoundingMode.class.getName().length()) { |
| parameter = parameter.substring(RoundingMode.class.getName().length() + 1); |
| } |
| if (parameter.startsWith(RoundingMode.class.getSimpleName()) && parameter.length() > RoundingMode.class.getSimpleName().length()) { |
| parameter = parameter.substring(RoundingMode.class.getSimpleName().length() + 1); |
| } |
| RoundingMode mode = RoundingMode.valueOf(parameter); |
| if (mode != null) { |
| return mode; |
| } |
| throw new CustomImplementationException(); |
| } |
| |
| /** |
| * parses the given return clause input string into a big integer.<br> |
| * <br> |
| * Example:<br> |
| * Input: new BigInteger("-999999999999999999999999999999999999999999999999999999999999")<br> |
| * Output: -999999999999999999999999999999999999999999999999999999999999<br> |
| * <br> |
| * Input: 2358<br> |
| * Output: 2358 |
| * |
| * @param parameter |
| * @return |
| * @throws CoreException |
| */ |
| public static BigInteger parseReturnParameterBigInteger(String parameter) throws CoreException { |
| if (parameter == null || REGEX_NULL.matcher(parameter).matches() || "".equals(parameter)) { |
| return null; |
| } |
| Matcher m = REGEX_SIMPLE_BIG_INTEGER.matcher(parameter); |
| if (m.find()) { |
| return new BigInteger(m.group(3)); |
| } |
| throw new CustomImplementationException(); |
| } |
| |
| public static Long parseReturnParameterLong(String parameter) throws CoreException { |
| if (parameter == null || REGEX_NULL.matcher(parameter).matches() || "".equals(parameter)) { |
| return null; |
| } |
| // handle MIN_VAL / MAX_VAL |
| if ("Long.MAX_VALUE".equals(parameter)) { |
| return Long.MAX_VALUE; |
| } |
| // handle MIN_VAL / MAX_VAL |
| if ("Long.MIN_VALUE".equals(parameter)) { |
| return Long.MIN_VALUE; |
| } |
| Matcher infMatcher = REGEX_NUMBER_INFINITY.matcher(parameter); |
| if (infMatcher.find()) { |
| if (infMatcher.group(1) != null) { |
| return Long.MIN_VALUE; |
| } |
| else { |
| return Long.MAX_VALUE; |
| } |
| } |
| if (REGEX_SIMPLE_LONG.matcher(parameter).matches()) { |
| parameter = parameter.replace('e', 'E'); |
| parameter = parameter.replace("E+", "E"); |
| try { |
| return DecimalFormat.getNumberInstance(Locale.ENGLISH).parse(parameter).longValue(); |
| } |
| catch (ParseException e) { |
| throw new CoreException(new ScoutStatus("Error parsing parameter '" + parameter + "' to a decimal.", e)); |
| } |
| } |
| throw new CustomImplementationException(); |
| } |
| |
| public static boolean parseReturnParameterBoolean(String parameter, IMethod method, ITypeHierarchy superTypeHierarchy) throws CoreException { |
| if (REGEX_SIMPLE_BOOLEAN.matcher(parameter).matches()) { |
| return Boolean.parseBoolean(parameter); |
| } |
| Matcher matcher = REGEX_NUMBER_PREFIX.matcher(parameter); |
| if (matcher.find()) { |
| parameter = matcher.group(2); |
| String referencedValue = findReferencedValue(parameter, method, superTypeHierarchy); |
| if (referencedValue != null) { |
| return Boolean.parseBoolean(referencedValue); |
| } |
| } |
| throw new CustomImplementationException(); |
| } |
| |
| /** |
| * @param input |
| * @param method |
| * @return |
| * @throws CoreException |
| */ |
| public static IType parseReturnParameterClass(String parameter, IMethod method) throws CoreException { |
| if (REGEX_NULL.matcher(parameter).matches()) { |
| return null; |
| } |
| Matcher matcher = REGEX_CLASS_REFERENCE.matcher(parameter); |
| if (matcher.find()) { |
| String className = matcher.group(1); |
| className = className.substring(0, className.length() - 1); |
| IType referencedType = TypeUtility.getReferencedType(method.getDeclaringType(), className, true); |
| if (referencedType == null) { |
| ScoutSdk.logWarning("referenced type could not be found '" + method.getElementName() + "' in class '" + method.getDeclaringType().getFullyQualifiedName() + "'"); |
| throw new CoreException(new ScoutStatus(Status.WARNING, "Referenced type '" + parameter + "' could not be found.", null)); |
| } |
| return referencedType; |
| } |
| throw new CustomImplementationException(); |
| } |
| |
| private static String findReferencedValue(String parameter, IMethod method, ITypeHierarchy superTypeHierarchy) throws CoreException { |
| Matcher matcher = REGEX_REFERENCED_VALUE.matcher(parameter); |
| if (matcher.find()) { |
| IType referencedType = null; |
| if (matcher.group(2) != null) { |
| String typeName = matcher.group(1); |
| typeName = typeName.substring(0, typeName.length() - 1); |
| referencedType = TypeUtility.getReferencedType(method.getDeclaringType(), typeName, true); |
| if (!TypeUtility.exists(referencedType)) { |
| throw new CoreException(new ScoutStatus(Status.WARNING, "Reference '" + parameter + "' could not be found.", null)); |
| } |
| } |
| else { |
| referencedType = method.getDeclaringType(); |
| } |
| return findReferencedFieldValue(referencedType, matcher.group(3), superTypeHierarchy); |
| } |
| throw new CustomImplementationException(); |
| } |
| |
| private static String findReferencedFieldValue(IType type, String value, ITypeHierarchy superTypeHierarchy) throws JavaModelException { |
| String retVal = findFieldValueInDeclaringHierarchy(type, value); |
| if (retVal == null) { |
| retVal = findFieldValueInHierarchy(type, value, superTypeHierarchy); |
| } |
| return retVal; |
| } |
| |
| public static String getFieldValue(IField field) throws JavaModelException { |
| String source = field.getSource(); |
| if (source == null) { |
| throw new NoSourceException(field.getDeclaringType().getElementName()); |
| } |
| Matcher matcher = REGEX_FIELD_VALUE.matcher(ScoutUtility.removeComments(source)); |
| if (matcher.find()) { |
| return matcher.group(1); |
| } |
| return null; |
| } |
| |
| public static String findFieldValueInHierarchy(IType type, String name, ITypeHierarchy superTypeHierarchy) throws JavaModelException { |
| if (!TypeUtility.exists(type)) { |
| return null; |
| } |
| IField field = type.getField(name); |
| if (TypeUtility.exists(field)) { |
| String val = getFieldValue(field); |
| if (val != null) { |
| return val; |
| } |
| } |
| String value = null; |
| for (IType supertype : superTypeHierarchy.getSupertypes(type)) { |
| value = findFieldValueInHierarchy(supertype, name, superTypeHierarchy); |
| if (value != null) { |
| return value; |
| } |
| } |
| return null; |
| } |
| |
| private static String findFieldValueInDeclaringHierarchy(IType type, String value) throws JavaModelException { |
| if (!TypeUtility.exists(type)) { |
| return null; |
| } |
| IField field = type.getField(value); |
| if (!TypeUtility.exists(field)) { |
| return findFieldValueInDeclaringHierarchy(type.getDeclaringType(), value); |
| } |
| else { |
| Matcher matcher = REGEX_FIELD_VALUE.matcher(ScoutUtility.removeComments(field.getSource())); |
| if (matcher.find()) { |
| return matcher.group(1); |
| } |
| } |
| return null; |
| } |
| |
| public static String parseReturnParameterIcon(String input, IMethod method) throws CoreException { |
| if ("null".equals(input)) { |
| return ""; |
| } |
| Matcher matcher = REGEX_REFERENCED_VALUE.matcher(input); |
| if (matcher.find()) { |
| if (matcher.group(2) != null) { |
| String typeName = matcher.group(1); |
| String fieldName = matcher.group(3); |
| typeName = typeName.substring(0, typeName.length() - 1); |
| IType iconsType = TypeUtility.getReferencedType(method.getDeclaringType(), typeName, true); |
| if (TypeUtility.exists(iconsType)) { |
| ITypeHierarchy iconsSuperTypeHierarchy = TypeUtility.getSupertypeHierarchy(iconsType); |
| while (TypeUtility.exists(iconsType)) { |
| IField field = iconsType.getField(fieldName); |
| if (TypeUtility.exists(field)) { |
| Object val = TypeUtility.getFieldConstant(field); |
| if (val instanceof String) { |
| return val.toString(); |
| } |
| } |
| iconsType = iconsSuperTypeHierarchy.getSuperclass(iconsType); |
| } |
| } |
| } |
| } |
| throw new CustomImplementationException(); |
| } |
| |
| /** |
| * Tries to find a NLS key in the input string.<br> |
| * <br> |
| * <code> |
| * Input: "" or null<br> |
| * Output: null<br><br> |
| * Input "abc"<br> |
| * Output: null<br><br> |
| * Input: Texts.get("abc")<br> |
| * Output: abc<br><br> |
| * Input: TEXTS.get("abc")<br> |
| * Output: abc |
| * </code> |
| * |
| * @param input |
| * The String to parse. |
| * @return |
| * @throws CustomImplementationException |
| * When the content could not be parsed. |
| */ |
| public static String parseReturnParameterNlsKey(String input) throws CustomImplementationException { |
| if (input == null || "null".equals(input.trim())) { |
| return null; |
| } |
| Matcher m = REGEX_METHOD_RETURN_NON_NLS_TEXT.matcher(input); |
| if (m.matches()) { |
| return null; |
| } |
| m = REGEX_METHOD_RETURN_NLS_TEXT.matcher(input); |
| if (m.matches()) { |
| String key = m.group(1); |
| return key; |
| } |
| throw new CustomImplementationException(); |
| } |
| } |
