Changes between Version 162 and Version 163 of j2p

Timestamp:

11/14/24 09:54:41 (5 months ago)

Author:

wouter

Comment:

--

j2p

@@ -128 +128 @@
 * For the non-static inner class: pass the enclosing class as argument to the child class constructor. You may have to use more tricks to get around cyclic dependencies.
 
-===== Workaround
+==== Example workaround
+Java has the arrow notation (x,y) -> methodcall(x,y) to write lambda expressions. 
+This notation can also be translated. This feature is especially useful when pulling inner classes out of a parent class, to pass parent class functions over to the pulled-out class. 
+For example, suppose you have a class like this
+
+{{{
+class Parent {
+  public void f() {...}
+  public String g(int x) {...}
+
+
+  public X h() {
+    ....
+    return new X{
+      f()
+      g(1)
+    }
+}
+}}}
+
+The "new X" call has to be converted into an explicit class, but somehow it needs to be able to call f and g. We suggest to do it like this:
+
+{{{
+class MyX extends X {
+  public MyX(Runnable f, Function<Integer,String> g) {
+    f.run();
+    g.apply(1);
+  }
+}
+
+class Parent {
+  public void f() {...}
+  public String g(int x) {...}
+
+
+  public X h() {
+    ....
+    return new MyX{()->f(),(x)->g(x));
+} 
+}}}
+
+===== Special cases
 If some particular inner classes, particularly constants, are used in very specific translators, these translators may opt to attempt to recognise these and process them separately (thus avoiding calling the translator for them). One example is the JsonDeserializer (jackson-t package) that recognises use of "com.fasterxml.jackson.databind.JsonDeserializer.None". 
 
@@ -444 +485 @@
 
 
-== Use of lambda notation, inner class extraction
-Java has the arrow notation (x,y) -> methodcall(x,y) to write lambda expressions. 
-This notation can also be translated. This feature is especially useful when pulling inner classes out of a parent class, to pass parent class functions over to the pulled-out class. 
-For example, suppose you have a class like this
-
-{{{
-class Parent {
-  public void f() {...}
-  public String g(int x) {...}
-
-
-  public X h() {
-    ....
-    return new X{
-      f()
-      g(1)
-    }
-}
-}}}
-
-The "new X" call has to be converted into an explicit class, but somehow it needs to be able to call f and g. We suggest to do it like this:
-
-{{{
-class MyX extends X {
-  public MyX(Runnable f, Function<Integer,String> g) {
-    f.run();
-    g.apply(1);
-  }
-}
-
-class Parent {
-  public void f() {...}
-  public String g(int x) {...}
-
-
-  public X h() {
-    ....
-    return new MyX{()->f(),(x)->g(x));
-} 
-}}}
 
 == FAQs