burningwave / reflection / #68

Committed 18 Oct 2023 11:19AM UTC coverage: 74.528% (+5.4%) from 69.107%

Build # #68

Build Type

push

Committed by

Commit Message

Bug fix

Run Details

790 of 1060 relevant lines covered (74.53%)

0.75 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

81.93

/src/main/java/org/burningwave/reflection/Members.java

/*
 * This file is part of Burningwave Reflection.
 *
 * Author: Roberto Gentili
 *
 * Hosted at: https://github.com/burningwave/reflection
 *
 * --
 *
 * The MIT License (MIT)
 *
 * Copyright (c) 2022 Roberto Gentili
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
 * documentation files (the "Software"), to deal in the Software without restriction, including without
 * limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 * the Software, and to permit persons to whom the Software is furnished to do so, subject to the following
 * conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or substantial
 * portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
 * LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
 * EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
 * OR OTHER DEALINGS IN THE SOFTWARE.
 */
package org.burningwave.reflection;


import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Array;
import java.lang.reflect.Executable;
import java.lang.reflect.Member;
import java.lang.reflect.Parameter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.TreeSet;
import java.util.function.BiFunction;
import java.util.function.BiPredicate;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import org.burningwave.Classes;
import org.burningwave.Throwables;
import org.burningwave.TriFunction;

@SuppressWarnings("unchecked")
public class Members {
        public static final Members INSTANCE;
        static final String ALL_FOR_CLASS = "all for class";

        static {
                INSTANCE = new Members();
        }

        private Members() {}

        public <M extends Member> Collection<M> findAll(MemberCriteria<M, ?, ?> criteria, Class<?> classFrom) {
                Collection<M> result = findAll(
                        classFrom,
                        classFrom,
                        criteria.getScanUpToPredicate(),
                        criteria.getMembersSupplier(),
                        criteria.getPredicateOrTruePredicateIfPredicateIsNull(),
                        new HashSet<>(),
                        new LinkedHashSet<>()
                );
                Predicate<Collection<M>> resultPredicate = criteria.getResultPredicate();
                return resultPredicate == null?
                                result :
                                resultPredicate.test(result)?
                                        result :
                                        new LinkedHashSet<>();
        }

        public <M extends Member> M findFirst(MemberCriteria<M, ?, ?> criteria, Class<?> classFrom) {
                Predicate<Collection<M>> resultPredicate = criteria.getResultPredicate();
                if (resultPredicate == null) {
                        return findFirst(
                                classFrom,
                                classFrom,
                                criteria.getScanUpToPredicate(),
                                criteria.getMembersSupplier(),
                                criteria.getPredicateOrTruePredicateIfPredicateIsNull(),
                                new HashSet<>()
                        );
                } else {
                        Collection<M> result = findAll(
                                classFrom,
                                classFrom,
                                criteria.getScanUpToPredicate(),
                                criteria.getMembersSupplier(),
                                criteria.getPredicateOrTruePredicateIfPredicateIsNull(),
                                new HashSet<>(),
                                new LinkedHashSet<>()
                        );
                        return resultPredicate.test(result) ?
                                result.stream().findFirst().orElseGet(() -> null) :
                                null;
                }
        }

        public <M extends Member> M findOne(MemberCriteria<M, ?, ?> criteria, Class<?> classFrom) {
                Collection<M> members = findAll(criteria, classFrom);
                if (members.size() > 1) {
                        Throwables.INSTANCE.throwException("More than one member found for class {}", classFrom.getName());
                }
                return members.stream().findFirst().orElse(null);
        }

        public <M extends Member> boolean match(MemberCriteria<M, ?, ?> criteria, Class<?> classFrom) {
                return findFirst(criteria, classFrom) != null;
        }

        private <M extends Member> Collection<M> findAll(
                Class<?> initialClsFrom,
                Class<?> currentScannedClass,
                BiPredicate<Class<?>, Class<?>> clsPredicate,
                BiFunction<Class<?>, Class<?>, M[]> memberSupplier,
                Predicate<M> predicate,
                Set<Class<?>> visitedInterfaces,
                Collection<M> collection
        ) {
                for (M member : memberSupplier.apply(initialClsFrom, currentScannedClass)) {
                        if (predicate.test(member)) {
                                collection.add(member);
                        }
                }
                for (Class<?> interf : currentScannedClass.getInterfaces()) {
                        if (!visitedInterfaces.add(interf)) {
                                continue;
                        }
                        collection = findAll((Class<?>) initialClsFrom, interf, clsPredicate, memberSupplier, predicate, visitedInterfaces, collection);
                        if (!(collection instanceof Set)) {
                                return collection;
                        }
                        if (clsPredicate.test(initialClsFrom, currentScannedClass)) {
                                return Collections.unmodifiableCollection(collection);
                        }
                }
                Class<?> superClass = currentScannedClass.getSuperclass();
                if (!(collection instanceof Set) || ((superClass = currentScannedClass.getSuperclass()) == null && currentScannedClass.isInterface())) {
                        return collection;
                }
                if (superClass == null || clsPredicate.test(initialClsFrom, currentScannedClass)) {
                        return Collections.unmodifiableCollection(collection);
                }
                return findAll(
                        initialClsFrom,
                        superClass,
                        clsPredicate,
                        memberSupplier,
                        predicate,
                        visitedInterfaces,
                        collection
                );
        }

