/** Returns <code>true</code> if the rhs array type can be assigned to the lhs array type. */ private static boolean areArraysAssignable(JArrayType lhsType, JArrayType rhsType) { // areClassTypesAssignable should prevent us from getting here if the types // are referentially equal. assert (lhsType != rhsType); JType lhsComponentType = lhsType.getComponentType(); JType rhsComponentType = rhsType.getComponentType(); if (lhsComponentType.isPrimitive() != null || rhsComponentType.isPrimitive() != null) { /* * Arrays are referentially stable so there will only be one int[] no * matter how many times it is referenced in the code. So, if either * component type is a primitive then we know that we are not assignable. */ return false; } assert (lhsComponentType instanceof JClassType); assert (rhsComponentType instanceof JClassType); JClassType thisComponentClass = (JClassType) lhsComponentType; JClassType subtypeComponentClass = (JClassType) rhsComponentType; return areClassTypesAssignable(thisComponentClass, subtypeComponentClass); }
protected String toFormStringExpression(JParameter argument, Style classStyle) throws UnableToCompleteException { JType type = argument.getType(); String expr = argument.getName(); if (type.isPrimitive() != null) { return "\"\"+" + expr; } if (STRING_TYPE == type) { return expr; } if (type.isClass() != null && isOverlayArrayType(type.isClass())) { return "(new " + JSON_ARRAY_CLASS + "(" + expr + ")).toString()"; } if (type.isClass() != null && OVERLAY_VALUE_TYPE.isAssignableFrom(type.isClass())) { return "(new " + JSON_OBJECT_CLASS + "(" + expr + ")).toString()"; } if (type.getQualifiedBinaryName().startsWith("java.lang.")) { return String.format("(%s != null ? %s.toString() : null)", expr, expr); } Json jsonAnnotation = argument.getAnnotation(Json.class); final Style style = jsonAnnotation != null ? jsonAnnotation.style() : classStyle; return locator.encodeExpression(type, expr, style) + ".toString()"; }
/** * Adds the given parameter to this JConstructor's list of parameters. * * @param parameter The parameter to add to the this JConstructor's list of parameters. */ public void addParameter(final JParameter parameter) { if (parameter == null) { return; } // -- check current params if (_params.get(parameter.getName()) != null) { StringBuilder err = new StringBuilder(64); err.append("A parameter already exists for the constructor, "); err.append(this._declaringClass.getName()); err.append(", with the name: "); err.append(parameter.getName()); throw new IllegalArgumentException(err.toString()); } _params.put(parameter.getName(), parameter); // -- be considerate and add the class name to the // -- declaring class's list of imports if (_declaringClass != null) { JType jType = parameter.getType(); if (!jType.isPrimitive()) { _declaringClass.addImport(jType.getName()); } } }
public void addMethod(JMethod jMethod) throws IllegalArgumentException { if (jMethod == null) { throw new IllegalArgumentException("Class methods cannot be null"); } // -- check method name and signatures *add later* // -- keep method list sorted for esthetics when printing // -- START SORT :-) boolean added = false; short modifierVal = 0; JModifiers modifiers = jMethod.getModifiers(); for (int i = 0; i < methods.size(); i++) { JMethod tmp = (JMethod) methods.elementAt(i); // -- first compare modifiers if (tmp.getModifiers().isPrivate()) { if (!modifiers.isPrivate()) { methods.insertElementAt(jMethod, i); added = true; break; } } // -- compare names if (jMethod.getName().compareTo(tmp.getName()) < 0) { methods.insertElementAt(jMethod, i); added = true; break; } } // -- END SORT if (!added) methods.addElement(jMethod); // -- check parameter packages to make sure we have them // -- in our import list String[] pkgNames = jMethod.getParameterClassNames(); for (int i = 0; i < pkgNames.length; i++) { addImport(pkgNames[i]); } // -- check return type to make sure it's included in the // -- import list JType jType = jMethod.getReturnType(); if (jType != null) { while (jType.isArray()) jType = jType.getComponentType(); if (!jType.isPrimitive()) addImport(((JClass) jType).getName()); } // -- check exceptions JClass[] exceptions = jMethod.getExceptions(); for (int i = 0; i < exceptions.length; i++) { addImport(exceptions[i].getName()); } } // -- addMethod
protected String toStringExpression(JType type, String expr) { if (type.isPrimitive() != null) { return "\"\"+" + expr; } if (STRING_TYPE == type) { return expr; } if (type.isClass() != null && isOverlayArrayType(type.isClass())) { return "(new " + JSON_ARRAY_CLASS + "(" + expr + ")).toString()"; } if (type.isClass() != null && OVERLAY_VALUE_TYPE.isAssignableFrom(type.isClass())) { return "(new " + JSON_OBJECT_CLASS + "(" + expr + ")).toString()"; } return String.format("(%s != null ? %s.toString() : null)", expr, expr); }
/** * Adds the given JMethodSignature to this JClass * * @param jMethodSig the JMethodSignature to add. * @throws java.lang.IllegalArgumentException when the given JMethodSignature conflicts with an * existing method signature. */ public void addMethod(JMethodSignature jMethodSig) throws IllegalArgumentException { if (jMethodSig == null) { String err = "The JMethodSignature cannot be null."; throw new IllegalArgumentException(err); } // -- check method name and signatures *add later* // -- keep method list sorted for esthetics when printing // -- START SORT :-) boolean added = false; // short modifierVal = 0; JModifiers modifiers = jMethodSig.getModifiers(); for (int i = 0; i < methods.size(); i++) { JMethodSignature tmp = (JMethodSignature) methods.elementAt(i); // -- first compare modifiers if (tmp.getModifiers().isProtected()) { if (!modifiers.isProtected()) { methods.insertElementAt(jMethodSig, i); added = true; break; } } // -- compare names if (jMethodSig.getName().compareTo(tmp.getName()) < 0) { methods.insertElementAt(jMethodSig, i); added = true; break; } } // -- END SORT if (!added) methods.addElement(jMethodSig); // -- check return type to make sure it's included in the // -- import list JType jType = jMethodSig.getReturnType(); if (jType != null) { while (jType.isArray()) jType = jType.getComponentType(); if (!jType.isPrimitive()) addImport(jType.getName()); } // -- check exceptions JClass[] exceptions = jMethodSig.getExceptions(); for (JClass exception : exceptions) { addImport(exception.getName()); } } // -- addMethod
public void addMember(JMember jMember) throws IllegalArgumentException { if (jMember == null) { throw new IllegalArgumentException("Class members cannot be null"); } if (members.get(jMember.getName()) != null) { String err = "duplicate name found: " + jMember.getName(); throw new IllegalArgumentException(err); } members.put(jMember.getName(), jMember); // if member is of a type not imported by this class // then add import JType type = jMember.getType(); while (type.isArray()) type = type.getComponentType(); if (!type.isPrimitive()) { addImport(((JClass) type).getName()); } } // -- addMember