com.groupbyinc.common.joda.time.format.FormatUtils Maven / Gradle / Ivy
/*
* Copyright 2001-2014 Stephen Colebourne
*
* 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 org.joda.time.format;
import java.io.IOException;
import java.io.Writer;
/**
* Utility methods used by formatters.
*
* FormatUtils is thread-safe and immutable.
*
* @author Brian S O'Neill
* @since 1.0
*/
public class FormatUtils {
private static final double LOG_10 = Math.log(10);
/**
* Restricted constructor.
*/
private FormatUtils() {
}
/**
* Converts an integer to a string, prepended with a variable amount of '0'
* pad characters, and appends it to the given buffer.
*
*
This method is optimized for converting small values to strings.
*
* @param buf receives integer converted to a string
* @param value value to convert to a string
* @param size minimum amount of digits to append
*/
public static void appendPaddedInteger(StringBuffer buf, int value, int size) {
try {
appendPaddedInteger((Appendable)buf, value, size);
} catch (IOException e) {
// StringBuffer does not throw IOException
}
}
/**
* Converts an integer to a string, prepended with a variable amount of '0'
* pad characters, and appends it to the given appendable.
*
*
This method is optimized for converting small values to strings.
*
* @param appenadble receives integer converted to a string
* @param value value to convert to a string
* @param size minimum amount of digits to append
* @since 2.4
*/
public static void appendPaddedInteger(Appendable appenadble, int value, int size) throws IOException {
if (value < 0) {
appenadble.append('-');
if (value != Integer.MIN_VALUE) {
value = -value;
} else {
for (; size > 10; size--) {
appenadble.append('0');
}
appenadble.append("" + -(long)Integer.MIN_VALUE);
return;
}
}
if (value < 10) {
for (; size > 1; size--) {
appenadble.append('0');
}
appenadble.append((char)(value + '0'));
} else if (value < 100) {
for (; size > 2; size--) {
appenadble.append('0');
}
// Calculate value div/mod by 10 without using two expensive
// division operations. (2 ^ 27) / 10 = 13421772. Add one to
// value to correct rounding error.
int d = ((value + 1) * 13421772) >> 27;
appenadble.append((char) (d + '0'));
// Append remainder by calculating (value - d * 10).
appenadble.append((char) (value - (d << 3) - (d << 1) + '0'));
} else {
int digits;
if (value < 1000) {
digits = 3;
} else if (value < 10000) {
digits = 4;
} else {
digits = (int)(Math.log(value) / LOG_10) + 1;
}
for (; size > digits; size--) {
appenadble.append('0');
}
appenadble.append(Integer.toString(value));
}
}
/**
* Converts an integer to a string, prepended with a variable amount of '0'
* pad characters, and appends it to the given buffer.
*
*
This method is optimized for converting small values to strings.
*
* @param buf receives integer converted to a string
* @param value value to convert to a string
* @param size minimum amount of digits to append
*/
public static void appendPaddedInteger(StringBuffer buf, long value, int size) {
try {
appendPaddedInteger((Appendable)buf, value, size);
} catch (IOException e) {
// StringBuffer does not throw IOException
}
}
/**
* Converts an integer to a string, prepended with a variable amount of '0'
* pad characters, and appends it to the given buffer.
*
*
This method is optimized for converting small values to strings.
*
* @param appendable receives integer converted to a string
* @param value value to convert to a string
* @param size minimum amount of digits to append
* @since 2.4
*/
public static void appendPaddedInteger(Appendable appendable, long value, int size) throws IOException {
int intValue = (int)value;
if (intValue == value) {
appendPaddedInteger(appendable, intValue, size);
} else if (size <= 19) {
appendable.append(Long.toString(value));
} else {
if (value < 0) {
appendable.append('-');
if (value != Long.MIN_VALUE) {
value = -value;
} else {
for (; size > 19; size--) {
appendable.append('0');
}
appendable.append("9223372036854775808");
return;
}
}
int digits = (int)(Math.log(value) / LOG_10) + 1;
for (; size > digits; size--) {
appendable.append('0');
}
appendable.append(Long.toString(value));
}
}
/**
* Converts an integer to a string, prepended with a variable amount of '0'
* pad characters, and writes it to the given writer.
*
*
This method is optimized for converting small values to strings.
*
* @param out receives integer converted to a string
* @param value value to convert to a string
* @param size minimum amount of digits to append
*/
public static void writePaddedInteger(Writer out, int value, int size)
throws IOException
{
if (value < 0) {
out.write('-');
if (value != Integer.MIN_VALUE) {
value = -value;
} else {
for (; size > 10; size--) {
out.write('0');
}
out.write("" + -(long)Integer.MIN_VALUE);
return;
}
}
if (value < 10) {
for (; size > 1; size--) {
out.write('0');
}
out.write(value + '0');
} else if (value < 100) {
for (; size > 2; size--) {
out.write('0');
}
// Calculate value div/mod by 10 without using two expensive
// division operations. (2 ^ 27) / 10 = 13421772. Add one to
// value to correct rounding error.
int d = ((value + 1) * 13421772) >> 27;
out.write(d + '0');
// Append remainder by calculating (value - d * 10).
out.write(value - (d << 3) - (d << 1) + '0');
} else {
int digits;
if (value < 1000) {
digits = 3;
} else if (value < 10000) {
digits = 4;
} else {
digits = (int)(Math.log(value) / LOG_10) + 1;
}
for (; size > digits; size--) {
out.write('0');
}
out.write(Integer.toString(value));
}
}
/**
* Converts an integer to a string, prepended with a variable amount of '0'
* pad characters, and writes it to the given writer.
*
*
This method is optimized for converting small values to strings.
*
* @param out receives integer converted to a string
* @param value value to convert to a string
* @param size minimum amount of digits to append
*/
public static void writePaddedInteger(Writer out, long value, int size)
throws IOException
{
int intValue = (int)value;
if (intValue == value) {
writePaddedInteger(out, intValue, size);
} else if (size <= 19) {
out.write(Long.toString(value));
} else {
if (value < 0) {
out.write('-');
if (value != Long.MIN_VALUE) {
value = -value;
} else {
for (; size > 19; size--) {
out.write('0');
}
out.write("9223372036854775808");
return;
}
}
int digits = (int)(Math.log(value) / LOG_10) + 1;
for (; size > digits; size--) {
out.write('0');
}
out.write(Long.toString(value));
}
}
/**
* Converts an integer to a string, and appends it to the given buffer.
*
*
This method is optimized for converting small values to strings.
*
* @param buf receives integer converted to a string
* @param value value to convert to a string
*/
public static void appendUnpaddedInteger(StringBuffer buf, int value) {
try {
appendUnpaddedInteger((Appendable) buf, value);
} catch (IOException e) {
// StringBuffer do not throw IOException
}
}
/**
* Converts an integer to a string, and appends it to the given appendable.
*
*
This method is optimized for converting small values to strings.
*
* @param appendable receives integer converted to a string
* @param value value to convert to a string
* @since 2.4
*/
public static void appendUnpaddedInteger(Appendable appendable, int value) throws IOException {
if (value < 0) {
appendable.append('-');
if (value != Integer.MIN_VALUE) {
value = -value;
} else {
appendable.append("" + -(long)Integer.MIN_VALUE);
return;
}
}
if (value < 10) {
appendable.append((char)(value + '0'));
} else if (value < 100) {
// Calculate value div/mod by 10 without using two expensive
// division operations. (2 ^ 27) / 10 = 13421772. Add one to
// value to correct rounding error.
int d = ((value + 1) * 13421772) >> 27;
appendable.append((char) (d + '0'));
// Append remainder by calculating (value - d * 10).
appendable.append((char) (value - (d << 3) - (d << 1) + '0'));
} else {
appendable.append(Integer.toString(value));
}
}
/**
* Converts an integer to a string, and appends it to the given buffer.
*
*
This method is optimized for converting small values to strings.
*
* @param buf receives integer converted to a string
* @param value value to convert to a string
*/
public static void appendUnpaddedInteger(StringBuffer buf, long value) {
try {
appendUnpaddedInteger((Appendable) buf, value);
} catch (IOException e) {
// StringBuffer do not throw IOException
}
}
/**
* Converts an integer to a string, and appends it to the given appendable.
*
*
This method is optimized for converting small values to strings.
*
* @param appendable receives integer converted to a string
* @param value value to convert to a string
*/
public static void appendUnpaddedInteger(Appendable appendable, long value) throws IOException {
int intValue = (int)value;
if (intValue == value) {
appendUnpaddedInteger(appendable, intValue);
} else {
appendable.append(Long.toString(value));
}
}
/**
* Converts an integer to a string, and writes it to the given writer.
*
*
This method is optimized for converting small values to strings.
*
* @param out receives integer converted to a string
* @param value value to convert to a string
*/
public static void writeUnpaddedInteger(Writer out, int value)
throws IOException
{
if (value < 0) {
out.write('-');
if (value != Integer.MIN_VALUE) {
value = -value;
} else {
out.write("" + -(long)Integer.MIN_VALUE);
return;
}
}
if (value < 10) {
out.write(value + '0');
} else if (value < 100) {
// Calculate value div/mod by 10 without using two expensive
// division operations. (2 ^ 27) / 10 = 13421772. Add one to
// value to correct rounding error.
int d = ((value + 1) * 13421772) >> 27;
out.write(d + '0');
// Append remainder by calculating (value - d * 10).
out.write(value - (d << 3) - (d << 1) + '0');
} else {
out.write(Integer.toString(value));
}
}
/**
* Converts an integer to a string, and writes it to the given writer.
*
*
This method is optimized for converting small values to strings.
*
* @param out receives integer converted to a string
* @param value value to convert to a string
*/
public static void writeUnpaddedInteger(Writer out, long value)
throws IOException
{
int intValue = (int)value;
if (intValue == value) {
writeUnpaddedInteger(out, intValue);
} else {
out.write(Long.toString(value));
}
}
/**
* Calculates the number of decimal digits for the given value,
* including the sign.
*/
public static int calculateDigitCount(long value) {
if (value < 0) {
if (value != Long.MIN_VALUE) {
return calculateDigitCount(-value) + 1;
} else {
return 20;
}
}
return
(value < 10 ? 1 :
(value < 100 ? 2 :
(value < 1000 ? 3 :
(value < 10000 ? 4 :
((int)(Math.log(value) / LOG_10) + 1)))));
}
static int parseTwoDigits(CharSequence text, int position) {
int value = text.charAt(position) - '0';
return ((value << 3) + (value << 1)) + text.charAt(position + 1) - '0';
}
static String createErrorMessage(final String text, final int errorPos) {
int sampleLen = errorPos + 32;
String sampleText;
if (text.length() <= sampleLen + 3) {
sampleText = text;
} else {
sampleText = text.substring(0, sampleLen).concat("...");
}
if (errorPos <= 0) {
return "Invalid format: \"" + sampleText + '"';
}
if (errorPos >= text.length()) {
return "Invalid format: \"" + sampleText + "\" is too short";
}
return "Invalid format: \"" + sampleText + "\" is malformed at \"" +
sampleText.substring(errorPos) + '"';
}
}