Add MatcherOperatorRegistry and MatcherOperatorRetriever (#1237)

Author: rlaxowns7916

fixture-monkey-api/src/main/java/com/navercorp/fixturemonkey/api/introspector/JavaArbitraryIntrospector.java

@@ -30,8 +30,6 @@
 
 import com.navercorp.fixturemonkey.api.arbitrary.JavaTypeArbitraryGeneratorSet;
 import com.navercorp.fixturemonkey.api.generator.ArbitraryGeneratorContext;
-import com.navercorp.fixturemonkey.api.introspector.ArbitraryIntrospector;
-import com.navercorp.fixturemonkey.api.introspector.ArbitraryIntrospectorResult;
 import com.navercorp.fixturemonkey.api.matcher.Matcher;
 import com.navercorp.fixturemonkey.api.property.Property;
 import com.navercorp.fixturemonkey.api.type.Types;

fixture-monkey-api/src/main/java/com/navercorp/fixturemonkey/api/matcher/AssignableTypeMatcher.java

@@ -37,4 +37,8 @@ public boolean match(Property property) {
 		Class<?> propertyType = Types.getActualType(property.getType());
 		return this.type.isAssignableFrom(propertyType);
 	}
+
+	public Class<?> getAnchorType() {
+		return this.type;
+	}
 }

fixture-monkey-api/src/main/java/com/navercorp/fixturemonkey/api/matcher/DefaultMatcherOperatorContainer.java

