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

86.05

/src/main/java/org/burningwave/reflection/ExecutableMemberCriteria.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.reflect.Executable;
import java.lang.reflect.Parameter;
import java.util.Arrays;
import java.util.List;
import java.util.function.BiPredicate;
import java.util.function.Predicate;

import org.burningwave.Classes;
import org.burningwave.TriPredicate;
import org.burningwave.reflection.Members.Handler;

@SuppressWarnings("unchecked")
public abstract class ExecutableMemberCriteria<
        E extends Executable,
        C extends ExecutableMemberCriteria<E, C, T>,
        T extends Criteria.TestContext<E, C>
> extends MemberCriteria<E, C, T> {

        public C parameter(final BiPredicate<Parameter[], Integer> predicate) {
                this.predicate = concat(
                        this.predicate,
                        getPredicateWrapper(
                                (testContext, member) -> member.getParameters(),
                                (testContext, array, index) -> predicate.test(array, index)
                        )
                );
                return (C)this;
        }

        public C parameterType(final BiPredicate<Class<?>[], Integer> predicate) {
                this.predicate = concat(
                        this.predicate,
                        getPredicateWrapper(
                                (testContext, member) -> member.getParameterTypes(),
                                (testContext, array, index) -> predicate.test(array, index)
                        )
                );
                return (C)this;
        }


        public C parameterTypes(final Predicate<Class<?>[]> predicate) {
                this.predicate = concat(
                        this.predicate,
                        (context, member) -> predicate.test(member.getParameterTypes())
                );
                return (C)this;
        }

        public C parameterTypesAreAssignableFrom(Class<?>... argumentsClasses) {
                return parameterTypesMatch(
                        (argClasses, paramTypes, innerIdx) ->
                                (argClasses.get(innerIdx) == null || Classes.INSTANCE.isAssignableFrom(paramTypes[innerIdx], argClasses.get(innerIdx))),
                        argumentsClasses
                );
        }

        public C parameterTypesAreAssignableFromTypesOf(Object... arguments) {
                return parameterTypesAreAssignableFrom(Classes.INSTANCE.retrieveFrom(arguments));
        }


        public C parameterTypesExactlyMatch(Class<?>... argumentsClasses) {
                return parameterTypesMatch(
                        (argClasses, paramTypes, innerIdx) ->
                                (argClasses.get(innerIdx) == null || Classes.INSTANCE.getClassOrWrapper(paramTypes[innerIdx]).equals(Classes.INSTANCE.getClassOrWrapper(argClasses.get(innerIdx)))),
                        argumentsClasses
                );
        }


        public C parameterTypesExactlyMatchTypesOf(Object... arguments) {
                return parameterTypesAreAssignableFrom(Classes.INSTANCE.retrieveFrom(arguments));
        }

        private C parameterTypesMatch(TriPredicate<List<Class<?>>, Class<?>[], Integer> predicate, Class<?>... arguments) {
                if (arguments == null) {
                        arguments = new Class<?>[]{null};
                }
                Class<?>[] argumentsClasses = arguments;
                if (argumentsClasses != null && argumentsClasses.length > 0) {
                        List<Class<?>> argumentsClassesAsList = Arrays.asList(argumentsClasses);
                        for (int i = 0; i < argumentsClasses.length; i++) {
                                final int index = i;
                                this.predicate = concat(
                                        this.predicate,
                                        (context, member) -> {
                                                Parameter[] memberParameter = member.getParameters();
                                                if (memberParameter.length > 1 &&
                                                        memberParameter[memberParameter.length - 1].isVarArgs() &&
                                                        (memberParameter.length - 1) > argumentsClassesAsList.size()
                                                ) {
                                                        return false;
                                                }
                                                Class<?>[] memberParameterTypes = Handler.OfExecutable.retrieveParameterTypes(member, argumentsClassesAsList);
                                                if (argumentsClassesAsList.size() == memberParameterTypes.length) {
                                                        return predicate.test(argumentsClassesAsList, memberParameterTypes, index);
                                                } else {
                                                        return false;
                                                }
                                        }
                                );
                                if (index < arguments.length - 1) {
                                        and();
                                }
                        }
                } else {
                        parameterTypes(
                                parameters ->
                                parameters.length == 0
                        );
                }
                return (C)this;
        }
}

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	import java.lang.reflect.Executable;
32	import java.lang.reflect.Parameter;
33	import java.util.Arrays;
34	import java.util.List;
35	import java.util.function.BiPredicate;
36	import java.util.function.Predicate;
37
38	import org.burningwave.Classes;
39	import org.burningwave.TriPredicate;
40	import org.burningwave.reflection.Members.Handler;
41
42	@SuppressWarnings("unchecked")
43	public abstract class ExecutableMemberCriteria<	1✔
44	E extends Executable,
45	C extends ExecutableMemberCriteria<E, C, T>,
46	T extends Criteria.TestContext<E, C>
47	> extends MemberCriteria<E, C, T> {
48
49	public C parameter(final BiPredicate<Parameter[], Integer> predicate) {
50	this.predicate = concat(	1✔
51	this.predicate,
52	getPredicateWrapper(	1✔
53	(testContext, member) -> member.getParameters(),	1✔
54	(testContext, array, index) -> predicate.test(array, index)	1✔
55	)
56	);
57	return (C)this;	1✔
58	}
59
60	public C parameterType(final BiPredicate<Class<?>[], Integer> predicate) {
61	this.predicate = concat(	1✔
62	this.predicate,
63	getPredicateWrapper(	1✔
64	(testContext, member) -> member.getParameterTypes(),	1✔
65	(testContext, array, index) -> predicate.test(array, index)	1✔
66	)
67	);
68	return (C)this;	1✔
69	}
70
71
72	public C parameterTypes(final Predicate<Class<?>[]> predicate) {
73	this.predicate = concat(	1✔
74	this.predicate,
75	(context, member) -> predicate.test(member.getParameterTypes())	1✔
76	);
77	return (C)this;	1✔
78	}
79
80	public C parameterTypesAreAssignableFrom(Class<?>... argumentsClasses) {
81	return parameterTypesMatch(	1✔
82	(argClasses, paramTypes, innerIdx) ->
83	(argClasses.get(innerIdx) == null \|\| Classes.INSTANCE.isAssignableFrom(paramTypes[innerIdx], argClasses.get(innerIdx))),	1✔
84	argumentsClasses
85	);
86	}
87
88	public C parameterTypesAreAssignableFromTypesOf(Object... arguments) {
89	return parameterTypesAreAssignableFrom(Classes.INSTANCE.retrieveFrom(arguments));	×
90	}
91
92
93	public C parameterTypesExactlyMatch(Class<?>... argumentsClasses) {
94	return parameterTypesMatch(	×
95	(argClasses, paramTypes, innerIdx) ->
96	(argClasses.get(innerIdx) == null \|\| Classes.INSTANCE.getClassOrWrapper(paramTypes[innerIdx]).equals(Classes.INSTANCE.getClassOrWrapper(argClasses.get(innerIdx)))),	×
97	argumentsClasses
98	);
99	}
100
101
102	public C parameterTypesExactlyMatchTypesOf(Object... arguments) {
103	return parameterTypesAreAssignableFrom(Classes.INSTANCE.retrieveFrom(arguments));	×
104	}
105
106	private C parameterTypesMatch(TriPredicate<List<Class<?>>, Class<?>[], Integer> predicate, Class<?>... arguments) {
107	if (arguments == null) {	1✔
108	arguments = new Class<?>[]{null};	×
109	}
110	Class<?>[] argumentsClasses = arguments;	1✔
111	if (argumentsClasses != null && argumentsClasses.length > 0) {	1✔
112	List<Class<?>> argumentsClassesAsList = Arrays.asList(argumentsClasses);	1✔
113	for (int i = 0; i < argumentsClasses.length; i++) {	1✔
114	final int index = i;	1✔
115	this.predicate = concat(	1✔
116	this.predicate,
117	(context, member) -> {
118	Parameter[] memberParameter = member.getParameters();	1✔
119	if (memberParameter.length > 1 &&	1✔
120	memberParameter[memberParameter.length - 1].isVarArgs() &&	1✔
121	(memberParameter.length - 1) > argumentsClassesAsList.size()	1✔
122	) {
123	return false;	×
124	}
125	Class<?>[] memberParameterTypes = Handler.OfExecutable.retrieveParameterTypes(member, argumentsClassesAsList);	1✔
126	if (argumentsClassesAsList.size() == memberParameterTypes.length) {	1✔
127	return predicate.test(argumentsClassesAsList, memberParameterTypes, index);	1✔
128	} else {
129	return false;	1✔
130	}
131	}
132	);
133	if (index < arguments.length - 1) {	1✔
134	and();	1✔
135	}
136	}
137	} else {	1✔
138	parameterTypes(	1✔
139	parameters ->
140	parameters.length == 0	1✔
141	);
142	}
143	return (C)this;	1✔
144	}
145	}

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