Example usage for org.apache.commons.lang3 ClassUtils getClass

Introduction

In this page you can find the example usage for org.apache.commons.lang3 ClassUtils getClass.

Prototype

public static Class<?> getClass(final String className) throws ClassNotFoundException 

Source Link

Document

Returns the (initialized) class represented by className using the current thread's context class loader.

Usage

From source file:org.lenskit.data.entities.EntityDefaults.java

/**
 * Create an entity defaults object from a bean.
 * @param type The entity type./* w  w  w.  j a va2  s  . c om*/
 * @param bean The bean.
 * @return The entity defaults.
 */
private static EntityDefaults fromBean(EntityType type, DefaultsBean bean) {
    Map<String, TypedName<?>> attrs = new HashMap<>();
    for (Map.Entry<String, String> ab : bean.getAttributes().entrySet()) {
        attrs.put(ab.getKey(), TypedName.create(ab.getKey(), ab.getValue()));
    }

    List<TypedName<?>> cols = new ArrayList<>();
    for (String col : bean.getColumns()) {
        cols.add(attrs.get(col));
    }

    List<EntityDerivation> derivs = new ArrayList<>();
    for (Map.Entry<String, String> d : bean.getDerivations().entrySet()) {
        EntityType et = EntityType.forName(d.getKey());
        TypedName<?> attr = attrs.get(d.getValue());
        if (!attr.getType().equals(Long.class)) {
            throw new RuntimeException("derived entity derives from non-Long column");
        }
        derivs.add(EntityDerivation.create(et, type, (TypedName<Long>) attr));
    }

    Class<?> builder;
    String builderName = bean.getBuilder();
    if (builderName != null) {
        try {
            builder = ClassUtils.getClass(bean.getBuilder());
        } catch (ClassNotFoundException ex) {
            throw new RuntimeException("could not find builder class", ex);
        }
    } else {
        builder = BasicEntityBuilder.class;
    }

    return new EntityDefaults(type, attrs.values(), cols, builder.asSubclass(EntityBuilder.class), derivs);
}

---

From source file:org.lenskit.data.entities.TypedName.java

/**
 * Create an typed name from a name and type name.
 * @param name The name./*from   w  w  w .  j a v a 2  s .com*/
 * @param typeName The type name.
 * @return The attribute.
 * @throws IllegalArgumentException if `typeName` is not a valid type name.
 */
public static TypedName<?> create(String name, String typeName) {
    Class<?> type;
    switch (typeName) {
    case "string":
    case "String":
        type = String.class;
        break;
    case "int":
    case "Integer":
        type = Integer.class;
        break;
    case "long":
    case "Long":
        type = Long.class;
        break;
    case "double":
    case "real":
    case "Double":
        type = Double.class;
        break;
    default:
        try {
            type = ClassUtils.getClass(typeName);
        } catch (ClassNotFoundException e) {
            throw new IllegalArgumentException("Cannot load type name ", e);
        }
    }

    return create(name, type);
}

---

From source file:org.lenskit.util.TypeUtils.java

/**
 * Resolve a type name into a type.  This is like class lookup with a few additions:
 *
 * - Aliases for common types (`string`, `int`, `long`, `double`)
 * - Lists are handled with an array syntax (`string[]` becomes {@code List<String>})
 *
 * @param type The type name to resolve.
 * @return The type./*from  w  w w.  j  ava2 s  .c  o  m*/
 */
public static TypeToken<?> resolveTypeName(String type) {
    Preconditions.checkArgument(type.length() > 0, "type name is empty");
    if (type.endsWith("[]")) {
        String nt = type.substring(0, type.length() - 2);
        TypeToken<?> inner = resolveTypeName(nt);
        return makeListType(inner);
    }
    switch (type) {
    case "string":
    case "String":
        return TypeToken.of(String.class);
    case "int":
    case "Integer":
        return TypeToken.of(Integer.class);
    case "long":
    case "Long":
        return TypeToken.of(Long.class);
    case "double":
    case "real":
    case "Double":
        return TypeToken.of(Double.class);
    case "text":
    case "Text":
        return TypeToken.of(Text.class);
    default:
        try {
            return TypeToken.of(ClassUtils.getClass(type));
        } catch (ClassNotFoundException e) {
            throw new IllegalArgumentException("Cannot load type name ", e);
        }
    }
}

---

From source file:org.talend.daikon.properties.property.EnumProperty.java

@SuppressWarnings("unchecked")
@Override/*from   www  .j  av a2 s  .c o  m*/
public T getValue() {
    Object value = storedValue;
    if (propertyValueEvaluator != null) {
        value = propertyValueEvaluator.evaluate(this, storedValue);
    } // else not evaluator so return the storedValue
      // try to convert the String to the enum
    if (value instanceof String) {
        try {
            Class<T> enumClass = (Class<T>) ClassUtils.getClass(getType());
            return Enum.valueOf(enumClass, (String) value);
        } catch (ClassNotFoundException e) {
            TalendRuntimeException.unexpectedException(e);
        }
    }
    return (T) value;
}

