Updates

Author: kaspernielsen

TODO.txt

@@ -1,6 +1,5 @@
 Major Architectual
   Hooks
-  Namespaces/Extensions
   Lifetime
 
 Cleanup

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

@@ -212,6 +212,10 @@ public OperationMirror.OfStream<OperationMirror> operations() {
         return OperationMirror.OfStream.of(beans().flatMap(BeanMirror::operations));
     }
 
+    public <O extends OverviewMirror<?>> O extensionOverview(Class<? extends Extension<?>> extensionType, Class<O> type) {
+        return PackedOverviewHandle.ofExtension(application, extensionType, type);
+    }
+
     public <O extends OverviewMirror<?>> O overview(Class<O> type) {
         return PackedOverviewHandle.ofApplication(application, type);
     }

modules/packed/src/main/java/app/packed/extension/Extension.java

@@ -33,7 +33,6 @@
 import app.packed.container.ContainerHandle;
 import app.packed.extension.Extension.ExtensionProperty;
 import app.packed.extension.ExtensionPoint.ExtensionPointHandle;
-import app.packed.namespace.OverviewMirror;
 import app.packed.service.ProvidableBeanConfiguration;
 import app.packed.util.TreeView;
 import internal.app.packed.container.ContainerSetup;
@@ -291,10 +290,6 @@ protected ExtensionMirror<E> newExtensionMirror() {
         throw new InternalExtensionException("This method must be overridden by " + extension.extensionType);
     }
 
-    protected OverviewMirror<E> newOverviewMirror() {
-        throw new InternalExtensionException("This method must be overridden by " + extension.extensionType);
-    }
-
     /**
      * Returns a new extension point for the extension
      * <p>

modules/packed/src/main/java/app/packed/namespace/NamespaceMirror.java

@@ -33,6 +33,7 @@
 import app.packed.util.TreeView;
 import internal.app.packed.bean.introspection.IntrospectorOnAutoService;
 import internal.app.packed.extension.base.BaseExtensionBeanIntrospector;
+import internal.app.packed.component.PackedOverviewHandle;
 import internal.app.packed.namespace.NamespaceSetup;
 import internal.app.packed.util.PackedTreeView;
 import internal.app.packed.util.accesshelper.AccessHelper;
@@ -106,6 +107,10 @@ public ComponentPath componentPath() {
     public Set<String> componentTags() {
         throw new UnsupportedOperationException();
     }
+
+    public <O extends OverviewMirror<?>> O overview(Class<O> type) {
+        return PackedOverviewHandle.ofNamespace(namespace, type);
+    }
 }
 
 final class NamespaceMirrorBeanIntrospector extends BaseExtensionBeanIntrospector {

modules/packed/src/main/java/app/packed/namespace/Overview.md

@@ -1,43 +1,3 @@
-----
-  Namespace
-  NamespaceNode
-
-
-------
-Namespace
-  Set<ResourceKey> keys();
-  Set<ResourcePath> resourcePaths();
-
-NamespaceResource
-  ResourceKey
-  ComponentPath
-
-We need namespace because stuff with ids is shared across containers.
-Or for example multiple databases.
-
-Service.Namespace: ServiceNamespace
-Service: ServiceNamespace/Key
-
-// BeanNamespace -> all beans within a container have a unique name
-
-/// Extra namespaces
-
-// Tror ikke man som udgangspunkt kan lave namespaces lazily.
-// Altsaa man kan jo sige main er lazy. fx for eventbus
-
-A namespace has an id, a namespacetype, a name type, and an extend.
-
-// Namespace:Kind:Container:id
-
-// Namespace:Service:/:main
-
-
-HVORFOR fungere namespace bridge ikke
-
-// Den fungere ikke super godt. Problemet er at det er svaert at faa fat i namespace handles.
-// Med mindre vi laver en masse generics magi.
-// Meget lettere at lave sine egen wirelets.
-// Og metoder på NamespaceConfiguration
 
 
 Usecases

modules/packed/src/main/java/app/packed/namespace/OverviewHandle.java

@@ -20,16 +20,32 @@
 import internal.app.packed.component.PackedOverviewHandle;
 
 /**
+ * A handle that provides access to operations within a particular scope (such as an application or namespace) for a
+ * specific extension type. Overview handles are the backing implementation for {@link OverviewMirror} subclasses.
+ * <p>
+ * This interface is sealed and cannot be implemented directly by user code.
  *
+ * @param <E>
+ *            the type of extension whose operations are accessible through this handle
+ *
+ * @see OverviewMirror
  */
 public sealed interface OverviewHandle<E extends Extension<E>> permits PackedOverviewHandle {
 
+    /**
+     * {@return a stream of all operations within the scope of this handle that were installed by the extension type {@code E}}
+     */
     OperationMirror.OfStream<OperationMirror> operations();
 
-    <T extends OperationMirror> OperationMirror.OfStream<T> operations(Class<T> operations);
-
-    // isOverviewForWholeApplication
-    // isOverviewForExtension
-    // IsOverviewForNamespace
-    // IsOverviewForSingleContainer <--- (not sure if we want to implement
+    /**
+     * Returns a stream of all operations within the scope of this handle that were installed by the extension type
+     * {@code E} and are of the specified mirror type.
+     *
+     * @param <T>
+     *            the type of operation mirror
+     * @param operationType
+     *            the class of the operation mirror type to filter by
+     * @return a stream of matching operations
+     */
+    <T extends OperationMirror> OperationMirror.OfStream<T> operations(Class<T> operationType);
 }

