All Downloads are FREE. Search and download functionalities are using the official Maven repository.

akka.japi.pf.UnitPFBuilder Maven / Gradle / Ivy

Go to download 

/*
 * Copyright (C) 2009-2020 Lightbend Inc. 
 */

package akka.japi.pf;

import scala.runtime.BoxedUnit;

/**
 * A builder for {@link scala.PartialFunction}. This is a specialized version of {@link PFBuilder}
 * to map java void methods to {@link scala.runtime.BoxedUnit}.
 *
 * @param  the input type, that this PartialFunction to be applied to
 */
public final class UnitPFBuilder extends AbstractPFBuilder {

  /** Create a UnitPFBuilder. */
  public UnitPFBuilder() {}

  /**
   * Add a new case statement to this builder.
   *
   * @param type a type to match the argument against
   * @param apply an action to apply to the argument if the type matches
   * @return a builder with the case statement added
   */
  public 
 UnitPFBuilder match(final Class
 type, final FI.UnitApply
 apply) {
    return matchUnchecked(type, apply);
  }

  /**
   * Add a new case statement to this builder without compile time type check. Should normally not
   * be used, but when matching on class with generic type argument it can be useful, e.g. 
   * List.class and (List<String> list) -> {}.
   *
   * @param type a type to match the argument against
   * @param apply an action to apply to the argument if the type matches
   * @return a builder with the case statement added
   */
  @SuppressWarnings("unchecked")
  public UnitPFBuilder matchUnchecked(final Class type, final FI.UnitApply apply) {

    FI.Predicate predicate =
        new FI.Predicate() {
          @Override
          public boolean defined(Object o) {
            return type.isInstance(o);
          }
        };

    addStatement(new UnitCaseStatement(predicate, (FI.UnitApply) apply));

    return this;
  }

  /**
   * Add a new case statement to this builder.
   *
   * @param type a type to match the argument against
   * @param predicate a predicate that will be evaluated on the argument if the type matches
   * @param apply an action to apply to the argument if the type matches and the predicate returns
   *     true
   * @return a builder with the case statement added
   */
  public 
 UnitPFBuilder match(
      final Class
 type, final FI.TypedPredicate
 predicate, final FI.UnitApply
 apply) {
    return matchUnchecked(type, predicate, apply);
  }

  /**
   * Add a new case statement to this builder without compile time type check. Should normally not
   * be used, but when matching on class with generic type argument it can be useful, e.g. 
   * List.class and (List<String> list) -> {}.
   *
   * @param type a type to match the argument against
   * @param predicate a predicate that will be evaluated on the argument if the type matches
   * @param apply an action to apply to the argument if the type matches and the predicate returns
   *     true
   * @return a builder with the case statement added
   */
  @SuppressWarnings("unchecked")
  public UnitPFBuilder matchUnchecked(
      final Class type, final FI.TypedPredicate predicate, final FI.UnitApply apply) {
    FI.Predicate fiPredicate =
        new FI.Predicate() {
          @Override
          public boolean defined(Object o) {
            if (!type.isInstance(o)) return false;
            else {
              return ((FI.TypedPredicate) predicate).defined(o);
            }
          }
        };

    addStatement(new UnitCaseStatement(fiPredicate, (FI.UnitApply) apply));

    return this;
  }

  /**
   * Add a new case statement to this builder.
   *
   * @param object the object to compare equals with
   * @param apply an action to apply to the argument if the object compares equal
   * @return a builder with the case statement added
   */
  public 
 UnitPFBuilder matchEquals(final P object, final FI.UnitApply
 apply) {
    addStatement(
        new UnitCaseStatement(
            new FI.Predicate() {
              @Override
              public boolean defined(Object o) {
                return object.equals(o);
              }
            },
            apply));
    return this;
  }

  /**
   * Add a new case statement to this builder.
   *
   * @param object the object to compare equals with
   * @param predicate a predicate that will be evaluated on the argument if the object compares
   *     equal
   * @param apply an action to apply to the argument if the object compares equal
   * @return a builder with the case statement added
   */
  public 
 UnitPFBuilder matchEquals(
      final P object, final FI.TypedPredicate
 predicate, final FI.UnitApply
 apply) {
    addStatement(
        new UnitCaseStatement(
            new FI.Predicate() {
              @Override
              public boolean defined(Object o) {
                if (!object.equals(o)) return false;
                else {
                  @SuppressWarnings("unchecked")
                  P p = (P) o;
                  return predicate.defined(p);
                }
              }
            },
            apply));
    return this;
  }

  /**
   * Add a new case statement to this builder, that matches any argument.
   *
   * @param apply an action to apply to the argument
   * @return a builder with the case statement added
   */
  public UnitPFBuilder matchAny(final FI.UnitApply apply) {
    addStatement(
        new UnitCaseStatement(
            new FI.Predicate() {
              @Override
              public boolean defined(Object o) {
                return true;
              }
            },
            apply));
    return this;
  }
}
 















© 2015 - 2024 Weber Informatics LLC | Privacy Policy