Size Adapter

Author: SentryMan

validator/src/main/java/io/avaje/validation/ValidPojo.java

@@ -1,22 +1,24 @@
 package io.avaje.validation;
 
+import static java.lang.annotation.ElementType.FIELD;
+import static java.lang.annotation.ElementType.PACKAGE;
+import static java.lang.annotation.ElementType.TYPE;
 import static java.lang.annotation.RetentionPolicy.CLASS;
 
-import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.Target;
 
 /**
  * Marks a type for validation.
  */
 @Retention(CLASS)
-@Target(ElementType.TYPE)
+@Target({TYPE, FIELD})
 public @interface ValidPojo {
 
   /**
    */
   @Retention(CLASS)
-  @Target({ElementType.TYPE, ElementType.PACKAGE})
+  @Target({TYPE, PACKAGE})
   @interface Import {
 
     /**

validator/src/main/java/io/avaje/validation/core/JakartaTypeAdapters.java

@@ -15,28 +15,95 @@
  */
 package io.avaje.validation.core;
 
+import java.lang.reflect.Array;
 import java.time.LocalDate;
 import java.time.LocalTime;
 import java.time.temporal.TemporalAccessor;
+import java.util.Collection;
 import java.util.Map;
 
 import io.avaje.validation.adapter.AnnotationValidationAdapter;
 import io.avaje.validation.adapter.ValidationRequest;
 import jakarta.validation.constraints.AssertTrue;
 import jakarta.validation.constraints.NotBlank;
 import jakarta.validation.constraints.Past;
+import jakarta.validation.constraints.Size;
 
 final class JakartaTypeAdapters {
+  private JakartaTypeAdapters() {}
 
   @SuppressWarnings({"unchecked", "rawtypes"})
   static final AnnotationValidationAdapter.Factory FACTORY =
       (annotationType, validator, interpolator) -> {
         if (annotationType == AssertTrue.class) return new AssertTrueAdapter(interpolator);
         if (annotationType == NotBlank.class) return new NotBlankAdapter(interpolator);
         if (annotationType == Past.class) return new PastAdapter(interpolator);
+        if (annotationType == Size.class) return new SizeAdapter(interpolator);
         return null;
       };
 
+  private static final class SizeAdapter implements AnnotationValidationAdapter<Object> {
+
+    private String message;
+    private final MessageInterpolator interpolator;
+    private int min;
+    private int max;
+
+    public SizeAdapter(MessageInterpolator interpolator) {
+      this.interpolator = interpolator;
+    }
+
+    @Override
+    public AnnotationValidationAdapter<Object> init(Map<String, String> annotationValueMap) {
+      message = interpolator.interpolate(annotationValueMap.get("message"));
+      min = Integer.parseInt(interpolator.interpolate(annotationValueMap.get("min")));
+      max = Integer.parseInt(interpolator.interpolate(annotationValueMap.get("max")));
+      return this;
+    }
+
+    @Override
+    public boolean validate(Object value, ValidationRequest req, String propertyName) {
+
+      if (value instanceof CharSequence) {
+        final var sequence = (CharSequence) value;
+        final var len = sequence.length();
+        if (len > max || len < min) {
+          req.addViolation(message, propertyName);
+          return false;
+        }
+      }
+
+      if (value instanceof Collection<?>) {
+        final var col = (Collection<?>) value;
+        final var len = col.size();
+        if (len > max || len < min) {
+          req.addViolation(message, propertyName);
+          return false;
+        }
+      }
+
+      if (value instanceof Map<?, ?>) {
+        final var col = (Map<?, ?>) value;
+        final var len = col.size();
+        if (len > max || len < min) {
+          req.addViolation(message, propertyName);
+          return false;
+        }
+      }
+
+      if (value.getClass().isArray()) {
+
+        final var len = Array.getLength(value);
+        if (len > max || len < min) {
+          req.addViolation(message, propertyName);
+          return false;
+        }
+      }
+
+      return true;
+    }
+  }
+
   private static final class PastAdapter implements AnnotationValidationAdapter<TemporalAccessor> {
 
     private String message;