UnitBuilder.java

// Copyright (c) FIRST and other WPILib contributors.
// Open Source Software; you can modify and/or share it under the terms of
// the WPILib BSD license file in the root directory of this project.
 
package org.wpilib.units;
 
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.Objects;

public final class UnitBuilder<U extends Unit> {
  private final U m_base;
  private UnaryFunction m_fromBase = UnaryFunction.IDENTITY;
  private UnaryFunction m_toBase = UnaryFunction.IDENTITY;
  private String m_name;
  private String m_symbol;

  public UnitBuilder(U base) {
    this.m_base = Objects.requireNonNull(base, "Base unit cannot be null");
  }

  public UnitBuilder<U> offset(double offset) {
    m_toBase = derivedValue -> derivedValue + offset;
    m_fromBase = baseValue -> baseValue - offset;
    return this;
  }

  // NOTE: This method lives here instead of in MappingBuilder because inner classes can't
  // define static methods prior to Java 16.
  private static double mapValue(
      double value, double inMin, double inMax, double outMin, double outMax) {
    return (value - inMin) * (outMax - outMin) / (inMax - inMin) + outMin;
  }

  public final class MappingBuilder {
    private final double m_minInput;
    private final double m_maxInput;
 
    private MappingBuilder(double minInput, double maxInput) {
      this.m_minInput = minInput;
      this.m_maxInput = maxInput;
    }

    public UnitBuilder<U> toOutputRange(double minOutput, double maxOutput) {
      UnitBuilder.this.m_fromBase = x -> mapValue(x, m_minInput, m_maxInput, minOutput, maxOutput);
      UnitBuilder.this.m_toBase = y -> mapValue(y, minOutput, maxOutput, m_minInput, m_maxInput);
      return UnitBuilder.this;
    }
  }

  public MappingBuilder mappingInputRange(double minBase, double maxBase) {
    return new MappingBuilder(minBase, maxBase);
  }

  public UnitBuilder<U> fromBase(UnaryFunction fromBase) {
    this.m_fromBase = Objects.requireNonNull(fromBase, "fromBase function cannot be null");
    return this;
  }

  public UnitBuilder<U> toBase(UnaryFunction toBase) {
    this.m_toBase = Objects.requireNonNull(toBase, "toBase function cannot be null");
    return this;
  }

  public UnitBuilder<U> named(String name) {
    this.m_name = name;
    return this;
  }

  public UnitBuilder<U> symbol(String symbol) {
    this.m_symbol = symbol;
    return this;
  }

  public UnitBuilder<U> splitInto(double fraction) {
    if (fraction == 0) {
      throw new IllegalArgumentException("Fraction must be nonzero");
    }
 
    return toBase(x -> x / fraction).fromBase(b -> b * fraction);
  }

  public UnitBuilder<U> aggregate(double aggregation) {
    if (aggregation == 0) {
      throw new IllegalArgumentException("Aggregation amount must be nonzero");
    }
 
    return toBase(x -> x * aggregation).fromBase(b -> b / aggregation);
  }

  @FunctionalInterface
  public interface UnitConstructorFunction<U extends Unit> {
    U create(
        U baseUnit,
        UnaryFunction toBaseUnits,
        UnaryFunction fromBaseUnits,
        String name,
        String symbol);
  }

  @SuppressWarnings("unchecked")
  public U make(UnitConstructorFunction<U> constructor) {
    Objects.requireNonNull(m_fromBase, "fromBase function was not set");
    Objects.requireNonNull(m_toBase, "toBase function was not set");
    Objects.requireNonNull(m_name, "new unit name was not set");
    Objects.requireNonNull(m_symbol, "new unit symbol was not set");
 
    return constructor.create(
        (U) m_base.getBaseUnit(),
        m_toBase.pipeTo(m_base.getConverterToBase()),
        m_base.getConverterFromBase().pipeTo(m_fromBase),
        m_name,
        m_symbol);
  }

  public U make() {
    return make(
        (baseUnit, toBaseUnits, fromBaseUnits, name, symbol) -> {
          var baseClass = baseUnit.getClass();
 
          try {
            var ctor = getConstructor(baseUnit);
 
            return ctor.newInstance(baseUnit, toBaseUnits, fromBaseUnits, name, symbol);
          } catch (InstantiationException e) {
            throw new RuntimeException("Could not instantiate class " + baseClass.getName(), e);
          } catch (IllegalAccessException e) {
            throw new RuntimeException("Could not access constructor", e);
          } catch (InvocationTargetException e) {
            throw new RuntimeException(
                "Constructing " + baseClass.getName() + " raised an exception", e);
          } catch (NoSuchMethodException e) {
            throw new RuntimeException(
                "No compatible constructor "
                    + baseClass.getSimpleName()
                    + "("
                    + baseClass.getSimpleName()
                    + ", UnaryFunction, UnaryFunction, String, String)",
                e);
          }
        });
  }
 
  @SuppressWarnings({"unchecked", "PMD.AvoidAccessibilityAlteration"})
  private static <U extends Unit> Constructor<? extends U> getConstructor(U baseUnit)
      throws NoSuchMethodException {
    var baseClass = baseUnit.getClass();
 
    var ctor =
        baseClass.getDeclaredConstructor(
            baseClass, // baseUnit
            UnaryFunction.class, // toBaseUnits
            UnaryFunction.class, // fromBaseUnits
            String.class, // name
            String.class); // symbol
 
    // need to flag the constructor as accessible so we can use private, package-private,
    // and protected constructors
    ctor.setAccessible(true);
 
    return (Constructor<? extends U>) ctor;
  }
}