public Object invoke()

in deltaspike/core/impl/src/main/java/org/apache/deltaspike/core/impl/config/ProxyConfigurationLifecycle.java [59:207]
139 lines of code
28 McCabe index (conditional complexity)

        public Object invoke(final Object proxy, final Method method, final Object[] args) throws Throwable
        {
            if (Object.class == method.getDeclaringClass())
            {
                try
                {
                    return method.invoke(this, args);
                }
                catch (final InvocationTargetException ite)
                {
                    throw ite.getCause();
                }
            }

            Supplier<?> supplier = resolvers.get(method);
            if (supplier == null)
            {
                final ConfigProperty annotation = method.getAnnotation(ConfigProperty.class);
                if (annotation == null)
                {
                    throw new UnsupportedOperationException(
                            method + " doesn't have @ConfigProperty and therefore is illegal");
                }

                // handle primitive bridge there (cdi doesnt support primitives but no reason our proxies don't)
                final Class<? extends ConfigResolver.Converter> converter = annotation.converter();

                final Type genericReturnType = method.getGenericReturnType();
                Class<?> returnType = method.getReturnType();
                final boolean list;
                final boolean set;
                if (converter == ConfigResolver.Converter.class &&
                        ParameterizedType.class.isInstance(genericReturnType))
                {
                    ParameterizedType pt = ParameterizedType.class.cast(genericReturnType);
                    if (List.class == pt.getRawType() && pt.getActualTypeArguments().length == 1)
                    {
                        list = true;
                        set = false;
                        final Type arg = pt.getActualTypeArguments()[0];
                        if (Class.class.isInstance(arg))
                        {
                            returnType = Class.class.cast(arg);
                        }
                    }
                    else if (Set.class == pt.getRawType() && pt.getActualTypeArguments().length == 1)
                    {
                        list = false;
                        set = true;
                        final Type arg = pt.getActualTypeArguments()[0];
                        if (Class.class.isInstance(arg))
                        {
                            returnType = Class.class.cast(arg);
                        }
                    }
                    else
                    {
                        list = false;
                        set = false;
                    }
                }
                else
                {
                    list = false;
                    set = false;

                    if (int.class == returnType)
                    {
                        returnType = Integer.class;
                    }
                    else if (long.class == returnType)
                    {
                        returnType = Long.class;
                    }
                    else if (boolean.class == returnType)
                    {
                        returnType = Boolean.class;
                    }
                    else if (short.class == returnType)
                    {
                        returnType = Short.class;
                    }
                    else if (byte.class == returnType)
                    {
                        returnType = Byte.class;
                    }
                    else if (float.class == returnType)
                    {
                        returnType = Float.class;
                    }
                    else if (double.class == returnType)
                    {
                        returnType = Double.class;
                    }
                }

                final String defaultValue = annotation.defaultValue();
                ConfigResolver.TypedResolver<?> typedResolver = delegate.asResolver(
                        prefix + annotation.name(), list || set ? ConfigProperty.NULL : defaultValue,
                        returnType, converter, annotation.parameterizedBy(),
                        annotation.projectStageAware(), annotation.evaluateVariables());

                if (cacheMs > 0)
                {
                    typedResolver.cacheFor(MILLISECONDS, cacheMs);
                }

                if (list || set)
                {
                    ConfigResolver.TypedResolver<? extends List<?>> listTypedResolver = typedResolver.asList();
                    final ConfigResolver.TypedResolver<? extends List<?>> resolver;
                    if (!ConfigProperty.NULL.equals(defaultValue))
                    {
                        resolver = listTypedResolver.withStringDefault(defaultValue);
                    }
                    else
                    {
                        resolver = listTypedResolver;
                    }

                    if (list)
                    {
                        supplier = new DefaultSupplier(resolver);
                    }
                    else
                    {
                        supplier = new Supplier<Set<?>>()
                        {
                            @Override
                            public Set<?> get()
                            {
                                return new HashSet(resolver.getValue());
                            }
                        };
                    }
                }
                else
                {
                    supplier = new DefaultSupplier(typedResolver);
                }

                final Supplier<?> existing = resolvers.putIfAbsent(method, supplier);
                if (existing != null)
                {
                    supplier = existing;
                }
            }
            return supplier.get();
        }