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

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

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

public class Pattern3 implements PartialFunction3 {

  private final Pattern1, R> pattern;

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

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

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

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

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

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

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

  private Pattern3 add(Matcher3 matcher, Function3 handler) {
    return new Pattern3<>(pattern.add(matcher.tupled(), handler.tupled()));
  }

  public static final class CaseBuilder3 {

    private final Function2, Function3, B> finisher;
    private final Matcher3 matcher;

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

    private CaseBuilder3(Function2, Function3, B> finisher, Matcher3 matcher) {
      this.finisher = requireNonNull(finisher);
      this.matcher = requireNonNull(matcher);
    }

    public CaseBuilder3 when(Matcher3 matcher) {
      return new CaseBuilder3<>(finisher, matcher);
    }

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

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