        private <M extends Member> M findFirst(
                Class<?> initialClsFrom,
                Class<?> currentScannedClass,
                BiPredicate<Class<?>, Class<?>> clsPredicate,
                BiFunction<Class<?>, Class<?>, M[]>
                memberSupplier, Predicate<M> predicate,
                Set<Class<?>> visitedInterfaces
        ) {
                for (M member : memberSupplier.apply(initialClsFrom, currentScannedClass)) {
                        if (predicate.test(member)) {
                                return member;
                        }
                }
                for (Class<?> interf : currentScannedClass.getInterfaces()) {
                        if (!visitedInterfaces.add(interf)) {
                                continue;
                        }
                        M member = findFirst(initialClsFrom, interf, clsPredicate, memberSupplier, predicate, visitedInterfaces);
                        if (member != null || clsPredicate.test(initialClsFrom, currentScannedClass)) {
                                return member;
                        }
                }
                return
                        (clsPredicate.test(initialClsFrom, currentScannedClass) || currentScannedClass.getSuperclass() == null) ?
                                null :
                                findFirst(initialClsFrom, currentScannedClass.getSuperclass(), clsPredicate, memberSupplier, predicate, visitedInterfaces);
        }

        public static abstract class Handler<M extends Member, C extends MemberCriteria<M, C, ?>> {

                public static abstract class OfExecutable<E extends Executable, C extends ExecutableMemberCriteria<E, C, ?>> extends Members.Handler<E, C> {

                        OfExecutable() {}

                        public Collection<MethodHandle> findAllDirectHandle(C criteria, Class<?> clsFrom) {
                                return findAll(
                                        criteria, clsFrom
                                ).stream().map(this::findDirectHandle).collect(Collectors.toSet());
                        }

                        public MethodHandle findDirectHandle(E executable) {
                                return findDirectHandleBox(executable).getHandler();
                        }

                        public MethodHandle findFirstDirectHandle(C criteria, Class<?> clsFrom) {
                                return Optional.ofNullable(findFirst(criteria, clsFrom)).map(this::findDirectHandle).orElseGet(() -> null);
                        }


                        public MethodHandle findOneDirectHandle(C criteria, Class<?> clsFrom) {
                                return Optional.ofNullable(findOne(criteria, clsFrom)).map(this::findDirectHandle).orElseGet(() -> null);
                        }

                        Members.Handler.OfExecutable.Box<E> findDirectHandleBox(E executable) {
                                Class<?> targetClass = executable.getDeclaringClass();
                                String cacheKey = getCacheKey(targetClass, "equals " + retrieveNameForCaching(executable), executable.getParameterTypes());
                                return findDirectHandleBox(executable, cacheKey);
                        }

                        Members.Handler.OfExecutable.Box<E> checkAndGetExecutableBox(Members.Handler.OfExecutable.Box<E> executableBox) {
                                if (executableBox.getHandler() != null) {
                                        return executableBox;
                                }
                                return Throwables.INSTANCE.throwException(executableBox.getException());
                        }

                        Members.Handler.OfExecutable.Box<E> findDirectHandleBox(E executable, String cacheKey) {
                                return checkAndGetExecutableBox(
                                        (Members.Handler.OfExecutable.Box<E>)Cache.INSTANCE.uniqueKeyForExecutableAndMethodHandle.getOrUploadIfAbsent(
                                                cacheKey, () -> {
                                                        Class<?> methodDeclaringClass = executable.getDeclaringClass();
                                                        Collection<Members.Handler.OfExecutable.Box<E>> executableBoxes = new ArrayList<>();
                                                        try {
                                                                return (Members.Handler.OfExecutable.Box<E>)Facade.INSTANCE.executeWithConsulter(
                                                                        methodDeclaringClass,
                                                                        consulter -> {
                                                                                Throwable exception = null;
                                                                                MethodHandle methodHandle = null;
                                                                                try {
                                                                                        methodHandle = retrieveMethodHandle(consulter, executable);
                                                                                } catch (Throwable exc) {
                                                                                        exception = exc;
                                                                                }
                                                                                Members.Handler.OfExecutable.Box<E> executableBox = new Members.Handler.OfExecutable.Box<>(consulter,
                                                                                        executable,
                                                                                        methodHandle,
                                                                                        exception
                                                                                );
                                                                                executableBoxes.add(
                                                                                        executableBox
                                                                                );
                                                                                if (exception != null) {
                                                                                        throw exception;
                                                                                }
                                                                                return executableBox;
                                                                        }
                                                                ).getValue();
                                                        } catch (Throwable exc) {
                                                                return executableBoxes.iterator().next();
                                                        }
                                                }
                                        )
                                );
                        }

                        Object[] getArgumentArray(
                                E member,
                                TriFunction<E, Supplier<List<Object>>, Object[], List<Object>> argumentListSupplier,
                                Supplier<List<Object>> listSupplier,
                                Object... arguments
                        ) {
                                List<Object> argumentList = argumentListSupplier.apply(member, listSupplier, arguments);
                                return argumentList.toArray(new Object[argumentList.size()]);
                        }

