Example usage for com.google.common.reflect TypeToken unwrap

Introduction

In this page you can find the example usage for com.google.common.reflect TypeToken unwrap.

Prototype

public final TypeToken<T> unwrap() 

Source Link

Document

Returns the corresponding primitive type if this is a wrapper type; otherwise returns this itself.

Usage

From source file:com.microsoft.rest.Validator.java

/**
 * Validates a user provided required parameter to be not null.
 * An {@link IllegalArgumentException} is thrown if a property fails the validation.
 *
 * @param parameter the parameter to validate
 * @throws IllegalArgumentException thrown when the Validator determines the argument is invalid
 */// ww  w .  j  a  v a2s.co m
public static void validate(Object parameter) throws IllegalArgumentException {
    // Validation of top level payload is done outside
    if (parameter == null) {
        return;
    }

    Class parameterType = parameter.getClass();
    TypeToken<?> parameterToken = TypeToken.of(parameterType);
    if (Primitives.isWrapperType(parameterType)) {
        parameterToken = parameterToken.unwrap();
    }
    if (parameterToken.isPrimitive() || parameterType.isEnum()
            || parameterToken.isAssignableFrom(LocalDate.class)
            || parameterToken.isAssignableFrom(DateTime.class) || parameterToken.isAssignableFrom(String.class)
            || parameterToken.isAssignableFrom(DateTimeRfc1123.class)
            || parameterToken.isAssignableFrom(Period.class)) {
        return;
    }

    for (Class<?> c : parameterToken.getTypes().classes().rawTypes()) {
        // Ignore checks for Object type.
        if (c.isAssignableFrom(Object.class)) {
            continue;
        }
        for (Field field : c.getDeclaredFields()) {
            field.setAccessible(true);
            JsonProperty annotation = field.getAnnotation(JsonProperty.class);
            Object property;
            try {
                property = field.get(parameter);
            } catch (IllegalAccessException e) {
                throw new IllegalArgumentException(e.getMessage(), e);
            }
            if (property == null) {
                if (annotation != null && annotation.required()) {
                    throw new IllegalArgumentException(field.getName() + " is required and cannot be null.");
                }
            } else {
                try {
                    Class<?> propertyType = property.getClass();
                    if (TypeToken.of(List.class).isAssignableFrom(propertyType)) {
                        List<?> items = (List<?>) property;
                        for (Object item : items) {
                            Validator.validate(item);
                        }
                    } else if (TypeToken.of(Map.class).isAssignableFrom(propertyType)) {
                        Map<?, ?> entries = (Map<?, ?>) property;
                        for (Map.Entry<?, ?> entry : entries.entrySet()) {
                            Validator.validate(entry.getKey());
                            Validator.validate(entry.getValue());
                        }
                    } else if (parameterType != propertyType) {
                        Validator.validate(property);
                    }
                } catch (IllegalArgumentException ex) {
                    if (ex.getCause() == null) {
                        // Build property chain
                        throw new IllegalArgumentException(field.getName() + "." + ex.getMessage());
                    } else {
                        throw ex;
                    }
                }
            }
        }
    }
}

---

From source file:edu.mit.streamjit.impl.compiler2.Compiler2.java

/**
 * Unboxes storage types and Actor input and output types.
 *//*ww  w  .j a v a  2  s. c  o m*/
private void unbox() {
    for (Storage s : storage) {
        if (isUnboxable(s.contentType()) && UNBOXING_STRATEGY.unboxStorage(s, config)) {
            TypeToken<?> contents = s.contentType();
            Class<?> type = contents.unwrap().getRawType();
            s.setType(type);
            //            if (!s.type().equals(contents.getRawType()))
            //               System.out.println("unboxed "+s+" to "+type);
        }
    }

    for (WorkerActor a : Iterables.filter(actors, WorkerActor.class)) {
        if (isUnboxable(a.inputType()) && UNBOXING_STRATEGY.unboxInput(a, config)) {
            TypeToken<?> oldType = a.inputType();
            a.setInputType(oldType.unwrap());
            //            if (!a.inputType().equals(oldType))
            //               System.out.println("unboxed input of "+a+": "+oldType+" -> "+a.inputType());
        }
        if (isUnboxable(a.outputType()) && UNBOXING_STRATEGY.unboxOutput(a, config)) {
            TypeToken<?> oldType = a.outputType();
            a.setOutputType(oldType.unwrap());
            //            if (!a.outputType().equals(oldType))
            //               System.out.println("unboxed output of "+a+": "+oldType+" -> "+a.outputType());
        }
    }
}

---