(no commit message)

[utils] / system / TODO.txt

diff --git a/system/TODO.txt b/system/TODO.txt
index ff111104eec860c670177e4ced91481ef99346bc..cac157b27a0579a9f90e8099a3a8acdd34f689b7 100644 (file)
--- a/system/TODO.txt
+++ b/system/TODO.txt
@@ -1,39 +1,28 @@
+SetterConfiguration:
+- add type based removal of setters.
+- add values(Class aType) method for selecting a setter. 
+- add add(Class aType) method for selecting a type. 
+- verify that superclass setters are also taken into account.
+
+
+
+opzoeken waar de provided interfaces van de scope gebruikt worden, als het
+goed is nog nergens. Scope moet een Component worden en publiceren van een 
+interface leidt tot een nieuw provided interface.
+
 Component infrastructure
 * support simple component
   - requires through constructor
   - provides through getters
-* support pre-instantiated components
 * optional start and stop methods
-* directly implementing the Component interface
-* explicit wiring must be possible
 * giving names to a component must be optional
 * support for cached components and non-cached components.
 
 
-- rename System -> Component
-- rename CompositeComponent -> Container
-- qualified name zetten in de start methode
-- testen op multiple start methodes. 
-- geneste service registry maken, testen dat een component alleen maar
-  die componenten in de registry ziet die hij daadwerkelijk mag gebruiken
-- validate() in start() methode aanroepen.
-- validate() moet public zijn
-- Container abstraheren in API
-  addComponent(Component) methode toevoegen voor component 
-  addComponent(name, component) methode toevoegen voor component.
-
-- Toevoegen van Constraint interface
-     Constraint.isAllowed(provider, ProvidedInterface, client, RequiredInterface)
-  Eenvoudige constraint implementeren voor expliciete binding van provided
-  en required interfaces. 
-
-  CompositeConstraint implementeren. 
-
-  CompositeConstraint checken voor elke potentiele match. 
-
 - Annotaties definieren
 
-  @Component 
+
+@Component
   class MyComponent {  
 
   public MyComponent(Def aArg, Ghi aArg2) { 
@@ -46,16 +35,6 @@ Component infrastructure
   public void myStart(); // Unlike the component
 }
 
-- constraint definieren om constructor te selecteren. 
-  
-  // Select the constructor or setter to use.  
-  ArgumentConstraints(Class[] argTypes) 
-   // indicate which provided interface from what other component must be 
-   // used for the i-th parameter. 
-   constraint.require(int i, new ProvidedConstraint(component, intf)); 
-   // indicate the value to substitute for the i-th parameter. 
-   constraint.setValue(int i, Object aValue); 
-
 - Algemene classes maken die de constructor, start method, en 
   methodes  identificeren om de component als Component te benaderen. 
   in een object, samen met een wrapper die deze info gebruikt om het
@@ -66,13 +45,34 @@ Component infrastructure
   wrapper het object ontsluiten als component. 
   Zowel geinstantieerde objecten als classes ondersteunen. 
 
-- constructor toevoegen aan de container voor 
-  addComponent(Class) // use constructor with the most arguments
-  addComponent(Class, ArgumentConstraints) // use explicit constructor
-  addRunningComponent(Object) // running component with annotations or 
-      // subclass of Component
+- add support for private setters.
+- add support or exposing provided services 
+  - superclass or interface of the concrete type instead of the concrete type
+    or not based on the concrete type at all. 
+  - based on getters. 
+- add support for field injection. 
+
+- add support for annotation based configuration instead of API-based
+
+- add support for type conversions. 
+
+- add support for multiplicity. 
+
+- add support for aggregating multiple servicss. 
+
+- add support for explicitly configuring which provided interface of 
+  a container is provided by which internal service. 
+
+- do not use equality but use logic for matching external required and
+  provided interfaces of a container. 
 
-  addComponent(Object, ComponentAdapterInfo) // running component with 
-                     // info on how to adapt it to a component. 
+  e.g. a service T provided by a container can be provided by a service 
+  U that provides subclasses of the provided interfaces of T
 
+  a service T required by a component inside a container is covered
+  by stronger requirements for subclasses of T. 
 
+- separate logic for connecting required and provided interfaces 
+  through a general graph model of the application. 
+  Then use generic filters, validations, and graph traversal APIs 
+  to implement the current functionality in the container.