                        List<Object> getArgumentListWithArrayForVarArgs(E member, Supplier<List<Object>> argumentListSupplier, Object... arguments) {
                                Parameter[] parameters = member.getParameters();
                                List<Object> argumentList = argumentListSupplier.get();
                                if (arguments != null) {
                                        if (parameters.length > 0 && parameters[parameters.length - 1].isVarArgs()) {
                                                for (int i = 0; i < arguments.length && i < parameters.length - 1; i++) {
                                                        argumentList.add(arguments[i]);
                                                }
                                                Parameter lastParameter = parameters[parameters.length -1];
                                                if (arguments.length == parameters.length) {
                                                        Object lastArgument = arguments[arguments.length -1];
                                                        if (lastArgument != null &&
                                                                lastArgument.getClass().isArray() &&
                                                                lastArgument.getClass().equals(lastParameter.getType())) {
                                                                argumentList.add(lastArgument);
                                                        } else {
                                                                Object array = Array.newInstance(lastParameter.getType().getComponentType(), 1);
                                                                Array.set(array, 0, lastArgument);
                                                                argumentList.add(array);
                                                        }
                                                } else if (arguments.length > parameters.length) {
                                                        Object array = Array.newInstance(lastParameter.getType().getComponentType(), arguments.length - (parameters.length - 1));
                                                        for (int i = parameters.length - 1, j = 0; i < arguments.length; i++, j++) {
                                                                Array.set(array, j, arguments[i]);
                                                        }
                                                        argumentList.add(array);
                                                } else if (arguments.length < parameters.length) {
                                                        argumentList.add(Array.newInstance(lastParameter.getType().getComponentType(),0));
                                                }
                                        } else if (arguments.length > 0) {
                                                for (Object argument : arguments) {
                                                        argumentList.add(argument);
                                                }
                                        }
                                } else {
                                        argumentList.add(null);
                                }
                                return argumentList;
                        }

                        List<Object> getFlatArgumentList(E member, Supplier<List<Object>> argumentListSupplier, Object... arguments) {
                                Parameter[] parameters = member.getParameters();
                                List<Object> argumentList = argumentListSupplier.get();
                                if (arguments != null) {
                                        if (parameters.length > 0 && parameters[parameters.length - 1].isVarArgs()) {
                                                for (int i = 0; i < arguments.length && i < parameters.length - 1; i++) {
                                                        argumentList.add(arguments[i]);
                                                }
                                                if (arguments.length == parameters.length) {
                                                        Parameter lastParameter = parameters[parameters.length -1];
                                                        Object lastArgument = arguments[arguments.length -1];
                                                        if (lastArgument != null &&
                                                                lastArgument.getClass().isArray() &&
                                                                lastArgument.getClass().equals(lastParameter.getType())) {
                                                                for (int i = 0; i < Array.getLength(lastArgument); i++) {
                                                                        argumentList.add(Array.get(lastArgument, i));
                                                                }
                                                        } else {
                                                                argumentList.add(lastArgument);
                                                        }
                                                } else if (arguments.length > parameters.length) {
                                                        for (int i = parameters.length - 1; i < arguments.length; i++) {
                                                                argumentList.add(arguments[i]);
                                                        }
                                                } else if (arguments.length < parameters.length) {
                                                        argumentList.add(null);
                                                }
                                        } else if (arguments.length > 0) {
                                                for (Object argument : arguments) {
                                                        argumentList.add(argument);
                                                }
                                        }
                                } else {
                                        argumentList.add(null);
                                }
                                return argumentList;
                        }

                        abstract MethodHandle retrieveMethodHandle(MethodHandles.Lookup consulter, E executable) throws NoSuchMethodException, IllegalAccessException;

                        abstract String retrieveNameForCaching(E executable);

                        static Class<?>[] retrieveParameterTypes(Executable member, List<Class<?>> argumentsClassesAsList) {
                                Parameter[] memberParameter = member.getParameters();
                                Class<?>[] memberParameterTypes = member.getParameterTypes();
                                if (memberParameter.length > 0 && memberParameter[memberParameter.length - 1].isVarArgs()) {
                                        Class<?> varArgsType =
                                                argumentsClassesAsList.size() > 0 &&
                                                argumentsClassesAsList.get(argumentsClassesAsList.size()-1) != null &&
                                                argumentsClassesAsList.get(argumentsClassesAsList.size()-1).isArray()?
                                                memberParameter[memberParameter.length - 1].getType():
                                                memberParameter[memberParameter.length - 1].getType().getComponentType();
                                        if (memberParameter.length == 1) {
                                                memberParameterTypes = new Class<?>[argumentsClassesAsList.size()];
                                                for (int j = 0; j < memberParameterTypes.length; j++) {
                                                        memberParameterTypes[j] = varArgsType;
                                                }
                                        } else if (memberParameter.length - 1 <= argumentsClassesAsList.size()) {
                                                memberParameterTypes = new Class<?>[argumentsClassesAsList.size()];
                                                for (int j = 0; j < memberParameterTypes.length; j++) {
                                                        if (j < (memberParameter.length - 1)) {
                                                                memberParameterTypes[j] = memberParameter[j].getType();
                                                        } else {
                                                                memberParameterTypes[j] = varArgsType;
                                                        }
                                                }
                                        }
                                }
                                return memberParameterTypes;
                        }

                        Collection<E> searchForExactMatch(Collection<E> members, Class<?>... arguments) {
                                List<Class<?>> argumentsClassesAsList = Arrays.asList(arguments);
                                //Collection<E> membersThatMatch = new LinkedHashSet<>();
                                Collection<E> membersThatMatch = new TreeSet<>(new Comparator<E>() {
                                        @Override
                                        public int compare(E executableOne, E executableTwo) {
                                                Parameter[] executableOneParameters = executableOne.getParameters();
                                                Parameter[] executableTwoParameters = executableTwo.getParameters();
                                                if (executableOneParameters.length == argumentsClassesAsList.size()) {
                                                        if (executableTwoParameters.length == argumentsClassesAsList.size()) {
                                                                if (executableOneParameters.length > 0 && executableOneParameters[executableOneParameters.length - 1].isVarArgs()) {
                                                                        if (executableTwoParameters.length > 0 && executableTwoParameters[executableTwoParameters.length - 1].isVarArgs()) {
                                                                                return 0;
                                                                        }
                                                                        return 1;
                                                                } else if (executableTwoParameters.length > 0 && executableTwoParameters[executableTwoParameters.length - 1].isVarArgs()) {
                                                                        return -1;
                                                                } else {
                                                                        return 0;
                                                                }
                                                        }
                                                        return -1;
                                                } else if (executableTwoParameters.length == argumentsClassesAsList.size()) {
                                                        return 1;
                                                }
                                                return 0;
                                        }

                                });

                                for (E executable : members) {
                                        Class<?>[] parameterTypes = retrieveParameterTypes(executable, argumentsClassesAsList);
                                        boolean exactMatch = true;
                                        for (int i = 0; i < parameterTypes.length; i++) {
                                                if (argumentsClassesAsList.get(i) != null &&
                                                        !Classes.INSTANCE.getClassOrWrapper(argumentsClassesAsList.get(i)).equals(Classes.INSTANCE.getClassOrWrapper(parameterTypes[i]))
                                                ) {
                                                        exactMatch = false;
                                                }
                                        }
                                        if (exactMatch) {
                                                membersThatMatch.add(executable);
                                        }
                                }
                                return membersThatMatch;
                        }

