FrequencyFormatter.java
/*
* Copyright (C) 2018 Alberto Irurueta Carro (alberto@irurueta.com)
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.irurueta.units;
import java.text.ParseException;
import java.util.Locale;
/**
* Formats and parses frequency value and unit.
*/
public class FrequencyFormatter extends MeasureFormatter<Frequency, FrequencyUnit> {
/**
* Hertz symbol.
*/
public static final String HERTZ = "Hz";
/**
* KiloHertz symbol.
*/
public static final String KILOHERTZ = "KHz";
/**
* MegaHertz symbol.
*/
public static final String MEGAHERTZ = "MHz";
/**
* GigaHertz symbol.
*/
public static final String GIGAHERTZ = "GHz";
/**
* TeraHertz symbol.
*/
public static final String TERAHERTZ = "THz";
/**
* Constructor.
*/
public FrequencyFormatter() {
super();
}
/**
* Constructor with locale.
*
* @param locale locale.
* @throws IllegalArgumentException if locale is null.
*/
public FrequencyFormatter(final Locale locale) {
super(locale);
}
/**
* Copy constructor.
*
* @param formatter input instance to copy from.
* @throws NullPointerException if provided formatter is null.
*/
public FrequencyFormatter(final FrequencyFormatter formatter) {
this(formatter.getLocale());
}
/**
* Determines if two frequency formatters are equal by comparing all of their
* internal parameters.
*
* @param obj another object to compare.
* @return true if provided object is assumed to be equal to this instance.
*/
@Override
public boolean equals(final Object obj) {
final var equals = super.equals(obj);
return (obj instanceof FrequencyFormatter) && equals;
}
/**
* Hash code generated for this instance.
* Hash codes can be internally used by some collections to coarsely compare objects.
* This implementation only calls parent implementation to avoid static analyzer warning.
*
* @return hash code.
*/
@Override
public int hashCode() {
return super.hashCode();
}
/**
* Gets unit system for detected unit into provided string representation
* of a measurement.
*
* @param source a measurement string representation to be checked.
* @return a unit system (either metric or imperial) or null if unit
* cannot be determined.
*/
@Override
public UnitSystem getUnitSystem(final String source) {
return UnitSystem.METRIC;
}
/**
* Parses provided string and tries to determine a frequency value and unit.
*
* @param source a string to be parsed.
* @return a frequency containing a value and unit.
* @throws ParseException if provided string cannot be parsed.
* @throws UnknownUnitException if unit cannot be determined.
*/
@Override
public Frequency parse(final String source) throws ParseException, UnknownUnitException {
return internalParse(source, new Frequency());
}
/**
* Attempts to determine a frequency unit within a frequency string
* representation.
*
* @param source a frequency measurement string representation.
* @return a frequency unit, or null if none can be determined.
*/
@Override
public FrequencyUnit findUnit(final String source) {
if (source.contains(KILOHERTZ + " ") || source.endsWith(KILOHERTZ)) {
return FrequencyUnit.KILOHERTZ;
}
if (source.contains(MEGAHERTZ + " ") || source.endsWith(MEGAHERTZ)) {
return FrequencyUnit.MEGAHERTZ;
}
if (source.contains(GIGAHERTZ + " ") || source.endsWith(GIGAHERTZ)) {
return FrequencyUnit.GIGAHERTZ;
}
if (source.contains(TERAHERTZ + " ") || source.endsWith(TERAHERTZ)) {
return FrequencyUnit.TERAHERTZ;
}
if (source.contains(HERTZ + " ") || source.endsWith(HERTZ)) {
return FrequencyUnit.HERTZ;
}
return null;
}
/**
* Formats and converts provided frequency value and unit using provided unit
* system.
* If provided value is too large for provided unit, this method will convert
* it to a more appropriate unit. This implementation ignores unit system.
*
* @param value a measurement value.
* @param unit a measurement unit.
* @param system system unit to convert measurement to (it is ignored).
* @return a string representation of frequency value and unit.
*/
@Override
public String formatAndConvert(final Number value, final FrequencyUnit unit, final UnitSystem system) {
return formatAndConvertMetric(value, unit);
}
/**
* Formats and converts provided frequency value and unit using metric unit
* system.
* If provided frequency value is too large for provided frequency unit, this
* method will convert it to a more appropriate unit.
*
* @param value a frequency value.
* @param unit a frequency unit.
* @return a string representation of frequency value and unit using metric
* unit system.
*/
public String formatAndConvertMetric(final Number value, final FrequencyUnit unit) {
final var v = value.doubleValue();
final var hertz = FrequencyConverter.convert(v, unit, FrequencyUnit.HERTZ);
if (Math.abs(hertz) < FrequencyConverter.HERTZS_PER_KILOHERTZ) {
return format(hertz, FrequencyUnit.HERTZ);
}
final var kiloHertz = FrequencyConverter.convert(v, unit, FrequencyUnit.KILOHERTZ);
if (Math.abs(kiloHertz) < (FrequencyConverter.HERTZ_PER_MEGAHERTZ / FrequencyConverter.HERTZS_PER_KILOHERTZ)) {
return format(kiloHertz, FrequencyUnit.KILOHERTZ);
}
final var megaHertz = FrequencyConverter.convert(v, unit, FrequencyUnit.MEGAHERTZ);
if (Math.abs(megaHertz) < (FrequencyConverter.HERTZ_PER_GIGAHERTZ / FrequencyConverter.HERTZ_PER_MEGAHERTZ)) {
return format(megaHertz, FrequencyUnit.MEGAHERTZ);
}
final var gigaHertz = FrequencyConverter.convert(v, unit, FrequencyUnit.GIGAHERTZ);
if (Math.abs(gigaHertz) < (FrequencyConverter.HERTZ_PER_TERAHERTZ / FrequencyConverter.HERTZ_PER_GIGAHERTZ)) {
return format(gigaHertz, FrequencyUnit.GIGAHERTZ);
}
final var teraHertz = FrequencyConverter.convert(v, unit, FrequencyUnit.TERAHERTZ);
return format(teraHertz, FrequencyUnit.TERAHERTZ);
}
/**
* Returns unit string representation.
*
* @param unit a frequency unit.
* @return its string representation
*/
@SuppressWarnings("DuplicatedCode")
@Override
public String getUnitSymbol(final FrequencyUnit unit) {
return switch (unit) {
case KILOHERTZ -> KILOHERTZ;
case MEGAHERTZ -> MEGAHERTZ;
case GIGAHERTZ -> GIGAHERTZ;
case TERAHERTZ -> TERAHERTZ;
default -> HERTZ;
};
}
/**
* Returns unit system this instance will use based on its assigned locale.
* Notice that if no locale was assigned, then the default system locale
* will be used.
*
* @return unit system this instance will use.
*/
@Override
public UnitSystem getUnitSystem() {
return UnitSystem.METRIC;
}
}