com.github.tonivade.purefun.Pattern2 Maven / Gradle / Ivy

Go to download
/*
 * Copyright (c) 2018-2019, Antonio Gabriel Muñoz Conejo 
 * Distributed under the terms of the MIT License
 */
package com.github.tonivade.purefun;

import static com.github.tonivade.purefun.Matcher2.invalid;
import static java.util.Objects.requireNonNull;

public class Pattern2 implements PartialFunction2 {

  private final Pattern1, R> pattern;

  private Pattern2() {
    this(Pattern1.build());
  }

  private Pattern2(Pattern1, R> pattern) {
    this.pattern = requireNonNull(pattern);
  }

  @Override
  public boolean isDefinedAt(A a, B b) {
    return pattern.isDefinedAt(Tuple.of(a, b));
  }

  @Override
  public R apply(A a, B b) {
    return pattern.apply(Tuple.of(a, b));
  }

  public static  Pattern2 build() {
    return new Pattern2<>();
  }

  public CaseBuilder2, A, B, R> when(Matcher2 matcher) {
    return new CaseBuilder2<>(this::add).when(matcher);
  }

  public CaseBuilder2, A, B, R> otherwise() {
    return new CaseBuilder2<>(this::add).when(Matcher2.otherwise());
  }

  private Pattern2 add(Matcher2 matcher, Function2 handler) {
    return new Pattern2<>(pattern.add(matcher.tupled(), handler.tupled()));
  }

  public final static class CaseBuilder2 {

    private final Function2, Function2, B> finisher;
    private final Matcher2 matcher;

    private CaseBuilder2(Function2, Function2, B> finisher) {
      this.finisher = requireNonNull(finisher);
      this.matcher = invalid();
    }

    private CaseBuilder2(Function2, Function2, B> finisher, Matcher2 matcher) {
      this.finisher = requireNonNull(finisher);
      this.matcher = requireNonNull(matcher);
    }

    public CaseBuilder2 when(Matcher2 matcher) {
      return new CaseBuilder2<>(finisher, matcher);
    }

    public B then(Function2 handler) {
      return finisher.apply(matcher, handler);
    }

    public B returns(R value) {
      return then((a, b) -> value);
    }
  }
}