You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@deltaspike.apache.org by st...@apache.org on 2023/01/30 19:04:32 UTC
[deltaspike] 06/06: Merge branch 'master' into fb_ds20
This is an automated email from the ASF dual-hosted git repository.
struberg pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/deltaspike.git
commit 3484119c070198be99fc73b87baf31352a43d8d3
Merge: 851d8e241 91dc80c21
Author: Mark Struberg <st...@apache.org>
AuthorDate: Mon Jan 30 20:03:12 2023 +0100
Merge branch 'master' into fb_ds20
also fix more of the setup and move to CDI-3.0
build.sh | 33 --
deltaspike/buildall.sh => buildall.sh | 5 +-
.../cdise/weld/WeldContainerControl.java | 72 ++-
.../main/resources/deltaspike/default-checks.xml | 2 +-
.../deltaspike/core/api/control/HandlerMethod.java | 4 +-
.../core/api/literal/AlternativeLiteral.java | 2 +-
.../deltaspike/core/api/literal/AnyLiteral.java | 2 +-
.../deltaspike/core/api/literal/ModelLiteral.java | 2 +-
.../deltaspike/core/api/literal/NamedLiteral.java | 2 +-
.../core/api/literal/SingletonLiteral.java | 2 +-
.../deltaspike/core/api/literal/TypedLiteral.java | 2 +-
.../core/util/ParentExtensionStorage.java | 2 +-
.../core/util/bean/BaseImmutableBean.java | 2 +-
.../deltaspike/core/util/bean/BeanBuilder.java | 2 +-
.../deltaspike/core/util/bean/ImmutableBean.java | 8 +-
.../util/bean/ImmutablePassivationCapableBean.java | 8 +-
.../core/util/bean/WrappingBeanBuilder.java | 4 +-
.../deltaspike/core/api/config/ConfigProperty.java | 17 +
.../deltaspike/core/api/config/ConfigResolver.java | 42 ++
.../core/api/config/PropertyFileConfig.java | 2 +-
.../core/api/config/base/CoreBaseConfig.java | 4 +
.../core/api/provider/BeanManagerProvider.java | 2 +-
.../deltaspike/core/api/provider/BeanProvider.java | 5 +-
.../spi/config/BaseConfigPropertyProducer.java | 44 +-
.../deltaspike/core/spi/config/ConfigSource.java | 22 +-
.../apache/deltaspike/core/util/ClassUtils.java | 28 +-
.../core/util/context/ContextualInstanceInfo.java | 2 +-
.../core/util/context/ContextualStorage.java | 2 +-
.../util/metadata/AnnotationInstanceProvider.java | 6 +-
.../activation/ClassDeactivationEarFileTest.java | 10 +-
.../deltaspike/core/impl/config/ConfigImpl.java | 17 +-
.../core/impl/config/ConfigurationExtension.java | 6 -
.../impl/config/DefaultConfigPropertyProducer.java | 40 ++
.../core/impl/config/DeltaSpikeConfigInfo.java | 504 ++++++++++-----------
.../impl/config/DeltaSpikeConfigInfoMBean.java | 66 +--
.../core/impl/config/TypedResolverImpl.java | 89 +++-
.../config/converter/BeanConverterFactory.java | 71 +++
.../config/converter/CtInjectionBeanConverter.java | 87 ++++
.../converter/FieldInjectionBeanConverter.java | 88 ++++
.../impl/monitoring/InvocationResultLogger.java | 6 +
.../core/impl/util/AnnotationInstanceUtils.java | 2 +-
.../core/api/config/BeanConfigResolverTest.java | 74 +++
.../test/core/api/config/ConfigResolverTest.java | 3 +
.../core/api/config/TestConfigSourceProvider.java | 14 +-
.../ServerEndpointPojoWithCt.java} | 24 +-
.../config/beans/ServerEndpointPojoWithFields.java | 62 +++
.../injectable/InjectableConfigPropertyTest.java | 38 +-
.../core/api/config/injectable/SettingsBean.java | 19 +
.../MyCustomEarPropertyFileConfig.java | 2 +-
.../MyCustomPropertyFileConfig.java | 2 +-
.../test/core/api/exclude/ExcludeWarFileTest.java | 5 +-
.../test/core/impl/interdyn/InterDynTest.java | 12 +-
.../test/core/impl/interdyn/SomeTestService.java | 14 +
.../scope/window/DefaultWindowContextTest.java | 2 +-
.../META-INF/apache-deltaspike.properties | 14 +
deltaspike/examples/scheduler-playground/pom.xml | 2 +-
deltaspike/modules/data/impl/pom.xml | 2 +-
.../deltaspike/data/impl/property/Reflections.java | 2 +-
deltaspike/modules/data/test-ee7/pom.xml | 2 +-
deltaspike/modules/jpa/api/pom.xml | 2 +-
.../jpa/api/transaction/Transactional.java | 2 +-
.../EntityManagerFactoryProducer.java | 10 +
.../ResourceLocalTransactionStrategy.java | 2 +-
.../context/TransactionBeanStorage.java | 2 +-
.../deltaspike/jsf/api/config/JsfModuleConfig.java | 4 +-
deltaspike/modules/jsf/impl/pom.xml | 2 +-
.../listener/request/JsfRequestBroadcaster.java | 8 +-
.../scope/mapped/MappedJsf2ScopeExtension.java | 6 +-
.../jsf/impl/scope/view/ViewScopedExtension.java | 4 +-
deltaspike/modules/jsf/pom.xml | 2 +-
.../modules/obsolete_bean-validation/api/pom.xml | 2 +-
.../modules/obsolete_bean-validation/impl/pom.xml | 2 +-
.../modules/obsolete_bean-validation/pom.xml | 4 +-
deltaspike/modules/obsolete_servlet/api/pom.xml | 2 +-
deltaspike/modules/obsolete_servlet/impl/pom.xml | 4 +-
deltaspike/modules/obsolete_servlet/pom.xml | 4 +-
.../proxy/api/DeltaSpikeProxyFactory.java | 13 +-
.../proxy/api/DeltaSpikeProxyFactoryTest.java | 218 +++++++++
.../impl/AsmDeltaSpikeProxyClassGenerator.java | 46 +-
.../apache/deltaspike/proxy/impl/ClassDefiner.java | 160 +++++++
deltaspike/modules/scheduler/api/pom.xml | 2 +-
deltaspike/modules/scheduler/impl/pom.xml | 2 +-
.../api/authorization/AccessDecisionVoter.java | 4 +-
deltaspike/modules/test-control/api/pom.xml | 2 +-
.../testcontrol/api/junit/CdiTestSuiteRunner.java | 12 +-
.../testcontrol/impl/mock/BeanCacheKey.java | 4 +-
.../testcontrol/impl/mock/DefaultMockFilter.java | 2 +-
.../StandardContextTestControlValidator.java | 2 +-
deltaspike/parent/code/pom.xml | 130 +++---
deltaspike/parent/pom.xml | 125 +++--
deltaspike/pom.xml | 2 +
deltaspike/readme/ReleaseNotes-1.4.0.txt | 2 +-
deltaspike/readme/ReleaseNotes-1.7.1.txt | 2 +-
deltaspike/readme/ReleaseNotes-1.9.6.txt | 20 +
.../src/main/asciidoc/container-control.adoc | 4 +-
documentation/src/main/asciidoc/core.adoc | 12 +-
documentation/src/main/asciidoc/jsf.adoc | 2 +-
documentation/src/main/asciidoc/projectstage.adoc | 2 +-
documentation/src/main/asciidoc/spi.adoc | 2 +-
documentation/src/main/asciidoc/test-control.adoc | 2 +-
pom.xml | 7 +-
101 files changed, 1768 insertions(+), 682 deletions(-)
diff --cc deltaspike/cdictrl/impl-weld/src/main/java/org/apache/deltaspike/cdise/weld/WeldContainerControl.java
index 11f41df1b,c858e0b11..1b4afbd02
--- a/deltaspike/cdictrl/impl-weld/src/main/java/org/apache/deltaspike/cdise/weld/WeldContainerControl.java
+++ b/deltaspike/cdictrl/impl-weld/src/main/java/org/apache/deltaspike/cdise/weld/WeldContainerControl.java
@@@ -25,17 -25,20 +25,20 @@@ import org.jboss.weld.environment.se.We
import org.jboss.weld.environment.se.WeldContainer;
import org.jboss.weld.util.reflection.Formats;
-import javax.enterprise.context.spi.CreationalContext;
-import javax.enterprise.inject.spi.Bean;
-import javax.enterprise.inject.spi.BeanManager;
+import jakarta.enterprise.context.spi.CreationalContext;
+import jakarta.enterprise.inject.spi.Bean;
+import jakarta.enterprise.inject.spi.BeanManager;
+ import java.lang.reflect.InvocationTargetException;
+ import java.lang.reflect.Method;
import java.util.Map;
import java.util.Set;
import java.util.logging.Logger;
+ import java.util.stream.Collectors;
-import javax.enterprise.context.ConversationScoped;
-import javax.enterprise.context.RequestScoped;
-import javax.enterprise.context.SessionScoped;
+import jakarta.enterprise.context.ConversationScoped;
+import jakarta.enterprise.context.RequestScoped;
+import jakarta.enterprise.context.SessionScoped;
/**
* Weld specific implementation of {@link org.apache.deltaspike.cdise.api.CdiContainer}.
diff --cc deltaspike/checkstyle-rules/src/main/resources/deltaspike/default-checks.xml
index 219b70699,219b70699..a39199582
--- a/deltaspike/checkstyle-rules/src/main/resources/deltaspike/default-checks.xml
+++ b/deltaspike/checkstyle-rules/src/main/resources/deltaspike/default-checks.xml
@@@ -106,7 -106,7 +106,7 @@@
<!-- Checks for imports -->
<!-- See http://checkstyle.sf.net/config_import.html -->
<module name="AvoidStarImport">
-- <property name="excludes" value="java.io,java.net,java.util,javax.enterprise.inject.spi,javax.enterprise.context"/>
++ <property name="excludes" value="java.io,java.net,java.util,jakarta.enterprise.inject.spi,jakarta.enterprise.context"/>
</module>
<module name="IllegalImport"/>
<module name="RedundantImport"/>
diff --cc deltaspike/core/api/obsolete/src/main/java/org/apache/deltaspike/core/api/control/HandlerMethod.java
index 56402d620,000000000..24fd9edd1
mode 100644,000000..100644
--- a/deltaspike/core/api/obsolete/src/main/java/org/apache/deltaspike/core/api/control/HandlerMethod.java
+++ b/deltaspike/core/api/obsolete/src/main/java/org/apache/deltaspike/core/api/control/HandlerMethod.java
@@@ -1,79 -1,0 +1,79 @@@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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 org.apache.deltaspike.core.api.exception.control;
+
+import org.apache.deltaspike.core.api.exception.control.event.ExceptionEvent;
+
+import jakarta.enterprise.inject.spi.BeanManager;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Type;
+import java.util.Set;
+
+/**
+ * Metadata interface for an exception handler method. It is the responsibility of the
- * implementation to support {@link javax.enterprise.inject.spi.InjectionPoint}s and to
- * validate those {@link javax.enterprise.inject.spi.InjectionPoint}s.
++ * implementation to support {@link jakarta.enterprise.inject.spi.InjectionPoint}s and to
++ * validate those {@link jakarta.enterprise.inject.spi.InjectionPoint}s.
+ *
+ * @param <T> Exception for which this handler is responsible
+ */
+public interface HandlerMethod<T extends Throwable>
+{
+ /**
+ * Obtains the set of handled event qualifiers.
+ */
+ Set<Annotation> getQualifiers();
+
+ /**
+ * Obtains the handled event type.
+ */
+ Type getExceptionType();
+
+ /**
+ * Flag indicating this handler should be invoked during the before traversal.
+ */
+ boolean isBeforeHandler();
+
+ /**
+ * Calls the handler method, passing the given event object.
+ *
+ * @param event event to pass to the handler.
+ * @param beanManager The BeanManager to use
+ */
+ void notify(ExceptionEvent<T> event, BeanManager beanManager) throws Exception;
+
+ /**
+ * Obtains the precedence of the handler, relative to other handlers for the same type. Handler with a higher
+ * ordinal is invoked before a handler with a lower ordinal.
+ */
+ int getOrdinal();
+
+ /**
+ * Basic {@link Object#equals(Object)} but must use all of the get methods from this interface to
+ * maintain compatibility.
+ *
+ * @param o Object being compared to this.
+ * @return true or false based on standard equality.
+ */
+ @Override
+ boolean equals(Object o);
+
+ @Override
+ int hashCode();
+}
diff --cc deltaspike/core/api/obsolete/src/main/java/org/apache/deltaspike/core/api/literal/AlternativeLiteral.java
index 5d7decf6c,000000000..20b210b9d
mode 100644,000000..100644
--- a/deltaspike/core/api/obsolete/src/main/java/org/apache/deltaspike/core/api/literal/AlternativeLiteral.java
+++ b/deltaspike/core/api/obsolete/src/main/java/org/apache/deltaspike/core/api/literal/AlternativeLiteral.java
@@@ -1,31 -1,0 +1,31 @@@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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 org.apache.deltaspike.core.api.literal;
+
+import jakarta.enterprise.inject.Alternative;
+import jakarta.enterprise.util.AnnotationLiteral;
+
+/**
- * Literal for {@link javax.enterprise.inject.Alternative}.
++ * Literal for {@link jakarta.enterprise.inject.Alternative}.
+ */
+public class AlternativeLiteral extends AnnotationLiteral<Alternative> implements Alternative
+{
+ private static final long serialVersionUID = -4865048799125718216L;
+}
diff --cc deltaspike/core/api/obsolete/src/main/java/org/apache/deltaspike/core/api/literal/AnyLiteral.java
index c47dd8182,000000000..13b8f6bed
mode 100644,000000..100644
--- a/deltaspike/core/api/obsolete/src/main/java/org/apache/deltaspike/core/api/literal/AnyLiteral.java
+++ b/deltaspike/core/api/obsolete/src/main/java/org/apache/deltaspike/core/api/literal/AnyLiteral.java
@@@ -1,30 -1,0 +1,30 @@@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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 org.apache.deltaspike.core.api.literal;
+
+import jakarta.enterprise.inject.Any;
+import jakarta.enterprise.util.AnnotationLiteral;
+
+/**
- * Literal for the {@link javax.enterprise.inject.Any} annotation.
++ * Literal for the {@link jakarta.enterprise.inject.Any} annotation.
+ */
+public class AnyLiteral extends AnnotationLiteral<Any> implements Any
+{
+ private static final long serialVersionUID = -8623640277155878657L;
+}
diff --cc deltaspike/core/api/obsolete/src/main/java/org/apache/deltaspike/core/api/literal/ModelLiteral.java
index 88dcd04be,000000000..9c501efa8
mode 100644,000000..100644
--- a/deltaspike/core/api/obsolete/src/main/java/org/apache/deltaspike/core/api/literal/ModelLiteral.java
+++ b/deltaspike/core/api/obsolete/src/main/java/org/apache/deltaspike/core/api/literal/ModelLiteral.java
@@@ -1,31 -1,0 +1,31 @@@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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 org.apache.deltaspike.core.api.literal;
+
+import jakarta.enterprise.inject.Model;
+import jakarta.enterprise.util.AnnotationLiteral;
+
+/**
- * Literal for {@link javax.enterprise.inject.Model} annotation.
++ * Literal for {@link jakarta.enterprise.inject.Model} annotation.
+ */
+public class ModelLiteral extends AnnotationLiteral<Model> implements Model
+{
+ private static final long serialVersionUID = -1828119201454843678L;
+}
diff --cc deltaspike/core/api/obsolete/src/main/java/org/apache/deltaspike/core/api/literal/NamedLiteral.java
index e53e5dd10,000000000..21bcbb364
mode 100644,000000..100644
--- a/deltaspike/core/api/obsolete/src/main/java/org/apache/deltaspike/core/api/literal/NamedLiteral.java
+++ b/deltaspike/core/api/obsolete/src/main/java/org/apache/deltaspike/core/api/literal/NamedLiteral.java
@@@ -1,48 -1,0 +1,48 @@@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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 org.apache.deltaspike.core.api.literal;
+
+import jakarta.enterprise.util.AnnotationLiteral;
+import jakarta.inject.Named;
+
+/**
- * Literal for {@link javax.inject.Named} qualifier.
++ * Literal for {@link jakarta.inject.Named} qualifier.
+ */
+public class NamedLiteral extends AnnotationLiteral<Named> implements Named
+{
+ private static final long serialVersionUID = -1457223276475846060L;
+
+ private final String value;
+
+ public NamedLiteral(String value)
+ {
+ this.value = value;
+ }
+
+ public NamedLiteral()
+ {
+ value = "";
+ }
+
+ @Override public String value()
+ {
+ return value;
+ }
+}
diff --cc deltaspike/core/api/obsolete/src/main/java/org/apache/deltaspike/core/api/literal/SingletonLiteral.java
index 7640b5671,000000000..1f12185cd
mode 100644,000000..100644
--- a/deltaspike/core/api/obsolete/src/main/java/org/apache/deltaspike/core/api/literal/SingletonLiteral.java
+++ b/deltaspike/core/api/obsolete/src/main/java/org/apache/deltaspike/core/api/literal/SingletonLiteral.java
@@@ -1,31 -1,0 +1,31 @@@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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 org.apache.deltaspike.core.api.literal;
+
+import jakarta.enterprise.util.AnnotationLiteral;
+import jakarta.inject.Singleton;
+
+/**
- * Literal for {@link javax.inject.Singleton}
++ * Literal for {@link jakarta.inject.Singleton}
+ */
+public class SingletonLiteral extends AnnotationLiteral<Singleton> implements Singleton
+{
+ private static final long serialVersionUID = 2387772903537960411L;
+}
diff --cc deltaspike/core/api/obsolete/src/main/java/org/apache/deltaspike/core/api/literal/TypedLiteral.java
index 1736be40b,000000000..018278112
mode 100644,000000..100644
--- a/deltaspike/core/api/obsolete/src/main/java/org/apache/deltaspike/core/api/literal/TypedLiteral.java
+++ b/deltaspike/core/api/obsolete/src/main/java/org/apache/deltaspike/core/api/literal/TypedLiteral.java
@@@ -1,48 -1,0 +1,48 @@@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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 org.apache.deltaspike.core.api.literal;
+
+import jakarta.enterprise.inject.Typed;
+import jakarta.enterprise.util.AnnotationLiteral;
+
+/**
- * Literal for {@link javax.enterprise.inject.Typed}
++ * Literal for {@link jakarta.enterprise.inject.Typed}
+ */
+public class TypedLiteral extends AnnotationLiteral<Typed> implements Typed
+{
+ private static final long serialVersionUID = 6805980497117269525L;
+
+ private final Class<?>[] value;
+
+ public TypedLiteral()
+ {
+ value = new Class<?>[0];
+ }
+
+ public TypedLiteral(Class<?>[] value)
+ {
+ this.value = value;
+ }
+
+ @Override public Class<?>[] value()
+ {
+ return value;
+ }
+}
diff --cc deltaspike/core/api/obsolete/src/main/java/org/apache/deltaspike/core/util/ParentExtensionStorage.java
index 8b3fbe803,000000000..d738e66b3
mode 100644,000000..100644
--- a/deltaspike/core/api/obsolete/src/main/java/org/apache/deltaspike/core/util/ParentExtensionStorage.java
+++ b/deltaspike/core/api/obsolete/src/main/java/org/apache/deltaspike/core/util/ParentExtensionStorage.java
@@@ -1,159 -1,0 +1,159 @@@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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 org.apache.deltaspike.core.util;
+
+import jakarta.enterprise.inject.spi.Extension;
+
+import java.lang.ref.WeakReference;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+
+import org.apache.deltaspike.core.api.config.base.CoreBaseConfig;
+
+/**
+ * Support for Containers with 'hierarchic BeanManagers'
+ * This is mostly useful for EAR applications.
+ *
+ * Some EE Container scan the common shared EAR lib path and reuse this information
+ * for the webapps in the EAR. This is actually the only approach a container can
+ * do to prevent mem leaks and side effects spreading to different webapps.
+ * Of course this also means that the webapps get their own (different)
+ * instances of an Extension.
+ *
+ * To acknowledge this solution we provide a mechanism to lookup 'parent Extensions'
+ * which is very similar to handling parent ClassLoaders.
+ *
+ * Please note that you need to enable this handling if you are running DeltaSpike
+ * in an EAR on a container which supports parent Extensions.
+ * You can do that by settting {@code "deltaspike.parent.extension.enabled"} to "e;true"e;
+ *
+ * All your Extension has to do is to register itself in
- * {@link javax.enterprise.inject.spi.BeforeBeanDiscovery}.
++ * {@link jakarta.enterprise.inject.spi.BeforeBeanDiscovery}.
+ * Later at boot time the Extension can lookup it's parent Extension instance and
+ * e.g. check which classes got scanned in the parent ClassLoader.
+ *
+ * The ExtensionInfo automatically gets removed if the webapp gets undeployed.
+ *
+ * @see org.apache.deltaspike.core.api.config.base.CoreBaseConfig.ParentExtensionCustomization
+ */
+public final class ParentExtensionStorage
+{
+
+ private static Set<ExtensionStorageInfo> extensionStorage = new HashSet<ExtensionStorageInfo>();
+
+ private ParentExtensionStorage()
+ {
+ // utility class ct
+ }
+
+ /**
+ * Add info about an Extension to our storage
+ * This method is usually called during boostrap via {@code @Observes BeforeBeanDiscovery}.
+ */
+ public static synchronized void addExtension(Extension extension)
+ {
+ if (usingParentExtension())
+ {
+ removeAbandonedExtensions();
+
+ ClassLoader classLoader = ClassUtils.getClassLoader(null);
+ extensionStorage.add(new ExtensionStorageInfo(classLoader, extension));
+ }
+ }
+
+ /**
+ * When adding a new Extension we also clean up ExtensionInfos
+ * from ClassLoaders which got unloaded.
+ */
+
+ private static boolean usingParentExtension()
+ {
+ return CoreBaseConfig.ParentExtensionCustomization.PARENT_EXTENSION_ENABLED;
+ }
+
+ private static void removeAbandonedExtensions()
+ {
+ Iterator<ExtensionStorageInfo> it = extensionStorage.iterator();
+ while (it.hasNext())
+ {
+ ExtensionStorageInfo info = it.next();
+ if (info.isAbandoned())
+ {
+ it.remove();
+ }
+ }
+ }
+
+ /**
+ * @return the Extension from the same type but registered in a hierarchic 'parent' BeanManager
+ */
+ public static synchronized <T extends Extension> T getParentExtension(Extension extension)
+ {
+ if (usingParentExtension())
+ {
+ ClassLoader parentClassLoader = ClassUtils.getClassLoader(null).getParent();
+
+ Iterator<ExtensionStorageInfo> extIt = extensionStorage.iterator();
+ while (extIt.hasNext())
+ {
+ ExtensionStorageInfo extensionInfo = extIt.next();
+ if (!extensionInfo.isAbandoned() && // weak reference case
+ extension.getClass().equals(extensionInfo.getExtension().getClass()) &&
+ extensionInfo.getClassLoader().equals(parentClassLoader))
+ {
+ return (T) extensionInfo.getExtension();
+ }
+ }
+ }
+ return null;
+ }
+
+
+ /**
+ * Information about an Extension instance and in which classloader it got used
+ */
+ private static class ExtensionStorageInfo
+ {
+ // we use WeakReferences to allow perfect unloading of any webapp ClassLoader
+ private final WeakReference<ClassLoader> classLoader;
+ private final WeakReference<Extension> extension;
+
+ ExtensionStorageInfo(ClassLoader classLoader, Extension extension)
+ {
+ this.classLoader = new WeakReference<ClassLoader>(classLoader);
+ this.extension = new WeakReference<Extension>(extension);
+ }
+
+ boolean isAbandoned()
+ {
+ return classLoader.get() == null || extension.get() == null;
+ }
+
+ ClassLoader getClassLoader()
+ {
+ return classLoader.get();
+ }
+
+ Extension getExtension()
+ {
+ return extension.get();
+ }
+ }
+}
diff --cc deltaspike/core/api/obsolete/src/main/java/org/apache/deltaspike/core/util/bean/BaseImmutableBean.java
index 3b580f1a9,000000000..b79d3df99
mode 100644,000000..100644
--- a/deltaspike/core/api/obsolete/src/main/java/org/apache/deltaspike/core/util/bean/BaseImmutableBean.java
+++ b/deltaspike/core/api/obsolete/src/main/java/org/apache/deltaspike/core/util/bean/BaseImmutableBean.java
@@@ -1,243 -1,0 +1,243 @@@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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 org.apache.deltaspike.core.util.bean;
+
+import org.apache.deltaspike.core.api.literal.DefaultLiteral;
+import org.apache.deltaspike.core.util.ArraysUtils;
+import org.apache.deltaspike.core.util.metadata.InjectionPointWrapper;
+
+import jakarta.enterprise.context.Dependent;
+import jakarta.enterprise.inject.spi.Bean;
+import jakarta.enterprise.inject.spi.InjectionPoint;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Type;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.logging.Logger;
+
+/**
+ * <p>
+ * A base class for implementing {@link Bean}. The attributes are immutable, and
+ * collections are defensively copied on instantiation. It uses the defaults
+ * from the specification for properties if not specified.
+ * </p>
+ * <p/>
+ * <p>
+ * This class does not provide any bean lifecycle operations
+ * </p>
+ *
+ * @see ImmutableBeanWrapper
+ */
+public abstract class BaseImmutableBean<T> implements Bean<T>
+{
+ private static final Logger LOG = Logger.getLogger(BaseImmutableBean.class.getName());
+
+ private final Class<?> beanClass;
+ private final String name;
+ private final Set<Annotation> qualifiers;
+ private final Class<? extends Annotation> scope;
+ private final Set<Class<? extends Annotation>> stereotypes;
+ private final Set<Type> types;
+ private final boolean alternative;
+ private final boolean nullable;
+ private final Set<InjectionPoint> injectionPoints;
+ private final String toString;
+
+ /**
+ * Create a new, immutable bean. All arguments passed as collections are
+ * defensively copied.
+ *
+ * @param beanClass The Bean class, may not be null
+ * @param name The bean name
+ * @param qualifiers The bean's qualifiers, if null, a singleton set of
- * {@link javax.enterprise.inject.Default} is used
++ * {@link jakarta.enterprise.inject.Default} is used
+ * @param scope The bean's scope, if null, the default scope of
+ * {@link Dependent} is used
+ * @param stereotypes The bean's stereotypes, if null, an empty set is used
+ * @param types The bean's types, if null, the beanClass and {@link Object}
+ * will be used
+ * @param alternative True if the bean is an alternative
+ * @param nullable True if the bean is nullable
+ * @param injectionPoints the bean's injection points, if null an empty set is used
+ * @param toString the string which should be returned by #{@link #toString()}
+ * @throws IllegalArgumentException if the beanClass is null
+ */
+ public BaseImmutableBean(Class<?> beanClass,
+ String name,
+ Set<Annotation> qualifiers,
+ Class<? extends Annotation> scope,
+ Set<Class<? extends Annotation>> stereotypes,
+ Set<Type> types,
+ boolean alternative,
+ boolean nullable,
+ Set<InjectionPoint> injectionPoints,
+ String toString)
+ {
+ if (beanClass == null)
+ {
+ throw new IllegalArgumentException("beanClass cannot be null");
+ }
+
+ this.beanClass = beanClass;
+ this.name = name;
+
+ if (qualifiers == null)
+ {
+ this.qualifiers = Collections.<Annotation>singleton(new DefaultLiteral());
+
+ LOG.finest("No qualifers provided for bean class " + beanClass + ", using singleton set of @Default");
+ }
+ else
+ {
+ this.qualifiers = new HashSet<Annotation>(qualifiers);
+ }
+
+ if (scope == null)
+ {
+ this.scope = Dependent.class;
+
+ LOG.finest("No scope provided for bean class " + beanClass + ", using @Dependent");
+ }
+ else
+ {
+ this.scope = scope;
+ }
+
+ if (stereotypes == null)
+ {
+ this.stereotypes = Collections.emptySet();
+ }
+ else
+ {
+ this.stereotypes = new HashSet<Class<? extends Annotation>>(stereotypes);
+ }
+
+ if (types == null)
+ {
+ //noinspection unchecked
+ this.types = ArraysUtils.<Type>asSet(Object.class, beanClass);
+
+ LOG.finest("No types provided for bean class " + beanClass
+ + ", using [java.lang.Object.class, " + beanClass.getName()
+ + ".class]");
+ }
+ else
+ {
+ this.types = new HashSet<Type>(types);
+ }
+
+ if (injectionPoints == null)
+ {
+ this.injectionPoints = Collections.emptySet();
+ }
+ else
+ {
+ // Check for null Beans, wrap if there isn't one -- DELTASPIKE-400
+ final HashSet<InjectionPoint> ips = new HashSet<InjectionPoint>(injectionPoints.size());
+
+ for (InjectionPoint ip : injectionPoints)
+ {
+ if (ip.getBean() == null)
+ {
+ ips.add(new InjectionPointWrapper(ip, this));
+ }
+ else
+ {
+ ips.add(ip);
+ }
+ }
+
+ this.injectionPoints = ips;
+ }
+
+ this.alternative = alternative;
+ this.nullable = nullable;
+
+ if (toString != null)
+ {
+ this.toString = toString;
+ }
+ else
+ {
+ this.toString = "Custom Bean with bean class " + beanClass + " and qualifiers " + qualifiers;
+ }
+ }
+
+ @Override
+ public Class<?> getBeanClass()
+ {
+ return beanClass;
+ }
+
+ @Override
+ public Set<InjectionPoint> getInjectionPoints()
+ {
+ return injectionPoints;
+ }
+
+ @Override
+ public String getName()
+ {
+ return name;
+ }
+
+ @Override
+ public Set<Annotation> getQualifiers()
+ {
+ return Collections.unmodifiableSet(qualifiers);
+ }
+
+ @Override
+ public Class<? extends Annotation> getScope()
+ {
+ return scope;
+ }
+
+ @Override
+ public Set<Class<? extends Annotation>> getStereotypes()
+ {
+ return Collections.unmodifiableSet(stereotypes);
+ }
+
+ @Override
+ public Set<Type> getTypes()
+ {
+ return Collections.unmodifiableSet(types);
+ }
+
+ @Override
+ public boolean isAlternative()
+ {
+ return alternative;
+ }
+
+ @Override
+ public boolean isNullable()
+ {
+ return nullable;
+ }
+
+ @Override
+ public String toString()
+ {
+ return toString;
+ }
+}
diff --cc deltaspike/core/api/obsolete/src/main/java/org/apache/deltaspike/core/util/bean/BeanBuilder.java
index 1ec72b2eb,000000000..c2bc7024c
mode 100644,000000..100644
--- a/deltaspike/core/api/obsolete/src/main/java/org/apache/deltaspike/core/util/bean/BeanBuilder.java
+++ b/deltaspike/core/api/obsolete/src/main/java/org/apache/deltaspike/core/util/bean/BeanBuilder.java
@@@ -1,605 -1,0 +1,605 @@@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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 org.apache.deltaspike.core.util.bean;
+
+import org.apache.deltaspike.core.api.literal.AnyLiteral;
+import org.apache.deltaspike.core.api.literal.DefaultLiteral;
+import org.apache.deltaspike.core.util.Annotateds;
+import org.apache.deltaspike.core.util.metadata.builder.ContextualLifecycle;
+import org.apache.deltaspike.core.util.metadata.builder.DelegatingContextualLifecycle;
+import org.apache.deltaspike.core.util.metadata.builder.DummyInjectionTarget;
+
+import jakarta.enterprise.context.Dependent;
+import jakarta.enterprise.inject.Alternative;
+import jakarta.enterprise.inject.Typed;
+import jakarta.enterprise.inject.spi.AnnotatedType;
+import jakarta.enterprise.inject.spi.Bean;
+import jakarta.enterprise.inject.spi.BeanManager;
+import jakarta.enterprise.inject.spi.InjectionPoint;
+import jakarta.enterprise.inject.spi.InjectionTarget;
+import jakarta.inject.Named;
+
+import java.beans.Introspector;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Type;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * <p>
+ * A builder class for creating immutable beans. The builder can create
- * {@link javax.enterprise.inject.spi.PassivationCapable} beans.
++ * {@link jakarta.enterprise.inject.spi.PassivationCapable} beans.
+ * </p>
+ * <p/>
+ * <p>
+ * The builder can read from an {@link AnnotatedType} and have any attribute
+ * modified. This class is not thread-safe, but the bean created by calling
+ * {@link #create()} is.
+ * </p>
+ * <p/>
+ * <p>
+ * It is advised that a new bean builder is instantiated for each bean created.
+ * </p>
+ */
+public class BeanBuilder<T>
+{
+
+ protected final BeanManager beanManager;
+
+ protected Class<?> beanClass;
+ protected String name;
+ protected Set<Annotation> qualifiers;
+ protected Class<? extends Annotation> scope = Dependent.class;
+ protected Set<Class<? extends Annotation>> stereotypes;
+ protected Set<Type> types;
+ protected Set<InjectionPoint> injectionPoints;
+ protected boolean alternative;
+ protected boolean nullable;
+ protected ContextualLifecycle<T> beanLifecycle;
+ protected boolean passivationCapable;
+ protected String id;
+ protected String toString;
+
+ /**
+ * Instantiate a new bean builder.
+ *
+ * @param beanManager the bean manager to use for creating injection targets
+ * and determining if annotations are qualifiers, scopes or
+ * stereotypes.
+ */
+ public BeanBuilder(BeanManager beanManager)
+ {
+ this.beanManager = beanManager;
+ }
+
+ /**
+ * <p>
+ * Read the {@link AnnotatedType}, creating a bean from the class and it's
+ * annotations.
+ * </p>
+ * <p/>
+ * <p>
+ * By default the bean lifecycle will wrap the result of calling
+ * {@link BeanManager#createInjectionTarget(AnnotatedType)}.
+ * </p>
+ * <p/>
+ * <p>
+ * {@link BeanBuilder} does <em>not</em> support reading members of the class
+ * to create producers or observer methods.
+ * </p>
+ *
+ * @param type the type to read
+ */
+ public BeanBuilder<T> readFromType(AnnotatedType<T> type)
+ {
+ this.beanClass = type.getJavaClass();
+
+ if (beanLifecycle == null)
+ {
+ setDefaultBeanLifecycle(type);
+ }
+
+ this.qualifiers = new HashSet<Annotation>();
+ this.stereotypes = new HashSet<Class<? extends Annotation>>();
+ this.types = new HashSet<Type>();
+ for (Annotation annotation : type.getAnnotations())
+ {
+ if (beanManager.isQualifier(annotation.annotationType()))
+ {
+ this.qualifiers.add(annotation);
+ }
+ else if (beanManager.isScope(annotation.annotationType()))
+ {
+ this.scope = annotation.annotationType();
+ }
+ else if (beanManager.isStereotype(annotation.annotationType()))
+ {
+ this.stereotypes.add(annotation.annotationType());
+ }
+ if (annotation instanceof Named)
+ {
+ this.name = ((Named) annotation).value();
+ if (name == null || name.length() == 0)
+ {
+ name = createDefaultBeanName(type);
+ }
+ }
+ if (annotation instanceof Alternative)
+ {
+ this.alternative = true;
+ }
+ }
+ if (type.isAnnotationPresent(Typed.class))
+ {
+ Typed typed = type.getAnnotation(Typed.class);
+ this.types.addAll(Arrays.asList(typed.value()));
+
+ }
+ else
+ {
+ for (Class<?> c = type.getJavaClass(); c != Object.class && c != null; c = c.getSuperclass())
+ {
+ this.types.add(c);
+ }
+ Collections.addAll(this.types, type.getJavaClass().getInterfaces());
+ this.types.add(Object.class);
+ }
+
+ if (qualifiers.isEmpty())
+ {
+ qualifiers.add(new DefaultLiteral());
+ }
+ qualifiers.add(new AnyLiteral());
+
+ this.id = ImmutableBeanWrapper.class.getName() + ":" + Annotateds.createTypeId(type);
+ return this;
+ }
+
+ private String createDefaultBeanName(AnnotatedType<T> type)
+ {
+ Class<T> javaClass = type.getJavaClass();
+ return Introspector.decapitalize(javaClass.getSimpleName());
+ }
+
+
+ /**
+ * Set the ContextualLifecycle and the InjectionPoints for the AnnotatedType
+ * @param type
+ */
+ protected void setDefaultBeanLifecycle(AnnotatedType<T> type)
+ {
+ InjectionTarget<T> injectionTarget;
+ if (!type.getJavaClass().isInterface())
+ {
+ injectionTarget = beanManager.createInjectionTarget(type);
+ }
+ else
+ {
+ injectionTarget = new DummyInjectionTarget<T>();
+ }
+ this.beanLifecycle = new DelegatingContextualLifecycle<T>(injectionTarget);
+ this.injectionPoints = injectionTarget.getInjectionPoints();
+ }
+
+ /**
+ * <p>
+ * Use the bean builder's current state to define the bean.
+ * </p>
+ *
+ * @return the bean
+ */
+ public Bean<T> create()
+ {
+ if (!passivationCapable)
+ {
+ return new ImmutableBean<T>(beanClass, name, qualifiers, scope, stereotypes, types, alternative, nullable,
+ injectionPoints, toString, beanLifecycle);
+ }
+ else
+ {
+ return new ImmutablePassivationCapableBean<T>(beanClass, name, qualifiers, scope, stereotypes, types,
+ alternative, nullable, injectionPoints, toString, beanLifecycle, id);
+ }
+ }
+
+ /**
+ * Qualifiers currently defined for bean creation.
+ *
+ * @return the qualifiers current defined
+ */
+ public Set<Annotation> getQualifiers()
+ {
+ return qualifiers;
+ }
+
+ /**
+ * Define the qualifiers used for bean creation.
+ *
+ * @param qualifiers the qualifiers to use
+ */
+ public BeanBuilder<T> qualifiers(Set<Annotation> qualifiers)
+ {
+ this.qualifiers = qualifiers;
+ return this;
+ }
+
+ /**
+ * Define the qualifiers used for bean creation.
+ *
+ * @param qualifiers the qualifiers to use
+ */
+ public BeanBuilder<T> qualifiers(Annotation... qualifiers)
+ {
+ this.qualifiers = new HashSet<Annotation>(Arrays.asList(qualifiers));
+ return this;
+ }
+
+ /**
+ * Add to the qualifiers used for bean creation.
+ *
+ * @param qualifier the additional qualifier to use
+ */
+ public BeanBuilder<T> addQualifier(Annotation qualifier)
+ {
+ this.qualifiers.add(qualifier);
+ return this;
+ }
+
+ /**
+ * Add to the qualifiers used for bean creation.
+ *
+ * @param qualifiers the additional qualifiers to use
+ */
+ public BeanBuilder<T> addQualifiers(Annotation... qualifiers)
+ {
+ this.qualifiers.addAll(new HashSet<Annotation>(Arrays.asList(qualifiers)));
+ return this;
+ }
+
+ /**
+ * Add to the qualifiers used for bean creation.
+ *
+ * @param qualifiers the additional qualifiers to use
+ */
+ public BeanBuilder<T> addQualifiers(Collection<Annotation> qualifiers)
+ {
+ this.qualifiers.addAll(qualifiers);
+ return this;
+ }
+
+ /**
+ * Scope currently defined for bean creation.
+ *
+ * @return the scope currently defined
+ */
+ public Class<? extends Annotation> getScope()
+ {
+ return scope;
+ }
+
+ /**
+ * Define the scope used for bean creation.
+ *
+ * @param scope the scope to use
+ */
+ public BeanBuilder<T> scope(Class<? extends Annotation> scope)
+ {
+ this.scope = scope;
+ return this;
+ }
+
+ /**
+ * Stereotypes currently defined for bean creation.
+ *
+ * @return the stereotypes currently defined
+ */
+ public Set<Class<? extends Annotation>> getStereotypes()
+ {
+ return stereotypes;
+ }
+
+ /**
+ * Define the stereotypes used for bean creation.
+ *
+ * @param stereotypes the stereotypes to use
+ */
+ public BeanBuilder<T> stereotypes(Set<Class<? extends Annotation>> stereotypes)
+ {
+ this.stereotypes = stereotypes;
+ return this;
+ }
+
+ /**
+ * Type closure currently defined for bean creation.
+ *
+ * @return the type closure currently defined
+ */
+ public Set<Type> getTypes()
+ {
+ return types;
+ }
+
+ /**
+ * Define the type closure used for bean creation.
+ *
+ * @param types the type closure to use
+ */
+ public BeanBuilder<T> types(Set<Type> types)
+ {
+ this.types = types;
+ return this;
+ }
+
+ /**
+ * Define the type closure used for bean creation.
+ *
+ * @param types the type closure to use
+ */
+ public BeanBuilder<T> types(Type... types)
+ {
+ this.types = new HashSet<Type>(Arrays.asList(types));
+ return this;
+ }
+
+ /**
+ * Add to the type closure used for bean creation.
+ *
+ * @param type additional type to use
+ */
+ public BeanBuilder<T> addType(Type type)
+ {
+ this.types.add(type);
+ return this;
+ }
+
+ /**
+ * Add to the type closure used for bean creation.
+ *
+ * @param types the additional types to use
+ */
+ public BeanBuilder<T> addTypes(Type... types)
+ {
+ this.types.addAll(new HashSet<Type>(Arrays.asList(types)));
+ return this;
+ }
+
+ /**
+ * Add to the type closure used for bean creation.
+ *
+ * @param types the additional types to use
+ */
+ public BeanBuilder<T> addTypes(Collection<Type> types)
+ {
+ this.types.addAll(types);
+ return this;
+ }
+
+ /**
+ * Whether the created bean will be an alternative.
+ *
+ * @return <code>true</code> if the created bean will be an alternative,
+ * otherwise <code>false</code>
+ */
+ public boolean isAlternative()
+ {
+ return alternative;
+ }
+
+ /**
+ * Define that the created bean will (or will not) be an alternative.
+ *
+ * @param alternative <code>true</code> if the created bean should be an
+ * alternative, otherwise <code>false</code>
+ */
+ public BeanBuilder<T> alternative(boolean alternative)
+ {
+ this.alternative = alternative;
+ return this;
+ }
+
+ /**
+ * Whether the created bean will be nullable.
+ *
+ * @return <code>true</code> if the created bean will be nullable, otherwise
+ * <code>false</code>
+ */
+ public boolean isNullable()
+ {
+ return nullable;
+ }
+
+ /**
+ * Define that the created bean will (or will not) be nullable.
+ *
+ * @param nullable <code>true</code> if the created bean should be nullable,
+ * otherwise <code>false</code>
+ */
+ public BeanBuilder<T> nullable(boolean nullable)
+ {
+ this.nullable = nullable;
+ return this;
+ }
+
+ /**
+ * The {@link ContextualLifecycle} currently defined for bean creation.
+ *
+ * @return the bean lifecycle currently defined
+ */
+ public ContextualLifecycle<T> getBeanLifecycle()
+ {
+ return beanLifecycle;
+ }
+
+ /**
+ * Define the {@link ContextualLifecycle} used for bean creation.
+ *
+ * @param beanLifecycle the {@link ContextualLifecycle} to use for bean
+ * creation.
+ */
+ public BeanBuilder<T> beanLifecycle(ContextualLifecycle<T> beanLifecycle)
+ {
+ this.beanLifecycle = beanLifecycle;
+ return this;
+ }
+
+ /**
+ * The bean class currently defined for bean creation.
+ *
+ * @return the bean class currently defined.
+ */
+ public Class<?> getBeanClass()
+ {
+ return beanClass;
+ }
+
+ /**
+ * Define the bean class used for bean creation.
+ *
+ * @param beanClass the bean class to use
+ */
+ public BeanBuilder<T> beanClass(Class<?> beanClass)
+ {
+ this.beanClass = beanClass;
+ return this;
+ }
+
+ /**
+ * The bean manager in use. This cannot be changed for this
+ * {@link BeanBuilder}.
+ *
+ * @return the bean manager in use
+ */
+ public BeanManager getBeanManager()
+ {
+ return beanManager;
+ }
+
+ /**
+ * The name of the bean currently defined for bean creation.
+ *
+ * @return the name of the bean or <code>null</code> if the bean has no name
+ */
+ public String getName()
+ {
+ return name;
+ }
+
+ /**
+ * Define the name of the bean used for bean creation.
+ *
+ * @param name the name of the bean to use or <code>null</code> if the bean
+ * should have no name
+ */
+ public BeanBuilder<T> name(String name)
+ {
+ this.name = name;
+ return this;
+ }
+
+ /**
+ * Whether the created bean will be passivation capable.
+ *
+ * @return <code>true</code> if the created bean will be passivation capable,
+ * otherwise <code>false</code>
+ */
+ public boolean isPassivationCapable()
+ {
+ return passivationCapable;
+ }
+
+ /**
+ * Define that the created bean will (or will not) be passivation capable.
+ *
+ * @param passivationCapable <code>true</code> if the created bean should be
+ * passivation capable, otherwise <code>false</code>
+ */
+ public BeanBuilder<T> passivationCapable(boolean passivationCapable)
+ {
+ this.passivationCapable = passivationCapable;
+ return this;
+ }
+
+ /**
+ * The id currently defined for bean creation.
+ *
+ * @return the id currently defined.
+ */
+ public String getId()
+ {
+ return id;
+ }
+
+ /**
+ * Define the id used for bean creation.
+ *
+ * @param id the id to use
+ */
+ public BeanBuilder<T> id(String id)
+ {
+ this.id = id;
+ return this;
+ }
+
+ /**
+ * The injection points currently defined for bean creation.
+ *
+ * @return the injection points currently defined.
+ */
+ public Set<InjectionPoint> getInjectionPoints()
+ {
+ return injectionPoints;
+ }
+
+ /**
+ * Define the injection points used for bean creation.
+ *
+ * @param injectionPoints the injection points to use
+ */
+ public BeanBuilder<T> injectionPoints(Set<InjectionPoint> injectionPoints)
+ {
+ this.injectionPoints = injectionPoints;
+ return this;
+ }
+
+ /**
+ * Define the string used when {@link #toString()} is called on the bean.
+ *
+ * @param toString the string to use
+ */
+ public BeanBuilder<T> toString(String toString)
+ {
+ this.toString = toString;
+ return this;
+ }
+
+ /**
+ * The string used when {@link #toString()} is called on the bean.
+ *
+ * @return the string currently defined
+ */
+ public String getToString()
+ {
+ return toString;
+ }
+
+}
diff --cc deltaspike/core/api/obsolete/src/main/java/org/apache/deltaspike/core/util/bean/ImmutableBean.java
index 3e02d2003,000000000..5dc01ed9f
mode 100644,000000..100644
--- a/deltaspike/core/api/obsolete/src/main/java/org/apache/deltaspike/core/util/bean/ImmutableBean.java
+++ b/deltaspike/core/api/obsolete/src/main/java/org/apache/deltaspike/core/util/bean/ImmutableBean.java
@@@ -1,80 -1,0 +1,80 @@@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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 org.apache.deltaspike.core.util.bean;
+
+import org.apache.deltaspike.core.util.metadata.builder.ContextualLifecycle;
+
+import jakarta.enterprise.context.spi.CreationalContext;
+import jakarta.enterprise.inject.spi.InjectionPoint;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Type;
+import java.util.Set;
+
+/**
+ *
+ */
+public class ImmutableBean<T> extends BaseImmutableBean<T>
+{
+ private final ContextualLifecycle<T> lifecycle;
+
+ /**
+ * Create a new, immutable bean. All arguments passed as collections are
+ * defensively copied.
+ *
+ * @param beanClass The Bean class, may not be null
+ * @param name The bean name
+ * @param qualifiers The bean's qualifiers, if null, a singleton set of
- * {@link javax.enterprise.inject.Default} is used
++ * {@link jakarta.enterprise.inject.Default} is used
+ * @param scope The bean's scope, if null, the default scope of
- * {@link javax.enterprise.context.Dependent} is used
++ * {@link jakarta.enterprise.context.Dependent} is used
+ * @param stereotypes The bean's stereotypes, if null, an empty set is used
+ * @param types The bean's types, if null, the beanClass and {@link Object}
+ * will be used
+ * @param alternative True if the bean is an alternative
+ * @param nullable True if the bean is nullable
+ * @param injectionPoints the bean's injection points, if null an empty set is used
+ * @param toString the string which should be returned by #{@link #toString()}
- * @param contextualLifecycle Handler for {@link #create(javax.enterprise.context.spi.CreationalContext)} and
- * {@link #destroy(Object, javax.enterprise.context.spi.CreationalContext)}
++ * @param contextualLifecycle Handler for {@link #create(jakarta.enterprise.context.spi.CreationalContext)} and
++ * {@link #destroy(Object, jakarta.enterprise.context.spi.CreationalContext)}
+ * @throws IllegalArgumentException if the beanClass is null
+ */
+ // CHECKSTYLE:OFF
+ public ImmutableBean(Class<?> beanClass, String name, Set<Annotation> qualifiers, Class<? extends Annotation> scope,
+ Set<Class<? extends Annotation>> stereotypes, Set<Type> types, boolean alternative,
+ boolean nullable, Set<InjectionPoint> injectionPoints, String toString,
+ ContextualLifecycle<T> contextualLifecycle)
+ {
+ // CHECKSTYLE:ON
+ super(beanClass, name, qualifiers, scope, stereotypes, types, alternative, nullable, injectionPoints, toString);
+ this.lifecycle = contextualLifecycle;
+ }
+
+ @Override
+ public T create(CreationalContext<T> creationalContext)
+ {
+ return lifecycle.create(this, creationalContext);
+ }
+
+ @Override
+ public void destroy(T instance, CreationalContext<T> creationalContext)
+ {
+ this.lifecycle.destroy(this, instance, creationalContext);
+ }
+}
diff --cc deltaspike/core/api/obsolete/src/main/java/org/apache/deltaspike/core/util/bean/ImmutablePassivationCapableBean.java
index 810f16164,000000000..306c823b2
mode 100644,000000..100644
--- a/deltaspike/core/api/obsolete/src/main/java/org/apache/deltaspike/core/util/bean/ImmutablePassivationCapableBean.java
+++ b/deltaspike/core/api/obsolete/src/main/java/org/apache/deltaspike/core/util/bean/ImmutablePassivationCapableBean.java
@@@ -1,78 -1,0 +1,78 @@@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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 org.apache.deltaspike.core.util.bean;
+
+import org.apache.deltaspike.core.util.metadata.builder.ContextualLifecycle;
+
+import jakarta.enterprise.inject.spi.InjectionPoint;
+import jakarta.enterprise.inject.spi.PassivationCapable;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Type;
+import java.util.Set;
+
+/**
+ *
+ */
+public class ImmutablePassivationCapableBean<T> extends ImmutableBean<T> implements PassivationCapable
+{
+ private final String id;
+
+ /**
+ * Create a new, immutable bean. All arguments passed as collections are
+ * defensively copied.
+ *
+ * @param beanClass The Bean class, may not be null
+ * @param name The bean name
+ * @param qualifiers The bean's qualifiers, if null, a singleton set of
- * {@link javax.enterprise.inject.Default} is used
++ * {@link jakarta.enterprise.inject.Default} is used
+ * @param scope The bean's scope, if null, the default scope of
- * {@link javax.enterprise.context.Dependent} is used
++ * {@link jakarta.enterprise.context.Dependent} is used
+ * @param stereotypes The bean's stereotypes, if null, an empty set is used
+ * @param types The bean's types, if null, the beanClass and {@link Object}
+ * will be used
+ * @param alternative True if the bean is an alternative
+ * @param nullable True if the bean is nullable
+ * @param injectionPoints the bean's injection points, if null an empty set is used
+ * @param toString the string which should be returned by #{@link #toString()}
- * @param lifecycle Handler for {@link #create(javax.enterprise.context.spi.CreationalContext)} and
- * {@link #destroy(Object, javax.enterprise.context.spi.CreationalContext)}
++ * @param lifecycle Handler for {@link #create(jakarta.enterprise.context.spi.CreationalContext)} and
++ * {@link #destroy(Object, jakarta.enterprise.context.spi.CreationalContext)}
+ * @param passivationId Passivation bean Id.
+ * @throws IllegalArgumentException if the beanClass is null
+ */
+ // CHECKSTYLE:OFF
+ public ImmutablePassivationCapableBean(Class<?> beanClass, String name, Set<Annotation> qualifiers,
+ Class<? extends Annotation> scope,
+ Set<Class<? extends Annotation>> stereotypes, Set<Type> types,
+ boolean alternative, boolean nullable,
+ Set<InjectionPoint> injectionPoints, String toString,
+ ContextualLifecycle<T> lifecycle, String passivationId)
+ {
+ // CHECKSTYLE:ON
+ super(beanClass, name, qualifiers, scope, stereotypes, types, alternative, nullable, injectionPoints, toString,
+ lifecycle);
+ this.id = passivationId;
+ }
+
+ @Override
+ public String getId()
+ {
+ return this.id;
+ }
+}
diff --cc deltaspike/core/api/obsolete/src/main/java/org/apache/deltaspike/core/util/bean/WrappingBeanBuilder.java
index ac9da7f6a,000000000..8ceae334b
mode 100644,000000..100644
--- a/deltaspike/core/api/obsolete/src/main/java/org/apache/deltaspike/core/util/bean/WrappingBeanBuilder.java
+++ b/deltaspike/core/api/obsolete/src/main/java/org/apache/deltaspike/core/util/bean/WrappingBeanBuilder.java
@@@ -1,81 -1,0 +1,81 @@@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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 org.apache.deltaspike.core.util.bean;
+
+import jakarta.enterprise.inject.spi.AnnotatedType;
+import jakarta.enterprise.inject.spi.Bean;
+import jakarta.enterprise.inject.spi.BeanManager;
+
+/**
+ * <p>A WrappingBeanBuilder helps creating Beans which internally
+ * just wrap another existing Bean. The Types, Qualifiers
+ * and other attributes of the resulting Bean can be modified.</p>
+ * <p/>
- * <p>The {@link Bean#create(javax.enterprise.context.spi.CreationalContext)}
- * and {@link Bean#destroy(Object, javax.enterprise.context.spi.CreationalContext)}
++ * <p>The {@link Bean#create(jakarta.enterprise.context.spi.CreationalContext)}
++ * and {@link Bean#destroy(Object, jakarta.enterprise.context.spi.CreationalContext)}
+ * methods will get delegated to the underlying wrapped Bean.</p>
+ *
+ * @param <T> the type of the Bean
+ */
+public class WrappingBeanBuilder<T> extends BeanBuilder<T>
+{
+ private final Bean<T> delegate;
+
+
+ /**
+ * Instantiate a new {@link WrappingBeanBuilder}.
+ *
+ * @param delegate the delegate bean
+ * @param beanManager current bean-manager
+ */
+ public WrappingBeanBuilder(Bean<Object> delegate, BeanManager beanManager)
+ {
+ super(beanManager);
+ this.delegate = (Bean<T>) delegate;
+ }
+
+ protected void setDefaultBeanLifecycle(AnnotatedType<T> type)
+ {
+ // do nothing. We don't need that as we delegate this information
+ }
+
+ /**
+ * <p>
+ * Use the bean builder's current state to define the bean.
+ * </p>
+ *
+ * @return the bean
+ */
+ public Bean<T> create()
+ {
+ if (isPassivationCapable())
+ {
+ return new ImmutablePassivationCapableBeanWrapper<T>(delegate,
+ name, qualifiers, scope, stereotypes, types, alternative,
+ nullable, toString, id);
+ }
+ else
+ {
+ return new ImmutableBeanWrapper<T>(delegate, name, qualifiers, scope,
+ stereotypes, types, alternative, nullable, toString);
+ }
+ }
+
+
+}
diff --cc deltaspike/core/api/src/main/java/org/apache/deltaspike/core/api/config/ConfigResolver.java
index f5f088c50,e552405ac..f15bb1134
--- a/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/api/config/ConfigResolver.java
+++ b/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/api/config/ConfigResolver.java
@@@ -28,8 -28,9 +28,9 @@@ import java.util.Map
import java.util.ServiceLoader;
import java.util.Set;
import java.util.concurrent.TimeUnit;
+ import java.util.function.BiFunction;
-import javax.enterprise.inject.Typed;
+import jakarta.enterprise.inject.Typed;
import org.apache.deltaspike.core.spi.config.ConfigFilter;
import org.apache.deltaspike.core.spi.config.ConfigSource;
diff --cc deltaspike/core/api/src/main/java/org/apache/deltaspike/core/api/config/PropertyFileConfig.java
index 7ebe1e453,7ebe1e453..0a29d5711
--- a/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/api/config/PropertyFileConfig.java
+++ b/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/api/config/PropertyFileConfig.java
@@@ -28,7 -28,7 +28,7 @@@ package org.apache.deltaspike.core.api.
* <p>
* DeltaSpike will automatically pick up all the implementations which are
* inside a Bean Archive (a JAR or ClassPath entry with a META-INF/beans.xml file) during the
-- * {@link javax.enterprise.inject.spi.ProcessAnnotatedType} phase and create a new instance via reflection. Thus the
++ * {@link jakarta.enterprise.inject.spi.ProcessAnnotatedType} phase and create a new instance via reflection. Thus the
* implementations will need a non-private default constructor. There is <b>no</b> CDI injection being performed in
* those instances! The scope of the implementations will also be ignored as they will not get picked up as CDI
* beans.</p>
diff --cc deltaspike/core/api/src/main/java/org/apache/deltaspike/core/api/provider/BeanManagerProvider.java
index 3cda0fe51,5897b59f1..3eafa16a2
--- a/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/api/provider/BeanManagerProvider.java
+++ b/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/api/provider/BeanManagerProvider.java
@@@ -70,7 -70,7 +70,7 @@@ public class BeanManagerProvider implem
static
{
-- Class cdiClass = ClassUtils.tryToLoadClassForName("javax.enterprise.inject.spi.CDI");
++ Class cdiClass = ClassUtils.tryToLoadClassForName("jakarta.enterprise.inject.spi.CDI");
Method resolvedCdiCurrentMethod = null;
Method resolvedCdiBeanManagerMethod = null;
diff --cc deltaspike/core/api/src/main/java/org/apache/deltaspike/core/api/provider/BeanProvider.java
index 97411998f,7e9b05b4c..e4b5d128a
--- a/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/api/provider/BeanProvider.java
+++ b/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/api/provider/BeanProvider.java
@@@ -82,7 -82,7 +82,7 @@@ public final class BeanProvide
* injected into). But if we manually resolve a @Dependent bean, then it does <b>not</b> belong to such well
* defined lifecycle (because @Dependent is not @NormalScoped) and thus will not be automatically
* destroyed at the end of the lifecycle. You need to manually destroy this contextual instance via
-- * {@link javax.enterprise.context.spi.Contextual#destroy(Object, javax.enterprise.context.spi.CreationalContext)}.
++ * {@link jakarta.enterprise.context.spi.Contextual#destroy(Object, jakarta.enterprise.context.spi.CreationalContext)}.
* Thus you also need to manually store the CreationalContext and the Bean you used to create the contextual
* instance.</p>
*
@@@ -469,7 -469,7 +469,8 @@@
CreationalContext<T> creationalContext = beanManager.createCreationalContext(null);
AnnotatedType<T> annotatedType = beanManager.createAnnotatedType((Class<T>) instance.getClass());
-- InjectionTarget<T> injectionTarget = beanManager.createInjectionTarget(annotatedType);
++ InjectionTarget<T> injectionTarget = beanManager.getInjectionTargetFactory(annotatedType)
++ .createInjectionTarget(null);
injectionTarget.inject(instance, creationalContext);
return instance;
}
diff --cc deltaspike/core/api/src/main/java/org/apache/deltaspike/core/util/context/ContextualInstanceInfo.java
index ccb8487ce,3e265228b..d8f2186da
--- a/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/util/context/ContextualInstanceInfo.java
+++ b/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/util/context/ContextualInstanceInfo.java
@@@ -38,7 -38,7 +38,7 @@@ public class ContextualInstanceInfo<T>
/**
* We need to store the CreationalContext as we need it for
* properly destroying the contextual instance via
-- * {@link javax.enterprise.context.spi.Contextual#destroy(Object, javax.enterprise.context.spi.CreationalContext)}
++ * {@link jakarta.enterprise.context.spi.Contextual#destroy(Object, jakarta.enterprise.context.spi.CreationalContext)}
*/
private CreationalContext<T> creationalContext;
diff --cc deltaspike/core/api/src/main/java/org/apache/deltaspike/core/util/context/ContextualStorage.java
index a74260a69,c511bfcb6..64497b539
--- a/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/util/context/ContextualStorage.java
+++ b/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/util/context/ContextualStorage.java
@@@ -155,7 -155,7 +155,7 @@@ public class ContextualStorage implemen
/**
* Restores the Bean from its beanKey.
-- * @see #getBeanKey(javax.enterprise.context.spi.Contextual)
++ * @see #getBeanKey(jakarta.enterprise.context.spi.Contextual)
*/
public Contextual<?> getBean(Object beanKey)
{
diff --cc deltaspike/core/api/src/main/java/org/apache/deltaspike/core/util/metadata/AnnotationInstanceProvider.java
index d5238f23d,d5238f23d..e4790c998
--- a/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/util/metadata/AnnotationInstanceProvider.java
+++ b/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/util/metadata/AnnotationInstanceProvider.java
@@@ -36,7 -36,7 +36,7 @@@ import java.util.Map
* <p/>
* <p>This class can be used to dynamically create Annotations which can be usd in AnnotatedTyp.
* This is e.g. the case if you configure an annotation via properties or XML file. In those cases you
-- * cannot use {@link javax.enterprise.util.AnnotationLiteral} because the type is not known at compile time.</p>
++ * cannot use {@link jakarta.enterprise.util.AnnotationLiteral} because the type is not known at compile time.</p>
* <p>usage:</p>
* <pre>
* String annotationClassName = ...;
@@@ -56,7 -56,7 +56,7 @@@ public class AnnotationInstanceProvide
/**
* Required to use the result of the factory instead of a default implementation
-- * of {@link javax.enterprise.util.AnnotationLiteral}.
++ * of {@link jakarta.enterprise.util.AnnotationLiteral}.
*
* @param annotationClass class of the target annotation
*/
@@@ -161,7 -161,7 +161,7 @@@
}
/**
-- * Copied from Apache OWB (javax.enterprise.util.AnnotationLiteral#toString())
++ * Copied from Apache OWB (jakarta.enterprise.util.AnnotationLiteral#toString())
* with minor changes.
*
* @return the current state of the annotation as string
diff --cc deltaspike/core/impl/src/main/java/org/apache/deltaspike/core/impl/config/ConfigurationExtension.java
index adbb585e8,3b7fcad2c..f07055159
--- a/deltaspike/core/impl/src/main/java/org/apache/deltaspike/core/impl/config/ConfigurationExtension.java
+++ b/deltaspike/core/impl/src/main/java/org/apache/deltaspike/core/impl/config/ConfigurationExtension.java
@@@ -502,12 -489,12 +502,6 @@@ public class ConfigurationExtension imp
return producer.getName();
}
-- @Override
-- public boolean isNullable()
-- {
-- return producer.isNullable();
-- }
--
@Override
public Set<InjectionPoint> getInjectionPoints()
{
diff --cc deltaspike/core/impl/src/main/java/org/apache/deltaspike/core/impl/config/DefaultConfigPropertyProducer.java
index a7bc317c3,0a00ece76..2314ea8a1
--- a/deltaspike/core/impl/src/main/java/org/apache/deltaspike/core/impl/config/DefaultConfigPropertyProducer.java
+++ b/deltaspike/core/impl/src/main/java/org/apache/deltaspike/core/impl/config/DefaultConfigPropertyProducer.java
@@@ -18,11 -18,12 +18,12 @@@
*/
package org.apache.deltaspike.core.impl.config;
-import javax.enterprise.context.ApplicationScoped;
-import javax.enterprise.context.Dependent;
-import javax.enterprise.inject.Produces;
-import javax.enterprise.inject.spi.InjectionPoint;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.enterprise.context.Dependent;
+import jakarta.enterprise.inject.Produces;
+import jakarta.enterprise.inject.spi.InjectionPoint;
+ import org.apache.deltaspike.core.api.config.ConfigResolver;
import org.apache.deltaspike.core.spi.config.BaseConfigPropertyProducer;
import org.apache.deltaspike.core.api.config.ConfigProperty;
diff --cc deltaspike/core/impl/src/main/java/org/apache/deltaspike/core/impl/monitoring/InvocationResultLogger.java
index 4e6c6ab2e,de345b214..e51934307
--- a/deltaspike/core/impl/src/main/java/org/apache/deltaspike/core/impl/monitoring/InvocationResultLogger.java
+++ b/deltaspike/core/impl/src/main/java/org/apache/deltaspike/core/impl/monitoring/InvocationResultLogger.java
@@@ -18,11 -18,13 +18,13 @@@
*/
package org.apache.deltaspike.core.impl.monitoring;
+ import org.apache.deltaspike.core.api.config.base.CoreBaseConfig;
+ import org.apache.deltaspike.core.api.exclude.Exclude;
import org.apache.deltaspike.core.api.monitoring.MonitorResultEvent;
-import javax.annotation.PostConstruct;
-import javax.enterprise.context.ApplicationScoped;
-import javax.enterprise.event.Observes;
+import jakarta.annotation.PostConstruct;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.enterprise.event.Observes;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
diff --cc deltaspike/core/impl/src/main/java/org/apache/deltaspike/core/impl/util/AnnotationInstanceUtils.java
index 3a2865938,9c19215c8..541e529f5
--- a/deltaspike/core/impl/src/main/java/org/apache/deltaspike/core/impl/util/AnnotationInstanceUtils.java
+++ b/deltaspike/core/impl/src/main/java/org/apache/deltaspike/core/impl/util/AnnotationInstanceUtils.java
@@@ -48,7 -48,7 +48,7 @@@ public abstract class AnnotationInstanc
//check for @Priority and CDI v1.1+
if (priorityAnnotationClass != null &&
-- ClassUtils.tryToLoadClassForName("javax.enterprise.inject.spi.AfterTypeDiscovery") != null)
++ ClassUtils.tryToLoadClassForName("jakarta.enterprise.inject.spi.AfterTypeDiscovery") != null)
{
Map<String, Object> defaultValueMap = new HashMap<String, Object>();
defaultValueMap.put("value", priorityValue);
diff --cc deltaspike/core/impl/src/test/java/org/apache/deltaspike/test/core/api/config/injectable/InjectableConfigPropertyTest.java
index 2b4c8bee9,f7f27c0d6..80cfc9302
--- a/deltaspike/core/impl/src/test/java/org/apache/deltaspike/test/core/api/config/injectable/InjectableConfigPropertyTest.java
+++ b/deltaspike/core/impl/src/test/java/org/apache/deltaspike/test/core/api/config/injectable/InjectableConfigPropertyTest.java
@@@ -18,6 -18,7 +18,7 @@@
*/
package org.apache.deltaspike.test.core.api.config.injectable;
-import javax.inject.Inject;
++import jakarta.inject.Inject;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.HashSet;
diff --cc deltaspike/core/impl/src/test/java/org/apache/deltaspike/test/core/api/config/propertyconfigsource/MyCustomEarPropertyFileConfig.java
index ab9b00e44,ab9b00e44..2762838a3
--- a/deltaspike/core/impl/src/test/java/org/apache/deltaspike/test/core/api/config/propertyconfigsource/MyCustomEarPropertyFileConfig.java
+++ b/deltaspike/core/impl/src/test/java/org/apache/deltaspike/test/core/api/config/propertyconfigsource/MyCustomEarPropertyFileConfig.java
@@@ -23,7 -23,7 +23,7 @@@ import org.apache.deltaspike.core.api.e
/**
* Custom PropertyFileConfig which gets picked up during
-- * {@link javax.enterprise.inject.spi.ProcessAnnotatedType}.
++ * {@link jakarta.enterprise.inject.spi.ProcessAnnotatedType}.
* We need to do this hack to avoid
*/
@Exclude
diff --cc deltaspike/core/impl/src/test/java/org/apache/deltaspike/test/core/api/config/propertyconfigsource/MyCustomPropertyFileConfig.java
index edd700725,edd700725..f618dcf00
--- a/deltaspike/core/impl/src/test/java/org/apache/deltaspike/test/core/api/config/propertyconfigsource/MyCustomPropertyFileConfig.java
+++ b/deltaspike/core/impl/src/test/java/org/apache/deltaspike/test/core/api/config/propertyconfigsource/MyCustomPropertyFileConfig.java
@@@ -22,7 -22,7 +22,7 @@@ import org.apache.deltaspike.core.api.c
/**
* Custom PropertyFileConfig which gets picked up during
-- * {@link javax.enterprise.inject.spi.ProcessAnnotatedType}.
++ * {@link jakarta.enterprise.inject.spi.ProcessAnnotatedType}.
* The values will be available <em>after</em> the container got booted!
*/
public class MyCustomPropertyFileConfig implements PropertyFileConfig
diff --cc deltaspike/core/impl/src/test/java/org/apache/deltaspike/test/core/impl/interdyn/SomeTestService.java
index 104c7763e,6003c3fec..cfdd66744
--- a/deltaspike/core/impl/src/test/java/org/apache/deltaspike/test/core/impl/interdyn/SomeTestService.java
+++ b/deltaspike/core/impl/src/test/java/org/apache/deltaspike/test/core/impl/interdyn/SomeTestService.java
@@@ -21,8 -21,9 +21,9 @@@ package org.apache.deltaspike.test.core
import org.apache.deltaspike.core.api.monitoring.MonitorResultEvent;
import org.junit.Assert;
-import javax.annotation.PreDestroy;
-import javax.enterprise.context.ApplicationScoped;
-import javax.enterprise.event.Observes;
++import jakarta.annotation.PreDestroy;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.enterprise.event.Observes;
@ApplicationScoped
public class SomeTestService
diff --cc deltaspike/core/impl/src/test/java/org/apache/deltaspike/test/core/impl/scope/window/DefaultWindowContextTest.java
index d41abff2f,39640b8d4..f26790800
--- a/deltaspike/core/impl/src/test/java/org/apache/deltaspike/test/core/impl/scope/window/DefaultWindowContextTest.java
+++ b/deltaspike/core/impl/src/test/java/org/apache/deltaspike/test/core/impl/scope/window/DefaultWindowContextTest.java
@@@ -59,7 -59,7 +59,7 @@@ public class DefaultWindowContextTes
private SomeWindowScopedBean someWindowScopedBean;
/**
-- * Tests {@link org.apache.deltaspike.core.impl.util.JndiUtils#lookup(String, Class)} by looking up the {@link javax.enterprise.inject.spi.BeanManager}
++ * Tests {@link org.apache.deltaspike.core.impl.util.JndiUtils#lookup(String, Class)} by looking up the {@link jakarta.enterprise.inject.spi.BeanManager}
*/
@Test
public void testWindowScoedBean()
diff --cc deltaspike/modules/data/impl/src/main/java/org/apache/deltaspike/data/impl/property/Reflections.java
index ce8dd951d,ce8dd951d..d005bfdf8
--- a/deltaspike/modules/data/impl/src/main/java/org/apache/deltaspike/data/impl/property/Reflections.java
+++ b/deltaspike/modules/data/impl/src/main/java/org/apache/deltaspike/data/impl/property/Reflections.java
@@@ -31,7 -31,7 +31,7 @@@ import java.util.Set
/**
* Utility class for working with JDK Reflection and also CDI's
-- * {@link javax.enterprise.inject.spi.Annotated} metadata.
++ * {@link jakarta.enterprise.inject.spi.Annotated} metadata.
*/
public class Reflections
{
diff --cc deltaspike/modules/jpa/api/pom.xml
index 1620e9f33,30c6ff5f4..e73623590
--- a/deltaspike/modules/jpa/api/pom.xml
+++ b/deltaspike/modules/jpa/api/pom.xml
@@@ -38,7 -38,7 +38,7 @@@
</deltaspike.osgi.export.pkg>
<deltaspike.osgi.import>
javax.persistence*;version="[1.1,3)",
-- javax.enterprise.inject,
++ jakarta.enterprise.inject,
!org.apache.deltaspike.jpa.*,
*
</deltaspike.osgi.import>
diff --cc deltaspike/modules/jpa/api/src/main/java/org/apache/deltaspike/jpa/api/transaction/Transactional.java
index 36746d8a8,ba5fec7d6..9478d5ed2
--- a/deltaspike/modules/jpa/api/src/main/java/org/apache/deltaspike/jpa/api/transaction/Transactional.java
+++ b/deltaspike/modules/jpa/api/src/main/java/org/apache/deltaspike/jpa/api/transaction/Transactional.java
@@@ -49,7 -49,7 +49,7 @@@ public @interface Transactiona
* for the injected {@link javax.persistence.EntityManager}s.
* Default-value is {@link Any} which means any injected {@link javax.persistence.EntityManager}s
* should be detected automatically and transactions for all injected {@link javax.persistence.EntityManager}s
-- * will be started. Or the {@link javax.enterprise.inject.Default} {@link javax.persistence.EntityManager}
++ * will be started. Or the {@link jakarta.enterprise.inject.Default} {@link javax.persistence.EntityManager}
* will be used, if no qualifier and no {@link javax.persistence.EntityManager} was found (in the annotated class)
* (see DELTASPIKE-320).
*
diff --cc deltaspike/modules/jpa/impl/src/main/java/org/apache/deltaspike/jpa/impl/entitymanager/EntityManagerFactoryProducer.java
index 15e4fc813,567f9d852..e0a88766c
--- a/deltaspike/modules/jpa/impl/src/main/java/org/apache/deltaspike/jpa/impl/entitymanager/EntityManagerFactoryProducer.java
+++ b/deltaspike/modules/jpa/impl/src/main/java/org/apache/deltaspike/jpa/impl/entitymanager/EntityManagerFactoryProducer.java
@@@ -18,12 -18,13 +18,13 @@@
*/
package org.apache.deltaspike.jpa.impl.entitymanager;
-import javax.enterprise.context.Dependent;
-import javax.enterprise.inject.Disposes;
-import javax.enterprise.inject.Produces;
-import javax.enterprise.inject.spi.InjectionPoint;
-import javax.inject.Inject;
-import javax.persistence.EntityManagerFactory;
-import javax.persistence.Persistence;
+import jakarta.enterprise.context.Dependent;
++import jakarta.enterprise.inject.Disposes;
+import jakarta.enterprise.inject.Produces;
+import jakarta.enterprise.inject.spi.InjectionPoint;
+import jakarta.inject.Inject;
+import jakarta.persistence.EntityManagerFactory;
+import jakarta.persistence.Persistence;
import java.util.Properties;
import java.util.logging.Logger;
diff --cc deltaspike/modules/jpa/impl/src/main/java/org/apache/deltaspike/jpa/impl/transaction/ResourceLocalTransactionStrategy.java
index 7f370eee0,f21bd8c87..e9c2e1e8e
--- a/deltaspike/modules/jpa/impl/src/main/java/org/apache/deltaspike/jpa/impl/transaction/ResourceLocalTransactionStrategy.java
+++ b/deltaspike/modules/jpa/impl/src/main/java/org/apache/deltaspike/jpa/impl/transaction/ResourceLocalTransactionStrategy.java
@@@ -48,7 -48,7 +48,7 @@@ import org.apache.deltaspike.jpa.spi.tr
* It supports nested Transactions with the MANDATORY behaviour.</p>
*
* <p>The outermost @Transactional interceptor for the given
-- * {@link javax.inject.Qualifier} will open an {@link javax.persistence.EntityTransaction}
++ * {@link jakarta.inject.Qualifier} will open an {@link javax.persistence.EntityTransaction}
* and the outermost @Transactional interceptor for <b>all</b>
* EntityManagers will flush and subsequently close all open transactions.</p>
*
diff --cc deltaspike/modules/jpa/impl/src/main/java/org/apache/deltaspike/jpa/impl/transaction/context/TransactionBeanStorage.java
index bc5261114,376051e53..cccbb13fd
--- a/deltaspike/modules/jpa/impl/src/main/java/org/apache/deltaspike/jpa/impl/transaction/context/TransactionBeanStorage.java
+++ b/deltaspike/modules/jpa/impl/src/main/java/org/apache/deltaspike/jpa/impl/transaction/context/TransactionBeanStorage.java
@@@ -31,7 -31,7 +31,7 @@@ import java.util.logging.Logger
/**
* <p>This class stores information about
* @{@link org.apache.deltaspike.jpa.api.transaction.TransactionScoped}
-- * contextual instances, their {@link javax.enterprise.context.spi.CreationalContext} etc.</p>
++ * contextual instances, their {@link jakarta.enterprise.context.spi.CreationalContext} etc.</p>
*
* <p>We use a RequestScoped bean because this way we don't need to take
* care about cleaning up any ThreadLocals ourselves. This also makes sure that
diff --cc deltaspike/modules/jsf/api/src/main/java/org/apache/deltaspike/jsf/api/config/JsfModuleConfig.java
index 1ade44fb5,181a00d31..c2fdd5079
--- a/deltaspike/modules/jsf/api/src/main/java/org/apache/deltaspike/jsf/api/config/JsfModuleConfig.java
+++ b/deltaspike/modules/jsf/api/src/main/java/org/apache/deltaspike/jsf/api/config/JsfModuleConfig.java
@@@ -123,11 -123,11 +123,11 @@@ public class JsfModuleConfig implement
}
/**
-- * Defines the {@link javax.enterprise.Qualifier} which will be used to fire the
++ * Defines the {@link jakarta.enterprise.Qualifier} which will be used to fire the
* {@link org.apache.deltaspike.core.api.exception.control.event.ExceptionToCatchEvent}
* for unhandled JSF exceptions.
*
-- * @return the {@link javax.enterprise.Qualifier}.
++ * @return the {@link jakarta.enterprise.Qualifier}.
*/
public Class<? extends Annotation> getExceptionQualifier()
{
diff --cc deltaspike/modules/jsf/impl/pom.xml
index 8d2d25fa8,7a7294577..e279933b0
--- a/deltaspike/modules/jsf/impl/pom.xml
+++ b/deltaspike/modules/jsf/impl/pom.xml
@@@ -156,7 -156,7 +156,7 @@@
<scope>test</scope>
<exclusions>
<exclusion>
-- <groupId>javax.enterprise</groupId>
++ <groupId>jakarta.enterprise</groupId>
<artifactId>cdi-api</artifactId>
</exclusion>
</exclusions>
diff --cc deltaspike/modules/jsf/impl/src/main/java/org/apache/deltaspike/jsf/impl/listener/request/JsfRequestBroadcaster.java
index 67d60f21c,830683955..8c438a287
--- a/deltaspike/modules/jsf/impl/src/main/java/org/apache/deltaspike/jsf/impl/listener/request/JsfRequestBroadcaster.java
+++ b/deltaspike/modules/jsf/impl/src/main/java/org/apache/deltaspike/jsf/impl/listener/request/JsfRequestBroadcaster.java
@@@ -41,8 -41,8 +41,8 @@@ import java.util.Map
* with
* {@link FacesContext} as event-payload
* and/or in case of CDI 1.1+
-- * {@link javax.enterprise.context.Initialized}
-- * {@link javax.enterprise.context.Destroyed}
++ * {@link jakarta.enterprise.context.Initialized}
++ * {@link jakarta.enterprise.context.Destroyed}
* with
* {@link javax.faces.bean.RequestScoped} as annotation-parameter and
* {@link FacesContext} as event-payload
@@@ -65,14 -65,14 +65,14 @@@ public class JsfRequestBroadcaster impl
Map<String, Class> values = new HashMap<String, Class>();
values.put("value", RequestScoped.class);
Class<? extends Annotation> initializedAnnotationClass =
-- ClassUtils.tryToLoadClassForName("javax.enterprise.context.Initialized");
++ ClassUtils.tryToLoadClassForName("jakarta.enterprise.context.Initialized");
if (initializedAnnotationClass != null)
{
this.initializedAnnotationInstance = AnnotationInstanceProvider.of(initializedAnnotationClass, values);
}
Class<? extends Annotation> destroyedAnnotationClass =
-- ClassUtils.tryToLoadClassForName("javax.enterprise.context.Destroyed");
++ ClassUtils.tryToLoadClassForName("jakarta.enterprise.context.Destroyed");
if (destroyedAnnotationClass != null)
{
this.destroyedAnnotationInstance = AnnotationInstanceProvider.of(destroyedAnnotationClass, values);
diff --cc deltaspike/modules/jsf/impl/src/main/java/org/apache/deltaspike/jsf/impl/scope/mapped/MappedJsf2ScopeExtension.java
index c8fe5a7c9,854fb2a3f..bb2273420
--- a/deltaspike/modules/jsf/impl/src/main/java/org/apache/deltaspike/jsf/impl/scope/mapped/MappedJsf2ScopeExtension.java
+++ b/deltaspike/modules/jsf/impl/src/main/java/org/apache/deltaspike/jsf/impl/scope/mapped/MappedJsf2ScopeExtension.java
@@@ -57,11 -57,11 +57,11 @@@ public class MappedJsf2ScopeExtension i
if (ClassUtils.tryToLoadClassForName("javax.faces.bean.ApplicationScoped") != null)
{
this.mappedJsfScopes.put(javax.faces.bean.ApplicationScoped.class,
-- javax.enterprise.context.ApplicationScoped.class);
++ jakarta.enterprise.context.ApplicationScoped.class);
this.mappedJsfScopes.put(javax.faces.bean.SessionScoped.class,
-- javax.enterprise.context.SessionScoped.class);
++ jakarta.enterprise.context.SessionScoped.class);
this.mappedJsfScopes.put(javax.faces.bean.RequestScoped.class,
-- javax.enterprise.context.RequestScoped.class);
++ jakarta.enterprise.context.RequestScoped.class);
if (JsfUtils.isViewScopeDelegationEnabled())
{
diff --cc deltaspike/modules/jsf/impl/src/main/java/org/apache/deltaspike/jsf/impl/scope/view/ViewScopedExtension.java
index 30c4341b2,303e1fd85..c746c4db6
--- a/deltaspike/modules/jsf/impl/src/main/java/org/apache/deltaspike/jsf/impl/scope/view/ViewScopedExtension.java
+++ b/deltaspike/modules/jsf/impl/src/main/java/org/apache/deltaspike/jsf/impl/scope/view/ViewScopedExtension.java
@@@ -37,12 -37,12 +37,12 @@@ import org.apache.deltaspike.jsf.impl.u
* <p>2 steps are necessary:</p>
* <ol>
* <li>We have to manually add the @ViewScoped annotation
-- * as a passivating {@link javax.enterprise.context.NormalScope},
++ * as a passivating {@link jakarta.enterprise.context.NormalScope},
* since this annotation is neither a JSR-330 annotation
* nor a JSR-299 annotation and therefor doesn't get picked up automatically. This has to be
* before the bean scanning starts.</li>
* <li>After the bean scanning succeeded, we register the
-- * {@link javax.enterprise.context.spi.Context} for the
++ * {@link jakarta.enterprise.context.spi.Context} for the
* ViewScoped. The {@link ViewScopedContext} is responsible for actually storing all our
* @ViewScoped contextual instances in the JSF ViewMap.</li>
* </ol>
diff --cc deltaspike/modules/jsf/pom.xml
index 7b095029d,1a5dc5849..c675ca540
--- a/deltaspike/modules/jsf/pom.xml
+++ b/deltaspike/modules/jsf/pom.xml
@@@ -46,7 -46,7 +46,7 @@@
<groupId>org.apache.myfaces.core</groupId>
<artifactId>myfaces-api</artifactId>
<!-- just needed for compiling >optional< classes for jsf 2.2 jsf 2.0 and 2.1 compatibility is ensured via test-cases -->
-- <version>${myfaces22.version}</version>
++ <version>${myfaces.version}</version>
<scope>provided</scope>
<exclusions>
<!-- Exclude transitive CDI API dependencies -->
diff --cc deltaspike/modules/proxy/api/src/main/java/org/apache/deltaspike/proxy/api/DeltaSpikeProxyFactory.java
index 8fbcaf7f8,1654fdec1..d85f2102b
--- a/deltaspike/modules/proxy/api/src/main/java/org/apache/deltaspike/proxy/api/DeltaSpikeProxyFactory.java
+++ b/deltaspike/modules/proxy/api/src/main/java/org/apache/deltaspike/proxy/api/DeltaSpikeProxyFactory.java
@@@ -22,10 -22,13 +22,12 @@@ import java.lang.annotation.Annotation
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
+ import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
+import jakarta.enterprise.inject.spi.BeanManager;
+ import java.util.Set;
-import javax.enterprise.inject.spi.BeanManager;
-
import org.apache.deltaspike.core.util.ClassUtils;
import org.apache.deltaspike.core.util.ReflectionUtils;
import org.apache.deltaspike.proxy.spi.DeltaSpikeProxyClassGenerator;
diff --cc deltaspike/modules/scheduler/api/pom.xml
index e05da157b,e165cd303..8eb88b41b
--- a/deltaspike/modules/scheduler/api/pom.xml
+++ b/deltaspike/modules/scheduler/api/pom.xml
@@@ -37,7 -37,7 +37,7 @@@
org.apache.deltaspike.scheduler.*
</deltaspike.osgi.export.pkg>
<deltaspike.osgi.import>
-- javax.enterprise.inject,
++ jakarta.enterprise.inject,
!org.apache.deltaspike.scheduler.*,
*
</deltaspike.osgi.import>
diff --cc deltaspike/modules/security/api/src/main/java/org/apache/deltaspike/security/api/authorization/AccessDecisionVoter.java
index 625d032c9,625d032c9..defaa758a
--- a/deltaspike/modules/security/api/src/main/java/org/apache/deltaspike/security/api/authorization/AccessDecisionVoter.java
+++ b/deltaspike/modules/security/api/src/main/java/org/apache/deltaspike/security/api/authorization/AccessDecisionVoter.java
@@@ -31,8 -31,8 +31,8 @@@ import java.util.Set
* A voter has to be used in combination with
* {@link Secured}.<p/>
* A voter can use every scope which is active. It's recommended to use
-- * {@link javax.enterprise.context.ApplicationScoped} for stateless voters and e.g.
-- * {@link javax.enterprise.context.RequestScoped} otherwise.
++ * {@link jakarta.enterprise.context.ApplicationScoped} for stateless voters and e.g.
++ * {@link jakarta.enterprise.context.RequestScoped} otherwise.
*/
public interface AccessDecisionVoter extends Serializable
{
diff --cc deltaspike/modules/test-control/api/pom.xml
index 395177dac,af306bf30..f2d3e0a57
--- a/deltaspike/modules/test-control/api/pom.xml
+++ b/deltaspike/modules/test-control/api/pom.xml
@@@ -37,7 -37,7 +37,7 @@@
org.apache.deltaspike.testcontrol.*
</deltaspike.osgi.export.pkg>
<deltaspike.osgi.import>
-- javax.enterprise.inject,
++ jakarta.enterprise.inject,
!org.apache.deltaspike.testcontrol.*,
*
</deltaspike.osgi.import>
diff --cc deltaspike/modules/test-control/impl/src/main/java/org/apache/deltaspike/testcontrol/impl/mock/BeanCacheKey.java
index fd878d7f6,c3b084033..7674d9fd6
--- a/deltaspike/modules/test-control/impl/src/main/java/org/apache/deltaspike/testcontrol/impl/mock/BeanCacheKey.java
+++ b/deltaspike/modules/test-control/impl/src/main/java/org/apache/deltaspike/testcontrol/impl/mock/BeanCacheKey.java
@@@ -149,7 -149,7 +149,7 @@@ public class BeanCacheKe
}
/**
-- * Calculate the hashCode() of a qualifier, which ignores {@link javax.enterprise.util.Nonbinding} members.
++ * Calculate the hashCode() of a qualifier, which ignores {@link jakarta.enterprise.util.Nonbinding} members.
*/
private int getQualifierHashCode(Annotation a)
{
@@@ -157,7 -157,7 +157,7 @@@
}
/**
-- * Implements the equals() method for qualifiers, which ignores {@link javax.enterprise.util.Nonbinding} members.
++ * Implements the equals() method for qualifiers, which ignores {@link jakarta.enterprise.util.Nonbinding} members.
*/
private boolean qualifierEquals(Annotation qualifier1, Annotation qualifier2)
{
diff --cc deltaspike/modules/test-control/impl/src/main/java/org/apache/deltaspike/testcontrol/impl/mock/DefaultMockFilter.java
index 553cc2c2a,2c322fda6..360632b29
--- a/deltaspike/modules/test-control/impl/src/main/java/org/apache/deltaspike/testcontrol/impl/mock/DefaultMockFilter.java
+++ b/deltaspike/modules/test-control/impl/src/main/java/org/apache/deltaspike/testcontrol/impl/mock/DefaultMockFilter.java
@@@ -61,7 -61,7 +61,7 @@@ public class DefaultMockFilter implemen
annotations.addAll(annotated.getAnnotations());
for (AnnotatedMethod annotatedMethod :
-- (Set<javax.enterprise.inject.spi.AnnotatedMethod>)((AnnotatedType) annotated).getMethods())
++ (Set<jakarta.enterprise.inject.spi.AnnotatedMethod>)((AnnotatedType) annotated).getMethods())
{
annotations.addAll(annotatedMethod.getAnnotations());
}
diff --cc deltaspike/modules/test-control/impl/src/main/java/org/apache/deltaspike/testcontrol/impl/validation/StandardContextTestControlValidator.java
index 4e514e3d8,177a01c8b..d795855d4
--- a/deltaspike/modules/test-control/impl/src/main/java/org/apache/deltaspike/testcontrol/impl/validation/StandardContextTestControlValidator.java
+++ b/deltaspike/modules/test-control/impl/src/main/java/org/apache/deltaspike/testcontrol/impl/validation/StandardContextTestControlValidator.java
@@@ -72,7 -72,7 +72,7 @@@ public class StandardContextTestControl
for (Class<? extends Annotation> scopeClass : scopeClasses)
{
-- if (!scopeClass.getName().startsWith("javax.enterprise.context."))
++ if (!scopeClass.getName().startsWith("jakarta.enterprise.context."))
{
throw new IllegalStateException("Please remove " + scopeClass.getName() + " at " + declaringClass +
(testMethod != null ? "#" + testMethod.getName() : "") +
diff --cc deltaspike/parent/code/pom.xml
index 64e5dde07,f1ac467ea..6a5919473
--- a/deltaspike/parent/code/pom.xml
+++ b/deltaspike/parent/code/pom.xml
@@@ -149,31 -149,77 +149,6 @@@
</executions>
</plugin>
-- <plugin>
-- <groupId>org.apache.maven.plugins</groupId>
-- <artifactId>maven-shade-plugin</artifactId>
-- <version>3.2.1</version>
-- <executions>
-- <execution>
-- <id>shade-jakarta</id>
-- <phase>package</phase>
-- <goals>
-- <goal>shade</goal>
-- </goals>
-- <configuration>
-- <shadedArtifactAttached>true</shadedArtifactAttached>
-- <shadedClassifierName>jakarta</shadedClassifierName>
-- <createDependencyReducedPom>false</createDependencyReducedPom>
- <transformers>
- <transformer implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer" />
- </transformers>
-- <relocations>
-- <relocation>
- <pattern>javax</pattern>
- <shadedPattern>jakarta</shadedPattern>
- <pattern>javax.inject</pattern>
- <shadedPattern>jakarta.inject</shadedPattern>
- </relocation>
- <relocation>
- <pattern>javax.interceptor</pattern>
- <shadedPattern>jakarta.interceptor</shadedPattern>
- </relocation>
- <relocation>
- <pattern>javax.enterprise</pattern>
- <shadedPattern>jakarta.enterprise</shadedPattern>
- </relocation>
- <relocation>
- <pattern>javax.resource</pattern>
- <shadedPattern>jakarta.resource</shadedPattern>
- </relocation>
- <relocation>
- <pattern>javax.transaction</pattern>
- <shadedPattern>jakarta.transaction</shadedPattern>
- <excludes>
- <exclude>javax.transaction.xa.**</exclude>
- </excludes>
- </relocation>
- <relocation>
- <pattern>javax.validation</pattern>
- <shadedPattern>jakarta.validation</shadedPattern>
- </relocation>
- <relocation>
- <pattern>javax.persistence</pattern>
- <shadedPattern>jakarta.persistence</shadedPattern>
- </relocation>
- <relocation>
- <pattern>javax.faces</pattern>
- <shadedPattern>jakarta.faces</shadedPattern>
- </relocation>
- <relocation>
- <pattern>javax.decorator</pattern>
- <shadedPattern>jakarta.decorator</shadedPattern>
- </relocation>
- <relocation>
- <pattern>javax.servlet</pattern>
- <shadedPattern>jakarta.servlet</shadedPattern>
- </relocation>
- <relocation>
- <pattern>javax.el</pattern>
- <shadedPattern>jakarta.el</shadedPattern>
-- </relocation>
-- </relocations>
-- </configuration>
-- </execution>
-- </executions>
-- </plugin>
</plugins>
</build>
@@@ -214,6 -273,184 +189,13 @@@
<properties>
<cdicontainer.version>owb-${owb.version}</cdicontainer.version>
- <owb-arquillian.version>${owb.version}</owb-arquillian.version>
- </properties>
-
- <build>
- <plugins>
- <plugin>
- <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-surefire-plugin</artifactId>
- <configuration>
- <systemProperties>
- <cdicontainer.version>${cdicontainer.version}</cdicontainer.version>
- </systemProperties>
-
- <!-- Ignore these groups because they don't work with embedded OWB -->
- <excludedGroups>
- org.apache.deltaspike.test.category.WebProfileCategory,
- org.apache.deltaspike.test.category.WebEE7ProfileCategory,
- org.apache.deltaspike.test.category.FullProfileCategory,
- org.apache.deltaspike.test.category.EnterpriseArchiveProfileCategory
- </excludedGroups>
- </configuration>
- </plugin>
- </plugins>
- </build>
-
- <dependencies>
- <!-- OWB specific dependencies-->
- <dependency>
- <groupId>org.apache.geronimo.specs</groupId>
- <artifactId>geronimo-atinject_1.0_spec</artifactId>
- </dependency>
- <dependency>
- <groupId>org.apache.geronimo.specs</groupId>
- <artifactId>geronimo-jcdi_1.0_spec</artifactId>
- </dependency>
- <dependency>
- <groupId>org.apache.geronimo.specs</groupId>
- <artifactId>geronimo-interceptor_1.1_spec</artifactId>
- </dependency>
- <dependency>
- <groupId>org.apache.openwebbeans</groupId>
- <artifactId>openwebbeans-impl</artifactId>
- </dependency>
- <dependency>
- <groupId>org.apache.openwebbeans</groupId>
- <artifactId>openwebbeans-spi</artifactId>
- </dependency>
- <dependency>
- <groupId>org.apache.openwebbeans</groupId>
- <artifactId>openwebbeans-resource</artifactId>
- </dependency>
-
- <dependency>
- <groupId>org.apache.openwebbeans.arquillian</groupId>
- <artifactId>owb-arquillian-standalone</artifactId>
- <version>${owb-arquillian.version}</version>
- <scope>test</scope>
- </dependency>
-
- <dependency>
- <groupId>org.apache.geronimo.specs</groupId>
- <artifactId>${validation.artifactId}</artifactId>
- </dependency>
- <dependency>
- <groupId>org.apache.bval</groupId>
- <artifactId>${bval.artifactId}</artifactId>
- <scope>test</scope>
- </dependency>
- </dependencies>
- </profile>
-
- <profile>
- <!-- use this profile to compile and test DeltaSpike with Apache OpenWebBeans [1.5,2.0) -->
- <id>OWB15</id>
-
- <properties>
- <owb.version>1.7.5</owb.version>
- <cdicontainer.version>owb-${owb.version}</cdicontainer.version>
- </properties>
-
- <build>
- <plugins>
- <plugin>
- <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-surefire-plugin</artifactId>
- <configuration>
- <systemProperties>
- <cdicontainer.version>${cdicontainer.version}</cdicontainer.version>
- </systemProperties>
-
- <!-- Ignore these groups because they don't work with embedded OWB -->
- <excludedGroups>
- org.apache.deltaspike.test.category.WebProfileCategory,
- org.apache.deltaspike.test.category.WebEE7ProfileCategory,
- org.apache.deltaspike.test.category.FullProfileCategory,
- org.apache.deltaspike.test.category.EnterpriseArchiveProfileCategory
- </excludedGroups>
- </configuration>
- </plugin>
- </plugins>
- </build>
-
- <dependencies>
- <!-- OWB specific dependencies-->
- <dependency>
- <groupId>org.apache.geronimo.specs</groupId>
- <artifactId>geronimo-atinject_1.0_spec</artifactId>
- </dependency>
- <dependency>
- <!--X TODO move this to dependencyManagement once it is released -->
- <groupId>org.apache.geronimo.specs</groupId>
- <artifactId>geronimo-jcdi_1.1_spec</artifactId>
- <version>${geronimo-jcdi-1.1-spec.version}</version>
- <scope>provided</scope>
- </dependency>
- <dependency>
- <groupId>org.apache.geronimo.specs</groupId>
- <artifactId>geronimo-interceptor_1.2_spec</artifactId>
- <version>${geronimo-interceptor-1.2-spec.version}</version>
- <scope>provided</scope>
- </dependency>
- <dependency>
- <groupId>org.apache.geronimo.specs</groupId>
- <artifactId>geronimo-annotation_1.2_spec</artifactId>
- <version>${geronimo-annotation_1.2_spec.version}</version>
- <scope>provided</scope>
- </dependency>
- <dependency>
- <groupId>org.apache.geronimo.specs</groupId>
- <artifactId>geronimo-el_2.2_spec</artifactId>
- <version>1.0.2</version>
- </dependency>
-
- <dependency>
- <groupId>org.apache.openwebbeans</groupId>
- <artifactId>openwebbeans-impl</artifactId>
- </dependency>
- <dependency>
- <groupId>org.apache.openwebbeans</groupId>
- <artifactId>openwebbeans-spi</artifactId>
- </dependency>
- <dependency>
- <groupId>org.apache.openwebbeans</groupId>
- <artifactId>openwebbeans-resource</artifactId>
- </dependency>
-
- <dependency>
- <groupId>org.apache.openwebbeans.arquillian</groupId>
- <artifactId>owb-arquillian-standalone</artifactId>
- <!--
- quite a hack! the 1.7.5 does a bit too much with resource isolation
- Glad the 2.x version is still compatible and has all fixed.
- But eventually we should go back to the matching version.
- <version>${owb.version}</version>
- -->
- <version>2.0.5</version>
- <scope>test</scope>
- </dependency>
-
- <dependency>
- <groupId>org.apache.geronimo.specs</groupId>
- <artifactId>${validation.artifactId}</artifactId>
- </dependency>
- <dependency>
- <groupId>org.apache.bval</groupId>
- <artifactId>${bval.artifactId}</artifactId>
- <scope>test</scope>
- </dependency>
- </dependencies>
- </profile>
+
- <profile>
- <!-- use this profile to compile and test DeltaSpike with Apache OpenWebBeans [2.0,..) -->
- <id>OWB2</id>
-
- <properties>
- <owb.version>2.0.21</owb.version>
- <cdicontainer.version>owb-${owb.version}</cdicontainer.version>
++ <jakarta.atinject-api.version>2.0.0</jakarta.atinject-api.version>
++ <jakarta.cdi-api.version>4.0.0</jakarta.cdi-api.version>
++ <jakarta.interceptor-api.version>2.0.0</jakarta.interceptor-api.version>
++ <jakarta.annotation-api.version>2.0.0</jakarta.annotation-api.version>
++ <jakarta.el-api.version>4.0.0</jakarta.el-api.version>
++ <jakarta.transaction-api.version>2.0.0</jakarta.transaction-api.version>
</properties>
<repositories>
@@@ -254,81 -491,69 +236,88 @@@
<dependencies>
<!-- OWB specific dependencies-->
<dependency>
-- <groupId>org.apache.geronimo.specs</groupId>
-- <artifactId>geronimo-atinject_1.0_spec</artifactId>
- <classifier>jakarta</classifier>
++ <groupId>jakarta.annotation</groupId>
++ <artifactId>jakarta.annotation-api</artifactId>
++ <version>${jakarta.annotation-api.version}</version>
++ <scope>provided</scope>
</dependency>
++
<dependency>
-- <groupId>org.apache.geronimo.specs</groupId>
-- <artifactId>geronimo-annotation_1.3_spec</artifactId>
- <version>1.3</version>
- <classifier>jakarta</classifier>
- <version>${geronimo-jcdi-2.0-spec.version}</version>
++ <groupId>jakarta.inject</groupId>
++ <artifactId>jakarta.inject-api</artifactId>
++ <version>${jakarta.atinject-api.version}</version>
<scope>provided</scope>
</dependency>
++
<dependency>
-- <groupId>org.apache.geronimo.specs</groupId>
-- <artifactId>geronimo-jcdi_2.0_spec</artifactId>
- <classifier>jakarta</classifier>
- <version>${geronimo-jcdi-2.0-spec.version}</version>
++ <groupId>jakarta.enterprise</groupId>
++ <artifactId>jakarta.enterprise.cdi-api</artifactId>
++ <version>${jakarta.cdi-api.version}</version>
+ <scope>provided</scope>
++ <exclusions>
++ <exclusion>
++ <groupId>jakarta.inject</groupId>
++ <artifactId>jakarta.inject-api</artifactId>
++ </exclusion>
++ </exclusions>
+ </dependency>
++
+ <dependency>
- <groupId>org.apache.geronimo.specs</groupId>
- <artifactId>geronimo-interceptor_1.2_spec</artifactId>
- <version>${geronimo-interceptor-1.2-spec.version}</version>
++ <groupId>jakarta.interceptor</groupId>
++ <artifactId>jakarta.interceptor-api</artifactId>
++ <version>${jakarta.interceptor-api.version}</version>
<scope>provided</scope>
</dependency>
++
<dependency>
-- <groupId>org.apache.geronimo.specs</groupId>
- <artifactId>geronimo-interceptor_1.2_spec</artifactId>
- <classifier>jakarta</classifier>
- <artifactId>geronimo-el_2.2_spec</artifactId>
- <version>1.0.2</version>
++ <groupId>jakarta.el</groupId>
++ <artifactId>jakarta.el-api</artifactId>
++ <version>${jakarta.el-api.version}</version>
+ <scope>provided</scope>
</dependency>
+
<dependency>
- <groupId>org.apache.tomcat</groupId>
- <artifactId>tomcat-el-api</artifactId>
- <version>${tomcat.version}</version>
- <groupId>org.apache.openwebbeans</groupId>
- <artifactId>openwebbeans-impl</artifactId>
++ <groupId>jakarta.transaction</groupId>
++ <artifactId>jakarta.transaction-api</artifactId>
++ <version>${jakarta.transaction-api.version}</version>
++ <scope>provided</scope>
</dependency>
+
<dependency>
<groupId>org.apache.openwebbeans</groupId>
- <artifactId>openwebbeans-spi</artifactId>
+ <artifactId>openwebbeans-impl</artifactId>
- <classifier>jakarta</classifier>
- <exclusions>
- <exclusion>
- <groupId>org.apache.openwebbeans</groupId>
- <artifactId>openwebbeans-spi</artifactId>
- </exclusion>
- </exclusions>
++ <version>${owb.version}</version>
++ <scope>provided</scope>
</dependency>
<dependency>
<groupId>org.apache.openwebbeans</groupId>
- <artifactId>openwebbeans-resource</artifactId>
+ <artifactId>openwebbeans-spi</artifactId>
- <classifier>jakarta</classifier>
++ <version>${owb.version}</version>
++ <scope>provided</scope>
</dependency>
<dependency>
<groupId>org.apache.openwebbeans.arquillian</groupId>
<artifactId>owb-arquillian-standalone</artifactId>
<version>${owb.version}</version>
- <classifier>jakarta</classifier>
<scope>test</scope>
- <exclusions>
- <exclusion>
- <groupId>org.jboss.arquillian.testenricher</groupId>
- <artifactId>arquillian-testenricher-cdi</artifactId>
- </exclusion>
- </exclusions>
</dependency>
-
- <dependency>
- <groupId>org.apache.geronimo.specs</groupId>
- <artifactId>${validation.artifactId}</artifactId>
- </dependency>
<dependency>
- <groupId>org.apache.bval</groupId>
- <artifactId>${bval.artifactId}</artifactId>
+ <groupId>org.jboss.arquillian.testenricher</groupId>
+ <artifactId>arquillian-testenricher-cdi-jakarta</artifactId>
+ <version>${arquillian.version}</version>
<scope>test</scope>
</dependency>
+
</dependencies>
</profile>
<!-- please note that when changing any of these weld profiles, they are also used in some projects.
Make sure to update all pom's, if required -->
+
+
<profile>
- <!-- use this profile to compile and test DeltaSpike with JBoss Weld 1.x on an embedded container-->
- <id>Weld1</id>
+ <!-- use this profile to compile and test DeltaSpike with JBoss Weld 3.x on an embedded container -->
- <id>Weld3</id>
++ <id>Weld</id>
<properties>
<!-- Actual Weld version used with this profile -->
@@@ -549,29 -1703,94 +538,29 @@@
</properties>
<dependencies>
-
+ <!--This brings in the cdi-api in correct version corresponding to Weld version specified with ${weld.version}-->
+ <!--Only for build purposes, for tests, Wildfly provides that-->
<dependency>
- <groupId>javax.enterprise</groupId>
- <artifactId>cdi-api</artifactId>
- <version>1.0-SP4</version>
+ <groupId>org.jboss.weld</groupId>
+ <artifactId>weld-core-impl</artifactId>
+ <version>${weld.version}</version>
<scope>provided</scope>
</dependency>
-
<dependency>
- <groupId>javax.inject</groupId>
- <artifactId>javax.inject</artifactId>
- <groupId>javax</groupId>
- <artifactId>javaee-api</artifactId>
- <version>7.0</version>
++ <groupId>jakarta.inject</groupId>
++ <artifactId>jakarta.inject</artifactId>
+ <version>1</version>
<scope>provided</scope>
</dependency>
-
<dependency>
- <groupId>org.jboss.arquillian.container</groupId>
- <artifactId>arquillian-wls-remote-12.1</artifactId>
- <version>1.0.0.Alpha2</version>
+ <groupId>org.wildfly.arquillian</groupId>
+ <artifactId>wildfly-arquillian-container-managed</artifactId>
+ <version>${wildfly.arquillian.version}</version>
<scope>test</scope>
</dependency>
-
- </dependencies>
- <build>
- <plugins>
- <plugin>
- <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-surefire-plugin</artifactId>
- <version>${maven.surefire.plugin.version}</version>
- <configuration>
- <!-- until DELTASPIKE-996 is resolved -->
- <excludes>
- <exclude>**/BaseTestConfigProperty.java</exclude>
- <exclude>**/ConfigPropertyWARTest.java</exclude>
- <exclude>**/ConfigPropertyEARTest.java</exclude>
- </excludes>
- <systemProperties>
- <arquillian.launch>wls-remote-12c</arquillian.launch>
- <org.apache.deltaspike.ProjectStage>UnitTest</org.apache.deltaspike.ProjectStage>
- <cdicontainer.version>${cdicontainer.version}</cdicontainer.version>
- </systemProperties>
- <systemPropertyVariables>
- <WLS_HOME>${env.WLS_HOME}</WLS_HOME>
- </systemPropertyVariables>
- <!-- we just use groups to mark that a test should be executed only
- with specific environments. even though a java-ee6 application server has to be able to run
- all tests in theory, we have to exclude some tests because there are e.g. packaging issues or
- there are currently issues with arquillian. if a test isn't restricted to an environment,
- no category is used for the test-class. -->
- <excludedGroups>
- org.apache.deltaspike.test.category.FullProfileCategory,
- org.apache.deltaspike.test.category.WebEE7ProfileCategory,
- org.apache.deltaspike.test.category.SeCategory
- </excludedGroups>
- </configuration>
- </plugin>
- </plugins>
- </build>
-
- </profile>
-
- <profile>
- <id>wls-managed-12c</id>
-
- <properties>
- <cdicontainer.version>wls-${wls.version}</cdicontainer.version>
- </properties>
-
- <dependencies>
-
- <dependency>
- <groupId>javax.enterprise</groupId>
- <artifactId>cdi-api</artifactId>
- <version>1.0-SP4</version>
- <scope>provided</scope>
- </dependency>
-
- <dependency>
- <groupId>javax</groupId>
- <artifactId>javaee-api</artifactId>
- <version>7.0</version>
- <scope>provided</scope>
- </dependency>
-
<dependency>
- <groupId>org.jboss.arquillian.container</groupId>
- <artifactId>arquillian-wls-managed-12.1</artifactId>
- <version>1.0.0.Alpha3</version>
+ <groupId>org.jboss.arquillian.protocol</groupId>
+ <artifactId>arquillian-protocol-servlet</artifactId>
<scope>test</scope>
</dependency>
@@@ -633,8 -1870,8 +622,8 @@@
<scope>provided</scope>
</dependency>
<dependency>
-- <groupId>javax.inject</groupId>
-- <artifactId>javax.inject</artifactId>
++ <groupId>jakarta.inject</groupId>
++ <artifactId>jakarta.inject</artifactId>
<version>1</version>
<scope>provided</scope>
</dependency>
@@@ -673,7 -1901,7 +662,8 @@@
there are currently issues with arquillian. if a test isn't restricted to an environment,
no category is used for the test-class. -->
<excludedGroups>
- org.apache.deltaspike.test.category.WebEE7ProfileCategory,
++ org.apache.deltaspike.test.category.EnterpriseArchiveProfileCategory,
+ org.apache.deltaspike.test.category.FullProfileCategory,
org.apache.deltaspike.test.category.SeCategory
</excludedGroups>
</configuration>
@@@ -717,16 -1977,15 +707,16 @@@
</properties>
<dependencies>
+
<dependency>
-- <groupId>javax.enterprise</groupId>
++ <groupId>jakarta.enterprise</groupId>
<artifactId>cdi-api</artifactId>
- <version>1.0-SP4</version>
+ <version>1.1</version>
<scope>provided</scope>
</dependency>
<dependency>
-- <groupId>javax.inject</groupId>
-- <artifactId>javax.inject</artifactId>
++ <groupId>jakarta.inject</groupId>
++ <artifactId>jakarta.inject</artifactId>
<version>1</version>
<scope>provided</scope>
</dependency>
@@@ -780,14 -2085,14 +770,14 @@@
<dependencies>
<dependency>
-- <groupId>javax.enterprise</groupId>
++ <groupId>jakarta.enterprise</groupId>
<artifactId>cdi-api</artifactId>
<version>1.2</version>
<scope>provided</scope>
</dependency>
<dependency>
-- <groupId>javax.inject</groupId>
-- <artifactId>javax.inject</artifactId>
++ <groupId>jakarta.inject</groupId>
++ <artifactId>jakarta.inject</artifactId>
<version>1</version>
<scope>provided</scope>
</dependency>
@@@ -846,14 -2151,14 +836,14 @@@
<dependencies>
<dependency>
-- <groupId>javax.enterprise</groupId>
++ <groupId>jakarta.enterprise</groupId>
<artifactId>cdi-api</artifactId>
<version>1.2</version>
<scope>provided</scope>
</dependency>
<dependency>
-- <groupId>javax.inject</groupId>
-- <artifactId>javax.inject</artifactId>
++ <groupId>jakarta.inject</groupId>
++ <artifactId>jakarta.inject</artifactId>
<version>1</version>
<scope>provided</scope>
</dependency>
diff --cc deltaspike/parent/pom.xml
index 206a96ae9,935d7141a..9612cd792
--- a/deltaspike/parent/pom.xml
+++ b/deltaspike/parent/pom.xml
@@@ -47,37 -47,55 +47,35 @@@
<inceptionYear>2011</inceptionYear>
<properties>
- <java.version>8</java.version>
- <owb.version>2.0.23</owb.version>
- <java.version>1.8</java.version>
- <owb.version>1.2.8</owb.version>
++ <java.version>17</java.version>
++ <owb.version>4.0.0-SNAPSHOT</owb.version>
++
<!-- Weld profiles (in parent/code/pom.xml) override this version -->
-- <weld.version>1.1.34.Final</weld.version>
++ <weld.version>4.0.3.Final</weld.version>
<!-- for cdictrl-openejb -->
- <tomee.version>9.0.0-M7</tomee.version>
- <openejb.version>4.7.0</openejb.version>
++ <tomee.version>9.0.0.RC1</tomee.version>
<openejb.owb.version>${owb.version}</openejb.owb.version>
<!-- testing stuff -->
<junit.version>4.13.2</junit.version>
- <arquillian.version>1.7.0.Alpha10</arquillian.version>
- <arquillian.version>1.1.8.Final</arquillian.version>
- <tomee.version>1.7.0</tomee.version>
++ <arquillian.version>1.7.0.Alpha13</arquillian.version>
<!-- JSF-2.0 implementations-->
-- <myfaces2.version>2.0.14</myfaces2.version>
-- <myfaces22.version>2.2.3</myfaces22.version>
-- <myfaces2.version.current>2.1.8</myfaces2.version.current>
++ <myfaces.version>4.0.0-RC4</myfaces.version>
++ <myfaces2.version.current>4.0.0-RC4</myfaces2.version.current>
++<!--
<mojarra2.version>2.0.3-b03</mojarra2.version>
++-->
- <tomcat.version>10.0.11</tomcat.version>
-
-- <!-- JSF-1.2 implementations-->
-- <myfaces1.version>1.2.8</myfaces1.version>
-- <mojarra1.version>1.2_14</mojarra1.version>
++ <tomcat.version>10.1.5</tomcat.version>
<!-- used for some bytecode proxy stuff. Shaded in -->
- <asm.version>9.1</asm.version>
- <asm.version>9.3</asm.version>
-
- <!-- Geronimo specs -->
- <geronimo-annotation_1.2_spec.version>1.0</geronimo-annotation_1.2_spec.version>
- <geronimo-annotation_1.3_spec.version>1.0</geronimo-annotation_1.3_spec.version>
- <geronimo-atinject-1.0-spec.version>1.0</geronimo-atinject-1.0-spec.version>
- <geronimo-ejb-3.1-spec.version>1.0.2</geronimo-ejb-3.1-spec.version>
- <geronimo-jcdi-1.0-spec.version>1.0</geronimo-jcdi-1.0-spec.version>
- <geronimo-jcdi-1.1-spec.version>1.0</geronimo-jcdi-1.1-spec.version>
- <geronimo-jcdi-2.0-spec.version>1.0</geronimo-jcdi-2.0-spec.version>
- <geronimo-interceptor-1.1-spec.version>1.0</geronimo-interceptor-1.1-spec.version>
- <geronimo-interceptor-1.2-spec.version>1.0</geronimo-interceptor-1.2-spec.version>
- <geronimo-servlet-2.5-spec.version>1.2</geronimo-servlet-2.5-spec.version>
- <geronimo-servlet-3.0-spec.version>1.0</geronimo-servlet-3.0-spec.version>
- <geronimo-el-2.2-spec.version>1.0.3</geronimo-el-2.2-spec.version>
- <geronimo-validation-1.0-spec.version>1.1</geronimo-validation-1.0-spec.version>
- <geronimo-validation-1.1-spec.version>1.0</geronimo-validation-1.1-spec.version>
- <geronimo-validation-2.0-spec.version>1.1</geronimo-validation-2.0-spec.version>
- <geronimo-jpa-2.0-spec.version>1.1</geronimo-jpa-2.0-spec.version>
- <geronimo-jta-1.1-spec.version>1.1.1</geronimo-jta-1.1-spec.version>
-
- <maven.jetty.plugin.version>7.1.5.v20100705</maven.jetty.plugin.version>
- <maven.surefire.plugin.version>2.22.2</maven.surefire.plugin.version>
++ <asm.version>9.4</asm.version>
++
+
- <maven.jetty.plugin.version>7.1.5.v20100705</maven.jetty.plugin.version>
- <maven.surefire.plugin.version>2.19.1</maven.surefire.plugin.version>
++ <maven.surefire.plugin.version>3.0.0-M4</maven.surefire.plugin.version>
<maven.bundle.plugin.version>3.5.0</maven.bundle.plugin.version>
<maven.jar.plugin.version>3.1.2</maven.jar.plugin.version>
<maven.dependency.plugin.version>2.4</maven.dependency.plugin.version>
@@@ -122,37 -141,54 +121,11 @@@
<deltaspike.osgi.provide.capability />
<deltaspike.osgi.require.capability />
<cdi.osgi.beans-managed />
-- <!-- validator related -->
- <hibernate.validator.version>4.3.1.Final</hibernate.validator.version>
- <hibernate.validator.version>4.3.2.Final</hibernate.validator.version>
-- <bval.version>0.5</bval.version>
-- <bval1.version>1.1.2</bval1.version>
--
-- <!-- Versions of common dependencies within Weld profiles -->
-- <weld.el.api>2.2</weld.el.api>
-- <weld.sfl4j>1.7.2</weld.sfl4j>
- </properties>
+
- <repositories>
- <repository>
- <id>Apache Repository</id>
- <url>https://repository.apache.org/content/repositories/releases</url>
- <releases>
- <enabled>true</enabled>
- </releases>
- </repository>
- <repository>
- <id>Apache Snapshot Repository</id>
- <url>https://repository.apache.org/content/repositories/snapshots</url>
- <snapshots>
- <enabled>true</enabled>
- </snapshots>
- </repository>
- </repositories>
+ </properties>
<profiles>
-- <profile>
-- <id>JBossArchive</id>
-- <repositories>
-- <repository>
-- <id>JBoss-Archive</id>
-- <name>JBoss Archive</name>
-- <url>https://repository.jboss.org/nexus/content/groups/public</url>
-- </repository>
-- </repositories>
-- </profile>
-- <profile>
-- <id>JBossSnapshots</id>
-- <repositories>
-- <repository>
-- <id>JBoss-Snapshots</id>
-- <name>JBoss Snapshots</name>
-- <url>https://repository.jboss.org/nexus/content/repositories/snapshots/</url>
-- </repository>
-- </repositories>
-- </profile>
++
<profile>
<id>coverage</id>
@@@ -459,23 -548,34 +455,7 @@@
<scope>provided</scope>
</dependency>
- <dependency>
- <groupId>org.apache.geronimo.specs</groupId>
- <artifactId>geronimo-validation_1.1_spec</artifactId>
- <version>${geronimo-validation-1.1-spec.version}</version>
- <scope>provided</scope>
- </dependency>
-
- <dependency>
- <groupId>org.apache.geronimo.specs</groupId>
- <artifactId>geronimo-validation_2.0_spec</artifactId>
- <version>${geronimo-validation-2.0-spec.version}</version>
- <scope>provided</scope>
- </dependency>
-
- <dependency>
- <groupId>org.apache.geronimo.specs</groupId>
- <artifactId>geronimo-jpa_2.0_spec</artifactId>
- <version>${geronimo-jpa-2.0-spec.version}</version>
- <scope>provided</scope>
- </dependency>
-
- <dependency>
- <groupId>org.apache.geronimo.specs</groupId>
- <artifactId>geronimo-jta_1.1_spec</artifactId>
- <version>${geronimo-jta-1.1-spec.version}</version>
- <scope>provided</scope>
- </dependency>
- <!--
- <dependency>
- <groupId>org.apache.geronimo.specs</groupId>
- <artifactId>geronimo-jpa_2.0_spec</artifactId>
- <version>${geronimo-jpa-2.0-spec.version}</version>
- <scope>provided</scope>
- </dependency>
-
- <dependency>
- <groupId>org.apache.geronimo.specs</groupId>
- <artifactId>geronimo-jta_1.1_spec</artifactId>
- <version>${geronimo-jta-1.1-spec.version}</version>
- <scope>provided</scope>
- </dependency>
- -->
-
<dependency>
<groupId>org.hamcrest</groupId>
<artifactId>hamcrest-library</artifactId>
@@@ -506,11 -809,40 +486,18 @@@
<scope>test</scope>
</dependency>
- <!--
+ <!-- dependency for DELTASPIKE-113 -->
+ <dependency>
+ <groupId>javassist</groupId>
+ <artifactId>javassist</artifactId>
+ <version>3.12.1.GA</version>
+ <scope>provided</scope>
+ </dependency>
+
- <!-- validators, only needed in SE mode -->
- <dependency>
- <groupId>org.hibernate</groupId>
- <artifactId>hibernate-validator</artifactId>
- <version>${hibernate.validator.version}</version>
- <scope>test</scope>
- </dependency>
-
- <dependency>
- <groupId>org.apache.bval</groupId>
- <artifactId>bval-jsr303</artifactId>
- <version>${bval.version}</version>
- <scope>test</scope>
- </dependency>
-
- <dependency>
- <groupId>org.apache.bval</groupId>
- <artifactId>bval-jsr</artifactId>
- <version>${bval1.version}</version>
- <scope>test</scope>
- </dependency>
-
<dependency>
<groupId>org.apache.myfaces.core</groupId>
<artifactId>myfaces-api</artifactId>
-- <version>${myfaces22.version}</version>
++ <version>${myfaces.version}</version>
<scope>provided</scope>
<exclusions>
<exclusion>
@@@ -523,14 -855,14 +510,14 @@@
<dependency>
<groupId>org.apache.myfaces.core</groupId>
<artifactId>myfaces-impl</artifactId>
-- <version>${myfaces22.version}</version>
++ <version>${myfaces.version}</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.apache.myfaces.core</groupId>
<artifactId>myfaces-impl-test</artifactId>
-- <version>${myfaces22.version}</version>
++ <version>${myfaces.version}</version>
<scope>provided</scope>
</dependency>
@@@ -540,8 -872,14 +527,7 @@@
<version>1.0.6</version>
<scope>provided</scope>
</dependency>
- -->
- <dependency>
- <groupId>commons-logging</groupId>
- <artifactId>commons-logging</artifactId>
- <version>1.2</version>
- <scope>provided</scope>
- </dependency>
-
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-all</artifactId>
diff --cc deltaspike/readme/ReleaseNotes-1.4.0.txt
index 61a4d873a,61a4d873a..a212869b1
--- a/deltaspike/readme/ReleaseNotes-1.4.0.txt
+++ b/deltaspike/readme/ReleaseNotes-1.4.0.txt
@@@ -43,7 -43,7 +43,7 @@@ Improvemen
New Feature
[DELTASPIKE-420] - Transactional repositories
-- [DELTASPIKE-874] - observe @javax.faces.bean.RequestScoped via @javax.enterprise.context.Initialized and @javax.enterprise.context.Destroyed
++ [DELTASPIKE-874] - observe @javax.faces.bean.RequestScoped via @jakarta.enterprise.context.Initialized and @jakarta.enterprise.context.Destroyed
[DELTASPIKE-877] - allow to inherit dynamically changed metadata
[DELTASPIKE-888] - Add support for delete a job from the Scheduler
[DELTASPIKE-892] - type-safe static config
diff --cc deltaspike/readme/ReleaseNotes-1.7.1.txt
index a2fbbc94f,a2fbbc94f..40cc3f243
--- a/deltaspike/readme/ReleaseNotes-1.7.1.txt
+++ b/deltaspike/readme/ReleaseNotes-1.7.1.txt
@@@ -4,7 -4,7 +4,7 @@@ Bu
[DELTASPIKE-1167] - deltaspike configuration: Variable Replacement in Configured Values is NOT (!) stage aware
[DELTASPIKE-1173] - DefaultEntityManagerHolder is not registered in uber jars when discovery is annotated
[DELTASPIKE-1175] - Weld(1|2|3) profiles do not activate Weld profile in cdictrl
-- [DELTASPIKE-1179] - [Deltaspike Data] ContextNotActiveException: WELD-001303: No active contexts for scope type javax.enterprise.context.ApplicationScoped
++ [DELTASPIKE-1179] - [Deltaspike Data] ContextNotActiveException: WELD-001303: No active contexts for scope type jakarta.enterprise.context.ApplicationScoped
[DELTASPIKE-1183] - NPE in proxy handler with concurrent requests
Improvement
diff --cc documentation/src/main/asciidoc/container-control.adoc
index f7ff77f40,f7ff77f40..ac594da87
--- a/documentation/src/main/asciidoc/container-control.adoc
+++ b/documentation/src/main/asciidoc/container-control.adoc
@@@ -60,7 -60,7 +60,7 @@@ Starting the container does not automat
import org.apache.deltaspike.cdise.api.CdiContainer;
import org.apache.deltaspike.cdise.api.CdiContainerLoader;
import org.apache.deltaspike.cdise.api.ContextControl;
--import javax.enterprise.context.ApplicationScoped;
++import jakarta.enterprise.context.ApplicationScoped;
public class MainApp {
public static void main(String[] args) {
@@@ -99,7 -99,7 +99,7 @@@ The `ContextControl` interface provide
== Procedure for building an uber jar
Uber jar or executable jar can created by using the maven shade plugin. Some things you needs to be aware of when you use it.
--* Multiple `beans.xml` and `javax.enterprise.inject.spi.Extension` files needs to be merged into the final jar using a transformer.
++* Multiple `beans.xml` and `jakarta.enterprise.inject.spi.Extension` files needs to be merged into the final jar using a transformer.
[source,xml]
----
<transformer implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer"/>
diff --cc documentation/src/main/asciidoc/core.adoc
index 0c39cb964,0c39cb964..c9cd54ed5
--- a/documentation/src/main/asciidoc/core.adoc
+++ b/documentation/src/main/asciidoc/core.adoc
@@@ -83,7 -83,7 +83,7 @@@ implement a corresponding literal for p
.Literal Implementation for '@MyQualifier'
[source,java]
---------------------------------------------------------------------------------------------
--import javax.enterprise.util.AnnotationLiteral;
++import jakarta.enterprise.util.AnnotationLiteral;
//...
public class MyQualifierLiteral extends AnnotationLiteral<MyQualifier> implements MyQualifier
@@@ -384,7 -384,7 +384,7 @@@ TODO (Overview
== Literals
Literals allow the instantiation of annotations by extending the
--abstract class `javax.enterprise.util.AnnotationLiteral`
++abstract class `jakarta.enterprise.util.AnnotationLiteral`
.Example
[source,java]
@@@ -1012,7 -1012,7 +1012,7 @@@ all scopes are only implemented in the
To create a custom CDI scope to match your needs, complete the following steps:
--1. Create an Annotation with annotated with @javax.inject.Scope;
++1. Create an Annotation with annotated with @jakarta.inject.Scope;
+
.Example
[source,java]
@@@ -1040,8 -1040,8 +1040,8 @@@ public class ACustomScopeExtension impl
}
---------------------------------------------------------------------------------------
+
--3. Implement a javax.enterprise.context.spi.Context interface to hold the
--javax.enterprise.inject.spi.Bean instances according to your needs.
++3. Implement a jakarta.enterprise.context.spi.Context interface to hold the
++jakarta.enterprise.inject.spi.Bean instances according to your needs.
+
.Example
[source,java]
@@@ -1054,7 -1054,7 +1054,7 @@@ public class ACustomScopeContext implem
}
// Return an existing instance of certain contextual type or create a new instance by calling
-- // javax.enterprise.context.spi.Contextual.create(CreationalContext) and return the new instance.
++ // jakarta.enterprise.context.spi.Contextual.create(CreationalContext) and return the new instance.
public <T> T get(Contextual<T> contextual, CreationalContext<T> creationalContext) {
Bean bean = (Bean) contextual;
// you can store the bean somewhere
diff --cc documentation/src/main/asciidoc/jsf.adoc
index 22457f14a,22457f14a..6e42fafec
--- a/documentation/src/main/asciidoc/jsf.adoc
+++ b/documentation/src/main/asciidoc/jsf.adoc
@@@ -1588,7 -1588,7 +1588,7 @@@ public class DemoBean1 implements Seria
DemoBean1.
TIP: If you would like to use the bean within your JSF pages, you have
--to add `@Named` (javax.inject.Named ).
++to add `@Named` (jakarta.inject.Named ).
(In case of CDI standard conversations there is just one big conversation
which contains all conversation scoped beans.) The grouped conversations
diff --cc documentation/src/main/asciidoc/projectstage.adoc
index 7957ba46b,7957ba46b..7ab66b5b1
--- a/documentation/src/main/asciidoc/projectstage.adoc
+++ b/documentation/src/main/asciidoc/projectstage.adoc
@@@ -22,7 -22,7 +22,7 @@@ pre-defined ProjectStages
The core provides a pluggable and type-safe approach for using project
stages in a project (it is also used within the framework). Furthermore,
`@Exclude` allows use of, for example, implementations annotated with
--`javax.enterprise.inject.Alternative` for specific ProjectStages.
++`jakarta.enterprise.inject.Alternative` for specific ProjectStages.
Besides the out-of-the-box ProjectStages it is possible to implement
_custom but type-safe_ ProjectStages which will be exposed by
DeltaSpike.
diff --cc documentation/src/main/asciidoc/spi.adoc
index 28471173e,28471173e..af40278ea
--- a/documentation/src/main/asciidoc/spi.adoc
+++ b/documentation/src/main/asciidoc/spi.adoc
@@@ -6,7 -6,7 +6,7 @@@ DeltaSpike provides an Service Provide
== Deactivatable
--This mechanism is only used for artifacts *like* implementations of (`javax.enterprise.inject.spi.Extension`) which
++This mechanism is only used for artifacts *like* implementations of (`jakarta.enterprise.inject.spi.Extension`) which
*can not* be deactivated with standard CDI mechanisms.
This interface is just a marker interface which is implemented by all pre-configured DeltaSpike artifacts which can be deactivated manually (e.g. to improve the performance if a part isis not needed, to provide a custom implementation if the default implementation isis not pluggable by default or to bypass an implementation which causes an issue (in this case please also *contact us* and we will fix it)).
diff --cc documentation/src/main/asciidoc/test-control.adoc
index 2ed48f081,2ed48f081..6df44be55
--- a/documentation/src/main/asciidoc/test-control.adoc
+++ b/documentation/src/main/asciidoc/test-control.adoc
@@@ -419,7 -419,7 +419,7 @@@ public class MockedQualifiedBeanTes
}
-------------------------------------------------------------
--In some cases it is necessary to use `@javax.enterprise.inject.Typed`.
++In some cases it is necessary to use `@jakarta.enterprise.inject.Typed`.
Mocking such typed beans can result in an
`AmbiguousResolutionException`. Therefore it is necessary to exclude the
mocked implementation via `@Exclude` or `@Typed()` (or a parametrized