/** * Copyright (C) 2014-2020 Philip Helger (www.helger.com) * philip[at]helger[dot]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.helger.commons.string; import java.math.BigDecimal; import java.math.BigInteger; import java.math.RoundingMode; import javax.annotation.Nonnegative; import javax.annotation.Nonnull; import javax.annotation.Nullable; import javax.annotation.concurrent.Immutable; import com.helger.commons.ValueEnforcer; import com.helger.commons.annotation.Nonempty; import com.helger.commons.annotation.PresentForCodeCoverage; /** * This class contains the methods to parse String objects to numeric values. * Before v3.7.0 this was contained in class {@link StringHelper}. * * @author Philip Helger */ @Immutable public final class StringParser { /** The default radix used to convert string values to numeric values */ public static final int DEFAULT_RADIX = 10; @PresentForCodeCoverage private static final StringParser s_aInstance = new StringParser (); private StringParser () {} /** * Get the unified decimal string for parsing by the runtime library. This is * done by replacing ',' with '.'. * * @param sStr * The string to unified. Never <code>null</code>. * @return Never <code>null</code>. */ @Nonnull @Nonempty private static String _getUnifiedDecimal (@Nonnull @Nonempty final String sStr) { return StringHelper.replaceAll (sStr, ',', '.'); } // ---[boolean]--- /** * Try to interpret the passed object as boolean. This works only if the * passed object is either a {@link String} or a {@link Boolean}. * * @param aObject * The object to be interpreted. May be <code>null</code>. * @return <code>false</code> if the passed object cannot be interpreted as a * boolean. */ public static boolean parseBool (@Nullable final Object aObject) { return parseBool (aObject, false); } /** * Try to interpret the passed object as boolean. This works only if the * passed object is either a {@link String} or a {@link Boolean}. * * @param aObject * The object to be interpreted. May be <code>null</code>. * @param bDefault * The default value to be returned, if the object cannot be * interpreted. * @return The boolean representation or the default value if the passed * object cannot be interpreted as a boolean. */ public static boolean parseBool (@Nullable final Object aObject, final boolean bDefault) { if (aObject instanceof Boolean) return ((Boolean) aObject).booleanValue (); if (aObject instanceof String) return parseBool ((String) aObject); return bDefault; } /** * Parse the given {@link String} as boolean value. All values that are equal * to "true" (ignoring case) will result in <code>true</code> return values. * All other values result in <code>false</code> return values. This method is * equal to {@link Boolean#parseBoolean(String)} * * @param sStr * The string to be interpreted. May be <code>null</code>. * @return <code>true</code> if the passed string matches "true" (ignoring * case), <code>false</code> otherwise. * @see Boolean#parseBoolean(String) */ public static boolean parseBool (@Nullable final String sStr) { return Boolean.parseBoolean (sStr); } /** * Parse the given {@link String} as boolean value. All values that are equal * to "true" (ignoring case) will result in <code>true</code> return values. * All values that are equal to "false" (ignoring case) will result in * <code>false</code> return values. All other values will return the default. * * @param sStr * The string to be interpreted. May be <code>null</code>. * @param bDefault * The default value to be returned if the passed string is neither * "true" nor "false". * @return <code>true</code> or <code>false</code> :) */ public static boolean parseBool (@Nullable final String sStr, final boolean bDefault) { // Do we need to start thinking at all? if (sStr != null && sStr.length () > 0) { // Is it true? if (sStr.equalsIgnoreCase ("true")) return true; // Is it false? if (sStr.equalsIgnoreCase ("false")) return false; } // Neither true nor false return bDefault; } /** * Try to interpret the passed object as boolean. This works only if the * passed object is either a {@link String} or a {@link Boolean}. * * @param aObject * The object to be interpreted. May be <code>null</code>. * @return <code>null</code> if the passed object cannot be interpreted as a * boolean, any other {@link Boolean} otherwise. */ @Nullable public static Boolean parseBoolObj (@Nullable final Object aObject) { return parseBoolObj (aObject, null); } /** * Try to interpret the passed {@link Object} as {@link Boolean}. * * @param aObject * The object to be interpreted. May be <code>null</code>. * @param aDefault * The default value to be returned, if the passed object is * <code>null</code>. * @return The passed default value if the passed object is <code>null</code>, * the matching {@link Boolean} otherwise. */ @Nullable public static Boolean parseBoolObj (@Nullable final Object aObject, @Nullable final Boolean aDefault) { return aObject == null ? aDefault : parseBoolObj (aObject.toString ()); } /** * Returns a <code>Boolean</code> with a value represented by the specified * string. The <code>Boolean</code> returned represents a <code>true</code> * value if the string argument is not <code>null</code> and is equal, * ignoring case, to the string {@code "true"}. This method is equal to * {@link Boolean#valueOf(String)} * * @param sStr * The string to be parsed. May be <code>null</code>. * @return the <code>Boolean</code> value represented by the string. Never * <code>null</code>. */ @Nonnull public static Boolean parseBoolObj (@Nullable final String sStr) { return Boolean.valueOf (sStr); } /** * Returns a <code>Boolean</code> with a value represented by the specified * string. The <code>Boolean</code> returned represents a <code>true</code> * value if the string argument is not <code>null</code> and is equal, * ignoring case, to the string {@code "true"}, and it will return * <code>false</code> if the string argument is not <code>null</code> and is * equal, ignoring case, to the string {@code "false"}. In all other cases * <code>null</code> is returned. * * @param sStr * The string to be parsed. May be <code>null</code>. * @return the <code>Boolean</code> value represented by the string. Never * <code>null</code>. */ @Nullable public static Boolean parseBoolObjExact (@Nullable final String sStr) { return parseBoolObjExact (sStr, null); } /** * Returns a <code>Boolean</code> with a value represented by the specified * string. The <code>Boolean</code> returned represents a <code>true</code> * value if the string argument is not <code>null</code> and is equal, * ignoring case, to the string {@code "true"}, and it will return * <code>false</code> if the string argument is not <code>null</code> and is * equal, ignoring case, to the string {@code "false"}. In all other cases * <code>aDefault</code> is returned. * * @param sStr * The string to be parsed. May be <code>null</code>. * @param aDefault * The default value to be returned if the value is neither "true" nor * "false". May be <code>null</code>. * @return the <code>Boolean</code> value represented by the string. Never * <code>null</code>. */ @Nullable public static Boolean parseBoolObjExact (@Nullable final String sStr, @Nullable final Boolean aDefault) { if (Boolean.TRUE.toString ().equalsIgnoreCase (sStr)) return Boolean.TRUE; if (Boolean.FALSE.toString ().equalsIgnoreCase (sStr)) return Boolean.FALSE; return aDefault; } // ---[byte]--- /** * Parse the given {@link Object} as byte with radix {@value #DEFAULT_RADIX}. * * @param aObject * The Object to parse. May be <code>null</code>. * @param nDefault * The default value to be returned if the passed object could not be * converted to a valid value. * @return The default value if the string does not represent a valid value. */ public static byte parseByte (@Nullable final Object aObject, final byte nDefault) { return parseByte (aObject, DEFAULT_RADIX, nDefault); } /** * Parse the given {@link Object} as byte with the specified radix. * * @param aObject * The Object to parse. May be <code>null</code>. * @param nRadix * The radix to use. Must be ≥ {@link Character#MIN_RADIX} and ≤ * {@link Character#MAX_RADIX}. * @param nDefault * The default value to be returned if the passed object could not be * converted to a valid value. * @return The default value if the string does not represent a valid value. */ public static byte parseByte (@Nullable final Object aObject, @Nonnegative final int nRadix, final byte nDefault) { if (aObject == null) return nDefault; if (aObject instanceof Number) return ((Number) aObject).byteValue (); return parseByte (aObject.toString (), nRadix, nDefault); } /** * Parse the given {@link String} as byte with radix {@value #DEFAULT_RADIX}. * * @param sStr * The String to parse. May be <code>null</code>. * @param nDefault * The value to be returned if the string cannot be converted to a * valid value. * @return The passed default parameter if the string does not represent a * valid value. */ public static byte parseByte (@Nullable final String sStr, final byte nDefault) { return parseByte (sStr, DEFAULT_RADIX, nDefault); } /** * Parse the given {@link String} as byte with the specified radix. * * @param sStr * The String to parse. May be <code>null</code>. * @param nRadix * The radix to use. Must be ≥ {@link Character#MIN_RADIX} and ≤ * {@link Character#MAX_RADIX}. * @param nDefault * The value to be returned if the string cannot be converted to a * valid value. * @return The passed default parameter if the string does not represent a * valid value. */ public static byte parseByte (@Nullable final String sStr, @Nonnegative final int nRadix, final byte nDefault) { if (sStr != null && sStr.length () > 0) try { return Byte.parseByte (sStr, nRadix); } catch (final NumberFormatException ex) { // Fall through } return nDefault; } /** * Parse the given {@link Object} as {@link Byte} with radix * {@value #DEFAULT_RADIX}. * * @param aObject * The object to parse. May be <code>null</code>. * @return <code>null</code> if the object does not represent a valid value. */ @Nullable public static Byte parseByteObj (@Nullable final Object aObject) { return parseByteObj (aObject, DEFAULT_RADIX, null); } /** * Parse the given {@link Object} as {@link Byte} with radix * {@value #DEFAULT_RADIX}. * * @param aObject * The object to parse. May be <code>null</code>. * @param aDefault * The default value to be returned, if the passed object cannot be * converted. May be <code>null</code>. * @return the passed default value if the object does not represent a valid * value. */ @Nullable public static Byte parseByteObj (@Nullable final Object aObject, @Nullable final Byte aDefault) { return parseByteObj (aObject, DEFAULT_RADIX, aDefault); } /** * Parse the given {@link Object} as {@link Byte} with the specified radix. * * @param aObject * The object to parse. May be <code>null</code>. * @param nRadix * The radix to use. Must be ≥ {@link Character#MIN_RADIX} and ≤ * {@link Character#MAX_RADIX}. * @param aDefault * The default value to be returned, if the passed object cannot be * converted. May be <code>null</code>. * @return the passed default value if the object does not represent a valid * value. */ @Nullable public static Byte parseByteObj (@Nullable final Object aObject, @Nonnegative final int nRadix, @Nullable final Byte aDefault) { if (aObject == null) return aDefault; if (aObject instanceof Number) return Byte.valueOf (((Number) aObject).byteValue ()); return parseByteObj (aObject.toString (), nRadix, aDefault); } /** * Parse the given {@link String} as {@link Byte} with radix * {@value #DEFAULT_RADIX}. * * @param sStr * The String to parse. May be <code>null</code>. * @return <code>null</code> if the string does not represent a valid value. */ @Nullable public static Byte parseByteObj (@Nullable final String sStr) { return parseByteObj (sStr, DEFAULT_RADIX, null); } /** * Parse the given {@link String} as {@link Byte} with radix * {@value #DEFAULT_RADIX}. * * @param sStr * The String to parse. May be <code>null</code>. * @param aDefault * The default value to be returned if the passed string could not be * converted to a valid value. May be <code>null</code>. * @return <code>aDefault</code> if the string does not represent a valid * value. */ @Nullable public static Byte parseByteObj (@Nullable final String sStr, @Nullable final Byte aDefault) { return parseByteObj (sStr, DEFAULT_RADIX, aDefault); } /** * Parse the given {@link String} as {@link Byte} with the specified radix. * * @param sStr * The String to parse. May be <code>null</code>. * @param nRadix * The radix to use. Must be ≥ {@link Character#MIN_RADIX} and ≤ * {@link Character#MAX_RADIX}. * @param aDefault * The default value to be returned if the passed string could not be * converted to a valid value. May be <code>null</code>. * @return <code>aDefault</code> if the string does not represent a valid * value. */ @Nullable public static Byte parseByteObj (@Nullable final String sStr, @Nonnegative final int nRadix, @Nullable final Byte aDefault) { if (sStr != null && sStr.length () > 0) try { return Byte.valueOf (sStr, nRadix); } catch (final NumberFormatException ex) { // Fall through } return aDefault; } // ---[double]--- /** * Parse the given {@link Object} as double. Note: both the locale independent * form of a double can be parsed here (e.g. 4.523) as well as a localized * form using the comma as the decimal separator (e.g. the German 4,523). * * @param aObject * The object to parse. May be <code>null</code>. * @param dDefault * The default value to be returned if the passed object could not be * converted to a valid value. * @return The default value if the object does not represent a valid value. */ public static double parseDouble (@Nullable final Object aObject, final double dDefault) { if (aObject == null) return dDefault; if (aObject instanceof Number) return ((Number) aObject).doubleValue (); return parseDouble (aObject.toString (), dDefault); } /** * Parse the given {@link String} as double. * * @param sStr * The string to parse. May be <code>null</code>. * @param dDefault * The default value to be returned if the passed object could not be * converted to a valid value. * @return The default value if the string does not represent a valid value. */ public static double parseDouble (@Nullable final String sStr, final double dDefault) { // parseDouble throws a NPE if parameter is null if (sStr != null && sStr.length () > 0) try { // Single point where we replace "," with "." for parsing! return Double.parseDouble (_getUnifiedDecimal (sStr)); } catch (final NumberFormatException ex) { // Fall through } return dDefault; } /** * Parse the given {@link Object} as {@link Double}. Note: both the locale * independent form of a double can be parsed here (e.g. 4.523) as well as a * localized form using the comma as the decimal separator (e.g. the German * 4,523). * * @param aObject * The object to parse. May be <code>null</code>. * @return <code>null</code> if the object does not represent a valid value. */ @Nullable public static Double parseDoubleObj (@Nullable final Object aObject) { return parseDoubleObj (aObject, null); } /** * Parse the given {@link Object} as {@link Double}. Note: both the locale * independent form of a double can be parsed here (e.g. 4.523) as well as a * localized form using the comma as the decimal separator (e.g. the German * 4,523). * * @param aObject * The object to parse. May be <code>null</code>. * @param aDefault * The default value to be returned if the parsed object cannot be * converted to a double. May be <code>null</code>. * @return <code>aDefault</code> if the object does not represent a valid * value. */ @Nullable public static Double parseDoubleObj (@Nullable final Object aObject, @Nullable final Double aDefault) { final double dValue = parseDouble (aObject, Double.NaN); return Double.isNaN (dValue) ? aDefault : Double.valueOf (dValue); } /** * Parse the given {@link String} as {@link Double}. Note: both the locale * independent form of a double can be parsed here (e.g. 4.523) as well as a * localized form using the comma as the decimal separator (e.g. the German * 4,523). * * @param sStr * The string to parse. May be <code>null</code>. * @return <code>null</code> if the object does not represent a valid value. */ @Nullable public static Double parseDoubleObj (@Nullable final String sStr) { return parseDoubleObj (sStr, null); } /** * Parse the given {@link String} as {@link Double}. Note: both the locale * independent form of a double can be parsed here (e.g. 4.523) as well as a * localized form using the comma as the decimal separator (e.g. the German * 4,523). * * @param sStr * The string to parse. May be <code>null</code>. * @param aDefault * The default value to be returned if the parsed string cannot be * converted to a double. May be <code>null</code>. * @return <code>aDefault</code> if the object does not represent a valid * value. */ @Nullable public static Double parseDoubleObj (@Nullable final String sStr, @Nullable final Double aDefault) { final double dValue = parseDouble (sStr, Double.NaN); return Double.isNaN (dValue) ? aDefault : Double.valueOf (dValue); } // ---[float]--- /** * Parse the given {@link Object} as float. Note: both the locale independent * form of a float can be parsed here (e.g. 4.523) as well as a localized form * using the comma as the decimal separator (e.g. the German 4,523). * * @param aObject * The object to parse. May be <code>null</code>. * @param fDefault * The default value to be returned if the passed object could not be * converted to a valid value. * @return The default value if the object does not represent a valid value. */ public static float parseFloat (@Nullable final Object aObject, final float fDefault) { if (aObject == null) return fDefault; if (aObject instanceof Number) return ((Number) aObject).floatValue (); return parseFloat (aObject.toString (), fDefault); } /** * Parse the given {@link String} as float. * * @param sStr * The string to parse. May be <code>null</code>. * @param fDefault * The default value to be returned if the passed object could not be * converted to a valid value. * @return The default value if the string does not represent a valid value. */ public static float parseFloat (@Nullable final String sStr, final float fDefault) { // parseDouble throws a NPE if parameter is null if (sStr != null && sStr.length () > 0) try { // Single point where we replace "," with "." for parsing! return Float.parseFloat (_getUnifiedDecimal (sStr)); } catch (final NumberFormatException ex) { // Fall through } return fDefault; } /** * Parse the given {@link Object} as {@link Float}. Note: both the locale * independent form of a double can be parsed here (e.g. 4.523) as well as a * localized form using the comma as the decimal separator (e.g. the German * 4,523). * * @param aObject * The object to parse. May be <code>null</code>. * @return <code>null</code> if the object does not represent a valid value. */ @Nullable public static Float parseFloatObj (@Nullable final Object aObject) { return parseFloatObj (aObject, null); } /** * Parse the given {@link Object} as {@link Float}. Note: both the locale * independent form of a double can be parsed here (e.g. 4.523) as well as a * localized form using the comma as the decimal separator (e.g. the German * 4,523). * * @param aObject * The object to parse. May be <code>null</code>. * @param aDefault * The default value to be returned if the parsed object cannot be * converted to a float. May be <code>null</code>. * @return <code>aDefault</code> if the object does not represent a valid * value. */ @Nullable public static Float parseFloatObj (@Nullable final Object aObject, @Nullable final Float aDefault) { final float fValue = parseFloat (aObject, Float.NaN); return Float.isNaN (fValue) ? aDefault : Float.valueOf (fValue); } /** * Parse the given {@link String} as {@link Float}. Note: both the locale * independent form of a double can be parsed here (e.g. 4.523) as well as a * localized form using the comma as the decimal separator (e.g. the German * 4,523). * * @param sStr * The string to parse. May be <code>null</code>. * @return <code>null</code> if the object does not represent a valid value. */ @Nullable public static Float parseFloatObj (@Nullable final String sStr) { return parseFloatObj (sStr, null); } /** * Parse the given {@link String} as {@link Float}. Note: both the locale * independent form of a double can be parsed here (e.g. 4.523) as well as a * localized form using the comma as the decimal separator (e.g. the German * 4,523). * * @param sStr * The string to parse. May be <code>null</code>. * @param aDefault * The default value to be returned if the parsed string cannot be * converted to a float. May be <code>null</code>. * @return <code>aDefault</code> if the object does not represent a valid * value. */ @Nullable public static Float parseFloatObj (@Nullable final String sStr, @Nullable final Float aDefault) { final float fValue = parseFloat (sStr, Float.NaN); return Float.isNaN (fValue) ? aDefault : Float.valueOf (fValue); } // ---[int]--- /** * Parse the given {@link Object} as int with radix {@link #DEFAULT_RADIX}. * * @param aObject * The Object to parse. May be <code>null</code>. * @param nDefault * The default value to be returned if the passed object could not be * converted to a valid value. * @return The default value if the string does not represent a valid value. */ public static int parseInt (@Nullable final Object aObject, final int nDefault) { return parseInt (aObject, DEFAULT_RADIX, nDefault); } /** * Parse the given {@link Object} as int with the specified radix. * * @param aObject * The object to parse. May be <code>null</code>. * @param nRadix * The radix to use. Must be ≥ {@link Character#MIN_RADIX} and ≤ * {@link Character#MAX_RADIX}. * @param nDefault * The default value to be returned if the passed object could not be * converted to a valid value. * @return The default value if the string does not represent a valid value. */ public static int parseInt (@Nullable final Object aObject, @Nonnegative final int nRadix, final int nDefault) { if (aObject == null) return nDefault; if (aObject instanceof Number) return ((Number) aObject).intValue (); return parseInt (aObject.toString (), nRadix, nDefault); } /** * Parse the given {@link String} as int with radix {@value #DEFAULT_RADIX}. * * @param sStr * The String to parse. May be <code>null</code>. * @param nDefault * The value to be returned if the string cannot be converted to a * valid value. * @return The passed default parameter if the string does not represent a * valid value. */ public static int parseInt (@Nullable final String sStr, final int nDefault) { return parseInt (sStr, DEFAULT_RADIX, nDefault); } /** * Parse the given {@link String} as int with the specified radix. * * @param sStr * The String to parse. May be <code>null</code>. * @param nRadix * The radix to use. Must be ≥ {@link Character#MIN_RADIX} and ≤ * {@link Character#MAX_RADIX}. * @param nDefault * The value to be returned if the string cannot be converted to a * valid value. * @return The passed default parameter if the string does not represent a * valid value. */ public static int parseInt (@Nullable final String sStr, @Nonnegative final int nRadix, final int nDefault) { if (sStr != null && sStr.length () > 0) try { return Integer.parseInt (sStr, nRadix); } catch (final NumberFormatException ex) { // Fall through } return nDefault; } /** * Parse the given {@link Object} as {@link Integer} with radix * {@value #DEFAULT_RADIX}. * * @param aObject * The object to parse. May be <code>null</code>. * @return <code>null</code> if the object does not represent a valid value. */ @Nullable public static Integer parseIntObj (@Nullable final Object aObject) { return parseIntObj (aObject, DEFAULT_RADIX, null); } /** * Parse the given {@link Object} as {@link Integer} with radix * {@value #DEFAULT_RADIX}. * * @param aObject * The object to parse. May be <code>null</code>. * @param aDefault * The default value to be returned if the passed object cannot be * converted to an Integer. May be <code>null</code>. * @return <code>aDefault</code> if the object does not represent a valid * value. */ @Nullable public static Integer parseIntObj (@Nullable final Object aObject, @Nullable final Integer aDefault) { return parseIntObj (aObject, DEFAULT_RADIX, aDefault); } /** * Parse the given {@link Object} as {@link Integer} with the specified radix. * * @param aObject * The object to parse. May be <code>null</code>. * @param nRadix * The radix to use. Must be ≥ {@link Character#MIN_RADIX} and ≤ * {@link Character#MAX_RADIX}. * @param aDefault * The default value to be returned if the passed object cannot be * converted to an Integer. May be <code>null</code>. * @return <code>aDefault</code> if the object does not represent a valid * value. */ @Nullable public static Integer parseIntObj (@Nullable final Object aObject, @Nonnegative final int nRadix, @Nullable final Integer aDefault) { if (aObject == null) return aDefault; if (aObject instanceof Number) return Integer.valueOf (((Number) aObject).intValue ()); return parseIntObj (aObject.toString (), nRadix, aDefault); } /** * Parse the given {@link String} as {@link Integer} with radix * {@value #DEFAULT_RADIX}. * * @param sStr * The string to parse. May be <code>null</code>. * @return <code>null</code> if the string does not represent a valid value. */ @Nullable public static Integer parseIntObj (@Nullable final String sStr) { return parseIntObj (sStr, DEFAULT_RADIX, null); } /** * Parse the given {@link String} as {@link Integer} with radix * {@link #DEFAULT_RADIX}. * * @param sStr * The string to parse. May be <code>null</code>. * @param aDefault * The default value to be returned if the passed string could not be * converted to a valid value. May be <code>null</code>. * @return <code>aDefault</code> if the string does not represent a valid * value. */ @Nullable public static Integer parseIntObj (@Nullable final String sStr, @Nullable final Integer aDefault) { return parseIntObj (sStr, DEFAULT_RADIX, aDefault); } /** * Parse the given {@link String} as {@link Integer} with the specified radix. * * @param sStr * The string to parse. May be <code>null</code>. * @param nRadix * The radix to use. Must be ≥ {@link Character#MIN_RADIX} and ≤ * {@link Character#MAX_RADIX}. * @param aDefault * The default value to be returned if the passed string could not be * converted to a valid value. May be <code>null</code>. * @return <code>aDefault</code> if the string does not represent a valid * value. */ @Nullable public static Integer parseIntObj (@Nullable final String sStr, @Nonnegative final int nRadix, @Nullable final Integer aDefault) { if (sStr != null && sStr.length () > 0) try { return Integer.valueOf (sStr, nRadix); } catch (final NumberFormatException ex) { // Fall through } return aDefault; } /** * Parse the given {@link String} as unsigned {@link Integer} with radix * {@value #DEFAULT_RADIX}. * * @param sStr * The string to parse. May be <code>null</code>. * @return <code>null</code> if the string does not represent a valid value. * @since 9.0.0 */ @Nullable public static Long parseUnsignedIntObj (@Nullable final String sStr) { return parseUnsignedIntObj (sStr, DEFAULT_RADIX, null); } /** * Parse the given {@link String} as unsigned {@link Integer} with radix * {@link #DEFAULT_RADIX}. * * @param sStr * The string to parse. May be <code>null</code>. * @param aDefault * The default value to be returned if the passed string could not be * converted to a valid value. May be <code>null</code>. * @return <code>aDefault</code> if the string does not represent a valid * value. * @since 9.0.0 */ @Nullable public static Long parseUnsignedIntObj (@Nullable final String sStr, @Nullable final Long aDefault) { return parseUnsignedIntObj (sStr, DEFAULT_RADIX, aDefault); } /** * Parse the given {@link String} as unsigned {@link Integer} with the * specified radix. * * @param sStr * The string to parse. May be <code>null</code>. * @param nRadix * The radix to use. Must be ≥ {@link Character#MIN_RADIX} and ≤ * {@link Character#MAX_RADIX}. * @param aDefault * The default value to be returned if the passed string could not be * converted to a valid value. May be <code>null</code>. * @return <code>aDefault</code> if the string does not represent a valid * value. * @since 9.0.0 */ @Nullable public static Long parseUnsignedIntObj (@Nullable final String sStr, @Nonnegative final int nRadix, @Nullable final Long aDefault) { if (sStr != null && sStr.length () > 0) try { return Long.valueOf (Integer.parseUnsignedInt (sStr, nRadix) & 0xffff_ffffL); } catch (final NumberFormatException ex) { // Fall through } return aDefault; } // ---[long]--- /** * Parse the given {@link Object} as long with radix {@value #DEFAULT_RADIX}. * * @param aObject * The object to parse. May be <code>null</code>. * @param nDefault * The default value to be returned if the passed object could not be * converted to a valid value. * @return The default value if the object does not represent a valid value. */ public static long parseLong (@Nullable final Object aObject, final long nDefault) { return parseLong (aObject, DEFAULT_RADIX, nDefault); } /** * Parse the given {@link Object} as long with the specified radix. * * @param aObject * The object to parse. May be <code>null</code>. * @param nRadix * The radix to use. Must be ≥ {@link Character#MIN_RADIX} and ≤ * {@link Character#MAX_RADIX}. * @param nDefault * The default value to be returned if the passed object could not be * converted to a valid value. * @return The default value if the object does not represent a valid value. */ public static long parseLong (@Nullable final Object aObject, @Nonnegative final int nRadix, final long nDefault) { if (aObject == null) return nDefault; if (aObject instanceof Number) return ((Number) aObject).longValue (); return parseLong (aObject.toString (), nRadix, nDefault); } /** * Parse the given {@link String} as long with radix {@value #DEFAULT_RADIX}. * * @param sStr * The string to parse. May be <code>null</code>. * @param nDefault * The default value to be returned if the passed object could not be * converted to a valid value. * @return The default if the string does not represent a valid value. */ public static long parseLong (@Nullable final String sStr, final long nDefault) { return parseLong (sStr, DEFAULT_RADIX, nDefault); } /** * Parse the given {@link String} as long with the specified radix. * * @param sStr * The string to parse. May be <code>null</code>. * @param nRadix * The radix to use. Must be ≥ {@link Character#MIN_RADIX} and ≤ * {@link Character#MAX_RADIX}. * @param nDefault * The default value to be returned if the passed object could not be * converted to a valid value. * @return The default if the string does not represent a valid value. */ public static long parseLong (@Nullable final String sStr, @Nonnegative final int nRadix, final long nDefault) { if (sStr != null && sStr.length () > 0) try { return Long.parseLong (sStr, nRadix); } catch (final NumberFormatException ex) { // Fall through } return nDefault; } /** * Parse the given {@link Object} as {@link Long} with radix * {@value #DEFAULT_RADIX}. * * @param aObject * The object to parse. May be <code>null</code>. * @return <code>null</code> if the object does not represent a valid value. */ @Nullable public static Long parseLongObj (@Nullable final Object aObject) { return parseLongObj (aObject, DEFAULT_RADIX, null); } /** * Parse the given {@link Object} as {@link Long} with radix * {@value #DEFAULT_RADIX}. * * @param aObject * The object to parse. May be <code>null</code>. * @param aDefault * The default value to be returned if the passed object cannot be * converted to a Long. May be <code>null</code>. * @return <code>aDefault</code> if the object does not represent a valid * value. */ @Nullable public static Long parseLongObj (@Nullable final Object aObject, @Nullable final Long aDefault) { return parseLongObj (aObject, DEFAULT_RADIX, aDefault); } /** * Parse the given {@link Object} as {@link Long} with the specified radix. * * @param aObject * The object to parse. May be <code>null</code>. * @param nRadix * The radix to use. Must be ≥ {@link Character#MIN_RADIX} and ≤ * {@link Character#MAX_RADIX}. * @param aDefault * The default value to be returned if the passed object cannot be * converted to a Long. May be <code>null</code>. * @return <code>aDefault</code> if the object does not represent a valid * value. */ @Nullable public static Long parseLongObj (@Nullable final Object aObject, @Nonnegative final int nRadix, @Nullable final Long aDefault) { if (aObject == null) return aDefault; if (aObject instanceof Number) return Long.valueOf (((Number) aObject).longValue ()); return parseLongObj (aObject.toString (), nRadix, aDefault); } /** * Parse the given {@link String} as {@link Long} with radix * {@value #DEFAULT_RADIX}. * * @param sStr * The string to parse. May be <code>null</code>. * @return <code>null</code> if the string does not represent a valid value. */ @Nullable public static Long parseLongObj (@Nullable final String sStr) { return parseLongObj (sStr, DEFAULT_RADIX, null); } /** * Parse the given {@link String} as {@link Long} with radix * {@link #DEFAULT_RADIX}. * * @param sStr * The string to parse. May be <code>null</code>. * @param aDefault * The default value to be returned if the passed string could not be * converted to a valid value. May be <code>null</code>. * @return <code>aDefault</code> if the string does not represent a valid * value. */ @Nullable public static Long parseLongObj (@Nullable final String sStr, @Nullable final Long aDefault) { return parseLongObj (sStr, DEFAULT_RADIX, aDefault); } /** * Parse the given {@link String} as {@link Long} with the specified radix. * * @param sStr * The string to parse. May be <code>null</code>. * @param nRadix * The radix to use. Must be ≥ {@link Character#MIN_RADIX} and ≤ * {@link Character#MAX_RADIX}. * @param aDefault * The default value to be returned if the passed string could not be * converted to a valid value. May be <code>null</code>. * @return <code>aDefault</code> if the string does not represent a valid * value. */ @Nullable public static Long parseLongObj (@Nullable final String sStr, @Nonnegative final int nRadix, @Nullable final Long aDefault) { if (sStr != null && sStr.length () > 0) try { return Long.valueOf (sStr, nRadix); } catch (final NumberFormatException ex) { // Fall through } return aDefault; } // ---[short]--- /** * Parse the given {@link Object} as short with radix {@value #DEFAULT_RADIX}. * * @param aObject * The object to parse. May be <code>null</code>. * @param nDefault * The default value to be returned if the passed object could not be * converted to a valid value. * @return The default value if the object does not represent a valid value. */ public static short parseShort (@Nullable final Object aObject, final short nDefault) { return parseShort (aObject, DEFAULT_RADIX, nDefault); } /** * Parse the given {@link Object} as short with the specified radix. * * @param aObject * The object to parse. May be <code>null</code>. * @param nRadix * The radix to use. Must be ≥ {@link Character#MIN_RADIX} and ≤ * {@link Character#MAX_RADIX}. * @param nDefault * The default value to be returned if the passed object could not be * converted to a valid value. * @return The default value if the object does not represent a valid value. */ public static short parseShort (@Nullable final Object aObject, @Nonnegative final int nRadix, final short nDefault) { if (aObject == null) return nDefault; if (aObject instanceof Number) return ((Number) aObject).shortValue (); return parseShort (aObject.toString (), nRadix, nDefault); } /** * Parse the given {@link String} as short with radix {@value #DEFAULT_RADIX}. * * @param sStr * The string to parse. May be <code>null</code>. * @param nDefault * The default value to be returned if the passed object could not be * converted to a valid value. * @return The default if the string does not represent a valid value. */ public static short parseShort (@Nullable final String sStr, final short nDefault) { return parseShort (sStr, DEFAULT_RADIX, nDefault); } /** * Parse the given {@link String} as short with the specified radix. * * @param sStr * The string to parse. May be <code>null</code>. * @param nRadix * The radix to use. Must be ≥ {@link Character#MIN_RADIX} and ≤ * {@link Character#MAX_RADIX}. * @param nDefault * The default value to be returned if the passed object could not be * converted to a valid value. * @return The default if the string does not represent a valid value. */ public static short parseShort (@Nullable final String sStr, @Nonnegative final int nRadix, final short nDefault) { if (sStr != null && sStr.length () > 0) try { return Short.parseShort (sStr, nRadix); } catch (final NumberFormatException ex) { // Fall through } return nDefault; } /** * Parse the given {@link Object} as {@link Short} with radix * {@value #DEFAULT_RADIX}. * * @param aObject * The object to parse. May be <code>null</code>. * @return <code>null</code> if the object does not represent a valid value. */ @Nullable public static Short parseShortObj (@Nullable final Object aObject) { return parseShortObj (aObject, DEFAULT_RADIX, null); } /** * Parse the given {@link Object} as {@link Short} with radix * {@value #DEFAULT_RADIX}. * * @param aObject * The object to parse. May be <code>null</code>. * @param aDefault * The default value to be returned if the passed object cannot be * converted to a Short. May be <code>null</code>. * @return <code>aDefault</code> if the object does not represent a valid * value. */ @Nullable public static Short parseShortObj (@Nullable final Object aObject, @Nullable final Short aDefault) { return parseShortObj (aObject, DEFAULT_RADIX, aDefault); } /** * Parse the given {@link Object} as {@link Short} with the specified radix. * * @param aObject * The object to parse. May be <code>null</code>. * @param nRadix * The radix to use. Must be ≥ {@link Character#MIN_RADIX} and ≤ * {@link Character#MAX_RADIX}. * @param aDefault * The default value to be returned if the passed object cannot be * converted to a Short. May be <code>null</code>. * @return <code>aDefault</code> if the object does not represent a valid * value. */ @Nullable public static Short parseShortObj (@Nullable final Object aObject, @Nonnegative final int nRadix, @Nullable final Short aDefault) { if (aObject == null) return aDefault; if (aObject instanceof Number) return Short.valueOf (((Number) aObject).shortValue ()); return parseShortObj (aObject.toString (), nRadix, aDefault); } /** * Parse the given {@link String} as {@link Short} with radix * {@value #DEFAULT_RADIX}. * * @param sStr * The string to parse. May be <code>null</code>. * @return <code>null</code> if the string does not represent a valid value. */ @Nullable public static Short parseShortObj (@Nullable final String sStr) { return parseShortObj (sStr, DEFAULT_RADIX, null); } /** * Parse the given {@link String} as {@link Short} with radix * {@link #DEFAULT_RADIX}. * * @param sStr * The string to parse. May be <code>null</code>. * @param aDefault * The default value to be returned if the passed string could not be * converted to a valid value. May be <code>null</code>. * @return <code>aDefault</code> if the string does not represent a valid * value. */ @Nullable public static Short parseShortObj (@Nullable final String sStr, @Nullable final Short aDefault) { return parseShortObj (sStr, DEFAULT_RADIX, aDefault); } /** * Parse the given {@link String} as {@link Short} with the specified radix. * * @param sStr * The string to parse. May be <code>null</code>. * @param nRadix * The radix to use. Must be ≥ {@link Character#MIN_RADIX} and ≤ * {@link Character#MAX_RADIX}. * @param aDefault * The default value to be returned if the passed string could not be * converted to a valid value. May be <code>null</code>. * @return <code>aDefault</code> if the string does not represent a valid * value. */ @Nullable public static Short parseShortObj (@Nullable final String sStr, @Nonnegative final int nRadix, @Nullable final Short aDefault) { if (sStr != null && sStr.length () > 0) try { return Short.valueOf (sStr, nRadix); } catch (final NumberFormatException ex) { // Fall through } return aDefault; } // ---[BigInteger]--- /** * Parse the given {@link String} as {@link BigInteger} with radix * {@value #DEFAULT_RADIX}. * * @param sStr * The String to parse. May be <code>null</code>. * @return <code>null</code> if the string does not represent a valid value. */ @Nullable public static BigInteger parseBigInteger (@Nullable final String sStr) { return parseBigInteger (sStr, DEFAULT_RADIX, null); } /** * Parse the given {@link String} as {@link BigInteger} with the specified * radix. * * @param sStr * The String to parse. May be <code>null</code>. * @param nRadix * The radix to use. Must be ≥ {@link Character#MIN_RADIX} and ≤ * {@link Character#MAX_RADIX}. * @return <code>null</code> if the string does not represent a valid value. */ @Nullable public static BigInteger parseBigInteger (@Nullable final String sStr, @Nonnegative final int nRadix) { return parseBigInteger (sStr, nRadix, null); } /** * Parse the given {@link String} as {@link BigInteger} with radix * {@value #DEFAULT_RADIX}. * * @param sStr * The String to parse. May be <code>null</code>. * @param aDefault * The default value to be returned if the passed string could not be * converted to a valid value. May be <code>null</code>. * @return <code>aDefault</code> if the string does not represent a valid * value. */ @Nullable public static BigInteger parseBigInteger (@Nullable final String sStr, @Nullable final BigInteger aDefault) { return parseBigInteger (sStr, DEFAULT_RADIX, aDefault); } /** * Parse the given {@link String} as {@link BigInteger} with the specified * radix. * * @param sStr * The String to parse. May be <code>null</code>. * @param nRadix * The radix to use. Must be ≥ {@link Character#MIN_RADIX} and ≤ * {@link Character#MAX_RADIX}. * @param aDefault * The default value to be returned if the passed string could not be * converted to a valid value. May be <code>null</code>. * @return <code>aDefault</code> if the string does not represent a valid * value. */ @Nullable public static BigInteger parseBigInteger (@Nullable final String sStr, @Nonnegative final int nRadix, @Nullable final BigInteger aDefault) { if (sStr != null && sStr.length () > 0) try { return new BigInteger (sStr, nRadix); } catch (final NumberFormatException ex) { // Fall through } return aDefault; } // ---[BigDecimal]--- /** * Parse the given {@link String} as {@link BigDecimal}. * * @param sStr * The String to parse. May be <code>null</code>. * @return <code>null</code> if the string does not represent a valid value. */ @Nullable public static BigDecimal parseBigDecimal (@Nullable final String sStr) { return parseBigDecimal (sStr, null); } /** * Parse the given {@link String} as {@link BigDecimal}. * * @param sStr * The String to parse. May be <code>null</code>. * @param aDefault * The default value to be returned if the passed string could not be * converted to a valid value. May be <code>null</code>. * @return <code>aDefault</code> if the string does not represent a valid * value. */ @Nullable public static BigDecimal parseBigDecimal (@Nullable final String sStr, @Nullable final BigDecimal aDefault) { if (sStr != null && sStr.length () > 0) try { return new BigDecimal (_getUnifiedDecimal (sStr)); } catch (final NumberFormatException ex) { // Fall through } return aDefault; } /** * Parse the given {@link String} as {@link BigDecimal}. * * @param sStr * The String to parse. May be <code>null</code>. * @param nScale * The scaling (decimal places) to be used for the result. Must be ≥ * 0! * @param eRoundingMode * The rounding mode to be used to achieve the scale. May not be * <code>null</code>. * @return <code>null</code> if the string does not represent a valid value. */ @Nullable public static BigDecimal parseBigDecimal (@Nullable final String sStr, @Nonnegative final int nScale, @Nonnull final RoundingMode eRoundingMode) { return parseBigDecimal (sStr, nScale, eRoundingMode, null); } /** * Parse the given {@link String} as {@link BigDecimal}. * * @param sStr * The String to parse. May be <code>null</code>. * @param nScale * The scaling (decimal places) to be used for the result. Must be ≥ * 0! * @param eRoundingMode * The rounding mode to be used to achieve the scale. May not be * <code>null</code>. * @param aDefault * The default value to be returned if the passed string could not be * converted to a valid value. May be <code>null</code>. * @return <code>aDefault</code> if the string does not represent a valid * value. */ @Nullable public static BigDecimal parseBigDecimal (@Nullable final String sStr, @Nonnegative final int nScale, @Nonnull final RoundingMode eRoundingMode, @Nullable final BigDecimal aDefault) { ValueEnforcer.isGE0 (nScale, "Scale"); ValueEnforcer.notNull (eRoundingMode, "RoundingMode"); if (sStr != null && sStr.length () > 0) try { return new BigDecimal (_getUnifiedDecimal (sStr)).setScale (nScale, eRoundingMode); } catch (final NumberFormatException ex) { // Fall through } return aDefault; } // ---[check methods]--- /** * Checks if the given string is a numeric string that can be converted to a * long value with radix {@value #DEFAULT_RADIX}. * * @param sStr * The string to check. May be <code>null</code>. * @return <code>true</code> if the value can be converted to a valid value */ public static boolean isInt (@Nullable final String sStr) { if (sStr != null) try { Integer.parseInt (sStr, DEFAULT_RADIX); return true; } catch (final NumberFormatException ex) { // fall through } return false; } /** * Checks if the given string is a numeric string that can be converted to a * long value with radix {@value #DEFAULT_RADIX}. * * @param sStr * The string to check. May be <code>null</code>. * @return <code>true</code> if the value can be converted to a valid value */ public static boolean isLong (@Nullable final String sStr) { if (sStr != null) try { Long.parseLong (sStr, DEFAULT_RADIX); return true; } catch (final NumberFormatException ex) { // fall through } return false; } /** * Checks if the given string is a numeric string that can be converted to an * unsigned long value with radix {@value #DEFAULT_RADIX}. * * @param sStr * The string to check. May be <code>null</code>. * @return <code>true</code> if the value can be converted to a valid value */ public static boolean isUnsignedInt (@Nullable final String sStr) { if (sStr != null) try { Integer.parseUnsignedInt (sStr, DEFAULT_RADIX); return true; } catch (final NumberFormatException ex) { // fall through } return false; } /** * Checks if the given string is a numeric string that can be converted to an * unsigned long value with radix {@value #DEFAULT_RADIX}. * * @param sStr * The string to check. May be <code>null</code>. * @return <code>true</code> if the value can be converted to a valid value */ public static boolean isUnsignedLong (@Nullable final String sStr) { if (sStr != null) try { final long ret = Long.parseLong (sStr, DEFAULT_RADIX); return ret >= 0; } catch (final NumberFormatException ex) { // fall through } return false; } /** * Checks if the given string is a double string that can be converted to a * double value. * * @param sStr * The string to check. May be <code>null</code>. * @return <code>true</code> if the value can be converted to a valid value */ public static boolean isDouble (@Nullable final String sStr) { return !Double.isNaN (parseDouble (sStr, Double.NaN)); } /** * Checks if the given string is a float string that can be converted to a * double value. * * @param sStr * The string to check. May be <code>null</code>. * @return <code>true</code> if the value can be converted to a valid value */ public static boolean isFloat (@Nullable final String sStr) { return !Float.isNaN (parseFloat (sStr, Float.NaN)); } }