fixes converter util

Author: otaviojava

artemis-core/src/main/java/org/jnosql/artemis/util/ConverterUtil.java

@@ -14,13 +14,18 @@
  */
 package org.jnosql.artemis.util;
 
+import org.jnosql.artemis.AttributeConverter;
 import org.jnosql.artemis.Converters;
 import org.jnosql.artemis.reflection.ClassRepresentation;
 import org.jnosql.artemis.reflection.FieldRepresentation;
 import org.jnosql.diana.api.Value;
 
 import java.lang.reflect.Field;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
 import java.util.Optional;
+import java.util.function.Function;
+import java.util.function.Predicate;
 
 public class ConverterUtil {
 
@@ -30,7 +35,7 @@ private ConverterUtil() {
     }
 
     /**
-     * Converts
+     * Converts the value to database format
      *
      * @param value          the value
      * @param representation the class representation
@@ -48,24 +53,49 @@ public static Object getValue(Object value, ClassRepresentation representation,
     }
 
     /**
-     * Converts the value from the field with {@link FieldRepresentation}
-     * @param value the value to be converted
+     * Converts the value from the field with {@link FieldRepresentation} to database format
+     *
+     * @param value      the value to be converted
      * @param converters the converter
-     * @param field the field
+     * @param field      the field
      * @return tje value converted
      */
     public static Object getValue(Object value, Converters converters, FieldRepresentation field) {
         Field nativeField = field.getNativeField();
         if (!nativeField.getType().equals(value.getClass())) {
             return field.getConverter()
                     .map(converters::get)
-                    .map(a -> a.convertToDatabaseColumn(value))
+                    .map(useConverter(value))
                     .orElseGet(() -> Value.of(value).get(nativeField.getType()));
         }
 
         return field.getConverter()
                 .map(converters::get)
-                .map(a -> a.convertToDatabaseColumn(value))
+                .map(useConverter(value))
                 .orElse(value);
     }
+
+    private static Function<AttributeConverter, Object> useConverter(Object value) {
+        return a -> {
+            if (isNative(value).test(a)) {
+                return value;
+            }
+            return a.convertToDatabaseColumn(value);
+        };
+    }
+
+    private static Predicate<AttributeConverter> isNative(Object value) {
+        return a -> getGenericInterface(a).getActualTypeArguments()[1].equals(value.getClass());
+    }
+
+
+    private static ParameterizedType getGenericInterface(AttributeConverter a) {
+        for (Type genericInterface : a.getClass().getGenericInterfaces()) {
+            if (ParameterizedType.class.isAssignableFrom(genericInterface.getClass()) &&
+                    ParameterizedType.class.cast(genericInterface).getRawType().equals(AttributeConverter.class)) {
+                return (ParameterizedType) genericInterface;
+            }
+        }
+        throw new IllegalArgumentException("It does not found AttributeConverter implementation to this converter");
+    }
 }