SingleNumericalValue.java

package org.jscsi.target.settings;

import java.util.regex.Matcher;

/**
 * A {@link NumericalValue} sub-class for representing single integers.
 * 
 * @author Andreas Ergenzinger
 */
public final class SingleNumericalValue extends NumericalValue {

    /**
     * The represented integer.
     */
    private final int value;

    /**
     * The constructor.
     * <p>
     * This method is private to enforce usage of {@link #create(int)}, similar to the way new
     * {@link NumericalValueRange} objects are created.
     * 
     * @param value
     *            the value of the new {@link SingleNumericalValue}
     */
    private SingleNumericalValue(final int value) {
        this.value = value;
    }

    /**
     * Returns the represented value.
     * 
     * @return the represented value
     */
    public final int getValue() {
        return value;
    }

    /**
     * Returns a new {@link SingleNumericalValue} with the specified value.
     * 
     * @param value
     *            the value of the returned {@link SingleNumericalValue}
     * @return a new {@link SingleNumericalValue}
     */
    public static final SingleNumericalValue create(final int value) {
        return new SingleNumericalValue(value);
    }

    /**
     * Parses a {@link SingleNumericalValue} from a {@link String}. The
     * parameter must contain an integer value in decimal, hexadecimal, or
     * Base64 format. If it does not, <code>null</code> will be returned.
     * 
     * @param value
     *            the {@link String} to parse
     * @return a {@link SingleNumericalValue} with the parsed value or <code>null</code>
     */
    public static final SingleNumericalValue parseSingleNumericValue(final String value) {
        // decimal constant
        final Matcher decimalMatcher = DECIMAL_CONSTANT_PATTERN.matcher(value);
        if (decimalMatcher.matches())
            return new SingleNumericalValue(parseDecimalConstantString(value));
        // hex constant
        final Matcher hexMatcher = HEX_CONSTANT_PATTERN.matcher(value);
        if (hexMatcher.matches())
            return new SingleNumericalValue(parseHexConstantString(value));
        // base 64 constant
        final Matcher base64Matcher = BASE_64_CONSTANT_PATTERN.matcher(value);
        if (base64Matcher.matches())
            return new SingleNumericalValue(parseBase64ConstantString(value));
        // none of the above
        return null;
    }

    /**
     * Parses an integer value from a {@link String} encoded in decimal format.
     * <p>
     * This method does not check the passed {@link String} before parsing, so this method should only be used
     * on string which are certain to match the required format.
     * 
     * @param value
     *            a {@link String} containing (only) an integer encoded in
     *            decimal format
     * @return the parsed integer
     */
    private static final int parseDecimalConstantString(final String value) {
        return Integer.valueOf(value);
    }

    /**
     * Parses an integer value from a {@link String} encoded in hexadecimal
     * format.
     * <p>
     * This method does not check the passed {@link String} before parsing, so this method should only be used
     * on string which are certain to match the required format.
     * 
     * @param value
     *            a {@link String} containing (only) an integer encoded in
     *            hexadecimal format
     * @return the parsed integer
     */
    private static final int parseHexConstantString(final String value) {
        return Integer.parseInt(value.substring(2),// skip "0x" prefix
            16);
    }

    /**
     * Parses an integer value from a {@link String} encoded in Base64 format.
     * <p>
     * This method does not check the passed {@link String} before parsing, so this method should only be used
     * on string which are certain to match the required format.
     * 
     * @param value
     *            a {@link String} containing (only) an integer encoded in
     *            Base64 format
     * @return the parsed integer
     */
    private static final int parseBase64ConstantString(final String value) {
        final String s = value.substring(2);// crop "0b"/"0B" at the beginning
        final int length = s.length();
        int result = 0;
        for (int i = 0; i < length; ++i) {
            final char c = s.charAt(length - 1 - i);
            result += base64ValueOf(c) * Math.pow(64, i);
        }
        return result;
    }


    /**
     * Returns a character's value in Base64
     * 
     * @param c
     *            a character that is assigned a value from 0 to 63 in Base64
     * @throws NumberFormatException
     *             if the parameter is not a Base64 character
     * @return the character's value in Base64
     */
    private static final int base64ValueOf(final char c) {
        if ('A' <= c && c <= 'Z')
            return c - 'A';
        if ('a' <= c && c <= 'z')
            return c - 'a' + 26;
        if ('0' <= c && c <= '9')
            return c - '0' + 52;
        if (c == '+')
            return 62;
        if (c == '/')
            return 63;
        throw new NumberFormatException();
    }

    @Override
    public final String toString() {
        return "[" + value + "]";
    }

    @Override
    public boolean contains(Object value) {
        if (value == null)
            return false;
        if (value instanceof SingleNumericalValue)
            return contains(((SingleNumericalValue)value).getValue());
        if (value instanceof Integer)
            return contains((int)((Integer)value));
        return false;
    }

    @Override
    public boolean contains(final int value) {
        if (value == this.value)
            return true;
        return false;
    }
}