change name from Length to more general Distance

second-concept/src/main/java/com/synerset/unitsystem/distance/Distance.java

@@ -0,0 +1,122 @@
+package com.synerset.unitsystem.distance;
+
+import com.synerset.unitsystem.PhysicalQuantity;
+import com.synerset.unitsystem.Unit;
+import com.synerset.unitsystem.utils.ValueFormatter;
+
+import java.util.Objects;
+
+public final class Distance implements PhysicalQuantity<Distance> {
+
+    public static final byte TO_STRING_PRECISION = 3;
+    private final double value;
+    private final Unit<Distance> unit;
+
+    private Distance(double value, Unit<Distance> unit) {
+        this.value = value;
+        this.unit = unit;
+    }
+
+    @Override
+    public double getValue() {
+        return value;
+    }
+
+    @Override
+    public Unit<Distance> getUnit() {
+        return unit;
+    }
+
+    @Override
+    public Distance toBaseUnit() {
+        double valueInMeters = unit.toBaseUnit(value);
+        return Distance.of(valueInMeters, DistanceUnits.METER);
+    }
+
+    @Override
+    public Distance toUnit(Unit<Distance> targetUnit) {
+        double valueInMeters = unit.toBaseUnit(value);
+        double valueInTargetUnit = targetUnit.fromBaseToThisUnit(valueInMeters);
+        return Distance.of(valueInTargetUnit, targetUnit);
+    }
+
+    // Custom converter methods for most popular units
+    public Distance toMeter(){
+        return toUnit(DistanceUnits.METER);
+    }
+
+    public Distance toCentimeter(){
+        return toUnit(DistanceUnits.CENTIMETER);
+    }
+
+    public Distance toMillimeter(){
+        return toUnit(DistanceUnits.MILLIMETER);
+    }
+
+    public Distance toKilometer(){
+        return toUnit(DistanceUnits.KILOMETER);
+    }
+
+    public Distance toMile(){
+        return toUnit(DistanceUnits.MILE);
+    }
+
+    public Distance toFeet(){
+        return toUnit(DistanceUnits.FEET);
+    }
+
+    public Distance toInch(){
+        return toUnit(DistanceUnits.INCH);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Distance distance = (Distance) o;
+        return Double.compare(distance.value, value) == 0 && unit.equals(distance.unit);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(value, unit);
+    }
+
+    @Override
+    public String toString() {
+        return ValueFormatter.formatDoubleToRelevantPrecision(value, TO_STRING_PRECISION) + " " + unit.getSymbol();
+    }
+
+    public static Distance of(double value, Unit<Distance> unit) {
+        return new Distance(value, unit);
+    }
+
+    public static Distance ofMeters(double value) {
+        return new Distance(value, DistanceUnits.METER);
+    }
+
+    public static Distance ofCentimeters(double value) {
+        return new Distance(value, DistanceUnits.CENTIMETER);
+    }
+
+    public static Distance ofMillimeters(double value) {
+        return new Distance(value, DistanceUnits.MILLIMETER);
+    }
+
+    public static Distance ofKilometers(double value) {
+        return new Distance(value, DistanceUnits.KILOMETER);
+    }
+
+    public static Distance ofMiles(double value) {
+        return new Distance(value, DistanceUnits.MILE);
+    }
+
+    public static Distance ofFeet(double value) {
+        return new Distance(value, DistanceUnits.FEET);
+    }
+
+    public static Distance ofInches(double value) {
+        return new Distance(value, DistanceUnits.INCH);
+    }
+
+}

second-concept/src/main/java/com/synerset/unitsystem/length/LengthUnits.java → second-concept/src/main/java/com/synerset/unitsystem/distance/DistanceUnits.java

@@ -1,10 +1,10 @@
-package com.synerset.unitsystem.length;
+package com.synerset.unitsystem.distance;
 
 import com.synerset.unitsystem.Unit;
 
 import java.util.function.DoubleUnaryOperator;
 
