Changes between Version 34 and Version 35 of PRO_LIB_CORE_TUTORIAL_NEW

Timestamp:

07/02/09 18:21:24 (16 years ago)

Author:

gogov

Comment:

--

PRO_LIB_CORE_TUTORIAL_NEW

@@ -524 +524 @@
 [[Image(source:branches/private/gogov/PRO_LIB_CORE_TUTORIAL_R1/sophie2-platform/modules/org.sophie2.core/src/test/resources/ProObjects And Immutables.png)]]
 
-
-== Todo ==
- * only Immutables and ProObjects concept
- * use properties, not fields; fields can be used, though in specific purposes if you know what you're doing.
- * findOne(), findAll(), ProUitl.getKey()
- * PropretyStatus - A state of a trackable object.
+This is an example how the dependency graph between ProObjects should look.
+ * It should contain cycles, otherwise we can never initialize this graph.
+ * An Immutable shouldn't depend on anything.
+ * ProObjects could depend on other ProObjects and Immutables.
+ * The leafs of this acyclic graph should be Immutables.
+
+  If a ProObject A depends by a Prop<X> P on some object X which doesn't depend on anything, then there are two cases:
+  * X is immutable. Then when someone changes P, it would be through P's interface so the ProLib can detect this change and A can get notified that X has changed.
+  * X is mutable and ProObject. X can change in two ways:
+   * A Property Q of X has changed. Then P would detect when X's Q changes and A would get notified about it.
+   * The same as the above but Q is a normal Java field. Well, nothing conventional can be done to detect when Q changes, so we're screwed, so '''don't use normal Java fields in ProObjects, unless you're sure what you're doing'''.
+  * X is mutable but is not a ProObject. In this case obviously nothing can be automatically done by the ProLib to detect when X changes.
+
+ This means that you should follow the rules above in order to produce non-flawed ProLib code. In general you can use ProObject, Immutables and the rest is junk (:
+
+== ProLists, findOne(), findAll(), ProUtil.getKey() and ListEntry ==
+Let's have this case:
+{{{
+...
+class Party implements ProObject {
+    public ListProp<Person> people() { ... }
+
+    public ListProp<Person> invitedPeople() {
+        class invitedPeople extends AutoListProperty<Person> {
+            @Override
+            protected ProList<Person> constructList() {
+                return new ComposingProList<Person>() {
+                    @Override
+                    protected ProList<Person> computeData() {
+                        ArrayList<Person> res = new ArrayList<Person>();
+                        for (Person person : people().get()) {
+                            if (person.getName() == "Meddle") {
+                                res.add(person);
+                            }
+                        };
+                    }
+                }
+            }
+        }
+
+        return getBean().makeProp(invitedPeople.class);
+    }
+...
+}}}
+
+So, in this example you want to get the List of all invited people to your party, invite only people whose name is "Meddle" and update this list when a potential candidate to come to the party is added. This is kinda slow though, because each time a new Person is added to People, I don't want to reconstruct the whole invitedPeople list.
 
 === Bad Code Examples ===
@@ -557 +597 @@
 
 == Debugging ProLib ==
- * Inspector - A GUI tool that allows browsing the application state while it still works.
-
-== How to apply properties to Sophie 2.0 ==
- * To convert mutable classes to ProObjects
- * To gather more requirements to the properties library and apply them
- * To keep the properties library with high quality, because everything else will depend on it.
- * To be careful of cyclic dependencies (like a = b + 1, b = a + 1). No library can solve them.
+ * Inspector - A GUI tool that allows browsing the application state while it's still working.
+
+== Good Practices  ==
+ * Use ProObject and Immutables when using the ProLib. The rest is junk. Although if you know what you're doing, you can find useful stuff in the junk (:
+ * Convert mutable classes to ProObjects.
+ * Keep the ProLib and with high quality, because everything else will depend on it.
+ * Be careful not to create cyclic dependencies (like a = b + 1, b = a + 1). No library can solve them.