@@ -0,0 +1,110 @@
+/*
+ * Fixture Monkey
+ *
+ * Copyright (c) 2021-present NAVER Corp.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+package com.navercorp.fixturemonkey.api.matcher;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Collectors;
+
+import com.navercorp.fixturemonkey.api.property.Property;
+import com.navercorp.fixturemonkey.api.type.Types;
+import com.navercorp.fixturemonkey.api.type.Types.UnidentifiableType;
+
+public final class DefaultMatcherOperatorContainer<T>
+	implements MatcherOperatorRegistry<T>, MatcherOperatorRetriever<T> {
+	private final AtomicInteger sequenceIssuer = new AtomicInteger(0);
+	private final List<PriorityMatcherOperator<T>> typeUnknownIntrospectors = new ArrayList<>();
+	private final Map<Class<?>, List<PriorityMatcherOperator<T>>> typeAwareIntrospectors = new HashMap<>();
+	private final Map<Class<?>, List<PriorityMatcherOperator<T>>> typeAssignableIntrospectors = new HashMap<>();
+
+	@Override
+	public void addFirst(MatcherOperator<T> matcherOperator) {
+		addInternal(matcherOperator, true);
+	}
+
+	@Override
+	public void addLast(MatcherOperator<T> matcherOperator) {
+		addInternal(matcherOperator, false);
+	}
+
+	@Override
+	public List<MatcherOperator<T>> getListByProperty(Property property) {
+		Class<?> propertyType = Types.getActualType(property.getType());
+		List<PriorityMatcherOperator<T>> acc = new ArrayList<>(typeUnknownIntrospectors);
+
+		if (propertyType != UnidentifiableType.class) {
+			for (Map.Entry<Class<?>, List<PriorityMatcherOperator<T>>> e : typeAssignableIntrospectors.entrySet()) {
+				Class<?> anchorType = e.getKey();
+				if (anchorType.isAssignableFrom(propertyType)) {
+					acc.addAll(e.getValue());
+				}
+			}
+
+			acc.addAll(typeAwareIntrospectors.getOrDefault(propertyType, Collections.emptyList()));
+		}
+
+		return acc.stream()
+			.sorted(Comparator.comparingInt(PriorityMatcherOperator::getPriority))
+			.map(op -> (MatcherOperator<T>)op)
+			.collect(Collectors.toList());
+	}
+
+	@Override
+	public List<MatcherOperator<T>> getList() {
+		List<PriorityMatcherOperator<T>> acc = new ArrayList<>(typeUnknownIntrospectors);
+		typeAwareIntrospectors.values().forEach(acc::addAll);
+		typeAssignableIntrospectors.values().forEach(acc::addAll);
+
+		return acc.stream()
+			.sorted(Comparator.comparingInt(PriorityMatcherOperator::getPriority))
+			.map(op -> (MatcherOperator<T>)op)
+			.collect(Collectors.toList());
+	}
+
+	private void addInternal(MatcherOperator<T> matcherOperator, boolean prepend) {
+		int seq = sequenceIssuer.incrementAndGet();
+		int sequence = prepend ? -seq : seq;
+
+		Matcher matcher = matcherOperator.getMatcher();
+		T operator = matcherOperator.getOperator();
+
+		PriorityMatcherOperator<T> priorityMatcherOperator = new PriorityMatcherOperator<>(
+			matcher,
+			operator,
+			sequence
+		);
+
+		if (matcher instanceof ExactTypeMatcher) {
+			Class<?> type = ((ExactTypeMatcher)matcher).getType();
+			typeAwareIntrospectors.computeIfAbsent(type, k -> new ArrayList<>()).add(priorityMatcherOperator);
+		} else if (matcher instanceof AssignableTypeMatcher) {
+			Class<?> anchorType = ((AssignableTypeMatcher)matcher).getAnchorType();
+			typeAssignableIntrospectors.computeIfAbsent(anchorType, k -> new ArrayList<>())
+				.add(priorityMatcherOperator);
+		} else {
+			typeUnknownIntrospectors.add(priorityMatcherOperator);
+		}
+	}
+}

fixture-monkey-api/src/main/java/com/navercorp/fixturemonkey/api/matcher/ExactTypeMatcher.java

@@ -32,6 +32,10 @@ public ExactTypeMatcher(Class<?> type) {
 		this.type = type;
 	}
 
+	public Class<?> getType() {
+		return this.type;
+	}
+
 	@Override
 	public boolean match(Property property) {
 		return this.type == Types.getActualType(property.getType());

fixture-monkey-api/src/main/java/com/navercorp/fixturemonkey/api/matcher/MatcherOperatorRegistry.java

@@ -0,0 +1,31 @@
+/*
+ * Fixture Monkey
+ *
+ * Copyright (c) 2021-present NAVER Corp.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.navercorp.fixturemonkey.api.matcher;
+
+import static org.apiguardian.api.API.Status.EXPERIMENTAL;
+
+import org.apiguardian.api.API;
+
+@API(since = "1.1.16", status = EXPERIMENTAL)
+public interface MatcherOperatorRegistry<T> {
+
+	void addFirst(MatcherOperator<T> matcherOperator);
+
+	void addLast(MatcherOperator<T> matcherOperator);
+}

fixture-monkey-api/src/main/java/com/navercorp/fixturemonkey/api/matcher/MatcherOperatorRetriever.java

@@ -0,0 +1,30 @@
+/*
+ * Fixture Monkey
+ *
+ * Copyright (c) 2021-present NAVER Corp.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.navercorp.fixturemonkey.api.matcher;
+
+import java.util.List;
+
+import com.navercorp.fixturemonkey.api.property.Property;
+
+public interface MatcherOperatorRetriever<T> {
+
+	List<MatcherOperator<T>> getList();
+
+	List<MatcherOperator<T>> getListByProperty(Property property);
+}

fixture-monkey-api/src/main/java/com/navercorp/fixturemonkey/api/matcher/PriorityMatcherOperator.java

@@ -24,9 +24,11 @@
 
 /**
  * A class that represents a matcher operator with a priority.
+ * Priority may be negative or positive. {@link DefaultMatcherOperatorContainer}
  * This class extends {@link MatcherOperator} and adds a priority field.
  * This class is intended for internal use only.
  *
+ *
  * @param <T> the type of the operator
  * @since 1.1.15
  */
@@ -40,7 +42,6 @@ public PriorityMatcherOperator(
 		int priority
 	) {
 		super(matcher, operator);
-		checkPriority(priority);
 		this.priority = priority;
 	}
 
@@ -52,16 +53,4 @@ public PriorityMatcherOperator(
 	public int getPriority() {
 		return priority;
 	}
-
-	/**
-	 * Checks if the priority is valid.
-	 *
-	 * @param priority the priority to be checked
-	 * @throws IllegalArgumentException if the priority is less than 0
-	 */
-	private void checkPriority(int priority) {
-		if (priority < 0) {
-			throw new IllegalArgumentException("Priority must be greater than or equal to 0");
-		}
-	}
 }