---

From source file:therian.buildweaver.StandardOperatorsProcessor.java

@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
    try {/*from ww  w.  j  a  va2 s . c o m*/
        final FileObject resource = processingEnv.getFiler().getResource(StandardLocation.CLASS_OUTPUT,
                StringUtils.substringBeforeLast(TARGET_CLASSNAME, ".").replace('.', '/'),
                StringUtils.substringAfterLast(TARGET_CLASSNAME, ".") + ".class");

        if (resource.getLastModified() > 0L) {
            processingEnv.getMessager().printMessage(Kind.NOTE,
                    String.format("%s already generated", TARGET_CLASSNAME));
            return false;
        }
    } catch (IOException e1) {
        // expected, swallow
    }
    try {
        ClassUtils.getClass(TARGET_CLASSNAME);
        processingEnv.getMessager().printMessage(Kind.ERROR,
                String.format("%s exists on classpath", TARGET_CLASSNAME));
        return false;
    } catch (ClassNotFoundException e) {
        // expected, swallow
    }

    if (roundEnv.processingOver()) {
        write();
        return true;
    }
    for (TypeElement ann : annotations) {
        final Set<? extends Element> standardOperatorElements = roundEnv.getElementsAnnotatedWith(ann);
        originatingElements.addAll(standardOperatorElements);

        for (Element element : standardOperatorElements) {
            Validate.validState(isValidStandardOperator(element), "%s is not a valid @StandardOperator",
                    appendTo(new StringBuilder(), element).toString());

            if (element.getKind() == ElementKind.CLASS) {
                operators.add(appendTo(new StringBuilder("new "), element).append("()").toString());
            }
            if (element.getKind() == ElementKind.METHOD) {
                operators.add(appendTo(new StringBuilder(), element).append("()").toString());
            }
            if (element.getKind() == ElementKind.FIELD) {
                operators.add(appendTo(new StringBuilder(), element).toString());
            }
        }
    }
    return true;
}

---

From source file:yoyo.framework.standard.shared.commons.lang.ClassUtilsTest.java

@Test
public void test() throws ClassNotFoundException, SecurityException, NoSuchMethodException {
    List<Class<?>> classes = new ArrayList<Class<?>>() {
        {// ww  w .  ja  va 2s.  c o m
            add(Integer.class);
            add(Long.class);
        }
    };
    assertThat(ClassUtils.convertClassesToClassNames(classes).toArray(),
            is(new Object[] { "java.lang.Integer", "java.lang.Long" }));
    List<String> classNames = new ArrayList<String>() {
        {
            add("java.lang.Integer");
            add("java.lang.Long");
        }
    };
    assertThat(ClassUtils.convertClassNamesToClasses(classNames).toArray(), is(classes.toArray()));
    assertThat(ClassUtils.getAllInterfaces(String.class).toArray(), is(new Object[] {
            java.io.Serializable.class, java.lang.Comparable.class, java.lang.CharSequence.class }));
    assertThat(ClassUtils.getAllSuperclasses(HashMap.class).toArray(),
            is(new Object[] { java.util.AbstractMap.class, java.lang.Object.class }));
    assertThat(ClassUtils.getClass("java.lang.String").toString(), is("class java.lang.String"));
    assertThat(ClassUtils.getPackageCanonicalName(String.class), is("java.lang"));
    assertThat(ClassUtils.getPackageName(String.class), is("java.lang"));
    assertThat(ClassUtils.getPublicMethod(String.class, "length", new Class[] {}), is(not(nullValue())));
    assertThat(ClassUtils.getShortCanonicalName(String.class), is("String"));
    assertThat(ClassUtils.getShortClassName(String.class), is("String"));
    assertThat(ClassUtils.getSimpleName(String.class), is("String"));
    assertThat(ClassUtils.isAssignable(String.class, Object.class), is(true));
    assertThat(ClassUtils.isInnerClass(Foo.class), is(true));
    assertThat(ClassUtils.isInnerClass(String.class), is(false));
    assertThat(ClassUtils.isPrimitiveOrWrapper(Integer.class), is(true));
    assertThat(ClassUtils.isPrimitiveOrWrapper(String.class), is(false));
    assertThat(ClassUtils.isPrimitiveWrapper(Integer.class), is(true));
    assertThat(ClassUtils.isPrimitiveWrapper(String.class), is(false));
    assertThat(ClassUtils.primitivesToWrappers(new Class[] { Integer.class, Long.class }),
            is(not(nullValue())));
    assertThat(ClassUtils.primitiveToWrapper(Integer.class), is(not(nullValue())));
    assertThat(ClassUtils.toClass(1L, 2L), is(not(nullValue())));
    assertThat(ClassUtils.wrappersToPrimitives(new Class[] { Integer.class, Long.class }),
            is(not(nullValue())));
    assertThat(ClassUtils.wrapperToPrimitive(Integer.class), is(not(nullValue())));
}

---

• «
• 1
• 2
• 3
• 4
• 5
• »