[#3769] Add org.jooq.Converters, a chained Converter implementation

jOOQ/src/main/java/org/jooq/Converters.java

@@ -0,0 +1,131 @@
+/**
+ * Copyright (c) 2009-2014, Data Geekery GmbH (http://www.datageekery.com)
+ * All rights reserved.
+ *
+ * This work is dual-licensed
+ * - under the Apache Software License 2.0 (the "ASL")
+ * - under the jOOQ License and Maintenance Agreement (the "jOOQ License")
+ * =============================================================================
+ * You may choose which license applies to you:
+ *
+ * - If you're using this work with Open Source databases, you may choose
+ *   either ASL or jOOQ License.
+ * - If you're using this work with at least one commercial database, you must
+ *   choose jOOQ License
+ *
+ * For more information, please visit http://www.jooq.org/licenses
+ *
+ * Apache Software License 2.0:
+ * -----------------------------------------------------------------------------
+ * 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.
+ *
+ * jOOQ License and Maintenance Agreement:
+ * -----------------------------------------------------------------------------
+ * Data Geekery grants the Customer the non-exclusive, timely limited and
+ * non-transferable license to install and use the Software under the terms of
+ * the jOOQ License and Maintenance Agreement.
+ *
+ * This library is distributed with a LIMITED WARRANTY. See the jOOQ License
+ * and Maintenance Agreement for more details: http://www.jooq.org/licensing
+ */
+package org.jooq;
+
+import org.jooq.impl.SQLDataType;
+
+/**
+ * A chain of converters.
+ *
+ * @param <T> The database type - i.e. any type available from
+ *            {@link SQLDataType}
+ * @param <U> The user type
+ * @author Lukas Eder
+ */
+@SuppressWarnings({ "rawtypes", "unchecked" })
+public class Converters<T, U> implements Converter<T, U> {
+
+    /**
+     * Generated UID
+     */
+    private static final long serialVersionUID = -4307758248063822630L;
+
+    final Converter[] chain;
+
+    /**
+     * Create an identity converter.
+     */
+    public static <T, U> Converter<T, U> of() {
+        return new Converters();
+    }
+
+    /**
+     * Create a single converter.
+     */
+    public static <T, U> Converter<T, U> of(Converter<T, U> converter) {
+        return new Converters(converter);
+    }
+
+    /**
+     * Chain two converters.
+     */
+    public static <T, X1, U> Converter<T, U> of(Converter<T, X1> c1, Converter<X1, U> c2) {
+        return new Converters(c1, c2);
+    }
+
+    /**
+     * Chain three converters.
+     */
+    public static <T, X1, X2, U> Converter<T, U> of(Converter<T, X1> c1, Converter<X1, X2> c2, Converter<X2, U> c3) {
+        return new Converters(c1, c2, c3);
+    }
+
+    /**
+     * Chain four converters.
+     */
+    public static <T, X1, X2, X3, U> Converter<T, U> of(Converter<T, X1> c1, Converter<X1, X2> c2, Converter<X2, X3> c3, Converter<X3, U> c4) {
+        return new Converters(c1, c2, c3, c4);
+    }
+
+    Converters(Converter... chain) {
+        this.chain = chain == null ? new Converter[0] : chain;
+    }
+
+    @Override
+    public final U from(T t) {
+        Object result = t;
+
+        for (int i = 0; i < chain.length; i++)
+            result = chain[i].from(result);
+
+        return (U) result;
+    }
+
+    @Override
+    public final T to(U u) {
+        Object result = u;
+
+        for (int i = chain.length - 1; i >= 0; i--)
+            result = chain[i].to(result);
+
+        return (T) result;
+    }
+
+    @Override
+    public final Class<T> fromType() {
+        return chain[0].fromType();
+    }
+
+    @Override
+    public final Class<U> toType() {
+        return chain[chain.length - 1].toType();
+    }
+}

jOOQ/src/test/java/org/jooq/test/ConverterTest.java

@@ -44,6 +44,8 @@ import static org.jooq.test.data.BoolTable.BOOL_TABLE;
 
 import java.sql.SQLException;
 
+import org.jooq.Converter;
+import org.jooq.Converters;
 import org.jooq.Result;
 import org.jooq.impl.DSL;
 import org.jooq.test.data.BoolRecord;
@@ -96,4 +98,56 @@ public class ConverterTest extends AbstractTest {
         assertEquals(Bool.FALSE, BOOL_TABLE.BOOL.getDataType().convert(0));
         assertEquals(Bool.FALSE, BOOL_TABLE.BOOL.getDataType().convert("false"));
     }
+
+    @SuppressWarnings("serial")
+    @Test
+    public void testChainedConverters() {
+        Converter<Integer, Integer> c1 = Converters.of();
+
+        assertEquals(1, (int) c1.from(1));
+        assertEquals(1, (int) c1.to(1));
+        assertEquals(1, (int) c1.from(c1.to(1)));
+
+        Converter<Integer, Integer> add = new Converter<Integer, Integer>() {
+            @Override
+            public Integer from(Integer t) {
+                return t + 1;
+            }
+
+            @Override
+            public Integer to(Integer u) {
+                return u - 1;
+            }
+
+            @Override
+            public Class<Integer> fromType() {
+                return Integer.class;
+            }
+
+            @Override
+            public Class<Integer> toType() {
+                return Integer.class;
+            }
+        };
+
+        Converter<Integer, Integer> c2 = Converters.of(add);
+        Converter<Integer, Integer> c3 = Converters.of(add, add);
+        Converter<Integer, Integer> c4 = Converters.of(add, add, add);
+        Converter<Integer, Integer> c5 = Converters.of(add, add, add, add);
+
+        assertEquals(2, (int) c2.from(1));
+        assertEquals(3, (int) c3.from(1));
+        assertEquals(4, (int) c4.from(1));
+        assertEquals(5, (int) c5.from(1));
+
+        assertEquals(1, (int) c2.to(2));
+        assertEquals(1, (int) c3.to(3));
+        assertEquals(1, (int) c4.to(4));
+        assertEquals(1, (int) c5.to(5));
+
+        assertEquals(1, (int) c2.from(c2.to(1)));
+        assertEquals(1, (int) c3.from(c3.to(1)));
+        assertEquals(1, (int) c4.from(c4.to(1)));
+        assertEquals(1, (int) c5.from(c5.to(1)));
+    }
 }