Unit.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.util.Objects;

public abstract class Unit {
  private final UnaryFunction m_toBaseConverter;
  private final UnaryFunction m_fromBaseConverter;
 
  private final Unit m_baseUnit;
 
  private final String m_name;
  private final String m_symbol;
 
  private final Measure<?> m_zero;
  private final Measure<?> m_one;

  @SuppressWarnings("this-escape")
  protected Unit(
      Unit baseUnit,
      UnaryFunction toBaseConverter,
      UnaryFunction fromBaseConverter,
      String name,
      String symbol) {
    m_baseUnit = baseUnit == null ? this : baseUnit;
    m_toBaseConverter = Objects.requireNonNull(toBaseConverter);
    m_fromBaseConverter = Objects.requireNonNull(fromBaseConverter);
    m_name = Objects.requireNonNull(name);
    m_symbol = Objects.requireNonNull(symbol);
 
    m_zero = of(0);
    m_one = of(1);
  }

  protected Unit(Unit baseUnit, double baseUnitEquivalent, String name, String symbol) {
    this(baseUnit, x -> x * baseUnitEquivalent, x -> x / baseUnitEquivalent, name, symbol);
  }

  public abstract Measure<?> of(double magnitude);

  public abstract Measure<?> ofBaseUnits(double baseUnitMagnitude);

  public Measure<?> zero() {
    return m_zero;
  }

  public Measure<?> one() {
    return m_one;
  }

  public abstract Unit per(TimeUnit time);

  public Unit getBaseUnit() {
    return m_baseUnit;
  }

  public boolean isBaseUnit() {
    return this.equals(m_baseUnit);
  }

  public double fromBaseUnits(double valueInBaseUnits) {
    return m_fromBaseConverter.apply(valueInBaseUnits);
  }

  public double toBaseUnits(double valueInNativeUnits) {
    return m_toBaseConverter.apply(valueInNativeUnits);
  }

  public UnaryFunction getConverterToBase() {
    return m_toBaseConverter;
  }

  public UnaryFunction getConverterFromBase() {
    return m_fromBaseConverter;
  }

  public boolean equivalent(Unit other) {
    if (!getClass().equals(other.getClass())) {
      // different unit types, not compatible
      return false;
    }
 
    double arbitrary = 16_777.214; // 2^24 / 1e3
 
    return Math.abs(
                this.m_fromBaseConverter.apply(arbitrary)
                    - other.m_fromBaseConverter.apply(arbitrary))
            <= Measure.EQUIVALENCE_THRESHOLD
        && Math.abs(
                this.m_toBaseConverter.apply(arbitrary) - other.m_toBaseConverter.apply(arbitrary))
            <= Measure.EQUIVALENCE_THRESHOLD;
  }
 
  @Override
  public boolean equals(Object o) {
    return this == o
        || o instanceof Unit that
            && m_name.equals(that.m_name)
            && m_symbol.equals(that.m_symbol)
            && this.equivalent(that);
  }
 
  @Override
  public int hashCode() {
    return Objects.hash(m_toBaseConverter, m_fromBaseConverter, m_name, m_symbol);
  }

  public String name() {
    return m_name;
  }

  public String symbol() {
    return m_symbol;
  }
 
  @Override
  public String toString() {
    return name();
  }
}