private String resolveTypeLiteralName(TypeLiteral typeLiteral) { final Type<O> type = new TypeImpl<O>(getOrigin(), typeLiteral.getType()); if (type.isPrimitive()) { final Class<?>[] primitiveTypes = { boolean.class, byte.class, short.class, int.class, long.class, float.class, double.class }; for (Class<?> c : primitiveTypes) { if (c.getSimpleName().equals(type.getName())) { return c.getName(); } } return null; } final String classname = type.getQualifiedName(); return getOrigin().resolveType(classname); }
public static Object[] isSimpleGeneric(Type type, ClassTypeResolver classTypeResolver) throws ModelDriverException { Object[] result = new Object[3]; result[0] = false; result[1] = null; result[2] = null; if (type.isArray() || type.isPrimitive() || !type.isParameterized() || (type.isParameterized() && type.getTypeArguments().size() != 1)) { return result; } Type<?> argument = ((List<Type>) type.getTypeArguments()).get(0); if (!isSimpleClass(argument)) { return result; } try { String outerClass = classTypeResolver.getFullTypeName(type.getName()); String argumentClass = classTypeResolver.getFullTypeName(argument.getName()); result[0] = true; result[1] = outerClass; result[2] = argumentClass; return result; } catch (ClassNotFoundException e) { throw new ModelDriverException("Class could not be resolved for name: " + type.getName() + ". " + e.getMessage(), e); } }
if (field.getType().isArray()) fieldEqualityChecks.append(" return false; }"); else if (field.getType().isPrimitive()) if (field.getType().isType("float")) else if (field.getType().isType("double"))
public static boolean isSimpleClass(Type<?> type) { return !type.isArray() && !type.isPrimitive() && !type.isParameterized(); }
@Override public Import addImport(final Type<?> type) { Import imprt; if (requiresImport(type.getQualifiedName())) { imprt = addImport(type.getQualifiedName()); } else { imprt = getImport(type.getQualifiedName()); } for (Type<?> arg : type.getTypeArguments()) { if (!arg.isWildcard() && arg.isQualified()) { addImport(arg); } } return imprt; }
@Override public Import addImport(Type<?> type) { return addImport(type.getQualifiedName()); }
public static <O extends JavaType<O>> String rebuildGenericNameWithArrays(String resolvedTypeName, Type<O> type) { StringBuilder resolvedType = new StringBuilder(stripArray(resolvedTypeName)); resolvedType.append(getGenerics(type.toString())); for (int j = 0; j < getArrayDimension(type.getName()); j++) { resolvedType.append("[]"); } return resolvedType.toString(); }
if (fieldType.isPrimitive()) { fieldClassName = fieldType.getName(); } else if (DriverUtils.isSimpleClass(fieldType)) { fieldClassName = classTypeResolver.getFullTypeName(fieldType.getName()); } else { Type elementsType = ((List<Type>) fieldType.getTypeArguments()).get(0); fieldClassName = classTypeResolver.getFullTypeName(elementsType.getName()); fieldClassName = fieldType.getQualifiedName();
@Override public String getGenericType() { if (this.readMethod != null) { @SuppressWarnings({ "unchecked", "rawtypes" }) List<Type<?>> typeArguments = (List) this.readMethod.getReturnType().getTypeArguments(); if (!typeArguments.isEmpty()) { return typeArguments.get(0).getQualifiedName(); } } if (this.privateField != null) { @SuppressWarnings({ "unchecked", "rawtypes" }) List<Type<?>> typeArguments = (List) this.privateField.getType().getTypeArguments(); if (!typeArguments.isEmpty()) { return typeArguments.get(0).getQualifiedName(); } } return null; }
public static boolean equalsType(Type type, String fullClassName, boolean multiple, String fullBagClassName, ClassTypeResolver classTypeResolver) throws Exception { String currentClassName; String currentBag; if (type.isArray()) { return false; } if (type.isPrimitive()) { return !multiple && fullClassName.equals(type.getName()); } if (isSimpleClass(type)) { currentClassName = classTypeResolver.getFullTypeName(type.getName()); return !multiple && fullClassName.equals(currentClassName); } Object[] simpleGenerics = isSimpleGeneric(type, classTypeResolver); if (multiple && Boolean.TRUE.equals(simpleGenerics[0]) && isManagedType(type, classTypeResolver)) { currentBag = (String) simpleGenerics[1]; currentBag = classTypeResolver.getFullTypeName(currentBag); currentClassName = (String) simpleGenerics[2]; currentClassName = classTypeResolver.getFullTypeName(currentClassName); return fullBagClassName.equals(currentBag) && fullClassName.equals(currentClassName); } return false; }
@Override public boolean isReturnTypeVoid() { return getReturnType().isType(Void.TYPE); }
public boolean isEquals(MethodSource<?> method) { return method.getName().equals("equals") && (method.getParameters() == null || method.getParameters().size() == 1) && method.getReturnType() != null && method.getReturnType().isPrimitive() && "boolean".equals(method.getReturnType().getName()); }
if (type.isPrimitive()) { className = type.getName(); } else { if (DriverUtils.isSimpleClass(type)) { className = resolveTypeName(classTypeResolver, type.getName()); } else { Type elementsType = ((List<Type>) type.getTypeArguments()).get(0); className = resolveTypeName(classTypeResolver, elementsType.getName()); bag = resolveTypeName(classTypeResolver, type.getName());
if (!field.getType().isPrimitive()) if (field.getType().isType(String.class))
modelParameters.add(new org.kie.workbench.common.services.datamodeller.core.impl.ParameterImpl( new org.kie.workbench.common.services.datamodeller.core.impl.TypeImpl(resolveTypeName(classTypeResolver, parameter.getType().getName()), resolveTypeArguments(parameter.getType().getTypeArguments())), parameter.getName())); returnType = new org.kie.workbench.common.services.datamodeller.core.impl.TypeImpl( resolveTypeName(classTypeResolver, method.getReturnType().getName()), resolveTypeArguments(method.getReturnType().getTypeArguments()));
exampleClassNames.add(parameterSource.getType().getSimpleName()); XmlType xmlType = getXmlType(Class.forName(parameterSource.getType().getQualifiedName())); String name = xmlType.name().trim(); bodyParameter.name(name); throw new MojoExecutionException("Unable to instantiate class \"" + parameterSource.getType().getQualifiedName() + "\". Reason: " + e.getMessage(), e);
protected boolean canAddFieldToToString(Field<JavaClassSource> field) { return !field.isStatic() && !field.isTransient() && !field.getType().isArray(); }
/** * Returns whether the given method is a 'getter' method. * * @param method a parameterless method that returns a non-void * @return the property name */ protected String isGetter(final Method<?, ?> method) { String methodName = method.getName(); String propertyName; if (methodName.startsWith(ClassUtils.JAVABEAN_GET_PREFIX)) { propertyName = methodName.substring(ClassUtils.JAVABEAN_GET_PREFIX.length()); } else if (methodName.startsWith(ClassUtils.JAVABEAN_IS_PREFIX) && method.getReturnType() != null && boolean.class.equals(method.getReturnType().getQualifiedName())) { // As per section 8.3.2 (Boolean properties) of The JavaBeans API specification, 'is' // only applies to boolean (little 'b') propertyName = methodName.substring(ClassUtils.JAVABEAN_IS_PREFIX.length()); } else { return null; } return StringUtils.decapitalize(propertyName); }
public static <O extends JavaType<O>> String rebuildGenericNameWithArrays(String resolvedTypeName, Type<O> type) { StringBuilder resolvedType = new StringBuilder(stripArray(resolvedTypeName)); resolvedType.append(getGenerics(type.toString())); for (int j = 0; j < getArrayDimension(type.getName()); j++) { resolvedType.append("[]"); } return resolvedType.toString(); }