Changes between Version 5 and Version 6 of PRO_LIB_CORE_TUTORIAL_NEW

Timestamp:

06/29/09 17:33:42 (16 years ago)

Author:

gogov

Comment:

--

PRO_LIB_CORE_TUTORIAL_NEW

@@ -13 +13 @@
 
 == ProLib basics ==
- * ProObject vs Java Object
- * Propertry vs Java field
- * areaComputation example
-
-[[Include(source:/trunk/sophie2-platform/modules/org.sophie2.core/src/test/java/org/sophie2/core/prolib/tutorial/AutoPropertyDemo.java)]]
+Here we'll provide a simple comparison between ProLib code and normal Java code as well as an example.
+
+== ProObject & Properties vs Java Object & Java fields ==
+In Java, there are Objects and each Object has methods and fields.
+
+In the ProLib, there are ProObjects and each ProObject has normal Java methods and Properties instead of fields. The different concept here are that Properties are something like ''smart'' Java fields.
+ * You can create a ProObject by implementing the ProObject interface or by using the default implementation BaseProObject
+ * You can declare Properties inside the ProObject with Java methods which return a Prop<T> (later you'll get what is this), where T is a concrete class like Integer. The method executes some logic and returns the actual Property.
+  * There are different kind of Properties, so inside these methods you can provide logic which returns the desired kind of Property.
+
+=== Example ===
+Let's look at the following example:
+
+{{{
+// Basic rectangle class which is ProObject.
+class Rectangle extends BaseProObject {
+        // Integer property for the width of the rectangle. Analogical to an Integer Java field.
+        RwProp<Integer> width() {
+                return getBean().makeValueProp("width", Integer.class);
+        }
+
+        // Integer property for the height of the rectangle. Analogical to an Integer Java field.
+        RwProp<Integer> height() {
+                return getBean().makeValueProp("height", Integer.class);
+        }
+
+        // Smart property which returns the area of the rectangle.
+        Prop<Integer> area() {
+                class area extends AutoProperty<Integer> {
+                        @Override
+                        protected Integer compute() {
+                                Integer res = width().get() * height().get();
+                                return res;
+                        }
+                }
+
+                return getBean().makeProp(area.class);
+        }
+}
+
+// this is something like pseudo ProLib code which demonstrates basic ProLib usage
+public void demoCode() {
+    // create a new Rectangle
+    Rectangle rectangle = new Rectangle();              
+
+    // set the width to 6
+    rectangle.width().set(6);
+
+    // set the height to 8
+    rectangle.height().set(8);
+
+    // it is true then that the area is equal to 6*8 = 48
+    assertEquals(48, (int)rectangle.area().get());
+}
+}}}
+
+So, you can see the analogy with Java code, though the difference is with the area() Property. This is an AutoProperty: a property which is automatically computed. In the compute() method you specify the logic of the computation, and then this Property gets automatically computed. Even more, when the width and height change, this Property immediately gets recomputed and stay up-to-date which is very useful.
 
 == Problems Solved ==