e

Author: kaspernielsen

modules/packed/src/main/java/app/packed/application/BootstrapApp.java

@@ -24,7 +24,6 @@
 import app.packed.container.Wirelet;
 import app.packed.lifecycle.LifecycleKind;
 import app.packed.lifecycle.RunState;
-import internal.app.packed.application.PackedApplicationTemplate;
 import internal.app.packed.application.PackedBootstrapImage;
 import internal.app.packed.application.PackedBootstrapImage.ImageMapped;
 
@@ -191,14 +190,7 @@ default BootstrapApp<I> withWirelets(boolean before, Wirelet... wirelets) {
     }
 
     static <A> BootstrapApp<A> of(LifecycleKind lifecycleKind, Bean<A> bean) {
-        requireNonNull(bean, "bean is null");
-        requireNonNull(lifecycleKind, "lifecycleKind is null");
-        PackedApplicationTemplate.Builder<A> builder = new PackedApplicationTemplate.Builder<>(bean);
-        return switch (lifecycleKind) {
-            case NONE -> throw new IllegalArgumentException("LifecycleKind.NONE is not supported for BootstrapApp");
-            case UNMANAGED -> PackedBootstrapApp.of(builder.unmanaged().build());
-            case MANAGED -> PackedBootstrapApp.of(builder.build());
-        };
+        return PackedBootstrapApp.of(lifecycleKind, bean);
     }
 
     /**

modules/packed/src/main/java/app/packed/application/PackedBootstrapApp.java

@@ -24,6 +24,7 @@
 import app.packed.build.BuildGoal;
 import app.packed.container.Wirelet;
 import app.packed.extension.BaseExtension;
+import app.packed.lifecycle.LifecycleKind;
 import app.packed.lifecycle.RunState;
 import internal.app.packed.ValueBased;
 import internal.app.packed.application.PackedApplicationTemplate;
@@ -42,7 +43,7 @@ final class PackedBootstrapApp<A, H extends ApplicationHandle<A, ?>> implements
     // TODO we need to restrict the extensions that can be used to BaseExtension
     // So beans do not uses hooks from various extensions
     private static final PackedApplicationTemplate<?> BOOTSTRAP_APP_TEMPLATE =
-            new PackedApplicationTemplate.Builder<>(Bean.of(PackedBootstrapApp.class)).build();
+            PackedApplicationTemplate.of(LifecycleKind.UNMANAGED, Bean.of(PackedBootstrapApp.class));
 
     /** The application launcher. */
     private final ApplicationBaseLauncher launcher;
@@ -120,16 +121,13 @@ public PackedBootstrapApp<A, H> withExpectsResult(Class<?> resultType) {
         throw new UnsupportedOperationException();
     }
 
