Refactoring and renaming

src/main/java/dicontainer/ConstructionPolicy.java

@@ -2,7 +2,5 @@
 
 public enum ConstructionPolicy
 {
-    CONSTRUCT, SINGLETON;
-
-    public static final ConstructionPolicy defaultPolicy = CONSTRUCT;
+    CONSTRUCTION, SINGLETON
 }

src/main/java/dicontainer/DiContainer.java

@@ -1,29 +1,19 @@
 package dicontainer;
 
 import dicontainer.annotation.Dependency;
-import dicontainer.dictionary.DiDictionary;
-import dicontainer.resolver.DiResolver;
+import dicontainer.registry.DependencyRegistry;
+import dicontainer.resolver.TypesResolver;
 
 public final class DiContainer
+        implements DiResolver
 {
-    private final DiDictionary diDictionary;
-    private final DiResolver diResolver;
+    private final DependencyRegistry registry;
+    private final TypesResolver resolver;
 
     public DiContainer()
     {
-        diDictionary = new DiDictionary();
-        diResolver = new DiResolver(diDictionary);
-    }
-
-    /**
-     * Register concrete type class in the container.
-     * @param type type class
-     * @return {@code this} for method chaining
-     */
-    public <T> DiContainer registerType(Class<T> type)
-    {
-        diDictionary.addType(type);
-        return this;
+        registry = new DependencyRegistry();
+        resolver = new TypesResolver(registry);
     }
 
     /**
@@ -34,19 +24,7 @@ public <T> DiContainer registerType(Class<T> type)
      */
     public <T> DiContainer registerType(Class<T> type, ConstructionPolicy policy)
     {
-        diDictionary.addType(type, policy);
-        return this;
-    }
-
-    /**
-     * Register subtype class for its supertype.
-     * @param supertype supertype class
-     * @param subtype subtype class
-     * @return {@code this} for method chaining
-     */
-    public <T> DiContainer registerType(Class<T> supertype, Class<? extends T> subtype)
-    {
-        diDictionary.addType(supertype, subtype);
+        registry.addType(type, policy);
         return this;
     }
 
@@ -60,7 +38,7 @@ public <T> DiContainer registerType(Class<T> supertype, Class<? extends T> subty
     public <T> DiContainer registerType(
             Class<T> supertype, Class<? extends T> subtype, ConstructionPolicy policy)
     {
-        diDictionary.addType(supertype, subtype, policy);
+        registry.addType(supertype, subtype, policy);
         return this;
     }
 
@@ -72,7 +50,7 @@ public <T> DiContainer registerType(
      */
     public <T> DiContainer registerInstance(Class<T> type, T instance)
     {
-        diDictionary.addInstance(type, instance);
+        registry.addInstance(type, instance);
         return this;
     }
 
@@ -82,19 +60,9 @@ public <T> DiContainer registerInstance(Class<T> type, T instance)
      * @return new instance
      * @throws DiException if type cannot be resolved
      */
+    @Override
     public <T> T resolve(Class<T> type)
     {
-        return diResolver.construct(type);
-    }
-
-    /**
-     * Resolve and inject all dependencies to given object using {@link Dependency} on setters.
-     * @param instance instance object
-     * @return resolved instance
-     * @throws DiException if instance cannot be built up
-     */
-    public <T> T buildUp(T instance)
-    {
-        return diResolver.inject(instance);
+        return resolver.resolve(type);
     }
 }

src/main/java/dicontainer/DiException.java

@@ -1,17 +1,19 @@
 package dicontainer;
 
+import java.io.Serial;
+
 public class DiException
         extends RuntimeException
 {
-    private static final long serialVersionUID = -3019200382390630637L;
+    @Serial private static final long serialVersionUID = -3019200382390630637L;
 
-    public DiException(String s)
+    public DiException(String message)
     {
-        super(s);
+        super(message);
     }
 
-    public DiException(String s, Throwable t)
+    public DiException(String message, Throwable cause)
     {
-        super(s, t);
+        super(message, cause);
     }
 }

src/main/java/dicontainer/DiResolver.java

@@ -0,0 +1,31 @@
+package dicontainer;
+
+import dicontainer.annotation.Dependency;
+
+public interface DiResolver
+{
+    /**
+     * Resolve all dependencies and construct a new instance of given type using {@link Dependency}.
+     * @param type type class
+     * @return new instance
+     * @throws DiException if type cannot be resolved
+     */
+    <T> T resolve(Class<T> type);
+
+    /**
+     * Resolve all dependencies and construct a new instance of given type using {@link Dependency}.
+     * @param type type class
+     * @return new instance, or {@code null} if type cannot be resolved.
+     */
+    default <T> T resolveOrNull(Class<T> type)
+    {
+        try
+        {
+            return resolve(type);
+        }
+        catch(DiException ex)
+        {
+            return null;
+        }
+    }
+}

src/main/java/dicontainer/annotation/Register.java

@@ -15,5 +15,5 @@
 {
     Class<?> value();
 
-    ConstructionPolicy policy() default ConstructionPolicy.CONSTRUCT;
+    ConstructionPolicy policy() default ConstructionPolicy.CONSTRUCTION;
 }

src/main/java/dicontainer/annotation/SelfRegister.java

@@ -13,5 +13,5 @@
 @Target(ElementType.TYPE)
 public @interface SelfRegister
 {
-    ConstructionPolicy policy() default ConstructionPolicy.CONSTRUCT;
+    ConstructionPolicy policy() default ConstructionPolicy.CONSTRUCTION;
 }

src/main/java/dicontainer/dictionary/DiDictionary.java → src/main/java/dicontainer/registry/DependencyRegistry.java

@@ -1,33 +1,21 @@
-package dicontainer.dictionary;
+package dicontainer.registry;
 
 import dicontainer.ConstructionPolicy;
-import dicontainer.dictionary.exception.RegistrationException;
-import dicontainer.dictionary.valuetypes.Instance;
-import dicontainer.dictionary.valuetypes.Subtype;
+import dicontainer.registry.exception.RegistrationException;
+import dicontainer.registry.valuetypes.Instance;
+import dicontainer.registry.valuetypes.TypeConstruction;
 
-public class DiDictionary
+public class DependencyRegistry
 {
     private final TypesDictionary typesDictionary = new TypesDictionary();
     private final InstancesDictionary instancesDictionary = new InstancesDictionary();
 
-    public <T> void addType(Class<T> type)
-    {
-        validateRegisteredType(type);
-        typesDictionary.insert(type, ConstructionPolicy.defaultPolicy);
-    }
-
     public <T> void addType(Class<T> type, ConstructionPolicy policy)
     {
         validateRegisteredType(type);
         typesDictionary.insert(type, policy);
     }
 
-    public <T> void addType(Class<T> type, Class<? extends T> subtype)
-    {
-        validateRegisteredType(type);
-        typesDictionary.insert(type, subtype, ConstructionPolicy.defaultPolicy);
-    }
-
     public <T> void addType(Class<T> type, Class<? extends T> subtype, ConstructionPolicy policy)
     {
         validateRegisteredType(type);
@@ -40,12 +28,11 @@ public <T> void addInstance(Class<T> type, T instance)
         instancesDictionary.insert(type, instance);
     }
 
-    public <T> Subtype<? extends T> findType(Class<T> type)
+    public <T> TypeConstruction<? extends T> findType(Class<T> type)
     {
-        if(instancesDictionary.contains(type))
-            return new Subtype<>(type, ConstructionPolicy.SINGLETON);
-
-        return typesDictionary.find(type);
+        return instancesDictionary.contains(type)
+               ? new TypeConstruction<>(type, ConstructionPolicy.SINGLETON)
+               : typesDictionary.find(type);
     }
 
     public <T> Instance<T> findInstance(Class<T> type)

src/main/java/dicontainer/registry/InstancesDictionary.java

@@ -0,0 +1,27 @@
+package dicontainer.registry;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+
+import dicontainer.registry.valuetypes.Instance;
+
+class InstancesDictionary
+{
+    private final Map<Class<?>, Instance<?>> instancesMap = new HashMap<>();
+
+    <T> void insert(Class<T> type, T instance)
+    {
+        instancesMap.put(type, Instance.of(Objects.requireNonNull(instance)));
+    }
+
+    boolean contains(Class<?> type)
+    {
+        return instancesMap.containsKey(type);
+    }
+
+    <T> Instance<T> get(Class<T> type)
+    {
+        return Instance.cast(instancesMap.get(type));
+    }
+}