-public enum LengthUnits implements Unit<Length> {
+public enum DistanceUnits implements Unit<Distance> {
 
     METER("m", val -> val, val -> val),
     CENTIMETER("cm", val -> val / 100, val -> val * 100),
@@ -18,7 +18,7 @@ public enum LengthUnits implements Unit<Length> {
     private final DoubleUnaryOperator toBaseConverter;
     private final DoubleUnaryOperator fromBaseToUnitConverter;
 
-    LengthUnits(String symbol, DoubleUnaryOperator toBaseConverter, DoubleUnaryOperator fromBaseToUnitConverter) {
+    DistanceUnits(String symbol, DoubleUnaryOperator toBaseConverter, DoubleUnaryOperator fromBaseToUnitConverter) {
         this.symbol = symbol;
         this.toBaseConverter = toBaseConverter;
         this.fromBaseToUnitConverter = fromBaseToUnitConverter;
@@ -30,7 +30,7 @@ public String getSymbol() {
     }
 
     @Override
-    public Unit<Length> getBaseUnit() {
+    public Unit<Distance> getBaseUnit() {
         return METER;
     }
 

second-concept/src/test/java/com/synerset/unitsystem/distance/DistanceTest.java

@@ -0,0 +1,108 @@
+package com.synerset.unitsystem.distance;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class DistanceTest {
+
+    @Test
+    @DisplayName("should convert to m from mm and vice versa")
+    public void shouldProperlyConvertToMetersFromMillimeters() {
+        // Given
+        Distance initialDistanceInMillimeters = Distance.ofMillimeters(1000.0);
+
+        // When
+        Distance actualInMeters = initialDistanceInMillimeters.toBaseUnit();
+        Distance actualInMillimeters = actualInMeters.toUnit(DistanceUnits.MILLIMETER);
+
+        // Then
+        Distance expectedInMeters = Distance.ofMeters(1.0);
+        assertThat(actualInMeters).isEqualTo(expectedInMeters);
+        assertThat(actualInMillimeters).isEqualTo(initialDistanceInMillimeters);
+    }
+
+    @Test
+    @DisplayName("should convert to m from cm and vice versa")
+    public void shouldProperlyConvertToMetersFromCentimeters() {
+        // Given
+        Distance initialDistanceInCentimeters = Distance.ofCentimeters(100.0);
+
+        // When
+        Distance actualInMeters = initialDistanceInCentimeters.toBaseUnit();
+        Distance actualInCentimeters = actualInMeters.toUnit(DistanceUnits.CENTIMETER);
+
+        // Then
+        Distance expectedInMeters = Distance.ofMeters(1.0);
+        assertThat(actualInMeters).isEqualTo(expectedInMeters);
+        assertThat(actualInCentimeters).isEqualTo(initialDistanceInCentimeters);
+    }
+
+    @Test
+    @DisplayName("should convert to m from km and vice versa")
+    public void shouldProperlyConvertToMetersFromKilometers() {
+        // Given
+        Distance initialDistanceInKilometers = Distance.ofKilometers(1.0);
+
+        // When
+        Distance actualInMeters = initialDistanceInKilometers.toBaseUnit();
+        Distance actualInKilometers = actualInMeters.toUnit(DistanceUnits.KILOMETER);
+
+        // Then
+        Distance expectedInMeters = Distance.ofMeters(1000.0);
+        assertThat(actualInMeters).isEqualTo(expectedInMeters);
+        assertThat(actualInKilometers).isEqualTo(initialDistanceInKilometers);
+    }
+
+    @Test
+    @DisplayName("should convert to m from mi and vice versa")
+    public void shouldProperlyConvertToMetersFromMile() {
+        // Given
+        Distance initialDistanceInMiles = Distance.ofMiles(1.0);
+
+        // When
+        Distance actualInMeters = initialDistanceInMiles.toBaseUnit();
+        Distance actualInMiles = actualInMeters.toUnit(DistanceUnits.MILE);
+
+        // Then
+        Distance expectedInMeters = Distance.ofMeters(1609.344);
+        assertThat(actualInMeters).isEqualTo(expectedInMeters);
+        assertThat(actualInMiles).isEqualTo(initialDistanceInMiles);
+    }
+
+    @Test
+    @DisplayName("should convert to m from ft and vice versa")
+    public void shouldProperlyConvertToMetersFromFeet() {
+        // Given
+        Distance initialDistanceInFeet = Distance.ofFeet(10.0);
+
+        // When
+        Distance actualInMeters = initialDistanceInFeet.toBaseUnit();
+        Distance actualInFeet = actualInMeters.toUnit(DistanceUnits.FEET);
+
+        // Then
+        Distance expectedInMeters = Distance.ofMeters(3.048);
+        assertThat(actualInMeters).isEqualTo(expectedInMeters);
+        assertThat(actualInFeet).isEqualTo(initialDistanceInFeet);
+    }
+
+    @Test
+    @DisplayName("should convert to m from ft and vice versa")
+    public void shouldProperlyConvertToMetersFromInch() {
+        // Given
+        Distance initialDistanceInInch = Distance.ofInches(10.0);
+
+        // When
+        Distance actualInMeters = initialDistanceInInch.toBaseUnit();
+        Distance actualInInch = actualInMeters.toUnit(DistanceUnits.INCH);
+
+        // Then
+        Distance expectedInMeters = Distance.ofMeters(0.254);
+        assertThat(actualInMeters).isEqualTo(expectedInMeters);
+        assertThat(actualInInch).isEqualTo(initialDistanceInInch);
+    }
+
+
+
+}