Class Local

future-java/src/main/java/io/trane/future/Local.java:82–191

`Local`s are a mechanism similar to `ThreadLocal` but for asynchronous computations. It is not possible to use `ThreadLocal`s with `Future` because the data it holds become invalid when the computation reaches an asynchronous boundary. The thread returns to its thread pool to execute other computat

 *          the type of the local value.
 */
public final class Local<T> {

  protected static final Optional<?>[] EMPTY = new Optional<?>[0];
  private static ThreadLocal<Optional<?>[]> threadLocal = null;
  private static int size = 0;

  /**
   * Creates a new local value.
   * 
   * @param <T>  the type of the local value.
   * @return     the local value
   */
  public static final <T> Local<T> apply() {
    return new Local<>();
  }

  protected static final Optional<?>[] save() {
    if (threadLocal == null)
      return EMPTY;
    else {
      Optional<?>[] state = threadLocal.get();
      if (state == null)
        return EMPTY;
      else
        return state;
    }
  }

  protected static final void restore(final Optional<?>[] saved) {
    if (threadLocal != null)
      threadLocal.set(saved);
  }

  private static final synchronized int newPosition() {
    if (threadLocal == null)
      threadLocal = new ThreadLocal<>();
    return size++;
  }

  private final int position = newPosition();

  private Local() {
  }

  /**
   * Updates the local with the provided value.
   * 
   * @param value  value to set
   */
  public final void update(final T value) {
    set(Optional.of(value));
  }

  /**
   * Sets the value of the local. It's similar to update but receives an
   * optional value.
   * 
   * @param opt  optional value to set.