You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@logging.apache.org by ma...@apache.org on 2020/03/22 22:14:46 UTC
[logging-log4j2] branch mean-bean-machine updated (546ab29 ->
a7fbac6)
This is an automated email from the ASF dual-hosted git repository.
mattsicker pushed a change to branch mean-bean-machine
in repository https://gitbox.apache.org/repos/asf/logging-log4j2.git.
from 546ab29 Make test more explicit
new 5138f52 Split bean loading and validation
new a7fbac6 Clean up use of Variable
The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
.../log4j/plugins/defaults/bean/AbstractBean.java | 5 --
.../plugins/defaults/bean/DefaultBeanManager.java | 80 ++++++++++------------
.../log4j/plugins/defaults/bean/OptionalBean.java | 63 ++++++++++++++---
.../log4j/plugins/defaults/bean/SystemBean.java | 5 --
.../defaults/model/DefaultElementManager.java | 6 --
.../plugins/defaults/model/DefaultVariable.java | 5 --
.../log4j/plugins/spi/bean/BeanManager.java | 26 ++++---
.../log4j/plugins/spi/model/ElementManager.java | 5 --
.../logging/log4j/plugins/spi/model/Variable.java | 2 -
.../log4j/plugins/util/ParameterizedTypeImpl.java | 2 +-
.../logging/log4j/plugins/util/TypeUtil.java | 4 ++
.../log4j/plugins/test/BeanJUnit4Runner.java | 6 +-
12 files changed, 117 insertions(+), 92 deletions(-)
[logging-log4j2] 01/02: Split bean loading and validation
Posted by ma...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
mattsicker pushed a commit to branch mean-bean-machine
in repository https://gitbox.apache.org/repos/asf/logging-log4j2.git
commit 5138f527eaee7fe34c7c2f1bbd1f479e276fcd4c
Author: Matt Sicker <bo...@gmail.com>
AuthorDate: Sun Mar 22 14:29:31 2020 -0500
Split bean loading and validation
Signed-off-by: Matt Sicker <bo...@gmail.com>
---
.../plugins/defaults/bean/DefaultBeanManager.java | 3 ++-
.../log4j/plugins/spi/bean/BeanManager.java | 26 +++++++++++++++-------
.../log4j/plugins/test/BeanJUnit4Runner.java | 6 ++---
3 files changed, 23 insertions(+), 12 deletions(-)
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultBeanManager.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultBeanManager.java
index 46afdbf..5de7ec8 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultBeanManager.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultBeanManager.java
@@ -231,7 +231,8 @@ public class DefaultBeanManager implements BeanManager {
}
}
- private void validateInjectionPoint(final InjectionPoint point) {
+ @Override
+ public void validateInjectionPoint(final InjectionPoint point) {
final MetaElement element = point.getElement();
if (element.isAnnotationPresent(Produces.class)) {
throw new DefinitionException("Cannot inject into a @Produces element: " + element);
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/BeanManager.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/BeanManager.java
index acd772e..9df22e7 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/BeanManager.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/BeanManager.java
@@ -30,8 +30,8 @@ import java.util.Optional;
public interface BeanManager extends AutoCloseable {
/**
- * Loads beans from the given classes. This looks for injectable classes and producers, validates them, registers
- * them in this manager, then returns the loaded beans.
+ * Loads beans from the given classes. This looks for injectable classes and producers in the provided classes,
+ * loads them into this manager, and returns the loaded beans.
*
* @param beanClasses classes to load beans from
* @return beans loaded from the given classes
@@ -39,25 +39,35 @@ public interface BeanManager extends AutoCloseable {
Collection<Bean<?>> loadBeans(final Collection<Class<?>> beanClasses);
/**
- * Loads beans from the given classes. This looks for injectable classes and producers, validates them, registers
- * them in this manager, then returns the loaded beans.
+ * Loads beans from the given classes. This looks for injectable classes and producers, registers them in this
+ * manager, validates them, then returns the validated beans.
*
* @param beanClasses classes to load beans from
* @return beans loaded from the given classes
+ * @throws ValidationException if any beans have validation errors
*/
- default Collection<Bean<?>> loadBeans(final Class<?>... beanClasses) {
- return loadBeans(Arrays.asList(beanClasses));
+ default Collection<Bean<?>> loadAndValidateBeans(final Class<?>... beanClasses) {
+ final Collection<Bean<?>> beans = loadBeans(Arrays.asList(beanClasses));
+ validateBeans(beans);
+ return beans;
}
/**
* Validates beans and throws a {@link ValidationException} if there are any errors.
*
* @param beans beans to check for validation errors
+ * @throws ValidationException if any beans have validation errors
*/
void validateBeans(final Iterable<Bean<?>> beans);
- // TODO: re-add query methods for beans as needed
-// Collection<Bean<?>> getBeans();
+ /**
+ * Validates the given injection point.
+ *
+ * @param point injection point to validate
+ * @throws org.apache.logging.log4j.plugins.spi.DefinitionException if the injection point is improperly defined
+ * @throws org.apache.logging.log4j.plugins.spi.UnsatisfiedBeanException if no beans can satisfy the injection point
+ */
+ void validateInjectionPoint(InjectionPoint point);
/**
* Creates an InitializationContext for a given Bean instance for use in dependency injection SPIs.
diff --git a/log4j-plugins/src/test/java/org/apache/logging/log4j/plugins/test/BeanJUnit4Runner.java b/log4j-plugins/src/test/java/org/apache/logging/log4j/plugins/test/BeanJUnit4Runner.java
index 7376ab7..b1a2eb7 100644
--- a/log4j-plugins/src/test/java/org/apache/logging/log4j/plugins/test/BeanJUnit4Runner.java
+++ b/log4j-plugins/src/test/java/org/apache/logging/log4j/plugins/test/BeanJUnit4Runner.java
@@ -92,10 +92,10 @@ public class BeanJUnit4Runner extends BlockJUnit4ClassRunner {
injector = new DefaultInjector(beanManager);
final WithBeans testClassBeans = getTestClass().getAnnotation(WithBeans.class);
if (testClassBeans != null) {
- beanManager.loadBeans(testClassBeans.value());
+ beanManager.loadAndValidateBeans(testClassBeans.value());
}
final Class<T> testClass = TypeUtil.cast(getTestClass().getJavaClass());
- final Optional<Bean<T>> testBean = beanManager.loadBeans(testClass).stream()
+ final Optional<Bean<T>> testBean = beanManager.loadAndValidateBeans(testClass).stream()
.filter(bean -> bean.hasMatchingType(testClass))
.findAny()
.map(TypeUtil::cast);
@@ -118,7 +118,7 @@ public class BeanJUnit4Runner extends BlockJUnit4ClassRunner {
try (final InitializationContext<T> context = beanManager.createInitializationContext(testClassBean)) {
final WithBeans methodBeans = method.getAnnotation(WithBeans.class);
if (methodBeans != null) {
- beanManager.loadBeans(methodBeans.value());
+ beanManager.loadAndValidateBeans(methodBeans.value());
}
final Class<T> testClass = TypeUtil.cast(getTestClass().getJavaClass());
final MetaClass<T> metaClass = elementManager.getMetaClass(testClass);
[logging-log4j2] 02/02: Clean up use of Variable
Posted by ma...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
mattsicker pushed a commit to branch mean-bean-machine
in repository https://gitbox.apache.org/repos/asf/logging-log4j2.git
commit a7fbac6f9e80fd628b6c214452dc78fdb2c8cc7d
Author: Matt Sicker <bo...@gmail.com>
AuthorDate: Sun Mar 22 17:14:16 2020 -0500
Clean up use of Variable
This now avoids some hacks from previous commits.
Signed-off-by: Matt Sicker <bo...@gmail.com>
---
.../log4j/plugins/defaults/bean/AbstractBean.java | 5 --
.../plugins/defaults/bean/DefaultBeanManager.java | 77 ++++++++++------------
.../log4j/plugins/defaults/bean/OptionalBean.java | 63 +++++++++++++++---
.../log4j/plugins/defaults/bean/SystemBean.java | 5 --
.../defaults/model/DefaultElementManager.java | 6 --
.../plugins/defaults/model/DefaultVariable.java | 5 --
.../log4j/plugins/spi/model/ElementManager.java | 5 --
.../logging/log4j/plugins/spi/model/Variable.java | 2 -
.../log4j/plugins/util/ParameterizedTypeImpl.java | 2 +-
.../logging/log4j/plugins/util/TypeUtil.java | 4 ++
10 files changed, 94 insertions(+), 80 deletions(-)
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/AbstractBean.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/AbstractBean.java
index 1798af1..74f75c7 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/AbstractBean.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/AbstractBean.java
@@ -47,11 +47,6 @@ abstract class AbstractBean<T> implements Bean<T> {
}
@Override
- public Variable withTypes(final Collection<Type> types) {
- return variable.withTypes(types);
- }
-
- @Override
public Qualifiers getQualifiers() {
return variable.getQualifiers();
}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultBeanManager.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultBeanManager.java
index 5de7ec8..93196fe 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultBeanManager.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultBeanManager.java
@@ -46,7 +46,7 @@ import org.apache.logging.log4j.plugins.spi.model.MetaMethod;
import org.apache.logging.log4j.plugins.spi.model.MetaParameter;
import org.apache.logging.log4j.plugins.spi.model.Qualifiers;
import org.apache.logging.log4j.plugins.spi.model.Variable;
-import org.apache.logging.log4j.plugins.util.ParameterizedTypeImpl;
+import org.apache.logging.log4j.plugins.util.LazyValue;
import org.apache.logging.log4j.plugins.util.TypeUtil;
import java.lang.annotation.Annotation;
@@ -64,7 +64,6 @@ import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
-import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.Stream;
@@ -75,7 +74,6 @@ public class DefaultBeanManager implements BeanManager {
private final Collection<Bean<?>> enabledBeans = ConcurrentHashMap.newKeySet();
private final Map<Type, Collection<Bean<?>>> beansByType = new ConcurrentHashMap<>();
- private final Collection<Bean<?>> sharedBeans = ConcurrentHashMap.newKeySet();
private final Collection<DisposesMethod<?>> disposesMethods = Collections.synchronizedCollection(new ArrayList<>());
private final Map<Class<? extends Annotation>, ScopeContext> scopes = new ConcurrentHashMap<>();
@@ -121,9 +119,6 @@ public class DefaultBeanManager implements BeanManager {
private <T> Bean<T> addBean(final Bean<T> bean) {
if (enabledBeans.add(bean)) {
addBeanTypes(bean);
- if (!bean.isDependentScoped() && !isSystemBean(bean)) {
- sharedBeans.add(bean);
- }
}
return bean;
}
@@ -144,11 +139,7 @@ public class DefaultBeanManager implements BeanManager {
}
private void addBeanType(final Bean<?> bean, final Type type) {
- beansByType.computeIfAbsent(type, ignored -> new HashSet<>()).add(bean);
- }
-
- private boolean isSystemBean(final Bean<?> bean) {
- return bean instanceof SystemBean<?>;
+ beansByType.computeIfAbsent(type, ignored -> ConcurrentHashMap.newKeySet()).add(bean);
}
private <T> void loadDisposerMethods(final MetaClass<T> metaClass, final Bean<T> bean) {
@@ -257,7 +248,7 @@ public class DefaultBeanManager implements BeanManager {
validateBeanInjectionPoint(point, ((ProducerBean<?>) bean).getType());
}
}
- final Optional<Bean<?>> bean = getBeanForInjectionPoint(point);
+ final Optional<Bean<Object>> bean = getBeanForInjectionPoint(point);
if (!bean.isPresent() && !rawType.equals(Optional.class)) {
throw new UnsatisfiedBeanException(point);
}
@@ -282,13 +273,12 @@ public class DefaultBeanManager implements BeanManager {
}
}
- private Optional<Bean<?>> getBeanForInjectionPoint(final InjectionPoint point) {
+ private <T> Optional<Bean<T>> getBeanForInjectionPoint(final InjectionPoint point) {
// TODO: this will need to allow for TypeConverter usage somehow
// first, look for an existing bean
final Type type = point.getType();
final Qualifiers qualifiers = point.getQualifiers();
- final Optional<Bean<?>> existingBean = getExistingOrProvidedBean(type, qualifiers,
- () -> elementManager.createVariable(point));
+ final Optional<Bean<T>> existingBean = getExistingOrProvidedBean(type, qualifiers);
if (existingBean.isPresent()) {
return existingBean;
}
@@ -297,34 +287,30 @@ public class DefaultBeanManager implements BeanManager {
if (rawType == Provider.class) {
final Type actualType = ((ParameterizedType) type).getActualTypeArguments()[0];
// if a Provider<T> is requested, we can convert an existing Bean<T> into a Bean<Provider<T>>
- return getExistingBean(actualType, qualifiers)
- .map(bean -> new ProviderBean<>(
- elementManager.createVariable(point), context -> getValue(bean, context)))
- .map(this::addBean);
+ final Optional<Bean<T>> actualExistingBean = getExistingBean(actualType, qualifiers);
+ return actualExistingBean.map(bean -> new ProviderBean<>(bean, context -> getValue(bean, context)))
+ .map(this::addBean)
+ .map(TypeUtil::cast);
} else if (rawType == Optional.class) {
final Type actualType = ((ParameterizedType) type).getActualTypeArguments()[0];
- final Variable variable = elementManager.createVariable(point);
- return Optional.of(createOptionalBean(actualType, qualifiers, variable));
+ // fake T like in Provider above
+ final Bean<Optional<T>> optionalBean = createOptionalBean(type, actualType, qualifiers);
+ return Optional.of(optionalBean).map(TypeUtil::cast);
}
}
return Optional.empty();
}
- private Optional<Bean<?>> getExistingOrProvidedBean(final Type type, final Qualifiers qualifiers,
- final Supplier<Variable> variableSupplier) {
- final Optional<Bean<?>> existingBean = getExistingBean(type, qualifiers);
+ private <T> Optional<Bean<T>> getExistingOrProvidedBean(final Type type, final Qualifiers qualifiers) {
+ final Optional<Bean<T>> existingBean = getExistingBean(type, qualifiers);
if (existingBean.isPresent()) {
return existingBean;
}
- final Type providerType = new ParameterizedTypeImpl(null, Provider.class, type);
- return getExistingBean(providerType, qualifiers)
- .<Bean<Provider<?>>>map(TypeUtil::cast)
- .map(bean -> new ProvidedBean<>(variableSupplier.get(), context -> getValue(bean, context).get()))
- .map(this::addBean);
+ return getProvidedBean(type, qualifiers);
}
- private Optional<Bean<?>> getExistingBean(final Type type, final Qualifiers qualifiers) {
- final Set<Bean<?>> beans = beansWithType(type)
+ private <T> Optional<Bean<T>> getExistingBean(final Type type, final Qualifiers qualifiers) {
+ final Set<Bean<T>> beans = this.<T>beansWithType(type)
.filter(bean -> qualifiers.equals(bean.getQualifiers()))
.collect(Collectors.toSet());
if (beans.size() > 1) {
@@ -333,24 +319,30 @@ public class DefaultBeanManager implements BeanManager {
return beans.isEmpty() ? Optional.empty() : Optional.of(beans.iterator().next());
}
- private Stream<Bean<?>> beansWithType(final Type requiredType) {
+ private <T> Optional<Bean<T>> getProvidedBean(final Type providedType, final Qualifiers qualifiers) {
+ return getExistingBean(TypeUtil.getParameterizedType(Provider.class, providedType), qualifiers)
+ .<Bean<Provider<T>>>map(TypeUtil::cast)
+ .map(bean -> new ProvidedBean<>(bean, context -> getValue(bean, context).get()))
+ .map(this::addBean);
+ }
+
+ private <T> Stream<Bean<T>> beansWithType(final Type requiredType) {
if (beansByType.containsKey(requiredType)) {
- return beansByType.get(requiredType).stream();
+ return beansByType.get(requiredType).stream().map(TypeUtil::cast);
}
if (requiredType instanceof ParameterizedType) {
return beansByType.getOrDefault(((ParameterizedType) requiredType).getRawType(), Collections.emptySet())
.stream()
- .filter(bean -> bean.hasMatchingType(requiredType));
+ .filter(bean -> bean.hasMatchingType(requiredType))
+ .map(TypeUtil::cast);
}
return Stream.empty();
}
- private Bean<?> createOptionalBean(final Type actualType, final Qualifiers qualifiers, final Variable variable) {
- final Supplier<Variable> variableSupplier = () -> variable.withTypes(TypeUtil.getTypeClosure(actualType));
- final Bean<?> optionalBean = new OptionalBean<>(variable, context ->
- getExistingOrProvidedBean(actualType, qualifiers, variableSupplier)
- .map(bean -> getValue(bean, context)));
- return addBean(optionalBean);
+ private <T> Bean<Optional<T>> createOptionalBean(final Type type, final Type typeArgument, final Qualifiers qualifiers) {
+ return addBean(new OptionalBean<>(type, qualifiers,
+ LazyValue.forSupplier(() -> getExistingOrProvidedBean(typeArgument, qualifiers)),
+ this::getValue));
}
@Override
@@ -376,8 +368,8 @@ public class DefaultBeanManager implements BeanManager {
@Override
public <T> Optional<T> getInjectableValue(final InjectionPoint point, final InitializationContext<?> parentContext) {
- final Optional<Bean<T>> optionalResolvedBean = getBeanForInjectionPoint(point).map(TypeUtil::cast);
- final Bean<T> resolvedBean = optionalResolvedBean.orElseThrow(() -> new UnsatisfiedBeanException(point));
+ final Bean<T> resolvedBean = this.<T>getBeanForInjectionPoint(point)
+ .orElseThrow(() -> new UnsatisfiedBeanException(point));
final Optional<T> existingValue = point.getBean()
.filter(bean -> !bean.equals(resolvedBean))
.flatMap(bean -> getExistingValue(resolvedBean, bean, parentContext));
@@ -406,7 +398,6 @@ public class DefaultBeanManager implements BeanManager {
public void close() {
beansByType.clear();
enabledBeans.clear();
- sharedBeans.clear();
disposesMethods.clear();
scopes.values().forEach(ScopeContext::close);
scopes.clear();
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/OptionalBean.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/OptionalBean.java
index d98ce88..a0d6feb 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/OptionalBean.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/OptionalBean.java
@@ -17,22 +17,69 @@
package org.apache.logging.log4j.plugins.defaults.bean;
-import org.apache.logging.log4j.plugins.spi.model.Variable;
+import org.apache.logging.log4j.plugins.api.DependentScoped;
+import org.apache.logging.log4j.plugins.spi.bean.Bean;
import org.apache.logging.log4j.plugins.spi.bean.InitializationContext;
+import org.apache.logging.log4j.plugins.spi.model.InjectionPoint;
+import org.apache.logging.log4j.plugins.spi.model.MetaClass;
+import org.apache.logging.log4j.plugins.spi.model.Qualifiers;
+import org.apache.logging.log4j.plugins.util.TypeUtil;
+import org.apache.logging.log4j.plugins.util.Value;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Type;
+import java.util.Collection;
+import java.util.Collections;
import java.util.Optional;
-import java.util.function.Function;
+import java.util.function.BiFunction;
-class OptionalBean<T> extends SystemBean<Optional<T>> {
- private final Function<InitializationContext<?>, Optional<T>> optionalValueFactory;
+class OptionalBean<T> implements Bean<Optional<T>> {
+ private final Type type;
+ private final Qualifiers qualifiers;
+ private final Value<Optional<Bean<T>>> optionalBean;
+ private final BiFunction<Bean<T>, InitializationContext<?>, T> getBeanValue;
- OptionalBean(final Variable variable, final Function<InitializationContext<?>, Optional<T>> optionalValueFactory) {
- super(variable);
- this.optionalValueFactory = optionalValueFactory;
+ OptionalBean(final Type type, final Qualifiers qualifiers, final Value<Optional<Bean<T>>> optionalBean,
+ final BiFunction<Bean<T>, InitializationContext<?>, T> getBeanValue) {
+ this.type = type;
+ this.qualifiers = qualifiers;
+ this.optionalBean = optionalBean;
+ this.getBeanValue = getBeanValue;
+ }
+
+ @Override
+ public Collection<Type> getTypes() {
+ return TypeUtil.getTypeClosure(type);
+ }
+
+ @Override
+ public Qualifiers getQualifiers() {
+ return qualifiers;
+ }
+
+ @Override
+ public Class<? extends Annotation> getScopeType() {
+ final Optional<Class<? extends Annotation>> scopeType = optionalBean.get().map(Bean::getScopeType);
+ return scopeType.orElse(DependentScoped.class);
}
@Override
public Optional<T> create(final InitializationContext<Optional<T>> context) {
- return optionalValueFactory.apply(context);
+ return optionalBean.get().map(bean -> getBeanValue.apply(bean, context));
+ }
+
+ @Override
+ public void destroy(final Optional<T> instance, final InitializationContext<Optional<T>> context) {
+ context.close();
+ }
+
+ @Override
+ public Collection<InjectionPoint> getInjectionPoints() {
+ return optionalBean.get().map(Bean::getInjectionPoints).orElse(Collections.emptySet());
+ }
+
+ @Override
+ public MetaClass<?> getDeclaringClass() {
+ return optionalBean.get().map(Bean::getDeclaringClass).orElse(null);
}
}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/SystemBean.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/SystemBean.java
index 00771f8..c00eab6 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/SystemBean.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/SystemBean.java
@@ -42,11 +42,6 @@ abstract class SystemBean<T> implements Bean<T> {
}
@Override
- public Variable withTypes(final Collection<Type> types) {
- return variable.withTypes(types);
- }
-
- @Override
public Qualifiers getQualifiers() {
return variable.getQualifiers();
}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultElementManager.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultElementManager.java
index 9fed171..79fa0e1 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultElementManager.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultElementManager.java
@@ -184,12 +184,6 @@ public class DefaultElementManager implements ElementManager {
return createVariable(element, getQualifiers(element));
}
- @Override
- public Variable createVariable(final InjectionPoint point) {
- Objects.requireNonNull(point);
- return createVariable(point.getElement(), point.getQualifiers());
- }
-
private Variable createVariable(final MetaElement element, final Qualifiers qualifiers) {
final Collection<Type> types = element.getTypeClosure();
final Class<? extends Annotation> scopeType = getScopeType(element);
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultVariable.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultVariable.java
index 8fd2160..cc7cf4a 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultVariable.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultVariable.java
@@ -44,11 +44,6 @@ public class DefaultVariable implements Variable {
}
@Override
- public Variable withTypes(final Collection<Type> types) {
- return new DefaultVariable(types, getQualifiers(), getScopeType());
- }
-
- @Override
public Qualifiers getQualifiers() {
return qualifiers;
}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/ElementManager.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/ElementManager.java
index 32d94e2..5c98901 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/ElementManager.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/ElementManager.java
@@ -147,11 +147,6 @@ public interface ElementManager extends AutoCloseable {
*/
Variable createVariable(final MetaElement element);
- /**
- * Creates a variable for an injection point.
- */
- Variable createVariable(final InjectionPoint point);
-
@Override
void close();
}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/Variable.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/Variable.java
index 31b379a..789c886 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/Variable.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/Variable.java
@@ -27,8 +27,6 @@ import java.util.Collection;
public interface Variable {
Collection<Type> getTypes();
- Variable withTypes(final Collection<Type> types);
-
default boolean hasMatchingType(final Type requiredType) {
for (final Type type : getTypes()) {
if (TypeUtil.typesMatch(requiredType, type)) {
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/util/ParameterizedTypeImpl.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/util/ParameterizedTypeImpl.java
index 682a16a..b9a66e8 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/util/ParameterizedTypeImpl.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/util/ParameterizedTypeImpl.java
@@ -27,7 +27,7 @@ public class ParameterizedTypeImpl implements ParameterizedType {
private final Type rawType;
private final Type[] actualTypeArguments;
- public ParameterizedTypeImpl(final Type ownerType, final Type rawType, final Type... actualTypeArguments) {
+ ParameterizedTypeImpl(final Type ownerType, final Type rawType, final Type... actualTypeArguments) {
this.ownerType = ownerType;
this.rawType = rawType;
this.actualTypeArguments = actualTypeArguments;
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/util/TypeUtil.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/util/TypeUtil.java
index bd125dc..8f53575 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/util/TypeUtil.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/util/TypeUtil.java
@@ -538,4 +538,8 @@ public final class TypeUtil {
return t;
}
+ public static ParameterizedType getParameterizedType(final Type rawType, final Type... typeArguments) {
+ return new ParameterizedTypeImpl(null, rawType, typeArguments);
+ }
+
}