Let weak join support lambda API

Author: babyfish-ct

project/gradle.properties

@@ -1,2 +1,2 @@
 group=org.babyfish.jimmer
-version=0.9.95
+version=0.9.96

project/jimmer-apt/src/main/java/org/babyfish/jimmer/apt/immutable/generator/TableGenerator.java

@@ -105,6 +105,8 @@ private TypeSpec generateTable() {
             addDisableJoin();
             addWeakJoin(false);
             addWeakJoin(true);
+            addLambdaWeakJoin(false);
+            addLambdaWeakJoin(true);
             addRemote();
             return typeBuilder.build();
         } finally {
@@ -307,6 +309,73 @@ private void addWeakJoin(boolean withJoinType) {
         typeBuilder.addMethod(builder.build());
     }
 
+    private void addLambdaWeakJoin(boolean withJoinType) {
+        if (!isTableEx) {
+            return;
+        }
+        MethodSpec.Builder builder = MethodSpec
+                .methodBuilder("weakJoin")
+                .addModifiers(Modifier.PUBLIC)
+                .addTypeVariable(
+                        TypeVariableName.get(
+                                "TT",
+                                ParameterizedTypeName.get(
+                                        Constants.TABLE_CLASS_NAME,
+                                        WildcardTypeName.subtypeOf(TypeName.OBJECT)
+                                )
+                        )
+                )
+                .returns(TypeVariableName.get("TT"))
+                .addParameter(
+                        ParameterSpec
+                                .builder(
+                                        ParameterizedTypeName.get(
+                                                Constants.CLASS_CLASS_NAME,
+                                                TypeVariableName.get("TT")
+                                        ),
+                                        "targetTableType"
+                                )
+                                .build()
+                );
+        if (withJoinType) {
+            builder.addParameter(
+                    ParameterSpec
+                            .builder(Constants.JOIN_TYPE_CLASS_NAME, "joinType")
+                            .build()
+            );
+            builder.addAnnotation(suppressAllAnnotation());
+        }
+        builder.addParameter(
+                ParameterSpec
+                        .builder(
+                                ParameterizedTypeName.get(
+                                        Constants.WEAK_JOIN_CLASS_NAME,
+                                        type.getTableClassName(),
+                                        TypeVariableName.get("TT")
+                                ),
+                                "weakJoinLambda"
+                        )
+                        .build()
+        );
+        if (withJoinType) {
+            builder
+                    .addStatement("__beforeJoin()")
+                    .beginControlFlow("if (raw != null)")
+                    .addStatement(
+                            "return (TT)$T.wrap(raw.weakJoinImplementor(targetTableType, joinType, weakJoinLambda))",
+                            Constants.TABLE_PROXIES_CLASS_NAME
+                    )
+                    .endControlFlow()
+                    .addStatement(
+                            "return (TT)$T.fluent(joinOperation(targetTableType, joinType, weakJoinLambda))",
+                            Constants.TABLE_PROXIES_CLASS_NAME
+                    );
+        } else {
+            builder.addStatement("return weakJoin(targetTableType, JoinType.INNER, weakJoinLambda)");
+        }
+        typeBuilder.addMethod(builder.build());
+    }
+
     private void addRemote() {
         if (isTableEx) {
             return;

project/jimmer-core/src/main/java/org/babyfish/jimmer/ImmutableObjects.java

@@ -479,6 +479,69 @@ public static boolean isLogicalDeleted(Object o) {
         return info.isDeleted(spi.__get(propId));
     }
 
+    public static <T> Set<T> emptyStringToNull(Set<T> s) {
+        Set<T> newSet = new LinkedHashSet<>((s.size() * 4 + 2) / 3);
+        for (T e : s) {
+            newSet.add(emptyStringToNullImpl(e));
+        }
+        return newSet;
+    }
+
+    public static <T> List<T> emptyStringToNull(Collection<T> c) {
+        List<T> newList = new ArrayList<>(c.size());
+        for (T e : c) {
+            newList.add(emptyStringToNullImpl(e));
+        }
+        return newList;
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <T> T emptyStringToNull(T o) {
+        if (o instanceof Set<?>) {
+            return (T) emptyStringToNull((Set<?>) o);
+        }
+        if (o instanceof Collection<?>) {
+            return (T) emptyStringToNull((List<?>) o);
+        }
+        return emptyStringToNullImpl(o);
+    }
+
+    @SuppressWarnings("unchecked")
+    private static <T> T emptyStringToNullImpl(T o) {
+        if (!(o instanceof ImmutableSpi)) {
+            return o;
+        }
+        ImmutableSpi spi = (ImmutableSpi) o;
+        return (T) Internal.produce(spi.__type(), o, draft -> {
+            DraftSpi draftSpi = (DraftSpi) draft;
+            for (ImmutableProp prop : spi.__type().getProps().values()) {
+                if (!prop.isNullable()) {
+                    continue;
+                }
+                PropId propId = prop.getId();
+                if (!spi.__isLoaded(propId)) {
+                    continue;
+                }
+                if (prop.getReturnClass() == String.class) {
+                    Object value = spi.__get(propId);
+                    if ("".equals(value)) {
+                        draftSpi.__set(propId, null);
+                    }
+                } else if (prop.isAssociation(TargetLevel.OBJECT)) {
+                    Object value = spi.__get(propId);
+                    if (value == null) {
+                        continue;
+                    }
+                    if (value instanceof Collection<?>) {
+                        draftSpi.__set(propId, emptyStringToNull((Collection<?>)value));
+                    } else {
+                        draftSpi.__set(propId, emptyStringToNullImpl(value));
+                    }
+                }
+            }
+        });
+    }
+
     static {
         ObjectMapper mapper = new ObjectMapper();
         mapper.registerModule(new JavaTimeModule());

project/jimmer-core/src/main/java/org/babyfish/jimmer/impl/asm/Type.java

@@ -702,6 +702,25 @@ public int getSize() {
     }
   }
 
+  public static int getArgumentCount(final String methodDescriptor) {
+    int argumentCount = 0;
+    // Skip the first character, which is always a '('.
+    int currentOffset = 1;
+    // Parse the argument types, one at a each loop iteration.
+    while (methodDescriptor.charAt(currentOffset) != ')') {
+      while (methodDescriptor.charAt(currentOffset) == '[') {
+        currentOffset++;
+      }
+      if (methodDescriptor.charAt(currentOffset++) == 'L') {
+        // Skip the argument descriptor content.
+        int semiColumnOffset = methodDescriptor.indexOf(';', currentOffset);
+        currentOffset = Math.max(currentOffset, semiColumnOffset + 1);
+      }
+      ++argumentCount;
+    }
+    return argumentCount;
+  }
+
   /**
    * Returns the size of the arguments and of the return value of methods of this type. This method
    * should only be used for method types.