/** * Checks if classA or classB can be auto boxed by the JVM * * @return {@code true}, if both classes are either primitive or wrapper classes and * autoboxing is possible between {@code classA} and {@code classB} */ private static boolean canBeAutoboxed(Class<?> classA, Class<?> classB) { return ClassUtils.isPrimitiveOrWrapper(classA) && ClassUtils.isPrimitiveOrWrapper(classB) && (classB.equals(classA) // Same types || ClassUtils.primitiveToWrapper(classB).equals(classA) // Matching primitive-wrapper pair, e.g. double - Double || ClassUtils.primitiveToWrapper(classA).equals(classB)); // Matching wrapper-primitive pair, e.g. Long - long }
} else { if (testRecursive && !ClassUtils.isPrimitiveOrWrapper(lhsClass)) { reflectionAppend(lhs, rhs); } else {
@Test public void testIsPrimitiveOrWrapper() { // test primitive wrapper classes assertTrue("Boolean.class", ClassUtils.isPrimitiveOrWrapper(Boolean.class)); assertTrue("Byte.class", ClassUtils.isPrimitiveOrWrapper(Byte.class)); assertTrue("Character.class", ClassUtils.isPrimitiveOrWrapper(Character.class)); assertTrue("Short.class", ClassUtils.isPrimitiveOrWrapper(Short.class)); assertTrue("Integer.class", ClassUtils.isPrimitiveOrWrapper(Integer.class)); assertTrue("Long.class", ClassUtils.isPrimitiveOrWrapper(Long.class)); assertTrue("Double.class", ClassUtils.isPrimitiveOrWrapper(Double.class)); assertTrue("Float.class", ClassUtils.isPrimitiveOrWrapper(Float.class)); // test primitive classes assertTrue("boolean", ClassUtils.isPrimitiveOrWrapper(Boolean.TYPE)); assertTrue("byte", ClassUtils.isPrimitiveOrWrapper(Byte.TYPE)); assertTrue("char", ClassUtils.isPrimitiveOrWrapper(Character.TYPE)); assertTrue("short", ClassUtils.isPrimitiveOrWrapper(Short.TYPE)); assertTrue("int", ClassUtils.isPrimitiveOrWrapper(Integer.TYPE)); assertTrue("long", ClassUtils.isPrimitiveOrWrapper(Long.TYPE)); assertTrue("double", ClassUtils.isPrimitiveOrWrapper(Double.TYPE)); assertTrue("float", ClassUtils.isPrimitiveOrWrapper(Float.TYPE)); assertTrue("Void.TYPE", ClassUtils.isPrimitiveOrWrapper(Void.TYPE)); // others assertFalse("null", ClassUtils.isPrimitiveOrWrapper(null)); assertFalse("Void.class", ClassUtils.isPrimitiveOrWrapper(Void.class)); assertFalse("String.class", ClassUtils.isPrimitiveOrWrapper(String.class)); assertFalse("this.getClass()", ClassUtils.isPrimitiveOrWrapper(this.getClass())); }
@Override public <R> TypeAdapter<R> create(Gson gson, TypeToken<R> type) { if (ClassUtils.isPrimitiveOrWrapper(type.getRawType()) || type.getType() instanceof GenericArrayType || CharSequence.class.isAssignableFrom(type.getRawType()) || (type.getType() instanceof ParameterizedType && (Collection.class.isAssignableFrom(type.getRawType()) || Map.class.isAssignableFrom(type.getRawType())))) { // delegate primitives, arrays, collections, and maps return null; } if (!this.baseClass.isAssignableFrom(type.getRawType())) { // delegate anything not assignable from base class return null; } TypeAdapter<R> adapter = new InterfaceAdapter<>(gson, this, type); return adapter; }
/** * The result of a profile's triage expressions must be a string or primitive type. * * This ensures that the value can be easily serialized and appended to a message destined for Kafka. * * @param value The value of a triage expression. * @return True, if the type of the value is valid. */ private boolean isValidType(Object value) { return value != null && (value instanceof String || ClassUtils.isPrimitiveOrWrapper(value.getClass())); }
static String shortClassName(Class<?> type) { Package pkg = type.getPackage(); if (ClassUtils.isPrimitiveOrWrapper(type)) { if (!type.isPrimitive()) { type = ClassUtils.wrapperToPrimitive(type); } return type.getName(); } else if (pkg == null || pkg.equals(Package.getPackage("java.lang"))) { return type.getSimpleName(); } else { String[] words = type.getName().split(" "); String fullClassName = words[words.length - 1]; String[] path = fullClassName.split("\\."); int i = 0; while (i + 1 < path.length && !Character.isUpperCase(path[i + 1].charAt(0))) { path[i] = path[i].substring(0, 1); i++; } return StringUtils.join(path, "."); } }
/** * Checks to see if the given object is primitive or wrapper class, {@link String}, {@link Class}, instance of {@link Iterable}, * instance of {@link Map} or instance of {@link Enum}. * * @param object The object to validate * @return true if the object is not primitive/wrapper class and not an instance of * {@link String}, {@link Iterable}, {@link Map} or {@link Enum}) */ private boolean validateAnObject(Object object) { return !isPrimitiveOrWrapper(object.getClass()) && object.getClass() != String.class && object.getClass() != Class.class && !(object instanceof Iterable) && !(object instanceof Map) && !(object instanceof Enum); } }
private boolean isPrimitiveType(Type type) { if (type instanceof Class) { Class clazz = (Class) type; if (ClassUtils.isPrimitiveOrWrapper(clazz) || ClassUtils .isAssignable(clazz, String.class)) { return true; } } return false; }
public static Map<String, Object> getObjectMap(Object o) { if (ClassUtils.isPrimitiveOrWrapper(o.getClass()) || (o instanceof String)) { Map<String, Object> objectMap = new HashMap<String, Object>(); objectMap.put("fake_var_" + o.getClass().getName().replace('.', '_'), o); return objectMap; } else { return getAllVars(o, 0, ""); } }
private static boolean allKeysArePrimitiveOrStringOrEnum(ImmutableList<String> sortedMapKeySet, ArrayListMultimap<String, Object> objects) { for (String jsonRepresentation : sortedMapKeySet) { List<Object> mapKeys = objects.get(jsonRepresentation); for (Object object : mapKeys) { if (!(isPrimitiveOrWrapper(object.getClass()) || object.getClass() == String.class || object.getClass().isEnum())) { return false; } } } return true; }
private static boolean allKeysArePrimitiveOrStringOrEnum(ImmutableList<String> sortedMapKeySet, ArrayListMultimap<String, Object> objects) { for (String jsonRepresentation : sortedMapKeySet) { List<Object> mapKeys = objects.get(jsonRepresentation); for (Object object : mapKeys) { if (!(isPrimitiveOrWrapper(object.getClass()) || object.getClass() == String.class || object.getClass().isEnum())) { return false; } } } return true; }
/** * Checks if classA or classB can be auto boxed by the JVM * * @return {@code true}, if both classes are either primitive or wrapper classes and * autoboxing is possible between {@code classA} and {@code classB} */ private static boolean canBeAutoboxed(Class<?> classA, Class<?> classB) { return ClassUtils.isPrimitiveOrWrapper(classA) && ClassUtils.isPrimitiveOrWrapper(classB) && (classB.equals(classA) // Same types || ClassUtils.primitiveToWrapper(classB).equals(classA) // Matching primitive-wrapper pair, e.g. double - Double || ClassUtils.primitiveToWrapper(classA).equals(classB)); // Matching wrapper-primitive pair, e.g. Long - long }
/** * Check if the bean type can be wrapped or not. * * @param bean * the bean instance * @return false if null or valid type, true if primitive type or string */ public static boolean isInvalid(Object bean) { if (bean == null) { return false; } return isPrimitiveOrWrapper(bean.getClass()) || INVALID_TYPES.contains(bean.getClass()) || isInstanceOfInvalid(bean.getClass()); }
public String listToString(Collection<?> list) { final StringBuilder buf = new StringBuilder(); buf.append("'["); if (!list.isEmpty()) { for (Object o : list) { if (ClassUtils.isPrimitiveOrWrapper(o.getClass()) || o instanceof String) { buf.append("'" + o + "'"); } else { buf.append(valueToString(o)); } buf.append(", "); } buf.replace(buf.length() - 2, buf.length(), ""); } buf.append("]'"); return buf.toString(); }
public void setAttrValue(Object value) { Object newValue = value; if (newValue != null && (ClassUtils.isPrimitiveOrWrapper(newValue.getClass()) || newValue instanceof String)) { newValue = String.valueOf(newValue); } else if (newValue != null) { newValue = LAMBDA_VALUE;//NOSONAR } this.setValue(getSType().attrValue, newValue); }
public static boolean isPrimitiveOrWrapper(Class<?> param, Method getter) { return ClassUtils.isPrimitiveOrWrapper(param) || ClassUtils.isAssignable(param, String.class) || ClassUtils.isAssignable(param, File.class) || ClassUtils.isAssignable(param, Enum.class) || (getter != null && getter.isAnnotationPresent(DiffAtomic.class)) || (getter != null && isCollectionOrMapOfPrimitive(getter)); }
/** * Create a client builder for MessagePack values. * @return The builder */ public static <T> MemcachedClientBuilder<T> newMessagePackClient(final MessagePack messagePack, final Class<T> valueType) { if (!ClassUtils.isPrimitiveOrWrapper(valueType)) { messagePack.register(valueType); } return newClient(new MessagePackTranscoder<>(messagePack, valueType)); }
@Override public <R> TypeAdapter<R> create(Gson gson, TypeToken<R> type) { if (ClassUtils.isPrimitiveOrWrapper(type.getRawType()) || type.getType() instanceof GenericArrayType || CharSequence.class.isAssignableFrom(type.getRawType()) || (type.getType() instanceof ParameterizedType && (Collection.class.isAssignableFrom(type.getRawType()) || Map.class.isAssignableFrom(type.getRawType())))) { // delegate primitives, arrays, collections, and maps return null; } if (!this.baseClass.isAssignableFrom(type.getRawType())) { // delegate anything not assignable from base class return null; } TypeAdapter<R> adapter = new InterfaceAdapter<>(gson, this, type); return adapter; }
@Override public <R> TypeAdapter<R> create(Gson gson, TypeToken<R> type) { if (ClassUtils.isPrimitiveOrWrapper(type.getRawType()) || type.getType() instanceof GenericArrayType || CharSequence.class.isAssignableFrom(type.getRawType()) || (type.getType() instanceof ParameterizedType && (Collection.class.isAssignableFrom(type.getRawType()) || Map.class.isAssignableFrom(type.getRawType())))) { // delegate primitives, arrays, collections, and maps return null; } if (!this.baseClass.isAssignableFrom(type.getRawType())) { // delegate anything not assignable from base class return null; } TypeAdapter<R> adapter = new InterfaceAdapter<>(gson, this, type); return adapter; }
private static ConfigNewData<?> convertPrimitive(Class<?> type, ConfigNewData<?> v) { if (ClassUtils.isPrimitiveOrWrapper(type)) { try { return new ConfigNewData<>(v.getPrefixContext(), v.getFieldName(), ConvertUtils.convert(v.getNewValue(), type)); } catch (ConversionException e) { throw new IllegalArgumentException(e.getMessage(), e); } } return v; }