protected Object parseType()

in rt/rs/extensions/search/src/main/java/org/apache/cxf/jaxrs/ext/search/AbstractSearchConditionParser.java [126:263]
131 lines of code
42 McCabe index (conditional complexity)

    protected Object parseType(String originalPropName,
                             Object ownerBean,
                             Object lastCastedValue,
                             String setter,
                             TypeInfo typeInfo,
                             String value) throws SearchParseException {
        Class<?> valueType = typeInfo.getTypeClass();
        boolean isCollection = InjectionUtils.isSupportedCollectionOrArray(valueType);
        Class<?> actualType = isCollection ? InjectionUtils.getActualType(typeInfo.getGenericType()) : valueType;

        int index = getDotIndex(setter);
        if (index == -1) {
            Object castedValue = value;
            if (Date.class.isAssignableFrom(valueType)) {
                castedValue = convertToDate(valueType, value);
            } else if (Temporal.class.isAssignableFrom(valueType)) {
                castedValue = convertToTemporal((Class<? extends Temporal>)valueType, value);
            } else {
                boolean isPrimitive = InjectionUtils.isPrimitive(valueType);
                boolean isPrimitiveOrEnum = isPrimitive || valueType.isEnum();
                if (ownerBean == null || isPrimitiveOrEnum) {
                    try {
                        CollectionCheck collCheck = getCollectionCheck(originalPropName, isCollection, actualType);
                        if (collCheck == null) {
                            castedValue = InjectionUtils.convertStringToPrimitive(value, actualType);
                        }
                        if (collCheck == null && isCollection) {
                            castedValue = getCollectionSingleton(valueType, castedValue);
                        } else if (isCollection) {
                            typeInfo.setCollectionCheckInfo(new CollectionCheckInfo(collCheck, castedValue));
                            castedValue = getEmptyCollection(valueType);
                        }
                    } catch (Exception e) {
                        throw new SearchParseException("Cannot convert String value \"" + value
                                                     + "\" to a value of class " + valueType.getName(), e);
                    }
                } else {
                    Class<?> classType = isCollection ? valueType : value.getClass();
                    try {
                        Method setterM = valueType.getMethod("set" + getMethodNameSuffix(setter),
                                                             new Class[]{classType});
                        Object objectValue = !isCollection ? value : getCollectionSingleton(valueType, value);
                        setterM.invoke(ownerBean, new Object[]{objectValue});
                        castedValue = objectValue;
                    } catch (Throwable ex) {
                        throw new SearchParseException("Cannot convert String value \"" + value
                                                       + "\" to a value of class " + valueType.getName(), ex);
                    }

                }
            }
            if (lastCastedValue != null) {
                castedValue = lastCastedValue;
            }
            return castedValue;
        }
        String[] names = setter.split("\\.");
        try {
            String nextPart = getMethodNameSuffix(names[1]);
            Method getterM = actualType.getMethod("get" + nextPart, new Class[]{});
            Class<?> returnType = getterM.getReturnType();
            boolean returnCollection = InjectionUtils.isSupportedCollectionOrArray(returnType);
            Class<?> actualReturnType = !returnCollection ? returnType
                : InjectionUtils.getActualType(getterM.getGenericReturnType());

            boolean isPrimitive = !returnCollection
                && InjectionUtils.isPrimitive(returnType) || returnType.isEnum();
            boolean lastTry = names.length == 2
                && (isPrimitive
                    ||
                    Date.class.isAssignableFrom(returnType)
                    || Temporal.class.isAssignableFrom(returnType)
                    || returnCollection
                    || paramConverterAvailable(returnType));

            Object valueObject = ownerBean != null ? ownerBean
                : actualType.isInterface()
                ? Proxy.newProxyInstance(this.getClass().getClassLoader(),
                                         new Class[]{actualType},
                                         new InterfaceProxy())
                : actualType.getDeclaredConstructor().newInstance();
            Object nextObject;

            if (lastTry) {
                if (!returnCollection) {
                    if (isPrimitive) {
                        nextObject = InjectionUtils.convertStringToPrimitive(value, returnType);
                    } else if (Temporal.class.isAssignableFrom(returnType)) {
                        nextObject = convertToTemporal((Class<? extends Temporal>)returnType, value);
                    } else {
                        nextObject = convertToDate(returnType, value);
                    }
                } else {
                    CollectionCheck collCheck = getCollectionCheck(originalPropName, true, actualReturnType);
                    if (collCheck == null) {
                        nextObject = getCollectionSingleton(valueType, value);
                    } else {
                        typeInfo.setCollectionCheckInfo(new CollectionCheckInfo(collCheck, value));
                        nextObject = getEmptyCollection(valueType);
                    }
                }
            } else if (!returnCollection) {
                nextObject = returnType.getDeclaredConstructor().newInstance();
            } else {
                nextObject = actualReturnType.getDeclaredConstructor().newInstance();
            }
            Method setterM = actualType.getMethod("set" + nextPart, new Class[]{returnType});
            final Object valueObjectValue;
            if (lastTry || !returnCollection) {
                valueObjectValue = nextObject;
            } else {
                Class<?> collCls = Collection.class.isAssignableFrom(valueType) ? valueType : returnType;
                valueObjectValue = getCollectionSingleton(collCls, nextObject);
            }
            setterM.invoke(valueObject, new Object[]{valueObjectValue});

            if (lastTry) {
                lastCastedValue = lastCastedValue == null ? valueObject : lastCastedValue;
                return isCollection ? getCollectionSingleton(valueType, lastCastedValue) : lastCastedValue;
            }
            lastCastedValue = valueObject;

            TypeInfo nextTypeInfo = new TypeInfo(valueObjectValue.getClass(), getterM.getGenericReturnType());
            Object response = parseType(originalPropName,
                             nextObject,
                             lastCastedValue,
                             setter.substring(index + 1),
                             nextTypeInfo,
                             value);
            if (ownerBean == null) {
                return isCollection ? getCollectionSingleton(valueType, lastCastedValue) : lastCastedValue;
            }
            return response;
        } catch (Throwable e) {
            throw new SearchParseException("Cannot convert String value \"" + value
                                           + "\" to a value of class " + valueType.getName(), e);
        }
    }