                        public static class Box<E extends Member> {
                                MethodHandles.Lookup consulter;
                                E executable;
                                MethodHandle handler;
                                Throwable exception;

                                Box(final MethodHandles.Lookup consulter, final E executable, final MethodHandle handler, final Throwable exception) {
                                        super();
                                        this.consulter = consulter;
                                        this.executable = executable;
                                        this.handler = handler;
                                        this.exception = exception;
                                }

                                public MethodHandles.Lookup getConsulter() {
                                        return consulter;
                                }

                                public E getExecutable() {
                                        return executable;
                                }

                                public MethodHandle getHandler() {
                                        return handler;
                                }

                                public Throwable getException() {
                                        return exception;
                                }

                        }

                }

                public Collection<M> findAll(C criteria, Class<?> classFrom) {
                        return Members.INSTANCE.findAll(criteria, classFrom);
                }

                public Collection<M> findAllAndMakeThemAccessible(
                        C criteria,
                        Class<?> targetClass
                ) {
                        return findAllAndApply(
                                criteria, targetClass, (member) -> {
                                        setAccessible(member, true);
                                }
                        );
                }

                public M findFirst(C criteria, Class<?> classFrom) {
                        return Members.INSTANCE.findFirst(criteria, classFrom);
                }

                public M findOne(C criteria, Class<?> classFrom) {
                        return Members.INSTANCE.findOne(criteria, classFrom);
                }

                public boolean match(C criteria, Class<?> classFrom) {
                        return Members.INSTANCE.match(criteria, classFrom);
                }

                public void setAccessible(M member, boolean flag) {
                        Facade.INSTANCE.setAccessible(((AccessibleObject)member), flag);
                }

                Collection<M> findAllAndApply(C criteria, Class<?> targetClass, Consumer<M>... consumers) {
                        Collection<M> members = findAll(criteria, targetClass);
                        Optional.ofNullable(consumers).ifPresent(cnsms ->
                                members.stream().forEach(member ->
                                        Stream.of(cnsms).filter(consumer ->
                                                consumer != null
                                        ).forEach(consumer -> {
                                                consumer.accept(member);
                                        })
                                )
                        );
                        return members;
                }

                M findOneAndApply(C criteria, Class<?> targetClass, Consumer<M>... consumers) {
                        M member = findOne(criteria, targetClass);
                        Optional.ofNullable(consumers).ifPresent(cnsms ->
                                Optional.ofNullable(member).ifPresent(mmb ->
                                        Stream.of(cnsms).filter(consumer ->
                                                consumer != null
                                        ).forEach(consumer -> {
                                                consumer.accept(mmb);
                                        })
                                )
                        );
                        return member;
                }

                String getCacheKey(Class<?> targetClass, String groupName, Class<?>... arguments) {
                        if (arguments == null) {
                                arguments = new Class<?>[] {null};
                        }
                        String argumentsKey = "";
                        if (arguments != null && arguments.length > 0) {
                                StringBuffer argumentsKeyStringBuffer = new StringBuffer();
                                Stream.of(arguments).forEach(cls ->
                                        argumentsKeyStringBuffer.append("/" + Optional.ofNullable(cls).map(Class::getName).orElseGet(() ->"null"))
                                );
                                argumentsKey = argumentsKeyStringBuffer.toString();
                        }
                        String cacheKey = "/" + targetClass.getName() + "@" + targetClass.hashCode() +
                                "/" + groupName +
                                argumentsKey;
                        return cacheKey;
                }
        }

}

