/** * Returns the (initialized) class represented by {@code className} using the given class loader. * * @throws NestedClassNotFoundException if the class is not found */ public static Class<?> forName(ClassLoader classLoader, String className) throws NestedClassNotFoundException { return forName(classLoader, className, true); }
public boolean isPackageContains(Class<?> cls){ String clsPackageName = Classes.getPackageName(cls) + "."; for(OrmModelPkgConfig basePackage : basePackages.values()) { if(clsPackageName.startsWith(basePackage.getPkg())) { return true; } } return false; }
/** * Returns <code>true</code> if the given class name is present. */ public static boolean isPresent(String className) { return tryForName(className) != null; }
/** * Returns the (initialized) class represented by {@code className} using the given class's loader. * * <p/> * * returns {@code null} if the class is not found */ public static Class<?> tryForName(Class<?> loaderClass,String className) { return tryForName(getClassLoader(loaderClass),className); }
/** * Returns the (initialized) class represented by {@code className} using the current thread's context class loader. * * @throws NestedClassNotFoundException if the class is not found */ public static Class<?> forName(String className) throws NestedClassNotFoundException { return forName(getClassLoader(),className,true); }
@Override public boolean isExplicitEntity(MetadataContext context,Class<?> javaType) { if(isExplicitNonEntity(context, javaType)) { return false; } if(Model.class.isAssignableFrom(javaType) && !Modifier.isAbstract(javaType.getModifiers())) { return true; } for(Annotation a : Classes.getAnnotations(javaType)){ if(Classes.isAnnotationPresent(a.annotationType(), AEntity.class)){ return true; } } return false; }
if(Classes.isString(type)){ value = Randoms.nextString(1,fm.getColumn().getLength()); }else if(Classes.isInteger(type)){ value = Randoms.nextInt(); }else if(Classes.isLong(type)){ value = Randoms.nextLong(); }else if(Classes.isShort(type)){ value = Randoms.nextShort(); }else if(Classes.isFloat(type)){ value = Randoms.nextFloat(); }else if(Classes.isDouble(type)){ value = Randoms.nextDouble(); }else if(Classes.isCharacter(type)){ value = Randoms.nextCharacter(); }else if(Classes.isBoolean(type)){ value = Randoms.nextBoolean(); }else if(Classes.isBigDecimal(type)){ value = new BigDecimal(Randoms.nextDouble()); }else if(Classes.isBigInteger(type)){ value = new BigInteger(Randoms.nextStringNumeric(Randoms.nextInt(maxDecimalRandomLength))); }else if(Date.class.isAssignableFrom(type)){
public boolean isConfigurable() { if(null == configurable) { configurable = Classes.isAnnotationPresent(beanClass,Configurable.class); } return configurable; }
public static <T extends Annotation> T getAnnotation(Annotation[] annotations,Class<T> annotationType){ return getAnnotation(annotations, annotationType, false); }
Inject inject = Classes.getAnnotation(annotations, Inject.class); boolean nullable = Classes.isAnnotationPresent(annotations, NotNull.class) || Classes.isAnnotationPresent(annotations, M.class); boolean required = Classes.isAnnotationPresent(annotations, NotEmpty.class) || Classes.isAnnotationPresent(annotations, R.class); if(injectedBean == null && null != inject && inject.create() && Classes.isConcreteClass(type)) { injectedBean = createBean(type);
@Override public boolean load(BeanFactory factory) throws Exception { return Classes.isPresent(TOMCAT_DATASOURCE_CLASSNAME); }
clazz = Class.forName(clsName, initialize, classLoader).getComponentType(); } else { clazz = Class.forName(toCanonicalName(className), initialize, classLoader); return forName(classLoader, className.substring(0, lastDotIndex) + INNER_CLASS_SEPARATOR_CHAR + className.substring(lastDotIndex + 1), initialize); } catch (NestedClassNotFoundException ex2) { // NOPMD
/** * Check if the given type represents a "simple" property: * a primitive, a String or other CharSequence, a Number, a Date, * a URI, a URL, a Locale, a Class, or a corresponding array. * <p>Used to determine properties to check for a "simple" dependency-check. * @param clazz the type to check * @return whether the given type represents a "simple" property */ public static boolean isSimpleProperty(Class<?> clazz) { Args.notNull(clazz, "class"); return Classes.isSimpleValueType(clazz) || (clazz.isArray() && Classes.isSimpleValueType(clazz.getComponentType())); }
public ClassLoader getClassLoader() { return (this.classLoader != null ? this.classLoader : Classes.getClassLoader()); }
private ReflectMethod findSetter(){ String fieldName = field.getName().startsWith("_") ? field.getName().substring(1) : field.getName(); String nameToFind = "set" + Character.toUpperCase(fieldName.charAt(0)) + (fieldName.length() > 1 ? fieldName.substring(1) : ""); Class<?> fieldType = Primitives.wrap(field.getType()); ReflectMethod m = findSetter(fieldType, nameToFind); if(null == m && Classes.isBoolean(fieldType) && fieldName.startsWith("is") && fieldName.length() > 2){ nameToFind = "set" + Character.toUpperCase(fieldName.charAt(2)) + (fieldName.length() > 3 ? fieldName.substring(3) : ""); m = findSetter(fieldType,nameToFind); } if(null == m){ m = findSetter(fieldType,fieldName); } return m; }
private Object safeValue(Object value){ if(null == value){ return Classes.getDefaultValue(type); } return value; }
/** * Returns the (initialized) class represented by {@code className} using the given class's loader. * * @throws NestedClassNotFoundException if the class is not found */ public static Class<?> forName(Class<?> loaderClass,String className) throws NestedClassNotFoundException { return forName(getClassLoader(loaderClass),className); }
@Override public boolean isExplicitNonEntity(MetadataContext context,Class<?> javaType) { return Classes.isAnnotationPresent(javaType, NonEntity.class); }
public static boolean isAnnotationPresent(Annotation[] annotations, Class<? extends Annotation> annotationType){ return null != getAnnotation(annotations, annotationType); }
@Override public boolean isAvailable() { if(null == driverClassAvailable){ driverClassAvailable = Classes.isPresent(driverClassName); } return driverClassAvailable; }