modules/packed/src/main/java/app/packed/namespace/OverviewMirror.java

@@ -22,31 +22,58 @@
 import internal.app.packed.component.PackedOverviewHandle;
 
 /**
+ * A mirror that provides a read-only, extension-scoped view of operations within a particular scope such as an
+ * application, namespace, or container.
+ * <p>
+ * Subclasses are defined by extension authors to expose domain-specific queries over the operations that their
+ * extension installs. For example, a {@code JobOverviewMirror} might expose methods like {@code daemons()} or
+ * {@code jobs()} that filter and return extension-specific operation mirror types.
+ * <p>
+ * An overview mirror is obtained via {@link app.packed.application.ApplicationMirror#overview(Class)}.
+ * <p>
+ * Subclasses must declare exactly one constructor taking an {@link OverviewHandle} parameter.
  *
+ * @param <E>
+ *            the type of extension whose operations this overview provides access to
+ *
+ * @see OverviewHandle
+ * @see app.packed.application.ApplicationMirror#overview(Class)
  */
-// I don't think there is going to be any navigation, other than from
-
-// OverviewMirror.of(ApplicationMirror, ComponentPath, boolean includeExtensions)
-// ExtensionMirror.overview(SomeOverviewMirror.class)
-
-// ApplicationMirror.allOverview(xxx) <--
-
-// Options, includeExtensions?
-//// 99% of the time you are not interested in extensions Who cares about the extensions services, nevertheless,
-/// extension will find it interesting to find them in some way ServiceOverview Also
 public abstract class OverviewMirror<E extends Extension<E>> {
-    // ComponentPath componentPath();
+
+    /** The backing handle. */
     final PackedOverviewHandle<E> handle;
 
+    /**
+     * Creates a new overview mirror backed by the specified handle.
+     *
+     * @param overviewHandle
+     *            the handle providing access to operations
+     */
     protected OverviewMirror(OverviewHandle<E> overviewHandle) {
         this.handle = (PackedOverviewHandle<E>) requireNonNull(overviewHandle);
     }
 
+    /**
+     * {@return a stream of all operations within this overview's scope that were installed by extension {@code E}}
+     * <p>
+     * Only operations on userland beans are included; extension-owned beans are excluded.
+     */
     protected final OperationMirror.OfStream<OperationMirror> operations() {
         return handle.operations();
     }
 
-    protected final <T extends OperationMirror> OperationMirror.OfStream<T> operations(Class<T> operations) {
-        return handle.operations(operations);
+    /**
+     * Returns a stream of operations within this overview's scope that were installed by extension {@code E} and match the
+     * specified mirror type.
+     *
+     * @param <T>
+     *            the type of operation mirror
+     * @param operationType
+     *            the class of the operation mirror type to filter by
+     * @return a stream of matching operations
+     */
+    protected final <T extends OperationMirror> OperationMirror.OfStream<T> operations(Class<T> operationType) {
+        return handle.operations(operationType);
     }
 }

modules/packed/src/main/java/internal/app/packed/component/PackedOverviewHandle.java

@@ -19,10 +19,12 @@
 
 import app.packed.application.ApplicationMirror;
 import app.packed.extension.Extension;
+import app.packed.namespace.NamespaceMirror;
 import app.packed.namespace.OverviewHandle;
 import app.packed.namespace.OverviewMirror;
 import app.packed.operation.OperationMirror;
 import internal.app.packed.application.ApplicationSetup;
+import internal.app.packed.namespace.NamespaceSetup;
 import internal.app.packed.extension.ExtensionClassModel;
 import internal.app.packed.invoke.ConstructorSupport;
 import internal.app.packed.invoke.ConstructorSupport.OverviewMirrorFactory;
@@ -33,6 +35,16 @@
  */
 public abstract sealed class PackedOverviewHandle<E extends Extension<E>> implements OverviewHandle<E> {
 
+    /** Cache OverviewMirror constructor factories. */
+    private static final ClassValue<OverviewMirrorFactory> CONSTRUCTORS = new ClassValue<>() {
+
+        @SuppressWarnings("unchecked")
+        @Override
+        protected OverviewMirrorFactory computeValue(Class<?> type) {
+            return ConstructorSupport.findOverviewMirrorConstructor((Class<? extends OverviewMirror<?>>) type);
+        }
+    };
+
     /** Extract the extension type variable from OverviewMirror. */
     private static final ClassValue<Class<? extends Extension<?>>> EXTENSION_TYPES = new ClassValue<>() {
 
@@ -44,15 +56,11 @@ protected Class<? extends Extension<?>> computeValue(Class<?> type) {
         }
     };
 
-    /** Cache OverviewMirror constructor factories. */
-    private static final ClassValue<OverviewMirrorFactory> CONSTRUCTORS = new ClassValue<>() {
 
-        @SuppressWarnings("unchecked")
-        @Override
-        protected OverviewMirrorFactory computeValue(Class<?> type) {
-            return ConstructorSupport.findOverviewMirrorConstructor((Class<? extends OverviewMirror<?>>) type);
-        }
-    };
+    @Override
+    public final <T extends OperationMirror> OperationMirror.OfStream<T> operations(Class<T> operationType) {
+        return (OperationMirror.OfStream<T>) operations().ofType(operationType);
+    }
 
     @SuppressWarnings("unchecked")
     public static <O extends OverviewMirror<?>> O ofApplication(ApplicationSetup application, Class<O> type) {
@@ -66,6 +74,43 @@ public static <O extends OverviewMirror<?>> O ofApplication(ApplicationSetup app
         return (O) factory.create(handle);
     }
 
+    /**
+     * @param <O>
+     * @param application
+     * @param extensionType
+     * @param type
+     * @return
+     */
+    @SuppressWarnings("unchecked")
+    public static <O extends OverviewMirror<?>> O ofExtension(ApplicationSetup application, Class<? extends Extension<?>> extensionType, Class<O> type) {
+        requireNonNull(extensionType, "extensionType is null");
+        requireNonNull(type, "type is null");
+
+        Class<? extends Extension<?>> mirrorExtensionType = EXTENSION_TYPES.get(type);
+        if (extensionType != mirrorExtensionType) {
+            throw new IllegalArgumentException(
+                    "extensionType " + extensionType + " does not match the extension type of " + type + " which is " + mirrorExtensionType);
+        }
+
+        OverviewMirrorFactory factory = CONSTRUCTORS.get(type);
+
+        PackedExtensionOverviewHandle<?> handle = new PackedExtensionOverviewHandle<>(application.mirror(), extensionType);
+
+        return (O) factory.create(handle);
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <O extends OverviewMirror<?>> O ofNamespace(NamespaceSetup namespace, Class<O> type) {
+        requireNonNull(type, "type is null");
+
+        Class<? extends Extension<?>> extensionType = EXTENSION_TYPES.get(type);
+        OverviewMirrorFactory factory = CONSTRUCTORS.get(type);
+
+        PackedNamespaceOverviewHandle<?> handle = new PackedNamespaceOverviewHandle<>(namespace.mirror(), extensionType);
+
+        return (O) factory.create(handle);
+    }
+
     public static final class PackedApplicationOverviewHandle<E extends Extension<E>> extends PackedOverviewHandle<E> {
 
         private final ApplicationMirror applicationMirror;
@@ -82,9 +127,39 @@ public OperationMirror.OfStream<OperationMirror> operations() {
             return applicationMirror.operations().filter(op -> op.installedByExtension() == extensionType);
         }
 
+    }
+
+    public static final class PackedExtensionOverviewHandle<E extends Extension<E>> extends PackedOverviewHandle<E> {
+
+        private final ApplicationMirror applicationMirror;
+
+        private final Class<? extends Extension<?>> extensionType;
+
+        public PackedExtensionOverviewHandle(ApplicationMirror applicationMirror, Class<? extends Extension<?>> extensionType) {
+            this.applicationMirror = requireNonNull(applicationMirror);
+            this.extensionType = requireNonNull(extensionType);
+        }
+
+        @Override
+        public OperationMirror.OfStream<OperationMirror> operations() {
+            return applicationMirror.allOperations().filter(op -> op.bean().owner().isExtension(extensionType));
+        }
+    }
+
+    public static final class PackedNamespaceOverviewHandle<E extends Extension<E>> extends PackedOverviewHandle<E> {
+
+        private final NamespaceMirror namespaceMirror;
+
+        private final Class<? extends Extension<?>> extensionType;
+
+        public PackedNamespaceOverviewHandle(NamespaceMirror namespaceMirror, Class<? extends Extension<?>> extensionType) {
+            this.namespaceMirror = requireNonNull(namespaceMirror);
+            this.extensionType = requireNonNull(extensionType);
+        }
+
         @Override
-        public <T extends OperationMirror> OperationMirror.OfStream<T> operations(Class<T> operationType) {
-            return (OperationMirror.OfStream<T>) operations().ofType(operationType);
+        public OperationMirror.OfStream<OperationMirror> operations() {
+            return namespaceMirror.operations().filter(op -> op.installedByExtension() == extensionType);
         }
     }
 }