-    /**
-     * Builds a new bootstrap app for applications represented by the specified template.
-     *
-     * @param <A>
-     * @param template
-     *            the template for the type applications that should be bootstrapped
-     * @return a new bootstrap app
-     */
-    public static <A, H extends ApplicationHandle<A, ?>> BootstrapApp<A> of(PackedApplicationTemplate<H> template) {
-        // We need a an assembly to build the (bootstrap) application
+    public static <A> BootstrapApp<A> of(LifecycleKind lifecycleKind, Bean<A> bean) {
+        if (lifecycleKind == LifecycleKind.NONE) {
+            throw new IllegalArgumentException("LifecycleKind.NONE is not supported for BootstrapApp");
+        }
+        PackedApplicationTemplate<ApplicationHandle<A, ApplicationConfiguration>> template = PackedApplicationTemplate.of(lifecycleKind, bean);
+
+        // We need an assembly to build the (bootstrap) application
         BootstrapAppAssembly assembly = new BootstrapAppAssembly(template);
 
         // Creates a new application installer and installs the specified assembly and build the final bootstrap application
@@ -139,8 +137,8 @@ public PackedBootstrapApp<A, H> withExpectsResult(Class<?> resultType) {
         if (assembly.sidehandle != null) {
             launcher = ServiceSupport.newApplicationBaseLauncher(assembly.sidehandle);
         }
-        // Returned the bootstrap implementation (represented by a construcing method handle) wrapped in this class.
-        return new PackedBootstrapApp<A, H>(template, launcher);
+        // Returned the bootstrap implementation wrapped in this class.
+        return new PackedBootstrapApp<>(template, launcher);
     }
 
     /** The assembly responsible for building the bootstrap app. */

modules/packed/src/main/java/app/packed/application/registry/ApplicationTemplate.java

@@ -48,8 +48,6 @@ static <T> Builder<T> builder(Bean<T> bean) {
 
     interface Builder<I> {
 
-       Builder<I> unmanaged();
-
        ApplicationTemplate<ApplicationHandle<I, ApplicationConfiguration>> build();
 
        <H extends ApplicationHandle<I, ?>> ApplicationTemplate<H> build(Class<? super H> handleClass,

modules/packed/src/main/java/internal/app/packed/application/PackedApplicationTemplate.java

@@ -15,6 +15,8 @@
  */
 package internal.app.packed.application;
 
+import static java.util.Objects.requireNonNull;
+
 import java.util.function.Function;
 
 import app.packed.application.ApplicationConfiguration;
@@ -24,17 +26,24 @@
 import app.packed.bean.Bean;
 import app.packed.build.BuildGoal;
 import app.packed.container.Wirelet;
+import app.packed.lifecycle.LifecycleKind;
 import app.packed.util.Nullable;
 import internal.app.packed.invoke.MethodHandleInvoker.ApplicationBaseLauncher;
 
 /** Implementation of {@link ApplicationTemplate}. */
-public record PackedApplicationTemplate<H extends ApplicationHandle<?, ?>>(Bean<?> bean, Class<? super H> handleClass,
-        Function<? super ApplicationInstaller<H>, ? extends ApplicationHandle<?, ?>> handleFactory, boolean isManaged
-       ) implements ApplicationTemplate<H> {
+public record PackedApplicationTemplate<H extends ApplicationHandle<?, ?>>(LifecycleKind lifecycleKind, Bean<?> bean, Class<? super H> handleClass,
+        Function<? super ApplicationInstaller<H>, ? extends ApplicationHandle<?, ?>> handleFactory) implements ApplicationTemplate<H> {
 
     public Class<?> guestClass() {
         return bean.beanClass();
     }
+
+    public static <I> PackedApplicationTemplate<ApplicationHandle<I, ApplicationConfiguration>> of(LifecycleKind kind, Bean<I> bean) {
+        requireNonNull(kind, "lifecycleKind is null");
+        requireNonNull(bean, "bean is null");
+        return new PackedApplicationTemplate<>(kind, bean, ApplicationHandle.class, ApplicationHandle::new);
+    }
+
     /**
      * Creates a new {@link ApplicationInstaller} from this template.
      *
@@ -56,15 +65,15 @@ public interface ApplicationInstallingSource {}
     /** {@inheritDoc} */
     @Override
     public boolean isManaged() {
-        return isManaged;
+        return lifecycleKind == LifecycleKind.MANAGED;
     }
 
     /** Implementation of {@link ApplicationTemplate.Builder}. */
     public static final class Builder<I> implements ApplicationTemplate.Builder<I> {
 
         private final Bean<I> bean;
 
-        private boolean managed = true;
+        private LifecycleKind lifecycleKind = LifecycleKind.MANAGED;
 
         public Builder(Bean<I> bean) {
             this.bean = bean;
@@ -80,15 +89,7 @@ public PackedApplicationTemplate<ApplicationHandle<I, ApplicationConfiguration>>
         @Override
         public <H extends ApplicationHandle<I, ?>> PackedApplicationTemplate<H> build(Class<? super H> handleClass,
                 Function<? super ApplicationInstaller<H>, ? extends H> handleFactory) {
-            return new PackedApplicationTemplate<>(bean, handleClass,
-                    handleFactory, managed);
-        }
-
-        /** {@inheritDoc} */
-        @Override
-        public Builder<I> unmanaged() {
-            this.managed = false;
-            return this;
+            return new PackedApplicationTemplate<>(lifecycleKind, bean, handleClass, handleFactory);
         }
     }
 }

modules/packed/src/test/java/tck/AbstractAppTest.java

@@ -38,6 +38,7 @@
 import app.packed.build.BuildGoal;
 import app.packed.container.ContainerConfiguration;
 import app.packed.container.Wirelet;
+import app.packed.lifecycle.LifecycleKind;
 import app.packed.operation.OperationHandle;
 import internal.app.packed.application.ApplicationSetup;
 import internal.app.packed.application.ApplicationSetup.ApplicationBuildPhase;
@@ -213,8 +214,7 @@ public State1Setup wirelets(Wirelet... wirelets) {
 
         final class State2Building implements InternalTestState, ApplicationInstallingSource {
             public static final MethodHandle EMPTY_MH = MethodHandles.empty(MethodType.methodType(Object.class, ApplicationLaunchContext.class));
-            static final PackedApplicationTemplate<?> PAT = new PackedApplicationTemplate<>(Bean.of(), ApplicationHandle.class, ApplicationHandle::new,
-                    true);
+            static final PackedApplicationTemplate<?> PAT = new PackedApplicationTemplate<>(LifecycleKind.MANAGED, Bean.of(), ApplicationHandle.class, ApplicationHandle::new);
             final AssemblySetup assembly;
 
             final PackedApplicationInstaller<?> b;