private boolean nameMatches(String n, ElementDefn e, boolean throughChoice) {
if (e.getName().equals(n)) return true;
else if (!throughChoice || !e.getName().endsWith("[x]")) return false;
else {
String b = e.getName().substring(0, e.getName().indexOf("["));
if (!n.startsWith(b)) return false;
String tn = n.substring(b.length());
for (TypeRef t : e.getTypes()) if (t.getName().equalsIgnoreCase(tn)) return true;
return false;
}
}
@Override
public String getDefaultKW(TypeRef<?> ref, Object value) {
if (Boolean.class.isAssignableFrom(ref.getJavaClass())
|| boolean.class.isAssignableFrom(ref.getJavaClass())) {
if ((Boolean) value) {
return "b'1'";
} else {
return "b'0'";
}
}
return super.getDefaultKW(ref, value);
}
public StringBuilder getQualifiedName(StringBuilder b, boolean generic) {
if (getEnclosingType() instanceof ClassRef) {
getEnclosingType().getQualifiedName(b, generic).append('$');
} else if (getEnclosingType() instanceof NamespaceRef) {
getEnclosingType().getQualifiedName(b, generic).append('.');
}
b.append(ident.simpleName);
if (generic && ident.templateArguments != null) {
int args = 0;
for (int i = 0, n = ident.templateArguments.length; i < n; i++) {
TemplateArg arg = ident.templateArguments[i];
if (!(arg instanceof TypeRef)) {
continue;
}
if (args == 0) {
b.append('<');
} else {
b.append(", ");
}
((TypeRef) arg).getQualifiedName(b, generic);
args++;
}
if (args > 0) {
b.append('>');
}
}
return b;
}
private boolean matchesArgs(Type[] parameterTypes, Annotation[][] anns, int offset) {
int totalArgs = offset;
for (int i = 0, n = templateArguments == null ? 0 : templateArguments.length; i < n; i++) {
if (totalArgs >= parameterTypes.length) {
return false;
}
Type paramType = parameterTypes[offset + i];
TemplateArg arg = templateArguments[i];
if (arg instanceof TypeRef) {
if (!paramType.equals(Class.class)) {
return false;
}
} else if (arg instanceof Constant) {
try {
getTypeClass(paramType).cast(((Constant) arg).value);
} catch (ClassCastException ex) {
return false;
}
}
totalArgs++;
}
for (int i = 0, n = paramTypes == null ? 0 : paramTypes.length; i < n; i++) {
if (totalArgs >= parameterTypes.length) {
return false;
}
TypeRef paramType = paramTypes[i];
Type parameterType = parameterTypes[totalArgs];
if (!paramType.matches(parameterType, annotations(anns == null ? null : anns[i]))) {
return false;
}
totalArgs++;
}
if (totalArgs != parameterTypes.length) {
BridJ.error("Not enough args for " + this);
return false;
}
return true;
}
public boolean matchesEnclosingType(Method method) {
TypeRef et = getEnclosingType();
if (et == null) {
return true;
}
Annotations annotations = annotations(method);
Class dc = method.getDeclaringClass();
do {
if (et.matches(dc, annotations)) {
return true;
}
dc = dc.getSuperclass();
} while (dc != null && dc != Object.class);
return false;
}
protected void collectParamComments(Function f) {
for (Arg arg : f.getArgs()) {
arg.moveAllCommentsBefore();
TypeRef argType = arg.getValueType();
if (argType != null) {
if (!result.config.noComments) {
argType.moveAllCommentsBefore();
arg.addToCommentBefore(argType.getCommentBefore());
}
argType.stripDetails();
}
if (arg.getCommentBefore() != null) {
if (!result.config.noComments)
f.addToCommentBefore(
"@param " + arg.getName() + " " + Element.cleanComment(arg.getCommentBefore()));
arg.stripDetails();
}
}
}
private boolean nameMatches(
String n, ElementDefn e, boolean throughChoice, Definitions definitions) {
if (e.getName().equals(n)) return true;
else if (!throughChoice || !e.getName().endsWith("[x]")) return false;
else {
String b = e.getName().substring(0, e.getName().indexOf("["));
if (!n.startsWith(b)) return false;
String tn = n.substring(b.length());
if (e.typeCode().equals("*") && definitions != null) {
for (TypeRef t : definitions.getKnownTypes()) {
if (!definitions.getInfrastructure().containsKey(t.getName())
&& !definitions.getConstraints().containsKey(t.getName())) {
if (t.getName().equalsIgnoreCase(tn)) return true;
}
}
} else for (TypeRef t : e.getTypes()) if (t.getName().equalsIgnoreCase(tn)) return true;
return false;
}
}
public String typeCode() {
StringBuilder tn = new StringBuilder();
boolean first = true;
for (TypeRef t : types) {
if (!first) tn.append("|");
first = false;
tn.append(t.getName());
if (t.hasParams()) {
tn.append("(");
boolean f = true;
for (String s : t.getParams()) {
if (!f) tn.append("|");
f = false;
tn.append(s);
}
tn.append(")");
}
}
return tn.toString();
}
protected TypeRef asTypeRef(MethodDescriptor.Type type) {
if (type instanceof MethodDescriptor.Wildcard) {
MethodDescriptor.Wildcard wildcard = (MethodDescriptor.Wildcard) type;
if (wildcard.isExtends()) {
return Wildcard(Wildcard.Bound.EXTENDS, Type(wildcard.parameters[0].type));
} else if (wildcard.isSuper()) {
return Wildcard(Wildcard.Bound.SUPER, Type(wildcard.parameters[0].type));
} else {
return Wildcard();
}
}
TypeRef typeRef = Type(type.type);
if (type.parameters.length > 0) {
List<TypeRef> types = new ArrayList<>();
for (int i = 0; i < type.parameters.length; i++) {
types.add(asTypeRef(type.parameters[i]));
}
typeRef.withTypeArguments(types);
}
if (type.dimensions > 0) typeRef.withDimensions(type.dimensions);
return typeRef;
}
public boolean hasStatedProfile() {
if (types.isEmpty()) return false;
else for (TypeRef t : types) if (t.getProfile() != null) return true;
return false;
}
public boolean usesType(String name) {
for (TypeRef t : getTypes()) {
if (t.summary().equals(name)) return true;
}
return false;
}
public boolean hasType(String name) {
for (TypeRef t : types) {
if (t.getName().equals(name)) return true;
}
return false;
}
