private void _addReturnElement(Element methodElement, JavaMethod javaMethod) throws Exception {
Type returns = javaMethod.getReturns();
if (returns == null) {
return;
}
String returnsValue = returns.getValue();
if (returnsValue.equals("void")) {
return;
}
Element returnElement = methodElement.addElement("return");
DocletTag[] returnDocletTags = javaMethod.getTagsByName("return");
String comment = StringPool.BLANK;
if (returnDocletTags.length > 0) {
DocletTag returnDocletTag = returnDocletTags[0];
comment = GetterUtil.getString(returnDocletTag.getValue());
DocUtil.add(returnElement, "required", true);
}
comment = _trimMultilineText(comment);
Element commentElement = returnElement.addElement("comment");
commentElement.addCDATA(comment);
}
private void _addThrowsElement(
Element methodElement, Type exception, DocletTag[] throwsDocletTags) {
String name = exception.getJavaClass().getName();
String value = null;
for (DocletTag throwsDocletTag : throwsDocletTags) {
String curValue = throwsDocletTag.getValue();
if (!curValue.startsWith(name)) {
continue;
} else {
curValue = value;
break;
}
}
Element throwsElement = methodElement.addElement("throws");
DocUtil.add(throwsElement, "name", name);
DocUtil.add(throwsElement, "type", exception.getValue());
if (value != null) {
value = value.substring(name.length());
}
Element commentElement = throwsElement.addElement("comment");
commentElement.addCDATA(_getCDATA(value));
}
private void _addReturnElement(Element methodElement, JavaMethod javaMethod) {
Type returns = javaMethod.getReturns();
if ((returns == null) || returns.getValue().equals("void")) {
return;
}
_addDocletElements(methodElement, javaMethod, "return");
}
private String _getTypeValue(JavaParameter javaParameter) {
Type type = javaParameter.getType();
String typeValue = type.getValue();
if (type.isArray()) {
typeValue += "[]";
}
return typeValue;
}
private void _copyInterface(String parentDir, String srcFile) throws IOException {
JavaClass javaClass = _getJavaClass(parentDir, srcFile);
JavaMethod[] methods = javaClass.getMethods();
Arrays.sort(methods, new JavaMethodComparator());
StringMaker sm = new StringMaker();
// Package
sm.append("package " + javaClass.getPackage() + ";");
// Imports
sm.append("[$IMPORTS$]");
// Class declaration
sm.append(
"public class Copy" + javaClass.getName() + " implements " + javaClass.getName() + " {");
String varName = "_" + TextFormatter.format(javaClass.getName(), TextFormatter.I);
// Methods
Set imports = new TreeSet();
for (int i = 0; i < methods.length; i++) {
JavaMethod javaMethod = methods[i];
String methodName = javaMethod.getName();
if (javaMethod.isPublic()) {
String returnValueName = javaMethod.getReturns().getValue();
imports.add(returnValueName);
sm.append(
"public "
+ javaMethod.getReturns().getJavaClass().getName()
+ _getDimensions(javaMethod.getReturns())
+ " "
+ methodName
+ "(");
JavaParameter[] parameters = javaMethod.getParameters();
for (int j = 0; j < parameters.length; j++) {
JavaParameter javaParameter = parameters[j];
sm.append(
javaParameter.getType().getJavaClass().getName()
+ _getDimensions(javaParameter.getType())
+ " "
+ javaParameter.getName());
imports.add(javaParameter.getType().getValue());
if ((j + 1) != parameters.length) {
sm.append(", ");
}
}
sm.append(")");
Type[] thrownExceptions = javaMethod.getExceptions();
Set newExceptions = new LinkedHashSet();
for (int j = 0; j < thrownExceptions.length; j++) {
Type thrownException = thrownExceptions[j];
newExceptions.add(thrownException.getJavaClass().getName());
imports.add(thrownException.getValue());
}
if (newExceptions.size() > 0) {
sm.append(" throws ");
Iterator itr = newExceptions.iterator();
while (itr.hasNext()) {
sm.append(itr.next());
if (itr.hasNext()) {
sm.append(", ");
}
}
}
sm.append("{");
if (!returnValueName.equals("void")) {
sm.append("return ");
}
sm.append(varName + "." + methodName + "(");
for (int j = 0; j < parameters.length; j++) {
JavaParameter javaParameter = parameters[j];
sm.append(javaParameter.getName());
if ((j + 1) != parameters.length) {
sm.append(", ");
}
}
sm.append(");");
sm.append("}");
}
}
// Fields
sm.append("private " + javaClass.getName() + " " + varName + ";");
// Class close brace
sm.append("}");
// Imports
String content = sm.toString();
sm = new StringMaker();
Iterator itr = imports.iterator();
while (itr.hasNext()) {
String importClass = (String) itr.next();
if (!importClass.equals("boolean")
&& !importClass.equals("double")
&& !importClass.equals("int")
&& !importClass.equals("long")
&& !importClass.equals("short")
&& !importClass.equals("void")) {
sm.append("import " + importClass + ";");
}
}
content = StringUtil.replace(content, "[$IMPORTS$]", sm.toString());
// Write file
File file =
new File(
parentDir
+ "/"
+ StringUtil.replace(javaClass.getPackage(), ".", "/")
+ "/Copy"
+ javaClass.getName()
+ ".java");
ServiceBuilder.writeFile(file, content);
}
private boolean _isOverrideMethod(
JavaClass javaClass, JavaMethod javaMethod, Collection<Tuple> ancestorJavaClassTuples) {
if (javaMethod.isConstructor() || javaMethod.isPrivate() || javaMethod.isStatic()) {
return false;
}
String methodName = javaMethod.getName();
JavaParameter[] javaParameters = javaMethod.getParameters();
Type[] types = new Type[javaParameters.length];
for (int i = 0; i < javaParameters.length; i++) {
types[i] = javaParameters[i].getType();
}
// Check for matching method in each ancestor
for (Tuple ancestorJavaClassTuple : ancestorJavaClassTuples) {
JavaClass ancestorJavaClass = (JavaClass) ancestorJavaClassTuple.getObject(0);
JavaMethod ancestorJavaMethod = null;
if (ancestorJavaClassTuple.getSize() > 1) {
// LPS-35613
Type[] ancestorActualTypeArguments = (Type[]) ancestorJavaClassTuple.getObject(1);
Type[] genericTypes = new Type[types.length];
for (int i = 0; i < types.length; i++) {
Type type = types[i];
String typeValue = type.getValue();
boolean useGenericType = false;
for (int j = 0; j < ancestorActualTypeArguments.length; j++) {
if (typeValue.equals(ancestorActualTypeArguments[j].getValue())) {
useGenericType = true;
break;
}
}
if (useGenericType) {
genericTypes[i] = new Type("java.lang.Object");
} else {
genericTypes[i] = type;
}
}
ancestorJavaMethod = ancestorJavaClass.getMethodBySignature(methodName, genericTypes);
} else {
ancestorJavaMethod = ancestorJavaClass.getMethodBySignature(methodName, types);
}
if (ancestorJavaMethod == null) {
continue;
}
boolean samePackage = false;
JavaPackage ancestorJavaPackage = ancestorJavaClass.getPackage();
if (ancestorJavaPackage != null) {
samePackage = ancestorJavaPackage.equals(javaClass.getPackage());
}
// Check if the method is in scope
if (samePackage) {
return !ancestorJavaMethod.isPrivate();
} else {
if (ancestorJavaMethod.isProtected() || ancestorJavaMethod.isPublic()) {
return true;
} else {
return false;
}
}
}
return false;
}