001/*
002 * Copyright (C) 2008 The Guava Authors
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
005 * in compliance with the License. You may obtain a copy of the License at
006 *
007 * http://www.apache.org/licenses/LICENSE-2.0
008 *
009 * Unless required by applicable law or agreed to in writing, software distributed under the License
010 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
011 * or implied. See the License for the specific language governing permissions and limitations under
012 * the License.
013 */
014
015package com.google.common.base;
016
017import static com.google.common.base.Preconditions.checkNotNull;
018
019import com.google.common.annotations.GwtCompatible;
020import com.google.errorprone.annotations.CanIgnoreReturnValue;
021import com.google.errorprone.annotations.ForOverride;
022import com.google.errorprone.annotations.concurrent.LazyInit;
023import java.io.Serializable;
024import java.util.Iterator;
025import org.checkerframework.checker.nullness.compatqual.NullableDecl;
026
027/**
028 * A function from {@code A} to {@code B} with an associated <i>reverse</i> function from {@code B}
029 * to {@code A}; used for converting back and forth between <i>different representations of the same
030 * information</i>.
031 *
032 * <h3>Invertibility</h3>
033 *
034 * <p>The reverse operation <b>may</b> be a strict <i>inverse</i> (meaning that {@code
035 * converter.reverse().convert(converter.convert(a)).equals(a)} is always true). However, it is very
036 * common (perhaps <i>more</i> common) for round-trip conversion to be <i>lossy</i>. Consider an
037 * example round-trip using {@link com.google.common.primitives.Doubles#stringConverter}:
038 *
039 * <ol>
040 *   <li>{@code stringConverter().convert("1.00")} returns the {@code Double} value {@code 1.0}
041 *   <li>{@code stringConverter().reverse().convert(1.0)} returns the string {@code "1.0"} --
042 *       <i>not</i> the same string ({@code "1.00"}) we started with
043 * </ol>
044 *
045 * <p>Note that it should still be the case that the round-tripped and original objects are
046 * <i>similar</i>.
047 *
048 * <h3>Nullability</h3>
049 *
050 * <p>A converter always converts {@code null} to {@code null} and non-null references to non-null
051 * references. It would not make sense to consider {@code null} and a non-null reference to be
052 * "different representations of the same information", since one is distinguishable from
053 * <i>missing</i> information and the other is not. The {@link #convert} method handles this null
054 * behavior for all converters; implementations of {@link #doForward} and {@link #doBackward} are
055 * guaranteed to never be passed {@code null}, and must never return {@code null}.
056 *
057 *
058 * <h3>Common ways to use</h3>
059 *
060 * <p>Getting a converter:
061 *
062 * <ul>
063 *   <li>Use a provided converter implementation, such as {@link Enums#stringConverter}, {@link
064 *       com.google.common.primitives.Ints#stringConverter Ints.stringConverter} or the {@linkplain
065 *       #reverse reverse} views of these.
066 *   <li>Convert between specific preset values using {@link
067 *       com.google.common.collect.Maps#asConverter Maps.asConverter}. For example, use this to
068 *       create a "fake" converter for a unit test. It is unnecessary (and confusing) to <i>mock</i>
069 *       the {@code Converter} type using a mocking framework.
070 *   <li>Extend this class and implement its {@link #doForward} and {@link #doBackward} methods.
071 *   <li><b>Java 8 users:</b> you may prefer to pass two lambda expressions or method references to
072 *       the {@link #from from} factory method.
073 * </ul>
074 *
075 * <p>Using a converter:
076 *
077 * <ul>
078 *   <li>Convert one instance in the "forward" direction using {@code converter.convert(a)}.
079 *   <li>Convert multiple instances "forward" using {@code converter.convertAll(as)}.
080 *   <li>Convert in the "backward" direction using {@code converter.reverse().convert(b)} or {@code
081 *       converter.reverse().convertAll(bs)}.
082 *   <li>Use {@code converter} or {@code converter.reverse()} anywhere a {@link
083 *       java.util.function.Function} is accepted (for example {@link java.util.stream.Stream#map
084 *       Stream.map}).
085 *   <li><b>Do not</b> call {@link #doForward} or {@link #doBackward} directly; these exist only to
086 *       be overridden.
087 * </ul>
088 *
089 * <h3>Example</h3>
090 *
091 * <pre>
092 *   return new Converter&lt;Integer, String&gt;() {
093 *     protected String doForward(Integer i) {
094 *       return Integer.toHexString(i);
095 *     }
096 *
097 *     protected Integer doBackward(String s) {
098 *       return parseUnsignedInt(s, 16);
099 *     }
100 *   };</pre>
101 *
102 * <p>An alternative using Java 8:
103 *
104 * <pre>{@code
105 * return Converter.from(
106 *     Integer::toHexString,
107 *     s -> parseUnsignedInt(s, 16));
108 * }</pre>
109 *
110 * @author Mike Ward
111 * @author Kurt Alfred Kluever
112 * @author Gregory Kick
113 * @since 16.0
114 */
115@GwtCompatible
116public abstract class Converter<A, B> implements Function<A, B> {
117  private final boolean handleNullAutomatically;
118
119  // We lazily cache the reverse view to avoid allocating on every call to reverse().
120  @LazyInit @NullableDecl private transient Converter<B, A> reverse;
121
122  /** Constructor for use by subclasses. */
123  protected Converter() {
124    this(true);
125  }
126
127  /** Constructor used only by {@code LegacyConverter} to suspend automatic null-handling. */
128  Converter(boolean handleNullAutomatically) {
129    this.handleNullAutomatically = handleNullAutomatically;
130  }
131
132  // SPI methods (what subclasses must implement)
133
134  /**
135   * Returns a representation of {@code a} as an instance of type {@code B}. If {@code a} cannot be
136   * converted, an unchecked exception (such as {@link IllegalArgumentException}) should be thrown.
137   *
138   * @param a the instance to convert; will never be null
139   * @return the converted instance; <b>must not</b> be null
140   */
141  @ForOverride
142  protected abstract B doForward(A a);
143
144  /**
145   * Returns a representation of {@code b} as an instance of type {@code A}. If {@code b} cannot be
146   * converted, an unchecked exception (such as {@link IllegalArgumentException}) should be thrown.
147   *
148   * @param b the instance to convert; will never be null
149   * @return the converted instance; <b>must not</b> be null
150   * @throws UnsupportedOperationException if backward conversion is not implemented; this should be
151   *     very rare. Note that if backward conversion is not only unimplemented but
152   *     unimplement<i>able</i> (for example, consider a {@code Converter<Chicken, ChickenNugget>}),
153   *     then this is not logically a {@code Converter} at all, and should just implement {@link
154   *     Function}.
155   */
156  @ForOverride
157  protected abstract A doBackward(B b);
158
159  // API (consumer-side) methods
160
161  /**
162   * Returns a representation of {@code a} as an instance of type {@code B}.
163   *
164   * @return the converted value; is null <i>if and only if</i> {@code a} is null
165   */
166  @CanIgnoreReturnValue
167  @NullableDecl
168  public final B convert(@NullableDecl A a) {
169    return correctedDoForward(a);
170  }
171
172  @NullableDecl
173  B correctedDoForward(@NullableDecl A a) {
174    if (handleNullAutomatically) {
175      // TODO(kevinb): we shouldn't be checking for a null result at runtime. Assert?
176      return a == null ? null : checkNotNull(doForward(a));
177    } else {
178      return doForward(a);
179    }
180  }
181
182  @NullableDecl
183  A correctedDoBackward(@NullableDecl B b) {
184    if (handleNullAutomatically) {
185      // TODO(kevinb): we shouldn't be checking for a null result at runtime. Assert?
186      return b == null ? null : checkNotNull(doBackward(b));
187    } else {
188      return doBackward(b);
189    }
190  }
191
192  /**
193   * Returns an iterable that applies {@code convert} to each element of {@code fromIterable}. The
194   * conversion is done lazily.
195   *
196   * <p>The returned iterable's iterator supports {@code remove()} if the input iterator does. After
197   * a successful {@code remove()} call, {@code fromIterable} no longer contains the corresponding
198   * element.
199   */
200  @CanIgnoreReturnValue
201  public Iterable<B> convertAll(final Iterable<? extends A> fromIterable) {
202    checkNotNull(fromIterable, "fromIterable");
203    return new Iterable<B>() {
204      @Override
205      public Iterator<B> iterator() {
206        return new Iterator<B>() {
207          private final Iterator<? extends A> fromIterator = fromIterable.iterator();
208
209          @Override
210          public boolean hasNext() {
211            return fromIterator.hasNext();
212          }
213
214          @Override
215          public B next() {
216            return convert(fromIterator.next());
217          }
218
219          @Override
220          public void remove() {
221            fromIterator.remove();
222          }
223        };
224      }
225    };
226  }
227
228  /**
229   * Returns the reversed view of this converter, which converts {@code this.convert(a)} back to a
230   * value roughly equivalent to {@code a}.
231   *
232   * <p>The returned converter is serializable if {@code this} converter is.
233   *
234   * <p><b>Note:</b> you should not override this method. It is non-final for legacy reasons.
235   */
236  @CanIgnoreReturnValue
237  public Converter<B, A> reverse() {
238    Converter<B, A> result = reverse;
239    return (result == null) ? reverse = new ReverseConverter<>(this) : result;
240  }
241
242  private static final class ReverseConverter<A, B> extends Converter<B, A>
243      implements Serializable {
244    final Converter<A, B> original;
245
246    ReverseConverter(Converter<A, B> original) {
247      this.original = original;
248    }
249
250    /*
251     * These gymnastics are a little confusing. Basically this class has neither legacy nor
252     * non-legacy behavior; it just needs to let the behavior of the backing converter shine
253     * through. So, we override the correctedDo* methods, after which the do* methods should never
254     * be reached.
255     */
256
257    @Override
258    protected A doForward(B b) {
259      throw new AssertionError();
260    }
261
262    @Override
263    protected B doBackward(A a) {
264      throw new AssertionError();
265    }
266
267    @Override
268    @NullableDecl
269    A correctedDoForward(@NullableDecl B b) {
270      return original.correctedDoBackward(b);
271    }
272
273    @Override
274    @NullableDecl
275    B correctedDoBackward(@NullableDecl A a) {
276      return original.correctedDoForward(a);
277    }
278
279    @Override
280    public Converter<A, B> reverse() {
281      return original;
282    }
283
284    @Override
285    public boolean equals(@NullableDecl Object object) {
286      if (object instanceof ReverseConverter) {
287        ReverseConverter<?, ?> that = (ReverseConverter<?, ?>) object;
288        return this.original.equals(that.original);
289      }
290      return false;
291    }
292
293    @Override
294    public int hashCode() {
295      return ~original.hashCode();
296    }
297
298    @Override
299    public String toString() {
300      return original + ".reverse()";
301    }
302
303    private static final long serialVersionUID = 0L;
304  }
305
306  /**
307   * Returns a converter whose {@code convert} method applies {@code secondConverter} to the result
308   * of this converter. Its {@code reverse} method applies the converters in reverse order.
309   *
310   * <p>The returned converter is serializable if {@code this} converter and {@code secondConverter}
311   * are.
312   */
313  public final <C> Converter<A, C> andThen(Converter<B, C> secondConverter) {
314    return doAndThen(secondConverter);
315  }
316
317  /** Package-private non-final implementation of andThen() so only we can override it. */
318  <C> Converter<A, C> doAndThen(Converter<B, C> secondConverter) {
319    return new ConverterComposition<>(this, checkNotNull(secondConverter));
320  }
321
322  private static final class ConverterComposition<A, B, C> extends Converter<A, C>
323      implements Serializable {
324    final Converter<A, B> first;
325    final Converter<B, C> second;
326
327    ConverterComposition(Converter<A, B> first, Converter<B, C> second) {
328      this.first = first;
329      this.second = second;
330    }
331
332    /*
333     * These gymnastics are a little confusing. Basically this class has neither legacy nor
334     * non-legacy behavior; it just needs to let the behaviors of the backing converters shine
335     * through (which might even differ from each other!). So, we override the correctedDo* methods,
336     * after which the do* methods should never be reached.
337     */
338
339    @Override
340    protected C doForward(A a) {
341      throw new AssertionError();
342    }
343
344    @Override
345    protected A doBackward(C c) {
346      throw new AssertionError();
347    }
348
349    @Override
350    @NullableDecl
351    C correctedDoForward(@NullableDecl A a) {
352      return second.correctedDoForward(first.correctedDoForward(a));
353    }
354
355    @Override
356    @NullableDecl
357    A correctedDoBackward(@NullableDecl C c) {
358      return first.correctedDoBackward(second.correctedDoBackward(c));
359    }
360
361    @Override
362    public boolean equals(@NullableDecl Object object) {
363      if (object instanceof ConverterComposition) {
364        ConverterComposition<?, ?, ?> that = (ConverterComposition<?, ?, ?>) object;
365        return this.first.equals(that.first) && this.second.equals(that.second);
366      }
367      return false;
368    }
369
370    @Override
371    public int hashCode() {
372      return 31 * first.hashCode() + second.hashCode();
373    }
374
375    @Override
376    public String toString() {
377      return first + ".andThen(" + second + ")";
378    }
379
380    private static final long serialVersionUID = 0L;
381  }
382
383  /**
384   * @deprecated Provided to satisfy the {@code Function} interface; use {@link #convert} instead.
385   */
386  @Deprecated
387  @Override
388  @CanIgnoreReturnValue
389  @NullableDecl
390  public final B apply(@NullableDecl A a) {
391    return convert(a);
392  }
393
394  /**
395   * Indicates whether another object is equal to this converter.
396   *
397   * <p>Most implementations will have no reason to override the behavior of {@link Object#equals}.
398   * However, an implementation may also choose to return {@code true} whenever {@code object} is a
399   * {@link Converter} that it considers <i>interchangeable</i> with this one. "Interchangeable"
400   * <i>typically</i> means that {@code Objects.equal(this.convert(a), that.convert(a))} is true for
401   * all {@code a} of type {@code A} (and similarly for {@code reverse}). Note that a {@code false}
402   * result from this method does not imply that the converters are known <i>not</i> to be
403   * interchangeable.
404   */
405  @Override
406  public boolean equals(@NullableDecl Object object) {
407    return super.equals(object);
408  }
409
410  // Static converters
411
412  /**
413   * Returns a converter based on separate forward and backward functions. This is useful if the
414   * function instances already exist, or so that you can supply lambda expressions. If those
415   * circumstances don't apply, you probably don't need to use this; subclass {@code Converter} and
416   * implement its {@link #doForward} and {@link #doBackward} methods directly.
417   *
418   * <p>These functions will never be passed {@code null} and must not under any circumstances
419   * return {@code null}. If a value cannot be converted, the function should throw an unchecked
420   * exception (typically, but not necessarily, {@link IllegalArgumentException}).
421   *
422   * <p>The returned converter is serializable if both provided functions are.
423   *
424   * @since 17.0
425   */
426  public static <A, B> Converter<A, B> from(
427      Function<? super A, ? extends B> forwardFunction,
428      Function<? super B, ? extends A> backwardFunction) {
429    return new FunctionBasedConverter<>(forwardFunction, backwardFunction);
430  }
431
432  private static final class FunctionBasedConverter<A, B> extends Converter<A, B>
433      implements Serializable {
434    private final Function<? super A, ? extends B> forwardFunction;
435    private final Function<? super B, ? extends A> backwardFunction;
436
437    private FunctionBasedConverter(
438        Function<? super A, ? extends B> forwardFunction,
439        Function<? super B, ? extends A> backwardFunction) {
440      this.forwardFunction = checkNotNull(forwardFunction);
441      this.backwardFunction = checkNotNull(backwardFunction);
442    }
443
444    @Override
445    protected B doForward(A a) {
446      return forwardFunction.apply(a);
447    }
448
449    @Override
450    protected A doBackward(B b) {
451      return backwardFunction.apply(b);
452    }
453
454    @Override
455    public boolean equals(@NullableDecl Object object) {
456      if (object instanceof FunctionBasedConverter) {
457        FunctionBasedConverter<?, ?> that = (FunctionBasedConverter<?, ?>) object;
458        return this.forwardFunction.equals(that.forwardFunction)
459            && this.backwardFunction.equals(that.backwardFunction);
460      }
461      return false;
462    }
463
464    @Override
465    public int hashCode() {
466      return forwardFunction.hashCode() * 31 + backwardFunction.hashCode();
467    }
468
469    @Override
470    public String toString() {
471      return "Converter.from(" + forwardFunction + ", " + backwardFunction + ")";
472    }
473  }
474
475  /** Returns a serializable converter that always converts or reverses an object to itself. */
476  @SuppressWarnings("unchecked") // implementation is "fully variant"
477  public static <T> Converter<T, T> identity() {
478    return (IdentityConverter<T>) IdentityConverter.INSTANCE;
479  }
480
481  /**
482   * A converter that always converts or reverses an object to itself. Note that T is now a
483   * "pass-through type".
484   */
485  private static final class IdentityConverter<T> extends Converter<T, T> implements Serializable {
486    static final IdentityConverter<?> INSTANCE = new IdentityConverter<>();
487
488    @Override
489    protected T doForward(T t) {
490      return t;
491    }
492
493    @Override
494    protected T doBackward(T t) {
495      return t;
496    }
497
498    @Override
499    public IdentityConverter<T> reverse() {
500      return this;
501    }
502
503    @Override
504    <S> Converter<T, S> doAndThen(Converter<T, S> otherConverter) {
505      return checkNotNull(otherConverter, "otherConverter");
506    }
507
508    /*
509     * We *could* override convertAll() to return its input, but it's a rather pointless
510     * optimization and opened up a weird type-safety problem.
511     */
512
513    @Override
514    public String toString() {
515      return "Converter.identity()";
516    }
517
518    private Object readResolve() {
519      return INSTANCE;
520    }
521
522    private static final long serialVersionUID = 0L;
523  }
524}