Support custom conversions for the mapped Item fields

- Implemented resolution of convertible types

Closes gh-115

Author: evgeniycheban

src/main/java/ru/rt/restream/reindexer/convert/FieldConverter.java

@@ -15,6 +15,10 @@
  */
 package ru.rt.restream.reindexer.convert;
 
+import ru.rt.restream.reindexer.convert.util.ConversionUtils;
+import ru.rt.restream.reindexer.convert.util.ResolvableType;
+import ru.rt.restream.reindexer.util.Pair;
+
 /**
  * An interface that can be implemented to convert field value between the Reindexer stored database type: 
  * {@link ru.rt.restream.reindexer.FieldType}, and the one used within the POJO representation.
@@ -36,4 +40,14 @@ public interface FieldConverter<X, Y> {
      * @return the Reindexer stored database type value
      */
     Y convertToDatabaseType(X field);
+
+    /**
+     * Returns a {@link Pair} of source and target {@link ResolvableType}s.
+     * By default, the source and target types are determined based on {@link X} and {@link Y} parameters,
+     * this can be overridden to provide a custom implementation of how source and target types are determined.
+     * @return the {@link Pair} of source and target {@link ResolvableType}s to use
+     */
+    default Pair<ResolvableType, ResolvableType> getConvertiblePair() {
+        return ConversionUtils.resolveConvertiblePair(getClass(), FieldConverter.class);
+    }
 }

src/main/java/ru/rt/restream/reindexer/convert/util/ConversionUtils.java

@@ -0,0 +1,97 @@
+/*
+ * Copyright 2020 Restream
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package ru.rt.restream.reindexer.convert.util;
+
+import org.apache.commons.lang3.reflect.TypeUtils;
+import ru.rt.restream.reindexer.util.Pair;
+
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
+import java.util.Collection;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * For internal use only, as this contract is likely to change.
+ */
+public final class ConversionUtils {
+
+    private static final Map<Class<?>, Pair<ResolvableType, ResolvableType>> CONVERTIBLE_PAIR_CACHE = new ConcurrentHashMap<>();
+
+    /**
+     * Resolves source and target types based on {@code [0]} and {@code [1]} parameters from {@code converterType} interface implementation.
+     * If {@code converterType} source or target type is an array, the type is determined by {@code Class#getComponentType},
+     * in case of a generic type, only {@code java.util.Collection} assignable types are considered, nested generic types
+     * (i.e. {@code List<List<String>>}) are not supported, such types will not be recognized and IllegalArgumentException will be thrown.
+     * @param converterClass the {@code converterType} interface implementation class to use
+     * @param converterType the converter interface to use
+     * @return the {@link Pair} of source and target {@link ResolvableType}s to use
+     */
+    public static Pair<ResolvableType, ResolvableType> resolveConvertiblePair(Class<?> converterClass, Class<?> converterType) {
+        Objects.requireNonNull(converterClass, "converterClass must not be null");
+        // https://bugs.openjdk.java.net/browse/JDK-8161372
+        Pair<ResolvableType, ResolvableType> typePair = CONVERTIBLE_PAIR_CACHE.get(converterClass);
+        if (typePair != null) {
+            return typePair;
+        }
+        Objects.requireNonNull(converterType, "converterType must not be null");
+        TypeVariable<? extends Class<?>>[] typeParameters = converterType.getTypeParameters();
+        if (typeParameters.length < 2) {
+            throw new IllegalArgumentException(
+                    String.format("Converter type: %s must have 2 type arguments", converterType.getName()));
+        }
+        return CONVERTIBLE_PAIR_CACHE.computeIfAbsent(converterClass, k -> {
+            Map<TypeVariable<?>, Type> typeArguments = TypeUtils.getTypeArguments(converterClass, converterType);
+            Type sourceType = typeArguments.get(typeParameters[0]);
+            ResolvableType resolvableSourceType = resolveType(sourceType);
+            if (resolvableSourceType == null) {
+                throw new IllegalArgumentException(
+                        String.format("Cannot resolve source type: %s of converter type: %s for converter class: %s",
+                                sourceType, converterType.getName(), converterClass.getName()));
+            }
+            Type targetType = typeArguments.get(typeParameters[1]);
+            ResolvableType resolvableTargetType = resolveType(targetType);
+            if (resolvableTargetType == null) {
+                throw new IllegalArgumentException(
+                        String.format("Cannot resolve target type: %s of converter type: %s for converter class: %s",
+                                targetType, converterType.getName(), converterClass.getName()));
+            }
+            return new Pair<>(resolvableSourceType, resolvableTargetType);
+        });
+    }
+
+    private static ResolvableType resolveType(Type type) {
+        if (TypeUtils.isAssignable(type, Collection.class)) {
+            Type typeArgument = TypeUtils.getTypeArguments(type, Collection.class)
+                    .get(Collection.class.getTypeParameters()[0]);
+            if (typeArgument instanceof Class<?>) {
+                Class<?> containerType = TypeUtils.getRawType(type, Collection.class);
+                return new ResolvableType(containerType, (Class<?>) typeArgument, true);
+            }
+            return null;
+        }
+        if (type instanceof Class<?>) {
+            Class<?> targetType = (Class<?>) type;
+            return new ResolvableType(targetType, targetType.getComponentType(), targetType.isArray());
+        }
+        return null;
+    }
+
+    private ConversionUtils() {
+        // utils
+    }
+}

src/main/java/ru/rt/restream/reindexer/convert/util/ResolvableType.java

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2020 Restream
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package ru.rt.restream.reindexer.convert.util;
+
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import lombok.ToString;
+
+/**
+ * Represents a resolved type, this includes {@code type} information,
+ * {@code componentType} and {@code isCollectionLike} if the {@code type} is either
+ * assignable of {@code java.util.Collection} or an array.
+ */
+@Getter
+@ToString
+@EqualsAndHashCode
+@RequiredArgsConstructor
+public final class ResolvableType {
+    private final Class<?> type;
+    private final Class<?> componentType;
+    private final boolean isCollectionLike;
+}