public static void deserializeTaskData()

in data-orchestrator/workflow-engine/workflow-engine-core/src/main/java/org/apache/airavata/datalake/orchestrator/workflow/engine/task/TaskUtil.java [40:83]
40 lines of code
14 McCabe index (conditional complexity)

    public static <T extends AbstractTask> void deserializeTaskData(T instance, Map<String, String> params) throws IllegalAccessException, NoSuchMethodException, InvocationTargetException, InstantiationException {

        List<Field> allFields = new ArrayList<>();
        Class genericClass = instance.getClass();

        while (AbstractTask.class.isAssignableFrom(genericClass)) {
            Field[] declaredFields = genericClass.getDeclaredFields();
            for (Field declaredField : declaredFields) {
                allFields.add(declaredField);
            }
            genericClass = genericClass.getSuperclass();
        }

        for (Field classField : allFields) {
            TaskParam param = classField.getAnnotation(TaskParam.class);
            if (param != null) {
                if (params.containsKey(param.name())) {
                    classField.setAccessible(true);
                    PropertyDescriptor propertyDescriptor = PropertyUtils.getPropertyDescriptor(instance, classField.getName());
                    Method writeMethod = PropertyUtils.getWriteMethod(propertyDescriptor);
                    Class<?>[] methodParamType = writeMethod.getParameterTypes();
                    Class<?> writeParameterType = methodParamType[0];

                    if (writeParameterType.isAssignableFrom(String.class)) {
                        writeMethod.invoke(instance, params.get(param.name()));
                    } else if (writeParameterType.isAssignableFrom(Integer.class) ||
                            writeParameterType.isAssignableFrom(Integer.TYPE)) {
                        writeMethod.invoke(instance, Integer.parseInt(params.get(param.name())));
                    } else if (writeParameterType.isAssignableFrom(Long.class) ||
                            writeParameterType.isAssignableFrom(Long.TYPE)) {
                        writeMethod.invoke(instance, Long.parseLong(params.get(param.name())));
                    } else if (writeParameterType.isAssignableFrom(Boolean.class) ||
                            writeParameterType.isAssignableFrom(Boolean.TYPE)) {
                        writeMethod.invoke(instance, Boolean.parseBoolean(params.get(param.name())));
                    } else if (TaskParamType.class.isAssignableFrom(writeParameterType)) {
                        Constructor<?> ctor = writeParameterType.getConstructor();
                        Object obj = ctor.newInstance();
                        ((TaskParamType)obj).deserialize(params.get(param.name()));
                        writeMethod.invoke(instance, obj);
                    }
                }
            }
        }
    }