/** * Apply the specified changes on the given type. * This method can be used as a dry run without modifying an annotation file. * * @param originalSignature the original type signature, may be annotated already * @param annotatedType a type signature with additional annotations (incl. {@link #NO_ANNOTATION}). * @param mergeStrategy controls how old and new signatures should be merged * @return an array of length four: <ul> * <li>prefix up-to the changed type</li> * <li>original type</li> * <li>changed type</li> * <li>postfix after the changed type <em>(here: empty string)</li> * </ul> */ public static String[] annotateType(String originalSignature, String annotatedType, MergeStrategy mergeStrategy) { String[] result = new String[4]; // prefix, orig, replacement, postfix StringBuffer buf; result[0] = ""; //$NON-NLS-1$ buf = new StringBuffer(); result[1] = originalSignature; updateType(buf, originalSignature.toCharArray(), annotatedType.toCharArray(), mergeStrategy); result[2] = buf.toString(); result[3] = ""; //$NON-NLS-1$ return result; }
/** * Apply the specified changes on the given type. * This method can be used as a dry run without modifying an annotation file. * * @param originalSignature the original type signature, may be annotated already * @param annotatedType a type signature with additional annotations (incl. {@link #NO_ANNOTATION}). * @param mergeStrategy controls how old and new signatures should be merged * @return an array of length four: <ul> * <li>prefix up-to the changed type</li> * <li>original type</li> * <li>changed type</li> * <li>postfix after the changed type <em>(here: empty string)</li> * </ul> */ public static String[] annotateType(String originalSignature, String annotatedType, MergeStrategy mergeStrategy) { String[] result = new String[4]; // prefix, orig, replacement, postfix StringBuffer buf; result[0] = ""; //$NON-NLS-1$ buf = new StringBuffer(); result[1] = originalSignature; updateType(buf, originalSignature.toCharArray(), annotatedType.toCharArray(), mergeStrategy); result[2] = buf.toString(); result[3] = ""; //$NON-NLS-1$ return result; }
/** * Apply the specified changes on the given type. * This method can be used as a dry run without modifying an annotation file. * * @param originalSignature the original type signature, may be annotated already * @param annotatedType a type signature with additional annotations (incl. {@link #NO_ANNOTATION}). * @param mergeStrategy controls how old and new signatures should be merged * @return an array of length four: <ul> * <li>prefix up-to the changed type</li> * <li>original type</li> * <li>changed type</li> * <li>postfix after the changed type <em>(here: empty string)</li> * </ul> */ public static String[] annotateType(String originalSignature, String annotatedType, MergeStrategy mergeStrategy) { String[] result = new String[4]; // prefix, orig, replacement, postfix StringBuffer buf; result[0] = ""; //$NON-NLS-1$ buf = new StringBuffer(); result[1] = originalSignature; updateType(buf, originalSignature.toCharArray(), annotatedType.toCharArray(), mergeStrategy); result[2] = buf.toString(); result[3] = ""; //$NON-NLS-1$ return result; }
/** * Apply the specified changes on the return type of the given signature. * This method can be used as a dry run without modifying an annotation file. * * @param originalSignature the original full signature, may be annotated already * @param annotatedType a type signature with additional annotations (incl. {@link #NO_ANNOTATION}). * @param mergeStrategy controls how old and new signatures should be merged * @return an array of length four: <ul> * <li>prefix up-to the changed type</li> * <li>original type</li> * <li>changed type</li> * <li>postfix after the changed type <em>(here: empty string)</li> * </ul> */ public static String[] annotateReturnType(String originalSignature, String annotatedType, MergeStrategy mergeStrategy) { String[] result = new String[4]; // prefix, orig, replacement, postfix StringBuffer buf; assert originalSignature.charAt(0) == '(' || originalSignature.charAt(0) == '<': "signature must start with '(' or '<'"; //$NON-NLS-1$ int close = originalSignature.indexOf(')'); result[0] = originalSignature.substring(0, close+1); buf = new StringBuffer(); result[1] = originalSignature.substring(close+1); updateType(buf, result[1].toCharArray(), annotatedType.toCharArray(), mergeStrategy); result[2] = buf.toString(); result[3] = ""; //$NON-NLS-1$ return result; }
/** * Apply the specified changes on the return type of the given signature. * This method can be used as a dry run without modifying an annotation file. * * @param originalSignature the original full signature, may be annotated already * @param annotatedType a type signature with additional annotations (incl. {@link #NO_ANNOTATION}). * @param mergeStrategy controls how old and new signatures should be merged * @return an array of length four: <ul> * <li>prefix up-to the changed type</li> * <li>original type</li> * <li>changed type</li> * <li>postfix after the changed type <em>(here: empty string)</li> * </ul> */ public static String[] annotateReturnType(String originalSignature, String annotatedType, MergeStrategy mergeStrategy) { String[] result = new String[4]; // prefix, orig, replacement, postfix StringBuffer buf; assert originalSignature.charAt(0) == '(' || originalSignature.charAt(0) == '<': "signature must start with '(' or '<'"; //$NON-NLS-1$ int close = originalSignature.indexOf(')'); result[0] = originalSignature.substring(0, close+1); buf = new StringBuffer(); result[1] = originalSignature.substring(close+1); updateType(buf, result[1].toCharArray(), annotatedType.toCharArray(), mergeStrategy); result[2] = buf.toString(); result[3] = ""; //$NON-NLS-1$ return result; }
/** * Apply the specified changes on the return type of the given signature. * This method can be used as a dry run without modifying an annotation file. * * @param originalSignature the original full signature, may be annotated already * @param annotatedType a type signature with additional annotations (incl. {@link #NO_ANNOTATION}). * @param mergeStrategy controls how old and new signatures should be merged * @return an array of length four: <ul> * <li>prefix up-to the changed type</li> * <li>original type</li> * <li>changed type</li> * <li>postfix after the changed type <em>(here: empty string)</li> * </ul> */ public static String[] annotateReturnType(String originalSignature, String annotatedType, MergeStrategy mergeStrategy) { String[] result = new String[4]; // prefix, orig, replacement, postfix StringBuffer buf; assert originalSignature.charAt(0) == '(' || originalSignature.charAt(0) == '<': "signature must start with '(' or '<'"; //$NON-NLS-1$ int close = originalSignature.indexOf(')'); result[0] = originalSignature.substring(0, close+1); buf = new StringBuffer(); result[1] = originalSignature.substring(close+1); updateType(buf, result[1].toCharArray(), annotatedType.toCharArray(), mergeStrategy); result[2] = buf.toString(); result[3] = ""; //$NON-NLS-1$ return result; }
private static String updateSignature(String originalSignature, String annotatedSignature, int updatePosition, MergeStrategy mergeStrategy) { StringBuffer buf = new StringBuffer(); String signatureToReplace; String postfix = null; switch (updatePosition) { case POSITION_FULL_SIGNATURE: signatureToReplace = originalSignature; break; case POSITION_RETURN_TYPE: assert originalSignature.charAt(0) == '(' || originalSignature.charAt(0) == '<': "signature must start with '(' or '<'"; //$NON-NLS-1$ int close = originalSignature.indexOf(')'); buf.append(originalSignature, 0, close+1); signatureToReplace = originalSignature.substring(close+1); break; default: // parameter SignatureWrapper wrapper = new SignatureWrapper(originalSignature.toCharArray(), true, true); // may already contain annotations wrapper.start = CharOperation.indexOf('(', wrapper.signature) + 1; // possibly skipping type parameters for (int i = 0; i < updatePosition; i++) wrapper.start = wrapper.skipAngleContents(wrapper.computeEnd()) + 1; int start = wrapper.start; int end = wrapper.skipAngleContents(wrapper.computeEnd()); buf.append(originalSignature, 0, start); signatureToReplace = originalSignature.substring(start, end+1); postfix = originalSignature.substring(end+1, originalSignature.length()); } updateType(buf, signatureToReplace.toCharArray(), annotatedSignature.toCharArray(), mergeStrategy); if (postfix != null) buf.append(postfix); return buf.toString(); }
private static String updateSignature(String originalSignature, String annotatedSignature, int updatePosition, MergeStrategy mergeStrategy) { StringBuffer buf = new StringBuffer(); String signatureToReplace; String postfix = null; switch (updatePosition) { case POSITION_FULL_SIGNATURE: signatureToReplace = originalSignature; break; case POSITION_RETURN_TYPE: assert originalSignature.charAt(0) == '(' || originalSignature.charAt(0) == '<': "signature must start with '(' or '<'"; //$NON-NLS-1$ int close = originalSignature.indexOf(')'); buf.append(originalSignature, 0, close+1); signatureToReplace = originalSignature.substring(close+1); break; default: // parameter SignatureWrapper wrapper = new SignatureWrapper(originalSignature.toCharArray(), true, true); // may already contain annotations wrapper.start = CharOperation.indexOf('(', wrapper.signature) + 1; // possibly skipping type parameters for (int i = 0; i < updatePosition; i++) wrapper.start = wrapper.skipAngleContents(wrapper.computeEnd()) + 1; int start = wrapper.start; int end = wrapper.skipAngleContents(wrapper.computeEnd()); buf.append(originalSignature, 0, start); signatureToReplace = originalSignature.substring(start, end+1); postfix = originalSignature.substring(end+1, originalSignature.length()); } updateType(buf, signatureToReplace.toCharArray(), annotatedSignature.toCharArray(), mergeStrategy); if (postfix != null) buf.append(postfix); return buf.toString(); }
private static String updateSignature(String originalSignature, String annotatedSignature, int updatePosition, MergeStrategy mergeStrategy) { StringBuffer buf = new StringBuffer(); String signatureToReplace; String postfix = null; switch (updatePosition) { case POSITION_FULL_SIGNATURE: signatureToReplace = originalSignature; break; case POSITION_RETURN_TYPE: assert originalSignature.charAt(0) == '(' || originalSignature.charAt(0) == '<': "signature must start with '(' or '<'"; //$NON-NLS-1$ int close = originalSignature.indexOf(')'); buf.append(originalSignature, 0, close+1); signatureToReplace = originalSignature.substring(close+1); break; default: // parameter SignatureWrapper wrapper = new SignatureWrapper(originalSignature.toCharArray(), true, true); // may already contain annotations wrapper.start = CharOperation.indexOf('(', wrapper.signature) + 1; // possibly skipping type parameters for (int i = 0; i < updatePosition; i++) wrapper.start = wrapper.skipAngleContents(wrapper.computeEnd()) + 1; int start = wrapper.start; int end = wrapper.skipAngleContents(wrapper.computeEnd()); buf.append(originalSignature, 0, start); signatureToReplace = originalSignature.substring(start, end+1); postfix = originalSignature.substring(end+1, originalSignature.length()); } updateType(buf, signatureToReplace.toCharArray(), annotatedSignature.toCharArray(), mergeStrategy); if (postfix != null) buf.append(postfix); return buf.toString(); }
buf = new StringBuffer(); result[1] = originalSignature.substring(start, end+1); updateType(buf, result[1].toCharArray(), annotatedType.toCharArray(), mergeStrategy); result[2] = buf.toString(); result[3] = originalSignature.substring(end+1, originalSignature.length());
buf = new StringBuffer(); result[1] = originalSignature.substring(start, end+1); updateType(buf, result[1].toCharArray(), annotatedType.toCharArray(), mergeStrategy); result[2] = buf.toString(); result[3] = originalSignature.substring(end+1, originalSignature.length());
buf = new StringBuffer(); result[1] = originalSignature.substring(start, end+1); updateType(buf, result[1].toCharArray(), annotatedType.toCharArray(), mergeStrategy); result[2] = buf.toString(); result[3] = originalSignature.substring(end+1, originalSignature.length());
oWrap.computeEnd(); nWrap.computeEnd(); if (updateType(buf, oWrap.getFrom(oStart), nWrap.getFrom(nStart), mergeStrategy)) mergeAnnotation(buf, oWrap, nWrap, mergeStrategy); } while (!match(buf, oWrap, nWrap, '>', false)); } else if (match(buf, oWrap, nWrap, '[', false)) { mergeAnnotation(buf, oWrap, nWrap, mergeStrategy); updateType(buf, oWrap.tail(), nWrap.tail(), mergeStrategy); } else if (match(buf, oWrap, nWrap, '*', false) || match(buf, oWrap, nWrap, '+', false)
oWrap.computeEnd(); nWrap.computeEnd(); if (updateType(buf, oWrap.getFrom(oStart), nWrap.getFrom(nStart), mergeStrategy)) mergeAnnotation(buf, oWrap, nWrap, mergeStrategy); } while (!match(buf, oWrap, nWrap, '>', false)); } else if (match(buf, oWrap, nWrap, '[', false)) { mergeAnnotation(buf, oWrap, nWrap, mergeStrategy); updateType(buf, oWrap.tail(), nWrap.tail(), mergeStrategy); } else if (match(buf, oWrap, nWrap, '*', false) || match(buf, oWrap, nWrap, '+', false)
oWrap.computeEnd(); nWrap.computeEnd(); if (updateType(buf, oWrap.getFrom(oStart), nWrap.getFrom(nStart), mergeStrategy)) mergeAnnotation(buf, oWrap, nWrap, mergeStrategy); } while (!match(buf, oWrap, nWrap, '>', false)); } else if (match(buf, oWrap, nWrap, '[', false)) { mergeAnnotation(buf, oWrap, nWrap, mergeStrategy); updateType(buf, oWrap.tail(), nWrap.tail(), mergeStrategy); } else if (match(buf, oWrap, nWrap, '*', false) || match(buf, oWrap, nWrap, '+', false)