Add BeanScope.all() method to return all BeanEntry

This changes the existing BeanEntry to be an interface and makes it more consistent API wise.

Author: rbygrave

inject-test/src/test/java/org/example/coffee/CoffeeMakerTest.java

@@ -1,10 +1,16 @@
 package org.example.coffee;
 
-import io.avaje.inject.ApplicationScope;
+import io.avaje.inject.BeanEntry;
 import io.avaje.inject.BeanScope;
 import org.example.coffee.core.DuperPump;
+import org.example.coffee.list.BSomei;
+import org.example.coffee.list.Somei;
 import org.junit.jupiter.api.Test;
 
+import java.util.List;
+import java.util.Optional;
+
+import static java.util.stream.Collectors.toList;
 import static org.assertj.core.api.Assertions.assertThat;
 
 public class CoffeeMakerTest {
@@ -22,7 +28,6 @@ public void makeIt_via_SystemContext() {
 
   @Test
   public void makeIt_via_BootContext_withNoShutdownHook() {
-
     try (BeanScope context = BeanScope.newBuilder()
       .withShutdownHook(false)
       .build()) {
@@ -34,10 +39,29 @@ public void makeIt_via_BootContext_withNoShutdownHook() {
 
   @Test
   public void makeIt_via_BootContext() {
-
     try (BeanScope context = BeanScope.newBuilder().build()) {
       String makeIt = context.get(CoffeeMaker.class).makeIt();
       assertThat(makeIt).isEqualTo("done");
+
+      final List<BeanEntry> beanEntries = context.all();
+      assertThat(beanEntries).hasSizeGreaterThan(10);
+
+      // all entries for an interface
+      final List<BeanEntry> someiEntries = beanEntries.stream()
+        .filter(beanEntry -> beanEntry.hasKey(Somei.class))
+        .collect(toList());
+      assertThat(someiEntries).hasSize(3);
+
+      final Optional<BeanEntry> bsomeEntry = someiEntries.stream().filter(entry -> entry.type().equals(BSomei.class)).findFirst();
+      assertThat(bsomeEntry).isPresent();
+
+      final BeanEntry entry = bsomeEntry.get();
+      assertThat(entry.qualifierName()).isEqualTo("b");
+      assertThat(entry.keys()).containsExactly(BSomei.class.getCanonicalName(), Somei.class.getCanonicalName());
+      assertThat(entry.type()).isEqualTo(BSomei.class);
+      assertThat(entry.priority()).isEqualTo(0);
+      assertThat(entry.bean()).isEqualTo(context.get(Somei.class, "b"));
+      assertThat(entry.bean()).isEqualTo(context.get(BSomei.class));
     }
   }
 

inject-test/src/test/java/org/example/custom/CustomBean.java

@@ -1,9 +1,10 @@
 package org.example.custom;
 
+import jakarta.inject.Named;
 import org.example.MyCustomScope;
 
+@Named("Hello")
 @MyCustomScope
 public class CustomBean {
 
-  int id;
 }

inject-test/src/test/java/org/example/custom/CustomScopeTest.java

@@ -1,10 +1,16 @@
 package org.example.custom;
 
+import io.avaje.inject.BeanEntry;
 import io.avaje.inject.BeanScope;
+import org.example.MyCustomScope;
 import org.example.coffee.CoffeeMaker;
 import org.junit.jupiter.api.Test;
 import org.mockito.Mockito;
 
+import java.util.List;
+import java.util.Optional;
+
+import static java.util.stream.Collectors.toList;
 import static org.assertj.core.api.Assertions.assertThat;
 
 class CustomScopeTest {
@@ -45,7 +51,7 @@ void buildSimpleCustomScope() {
 
     try (BeanScope beanScope = BeanScope.newBuilder()
       .withModules(new MyCustomModule())
-      .withBeans(LocalExternal.class, ext)
+      .withBean(LocalExternal.class, ext)
       .withBean(CoffeeMaker.class, suppliedCoffeeMaker)
       .build()) {
 
@@ -62,6 +68,60 @@ void buildSimpleCustomScope() {
     }
   }
 
+  @Test
+  void customScopeAll() {
+
+    LocalExt ext = new LocalExt();
+    CoffeeMaker suppliedCoffeeMaker = Mockito.mock(CoffeeMaker.class);
+
+    try (BeanScope beanScope = BeanScope.newBuilder()
+      .withModules(new MyCustomModule())
+      .withBean(LocalExternal.class, ext)
+      .withBean(CoffeeMaker.class, suppliedCoffeeMaker)
+      .build()) {
+
+      // includes the 2 supplied beans
+      final List<BeanEntry> all = beanScope.all();
+      assertThat(all).hasSize(5);
+
+      final CustomBean customBean = beanScope.get(CustomBean.class);
+
+      final Optional<BeanEntry> customBeanEntry = all.stream()
+        .filter(beanEntry -> beanEntry.hasKey(CustomBean.class))
+        .findFirst();
+
+      assertThat(customBeanEntry).isPresent();
+      assertThat(customBeanEntry.get().bean()).isSameAs(customBean);
+      assertThat(customBeanEntry.get().qualifierName()).isEqualTo("hello");
+      assertThat(customBeanEntry.get().priority()).isEqualTo(0);
+      assertThat(customBeanEntry.get().keys()).containsExactly(CustomBean.class.getCanonicalName(), MyCustomScope.class.getCanonicalName());
+
+
+      final Optional<BeanEntry> fooCustomEntry = all.stream()
+        .filter(beanEntry -> beanEntry.hasKey(FooCustom.class))
+        .findFirst();
+
+      assertThat(fooCustomEntry).isPresent();
+      assertThat(fooCustomEntry.get().qualifierName()).isNull();
+
+      // only the beans with MyCustomScope annotation
+      final List<BeanEntry> myCustomScopeBeans = all.stream()
+        .filter(beanEntry -> beanEntry.hasKey(MyCustomScope.class))
+        .collect(toList());
+      assertThat(myCustomScopeBeans).hasSize(3);
+
+      final OtherCBean cBean = beanScope.get(OtherCBean.class);
+      assertThat(customBean).isNotNull();
+      assertThat(cBean.dependency()).isSameAs(customBean);
+
+      final LocalExternal externallyProvided = beanScope.get(LocalExternal.class);
+      assertThat(externallyProvided).isSameAs(ext);
+
+      final CoffeeMaker coffeeMaker = beanScope.get(CoffeeMaker.class);
+      assertThat(coffeeMaker).isSameAs(suppliedCoffeeMaker);
+    }
+  }
+
   static class LocalExt implements LocalExternal {
 
   }

inject/src/main/java/io/avaje/inject/BeanEntry.java

@@ -1,107 +1,66 @@
 package io.avaje.inject;
 
+import java.util.Set;
+
 /**
  * A bean entry with priority and optional name.
  */
-public class BeanEntry<T> {
+public interface BeanEntry {
 
   /**
-   * An explicitly supplied bean. See BeanScopeBuilder.
+   * Priority of externally supplied bean.
    */
-  public static final int SUPPLIED = 2;
+  int SUPPLIED = 2;
 
   /**
-   * An <code>@Primary</code> bean.
+   * Priority of <code>@Primary</code> bean.
    */
-  public static final int PRIMARY = 1;
+  int PRIMARY = 1;
 
   /**
-   * A normal priority bean.
+   * Priority of normal bean.
    */
-  public static final int NORMAL = 0;
+  int NORMAL = 0;
 
   /**
-   * A <code>@Secondary</code> bean.
+   * Priority of <code>@Secondary</code> bean.
    */
-  public static final int SECONDARY = -1;
-
-  private final int priority;
-
-  private final T bean;
-
-  private final String name;
+  int SECONDARY = -1;
 
   /**
-   * Construct with priority, name and the bean.
-   */
-  public BeanEntry(int priority, T bean, String name) {
-    this.priority = priority;
-    this.bean = bean;
-    this.name = name;
-  }
-
-  /**
-   * Return the priority (Primary, Normal and Secondary).
+   * Return the bean name.
    */
-  public int getPriority() {
-    return priority;
-  }
+  String qualifierName();
 
   /**
-   * Return the bean.
+   * Return the bean instance.
    */
-  public T getBean() {
-    return bean;
-  }
+  Object bean();
 
   /**
-   * Return the bean name.
+   * The bean instance type.
    */
-  public String getName() {
-    return name;
-  }
+  Class<?> type();
 
   /**
-   * Return true if this entry has Supplied priority.
+   * Return the priority indicating if the bean is Supplied Primary, Normal or Secondary.
    */
-  public boolean isSupplied() {
-    return priority == SUPPLIED;
-  }
+  int priority();
 
   /**
-   * Return true if this entry has Primary priority.
+   * Return the type keys for this bean.
+   * <p>
+   * This is the set of type, interface types and annotation types that the entry is registered for.
    */
-  public boolean isPrimary() {
-    return priority == PRIMARY;
-  }
+  Set<String> keys();
 
   /**
-   * Return true if this entry has Secondary priority.
+   * Return true if the entry has a key for this type.
+   * <p>
+   * This is true if the keys contains the canonical name of the given type.
+   *
+   * @param type The type to match. Can be any type including concrete, interface or annotation type.
    */
-  public boolean isSecondary() {
-    return priority == SECONDARY;
-  }
+  boolean hasKey(Class<?> type);
 
-  @Override
-  public String toString() {
-    StringBuilder sb = new StringBuilder();
-    sb.append("{bean:").append(bean);
-    if (name != null) {
-      sb.append(", name:").append(name);
-    }
-    switch (priority) {
-      case SUPPLIED:
-        sb.append(", Supplied");
-        break;
-      case PRIMARY:
-        sb.append(", @Primary");
-        break;
-      case SECONDARY:
-        sb.append(", @Secondary");
-        break;
-      default:
-        sb.append(", Normal");
-    }
-    return sb.append("}").toString();
-  }
 }

inject/src/main/java/io/avaje/inject/BeanScope.java

@@ -141,6 +141,16 @@ static BeanScopeBuilder newBuilder() {
    */
   <T> List<T> listByPriority(Class<T> interfaceType, Class<? extends Annotation> priority);
 
+  /**
+   * Return all the bean entries from the scope.
+   * <p>
+   * The bean entries include
+   * This includes entries from the parent scope if it has one.
+   *
+   * @return All bean entries from the scope.
+   */
+  List<BeanEntry> all();
+
   /**
    * Close the scope firing any <code>@PreDestroy</code> methods.
    */

inject/src/main/java/io/avaje/inject/spi/DBeanMap.java

@@ -1,10 +1,11 @@
 package io.avaje.inject.spi;
 
-import io.avaje.inject.BeanEntry;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
 
-import java.util.*;
-
-import static io.avaje.inject.BeanEntry.*;
+import static io.avaje.inject.BeanEntry.SUPPLIED;
 
 /**
  * Map of types (class types, interfaces and annotations) to a DContextEntry where the
@@ -19,6 +20,17 @@ class DBeanMap {
   DBeanMap() {
   }
 
+  /**
+   * Add to the map of entries.
+   */
+  void addAll(Map<DContextEntryBean,DEntry> map) {
+    for (Map.Entry<String, DContextEntry> entry : beans.entrySet()) {
+      for (DContextEntryBean contentEntry : entry.getValue().entries()) {
+        map.computeIfAbsent(contentEntry, dContextEntryBean -> contentEntry.entry()).addKey(entry.getKey());
+      }
+    }
+  }
+
   /**
    * Add test double supplied beans.
    */

inject/src/main/java/io/avaje/inject/spi/DBeanScope.java

@@ -1,14 +1,13 @@
 package io.avaje.inject.spi;
 
+import io.avaje.inject.BeanEntry;
 import io.avaje.inject.BeanScope;
 import io.avaje.inject.Priority;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.lang.annotation.Annotation;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
+import java.util.*;
 import java.util.concurrent.locks.ReentrantLock;
 
 class DBeanScope implements BeanScope {
@@ -37,6 +36,20 @@ class DBeanScope implements BeanScope {
     }
   }
 
+  @Override
+  public List<BeanEntry> all() {
+    IdentityHashMap<DContextEntryBean, DEntry> map = new IdentityHashMap<>();
+    if (parent != null) {
+      ((DBeanScope) parent).addAll(map);
+    }
+    addAll(map);
+    return new ArrayList<>(map.values());
+  }
+
+  void addAll(Map<DContextEntryBean, DEntry> map) {
+    beans.addAll(map);
+  }
+
   @Override
   public <T> T get(Class<T> beanClass) {
     return get(beanClass, null);