TypeSafe.java

package playground;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.UUID;

import javax.annotation.CheckReturnValue;

import org.eclipse.jdt.annotation.NonNull;

/**
 * Description: Helps avoiding common Java typing pitfalls. <br>
 * Keywords csv: typing, type safety, compile, compiler
 * 
 * <p>
 * NOTE: Use <code>Ctrl+Shift+G</code> on the pitfall method you want to find occurences (scroll down to your packages).
 * <p>
 * NOTE: Findbugs may also find some of these bugs.
 * 
 * @author croussy
 */
@CheckReturnValue
public final class TypeSafe<T> {
  private final T element;

  private TypeSafe(final T element) {
    // NOTE: assert not null is used to avoid late NullPointerExceptions.
    assert element != null;
    this.element = element;
  }

  /**
   * NEVER USE THIS METHOD, use {@link #equalsTyped(Object)} instead (shows Object due to type erasure) !
   * 
   * Overriding of equals for this class is meant to enforce the use of equalsTyped in case equals was used by mistake.
   */
  @Override
  @Deprecated
  public boolean equals(final Object other) {
    assert false;
    // Always break
    throw new IllegalArgumentException("Use equalsTyped instead of equals !");
  }

  /**
   * <p>
   * <code>new TypeSafe<String>(first).equalsTyped(second)</code>
   * <p>
   * NOTE: for Strings you can use the simpler {@link #equalsString(String, String)} method.
   * <p>
   * NOTE: Cannot be named equals because of type erasure.
   */
  @SuppressWarnings("null")
  public boolean equalsTyped(final @NonNull T other) {
    return element.equals(other);
  }

  @Override
  public int hashCode() {
    // Should not be used.
    assert false;
    return -1;
  }

  public static <T> TypeSafe<T> build(final T element) {
    return new TypeSafe<>(element);
  }

  public static <T> boolean collectionContains(final Collection<T> collection, final T element) {
    return collection.contains(element);
  }

  public static <T> boolean collectionContainsAll(final Collection<T> collection, final Collection<T> elements) {
    assert elements != null;
    return collection.containsAll(elements);
  }

  public static <T> boolean collectionIntersects(final Collection<T> collection, final Collection<T> elements) {
    assert collection != null;
    assert elements != null;
    // Make a copy to avoid side-effects.
    final HashSet<T> copy = new HashSet<T>(collection);
    copy.retainAll(elements);
    return !copy.isEmpty();
  }

  public static <T> boolean collectionRemove(final Collection<T> collection, final T element) {
    return collection.remove(element);
  }

  public static <T> boolean collectionRemoveAll(final Collection<T> collection, final Collection<T> elements) {
    assert elements != null;
    return collection.removeAll(elements);
  }

  public static <T> boolean collectionRetainAll(final Collection<T> collection, final Collection<T> elements) {
    assert elements != null;
    return collection.retainAll(elements);
  }

  /**
   * For types different from String use {@link #equalsTyped(String, String)}.
   */
  public static boolean equalsString(final String s1, final String s2) {
    return s1.equals(s2);
  }

  /**
   * Type-safe equals check for UUID for convenience.
   */
  public static boolean equalsUuid(final UUID u1, final UUID u2) {
    return u1.equals(u2);
  }

  public static <K, V> boolean mapContainsKey(final Map<K, V> map, final K key) {
    assert key != null;
    return map.containsKey(key);
  }

  public static <K, V> V mapGet(final Map<K, V> map, final K key) {
    assert key != null;
    return map.get(key);
  }

  public static <K, V> V mapGetExpectValueNotNull(final Map<K, V> map, final K key) {
    assert key != null;
    final V value = map.get(key);
    assert value != null;
    return value;
  }

  public static <K, V> V mapRemove(final Map<K, V> map, final K key) {
    assert key != null;
    return map.remove(key);
  }

  public static String simpleDateFormatDoFormat(final SimpleDateFormat sdf, final Date date) {
    assert sdf != null;
    assert date != null;
    // Incredible, but this can take and Object, thus needs to be protected.
    return sdf.format(date);
  }
  
  // Some examples:
  public static void main(final String[] args) {
    {
      final String bob = "Bob";
      final String tom = "Tom";
      bob.equals(tom);
      // Equals breaks typing by accepting an Integer !
      // bob.equals(1);
      TypeSafe.build(bob).equalsTyped(tom);
      // TypeSafe.build(bob).equalsTyped(1);
      // TypeSafe.build(bob).equals(1);
      TypeSafe.equalsString(bob, tom);
    }
    {
      final Collection<String> collection = new ArrayList<>();
      TypeSafe.collectionContains(collection, "bob");
    }
    {
      final Map<String, Integer> map = new HashMap<>();
      TypeSafe.mapGet(map, "");
      TypeSafe.mapContainsKey(map, "");
    }
  }
}