1	/*
2	* This file is part of Burningwave Reflection.
3	*
4	* Author: Roberto Gentili
5	*
6	* Hosted at: https://github.com/burningwave/reflection
7	*
8	* --
9	*
10	* The MIT License (MIT)
11	*
12	* Copyright (c) 2022 Roberto Gentili
13	*
14	* Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
15	* documentation files (the "Software"), to deal in the Software without restriction, including without
16	* limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
17	* the Software, and to permit persons to whom the Software is furnished to do so, subject to the following
18	* conditions:
19	*
20	* The above copyright notice and this permission notice shall be included in all copies or substantial
21	* portions of the Software.
22	*
23	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
24	* LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
25	* EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
26	* AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
27	* OR OTHER DEALINGS IN THE SOFTWARE.
28	*/
29	package org.burningwave.reflection;
30
31
32	import java.lang.invoke.MethodHandle;
33	import java.lang.invoke.MethodHandles;
34	import java.lang.reflect.AccessibleObject;
35	import java.lang.reflect.Array;
36	import java.lang.reflect.Executable;
37	import java.lang.reflect.Member;
38	import java.lang.reflect.Parameter;
39	import java.util.ArrayList;
40	import java.util.Arrays;
41	import java.util.Collection;
42	import java.util.Collections;
43	import java.util.Comparator;
44	import java.util.HashSet;
45	import java.util.LinkedHashSet;
46	import java.util.List;
47	import java.util.Optional;
48	import java.util.Set;
49	import java.util.TreeSet;
50	import java.util.function.BiFunction;
51	import java.util.function.BiPredicate;
52	import java.util.function.Consumer;
53	import java.util.function.Predicate;
54	import java.util.function.Supplier;
55	import java.util.stream.Collectors;
56	import java.util.stream.Stream;
57
58	import org.burningwave.Classes;
59	import org.burningwave.Throwables;
60	import org.burningwave.TriFunction;
61
62	@SuppressWarnings("unchecked")
63	public class Members {
64	public static final Members INSTANCE;
65	static final String ALL_FOR_CLASS = "all for class";
66
67	static {
68	INSTANCE = new Members();	1✔
69	}	1✔
70
71	private Members() {}	1✔
72
73	public <M extends Member> Collection<M> findAll(MemberCriteria<M, ?, ?> criteria, Class<?> classFrom) {
74	Collection<M> result = findAll(	1✔
75	classFrom,
76	classFrom,
77	criteria.getScanUpToPredicate(),	1✔
78	criteria.getMembersSupplier(),	1✔
79	criteria.getPredicateOrTruePredicateIfPredicateIsNull(),	1✔
80	new HashSet<>(),
81	new LinkedHashSet<>()
82	);
83	Predicate<Collection<M>> resultPredicate = criteria.getResultPredicate();	1✔
84	return resultPredicate == null?	1✔
85	result :
86	resultPredicate.test(result)?	×
87	result :
88	new LinkedHashSet<>();
89	}
90
91	public <M extends Member> M findFirst(MemberCriteria<M, ?, ?> criteria, Class<?> classFrom) {
92	Predicate<Collection<M>> resultPredicate = criteria.getResultPredicate();	1✔
93	if (resultPredicate == null) {	1✔
94	return findFirst(	1✔
95	classFrom,
96	classFrom,
97	criteria.getScanUpToPredicate(),	1✔
98	criteria.getMembersSupplier(),	1✔
99	criteria.getPredicateOrTruePredicateIfPredicateIsNull(),	1✔
100	new HashSet<>()
101	);
102	} else {
103	Collection<M> result = findAll(	×
104	classFrom,
105	classFrom,
106	criteria.getScanUpToPredicate(),	×
107	criteria.getMembersSupplier(),	×
108	criteria.getPredicateOrTruePredicateIfPredicateIsNull(),	×
109	new HashSet<>(),
110	new LinkedHashSet<>()
111	);
112	return resultPredicate.test(result) ?	×
113	result.stream().findFirst().orElseGet(() -> null) :	×
114	null;
115	}
116	}
117
118	public <M extends Member> M findOne(MemberCriteria<M, ?, ?> criteria, Class<?> classFrom) {
119	Collection<M> members = findAll(criteria, classFrom);	1✔
120	if (members.size() > 1) {	1✔
121	Throwables.INSTANCE.throwException("More than one member found for class {}", classFrom.getName());	×
122	}
123	return members.stream().findFirst().orElse(null);	1✔
124	}
125
126	public <M extends Member> boolean match(MemberCriteria<M, ?, ?> criteria, Class<?> classFrom) {
127	return findFirst(criteria, classFrom) != null;	1✔
128	}
129
130	private <M extends Member> Collection<M> findAll(
131	Class<?> initialClsFrom,
132	Class<?> currentScannedClass,
133	BiPredicate<Class<?>, Class<?>> clsPredicate,
134	BiFunction<Class<?>, Class<?>, M[]> memberSupplier,
135	Predicate<M> predicate,
136	Set<Class<?>> visitedInterfaces,
137	Collection<M> collection
138	) {
139	for (M member : memberSupplier.apply(initialClsFrom, currentScannedClass)) {	1✔
140	if (predicate.test(member)) {	1✔
141	collection.add(member);	1✔
142	}
143	}
144	for (Class<?> interf : currentScannedClass.getInterfaces()) {	1✔
145	if (!visitedInterfaces.add(interf)) {	1✔
146	continue;	1✔
147	}
148	collection = findAll((Class<?>) initialClsFrom, interf, clsPredicate, memberSupplier, predicate, visitedInterfaces, collection);	1✔
149	if (!(collection instanceof Set)) {	1✔
150	return collection;	×
151	}
152	if (clsPredicate.test(initialClsFrom, currentScannedClass)) {	1✔
153	return Collections.unmodifiableCollection(collection);	×
154	}
155	}
156	Class<?> superClass = currentScannedClass.getSuperclass();	1✔
157	if (!(collection instanceof Set) \|\| ((superClass = currentScannedClass.getSuperclass()) == null && currentScannedClass.isInterface())) {	1✔
158	return collection;	1✔
159	}
160	if (superClass == null \|\| clsPredicate.test(initialClsFrom, currentScannedClass)) {	1✔
161	return Collections.unmodifiableCollection(collection);	1✔
162	}
163	return findAll(	1✔
164	initialClsFrom,
165	superClass,
166	clsPredicate,
167	memberSupplier,
168	predicate,
169	visitedInterfaces,
170	collection
171	);
172	}
173
174	private <M extends Member> M findFirst(
175	Class<?> initialClsFrom,
176	Class<?> currentScannedClass,
177	BiPredicate<Class<?>, Class<?>> clsPredicate,
178	BiFunction<Class<?>, Class<?>, M[]>
179	memberSupplier, Predicate<M> predicate,
180	Set<Class<?>> visitedInterfaces
181	) {
182	for (M member : memberSupplier.apply(initialClsFrom, currentScannedClass)) {	1✔
183	if (predicate.test(member)) {	1✔
184	return member;	1✔
185	}
186	}
187	for (Class<?> interf : currentScannedClass.getInterfaces()) {	×
188	if (!visitedInterfaces.add(interf)) {	×
189	continue;	×
190	}
191	M member = findFirst(initialClsFrom, interf, clsPredicate, memberSupplier, predicate, visitedInterfaces);	×
192	if (member != null \|\| clsPredicate.test(initialClsFrom, currentScannedClass)) {	×
193	return member;	×
194	}
195	}
196	return	×
197	(clsPredicate.test(initialClsFrom, currentScannedClass) \|\| currentScannedClass.getSuperclass() == null) ?	×
198	null :
199	findFirst(initialClsFrom, currentScannedClass.getSuperclass(), clsPredicate, memberSupplier, predicate, visitedInterfaces);	×
200	}
201
202	public static abstract class Handler<M extends Member, C extends MemberCriteria<M, C, ?>> {	1✔
203
204	public static abstract class OfExecutable<E extends Executable, C extends ExecutableMemberCriteria<E, C, ?>> extends Members.Handler<E, C> {
205
206	OfExecutable() {}	1✔
207
208	public Collection<MethodHandle> findAllDirectHandle(C criteria, Class<?> clsFrom) {
209	return findAll(	×
210	criteria, clsFrom
211	).stream().map(this::findDirectHandle).collect(Collectors.toSet());	×
212	}
213
214	public MethodHandle findDirectHandle(E executable) {
215	return findDirectHandleBox(executable).getHandler();	1✔
216	}
217
218	public MethodHandle findFirstDirectHandle(C criteria, Class<?> clsFrom) {
219	return Optional.ofNullable(findFirst(criteria, clsFrom)).map(this::findDirectHandle).orElseGet(() -> null);	×
220	}
221
222
223	public MethodHandle findOneDirectHandle(C criteria, Class<?> clsFrom) {
224	return Optional.ofNullable(findOne(criteria, clsFrom)).map(this::findDirectHandle).orElseGet(() -> null);	×
225	}
226
227	Members.Handler.OfExecutable.Box<E> findDirectHandleBox(E executable) {
228	Class<?> targetClass = executable.getDeclaringClass();	1✔
229	String cacheKey = getCacheKey(targetClass, "equals " + retrieveNameForCaching(executable), executable.getParameterTypes());	1✔
230	return findDirectHandleBox(executable, cacheKey);	1✔
231	}
232
233	Members.Handler.OfExecutable.Box<E> checkAndGetExecutableBox(Members.Handler.OfExecutable.Box<E> executableBox) {
234	if (executableBox.getHandler() != null) {	1✔
235	return executableBox;	1✔
236	}
237	return Throwables.INSTANCE.throwException(executableBox.getException());	×
238	}
239
240	Members.Handler.OfExecutable.Box<E> findDirectHandleBox(E executable, String cacheKey) {
241	return checkAndGetExecutableBox(	1✔
242	(Members.Handler.OfExecutable.Box<E>)Cache.INSTANCE.uniqueKeyForExecutableAndMethodHandle.getOrUploadIfAbsent(	1✔
243	cacheKey, () -> {
244	Class<?> methodDeclaringClass = executable.getDeclaringClass();	1✔
245	Collection<Members.Handler.OfExecutable.Box<E>> executableBoxes = new ArrayList<>();	1✔
246	try {
247	return (Members.Handler.OfExecutable.Box<E>)Facade.INSTANCE.executeWithConsulter(	1✔
248	methodDeclaringClass,
249	consulter -> {
250	Throwable exception = null;	1✔
251	MethodHandle methodHandle = null;	1✔
252	try {
253	methodHandle = retrieveMethodHandle(consulter, executable);	1✔
254	} catch (Throwable exc) {	1✔
255	exception = exc;	1✔
256	}	1✔
257	Members.Handler.OfExecutable.Box<E> executableBox = new Members.Handler.OfExecutable.Box<>(consulter,	1✔
258	executable,
259	methodHandle,
260	exception
261	);
262	executableBoxes.add(	1✔
263	executableBox
264	);
265	if (exception != null) {	1✔
266	throw exception;	1✔
267	}
268	return executableBox;	1✔
269	}
270	).getValue();	1✔
271	} catch (Throwable exc) {	1✔
272	return executableBoxes.iterator().next();	1✔
273	}
274	}
275	)
276	);
277	}
278
279	Object[] getArgumentArray(
280	E member,
281	TriFunction<E, Supplier<List<Object>>, Object[], List<Object>> argumentListSupplier,
282	Supplier<List<Object>> listSupplier,
283	Object... arguments
284	) {
285	List<Object> argumentList = argumentListSupplier.apply(member, listSupplier, arguments);	1✔
286	return argumentList.toArray(new Object[argumentList.size()]);	1✔
287	}
288
289	List<Object> getArgumentListWithArrayForVarArgs(E member, Supplier<List<Object>> argumentListSupplier, Object... arguments) {
290	Parameter[] parameters = member.getParameters();	1✔
291	List<Object> argumentList = argumentListSupplier.get();	1✔
292	if (arguments != null) {	1✔
293	if (parameters.length > 0 && parameters[parameters.length - 1].isVarArgs()) {	1✔
294	for (int i = 0; i < arguments.length && i < parameters.length - 1; i++) {	1✔
295	argumentList.add(arguments[i]);	1✔
296	}
297	Parameter lastParameter = parameters[parameters.length -1];	1✔
298	if (arguments.length == parameters.length) {	1✔
299	Object lastArgument = arguments[arguments.length -1];	1✔
300	if (lastArgument != null &&	1✔
301	lastArgument.getClass().isArray() &&	1✔
302	lastArgument.getClass().equals(lastParameter.getType())) {	1✔
303	argumentList.add(lastArgument);	1✔
304	} else {
305	Object array = Array.newInstance(lastParameter.getType().getComponentType(), 1);	1✔
306	Array.set(array, 0, lastArgument);	1✔
307	argumentList.add(array);	1✔
308	}
309	} else if (arguments.length > parameters.length) {	1✔
310	Object array = Array.newInstance(lastParameter.getType().getComponentType(), arguments.length - (parameters.length - 1));	1✔
311	for (int i = parameters.length - 1, j = 0; i < arguments.length; i++, j++) {	1✔
312	Array.set(array, j, arguments[i]);	1✔
313	}
314	argumentList.add(array);	1✔
315	} else if (arguments.length < parameters.length) {	1✔
316	argumentList.add(Array.newInstance(lastParameter.getType().getComponentType(),0));	1✔
317	}
318	} else if (arguments.length > 0) {	1✔
319	for (Object argument : arguments) {	1✔
320	argumentList.add(argument);	1✔
321	}
322	}
323	} else {
324	argumentList.add(null);	1✔
325	}
326	return argumentList;	1✔
327	}
328
329	List<Object> getFlatArgumentList(E member, Supplier<List<Object>> argumentListSupplier, Object... arguments) {
330	Parameter[] parameters = member.getParameters();	1✔
331	List<Object> argumentList = argumentListSupplier.get();	1✔
332	if (arguments != null) {	1✔
333	if (parameters.length > 0 && parameters[parameters.length - 1].isVarArgs()) {	1✔
334	for (int i = 0; i < arguments.length && i < parameters.length - 1; i++) {	1✔
335	argumentList.add(arguments[i]);	1✔
336	}
337	if (arguments.length == parameters.length) {	1✔
338	Parameter lastParameter = parameters[parameters.length -1];	1✔
339	Object lastArgument = arguments[arguments.length -1];	1✔
340	if (lastArgument != null &&	1✔
341	lastArgument.getClass().isArray() &&	1✔
342	lastArgument.getClass().equals(lastParameter.getType())) {	1✔
343	for (int i = 0; i < Array.getLength(lastArgument); i++) {	1✔
344	argumentList.add(Array.get(lastArgument, i));	1✔
345	}
346	} else {
347	argumentList.add(lastArgument);	1✔
348	}
349	} else if (arguments.length > parameters.length) {	1✔
350	for (int i = parameters.length - 1; i < arguments.length; i++) {	1✔
351	argumentList.add(arguments[i]);	1✔
352	}
353	} else if (arguments.length < parameters.length) {	1✔
354	argumentList.add(null);	1✔
355	}
356	} else if (arguments.length > 0) {	1✔
357	for (Object argument : arguments) {	1✔
358	argumentList.add(argument);	1✔
359	}
360	}
361	} else {
362	argumentList.add(null);	1✔
363	}
364	return argumentList;	1✔
365	}
366
367	abstract MethodHandle retrieveMethodHandle(MethodHandles.Lookup consulter, E executable) throws NoSuchMethodException, IllegalAccessException;
368
369	abstract String retrieveNameForCaching(E executable);
370
371	static Class<?>[] retrieveParameterTypes(Executable member, List<Class<?>> argumentsClassesAsList) {
372	Parameter[] memberParameter = member.getParameters();	1✔
373	Class<?>[] memberParameterTypes = member.getParameterTypes();	1✔
374	if (memberParameter.length > 0 && memberParameter[memberParameter.length - 1].isVarArgs()) {	1✔
375	Class<?> varArgsType =	1✔
376	argumentsClassesAsList.size() > 0 &&	1✔
377	argumentsClassesAsList.get(argumentsClassesAsList.size()-1) != null &&	1✔
378	argumentsClassesAsList.get(argumentsClassesAsList.size()-1).isArray()?	1✔
379	memberParameter[memberParameter.length - 1].getType():	1✔
380	memberParameter[memberParameter.length - 1].getType().getComponentType();	1✔
381	if (memberParameter.length == 1) {	1✔
382	memberParameterTypes = new Class<?>[argumentsClassesAsList.size()];	1✔
383	for (int j = 0; j < memberParameterTypes.length; j++) {	1✔
384	memberParameterTypes[j] = varArgsType;	1✔
385	}
386	} else if (memberParameter.length - 1 <= argumentsClassesAsList.size()) {	1✔
387	memberParameterTypes = new Class<?>[argumentsClassesAsList.size()];	1✔
388	for (int j = 0; j < memberParameterTypes.length; j++) {	1✔
389	if (j < (memberParameter.length - 1)) {	1✔
390	memberParameterTypes[j] = memberParameter[j].getType();	1✔
391	} else {
392	memberParameterTypes[j] = varArgsType;	1✔
393	}
394	}
395	}
396	}
397	return memberParameterTypes;	1✔
398	}
399
400	Collection<E> searchForExactMatch(Collection<E> members, Class<?>... arguments) {
401	List<Class<?>> argumentsClassesAsList = Arrays.asList(arguments);	1✔
402	//Collection<E> membersThatMatch = new LinkedHashSet<>();
403	Collection<E> membersThatMatch = new TreeSet<>(new Comparator<E>() {	1✔
404	@Override
405	public int compare(E executableOne, E executableTwo) {
406	Parameter[] executableOneParameters = executableOne.getParameters();	1✔
407	Parameter[] executableTwoParameters = executableTwo.getParameters();	1✔
408	if (executableOneParameters.length == argumentsClassesAsList.size()) {	1✔
409	if (executableTwoParameters.length == argumentsClassesAsList.size()) {	1✔
410	if (executableOneParameters.length > 0 && executableOneParameters[executableOneParameters.length - 1].isVarArgs()) {	1✔
411	if (executableTwoParameters.length > 0 && executableTwoParameters[executableTwoParameters.length - 1].isVarArgs()) {	1✔
412	return 0;	1✔
413	}
414	return 1;	×
415	} else if (executableTwoParameters.length > 0 && executableTwoParameters[executableTwoParameters.length - 1].isVarArgs()) {	1✔
416	return -1;	×
417	} else {
418	return 0;	1✔
419	}
420	}
421	return -1;	×
422	} else if (executableTwoParameters.length == argumentsClassesAsList.size()) {	×
423	return 1;	×
424	}
425	return 0;	×
426	}
427
428	});
429
430	for (E executable : members) {	1✔
431	Class<?>[] parameterTypes = retrieveParameterTypes(executable, argumentsClassesAsList);	1✔
432	boolean exactMatch = true;	1✔
433	for (int i = 0; i < parameterTypes.length; i++) {	1✔
434	if (argumentsClassesAsList.get(i) != null &&	1✔
435	!Classes.INSTANCE.getClassOrWrapper(argumentsClassesAsList.get(i)).equals(Classes.INSTANCE.getClassOrWrapper(parameterTypes[i]))	1✔
436	) {
437	exactMatch = false;	1✔
438	}
439	}
440	if (exactMatch) {	1✔
441	membersThatMatch.add(executable);	1✔
442	}
443	}	1✔
444	return membersThatMatch;	1✔
445	}
446
447	public static class Box<E extends Member> {
448	MethodHandles.Lookup consulter;
449	E executable;
450	MethodHandle handler;
451	Throwable exception;
452
453	Box(final MethodHandles.Lookup consulter, final E executable, final MethodHandle handler, final Throwable exception) {
454	super();	1✔
455	this.consulter = consulter;	1✔
456	this.executable = executable;	1✔
457	this.handler = handler;	1✔
458	this.exception = exception;	1✔
459	}	1✔
460
461	public MethodHandles.Lookup getConsulter() {
462	return consulter;	×
463	}
464
465	public E getExecutable() {
466	return executable;	1✔
467	}
468
469	public MethodHandle getHandler() {
470	return handler;	1✔
471	}
472
473	public Throwable getException() {
474	return exception;	1✔
475	}
476
477	}
478
479	}
480
481	public Collection<M> findAll(C criteria, Class<?> classFrom) {
482	return Members.INSTANCE.findAll(criteria, classFrom);	1✔
483	}
484
485	public Collection<M> findAllAndMakeThemAccessible(
486	C criteria,
487	Class<?> targetClass
488	) {
489	return findAllAndApply(	1✔
490	criteria, targetClass, (member) -> {
491	setAccessible(member, true);	1✔
492	}	1✔
493	);
494	}
495
496	public M findFirst(C criteria, Class<?> classFrom) {
497	return Members.INSTANCE.findFirst(criteria, classFrom);	×
498	}
499
500	public M findOne(C criteria, Class<?> classFrom) {
501	return Members.INSTANCE.findOne(criteria, classFrom);	×
502	}
503
504	public boolean match(C criteria, Class<?> classFrom) {
505	return Members.INSTANCE.match(criteria, classFrom);	×
506	}
507
508	public void setAccessible(M member, boolean flag) {
509	Facade.INSTANCE.setAccessible(((AccessibleObject)member), flag);	1✔
510	}	1✔
511
512	Collection<M> findAllAndApply(C criteria, Class<?> targetClass, Consumer<M>... consumers) {
513	Collection<M> members = findAll(criteria, targetClass);	1✔
514	Optional.ofNullable(consumers).ifPresent(cnsms ->	1✔
515	members.stream().forEach(member ->	1✔
516	Stream.of(cnsms).filter(consumer ->	1✔
517	consumer != null	1✔
518	).forEach(consumer -> {	1✔
519	consumer.accept(member);	1✔
520	})	1✔
521	)
522	);
523	return members;	1✔
524	}
525
526	M findOneAndApply(C criteria, Class<?> targetClass, Consumer<M>... consumers) {
527	M member = findOne(criteria, targetClass);	×
528	Optional.ofNullable(consumers).ifPresent(cnsms ->	×
529	Optional.ofNullable(member).ifPresent(mmb ->	×
530	Stream.of(cnsms).filter(consumer ->	×
531	consumer != null	×
532	).forEach(consumer -> {	×
533	consumer.accept(mmb);	×
534	})	×
535	)
536	);
537	return member;	×
538	}
539
540	String getCacheKey(Class<?> targetClass, String groupName, Class<?>... arguments) {
541	if (arguments == null) {	1✔
542	arguments = new Class<?>[] {null};	1✔
543	}
544	String argumentsKey = "";	1✔
545	if (arguments != null && arguments.length > 0) {	1✔
546	StringBuffer argumentsKeyStringBuffer = new StringBuffer();	1✔
547	Stream.of(arguments).forEach(cls ->	1✔
548	argumentsKeyStringBuffer.append("/" + Optional.ofNullable(cls).map(Class::getName).orElseGet(() ->"null"))	1✔
549	);
550	argumentsKey = argumentsKeyStringBuffer.toString();	1✔
551	}
552	String cacheKey = "/" + targetClass.getName() + "@" + targetClass.hashCode() +	1✔
553	"/" + groupName +
554	argumentsKey;
555	return cacheKey;	1✔
556	}
557	}
558
559	}

burningwave / reflection / #68

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous