• Home
• com.numdata
• numdata-commons
• 1.2
• source code
• TextTools.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.numdata.oss.TextTools Maven / Gradle / Ivy

/*
 * Copyright (c) 2017, Numdata BV, The Netherlands.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of Numdata nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL NUMDATA BV BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
package com.numdata.oss;

import java.io.*;
import java.math.*;
import java.net.*;
import java.text.*;
import java.util.*;
import java.util.regex.*;

import org.jetbrains.annotations.*;

/**
 * This class is a text manipulation tool box.
 *
 * @author Sjoerd Bouwman
 * @author Peter S. Heijnen
 */
public class TextTools
{
	/**
	 * State used for whitespace by {@link #plainTextToHTML} method.
	 *
	 * @see #plainTextToHTML
	 */
	private static final int ASCII_HTML_SPACE = 0;

	/**
	 * State used for body text by {@link #plainTextToHTML} method.
	 *
	 * @see #plainTextToHTML
	 */
	private static final int ASCII_HTML_TEXT = 1;

	/**
	 * State used for HTML tags by {@link #plainTextToHTML} method.
	 *
	 * @see #plainTextToHTML
	 */
	private static final int ASCII_HTML_TAG = 2;

	/**
	 * Digit characters used by {@link #escape} and {@link #toHexString}.
	 *
	 * @see #escape
	 * @see #toHexString
	 */
	private static final char[] UPPER_DIGITS =
	{ '0', '1', '2', '3', '4', '5', '6', '7',
	  '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };

	/**
	 * Digit characters used by {@link #escape} and {@link #toHexString}.
	 *
	 * @see #escape
	 * @see #toHexString
	 */
	private static final char[] LOWER_DIGITS =
	{ '0', '1', '2', '3', '4', '5', '6', '7',
	  '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };

	/**
	 * This implementation of {@link Format} produces no output. It may be used
	 * to selectively disable components of a {@link MessageFormat}.
	 */
	public static final Format EMPTY_FORMAT = new Format()
	{
		@Override
		public StringBuffer format( final Object obj, @NotNull final StringBuffer toAppendTo, @NotNull final FieldPosition pos )
		{
			return toAppendTo;
		}

		@Override
		public Object parseObject( final String source, @NotNull final ParsePosition pos )
		{
			return source;
		}
	};

	/**
	 * Binary prefixes according to IEC 60027-2 A.2 and ISO/IEC 80000 standards
	 * (index = base 1024 exponent).
	 */
	private static final String[] IEC_BINARY_PREFIXES = { "", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei", "Zi", "Yi" };

	/**
	 * Pattern describing which email addresses are valid.
	 */
	private static final Pattern VALID_EMAIL_ADDRESS_PATTERN = Pattern.compile( "[A-Za-z0-9._%+-]+@[A-Za-z0-9][A-Za-z0-9.-]+[A-Za-z]" );

	/**
	 * Characters that are illegal for any position in a file name.
	 */
	public static final String ILLEGAL_FILENAME_CHARACTERS = "#%&$<>{}*?!/\\'`\":;@+|=";

	/**
	 * Characters that are illegal as start of a file name.
	 */
	public static final String ILLEGAL_FILENAME_START_CHARACTERS = ILLEGAL_FILENAME_CHARACTERS + "-_.";

	/**
	 * Maximum number of characters in a file name.
	 */
	public static final int MAXIMUM_FILENAME_LENGTH = 255;

	/**
	 * Platform-specific line separator.
	 */
	@SuppressWarnings( "StaticNonFinalField" )
	private static String lineSeparator = null;

	/**
	 * Utility class is not supposed to be instantiated.
	 */
	private TextTools()
	{
	}

	/**
	 * Appends a fixed-length string to an {@link Appendable}. Either fills the
	 * missing spaces with the specified character, or truncates the string.
	 *
	 * @param appendable   {@link Appendable} destination.
	 * @param source       String to fix.
	 * @param length       Length of the string to return.
	 * @param rightAligned Align text to right of resulting string.
	 * @param fillChar     Character to fill with.
	 *
	 * @throws IOException from {@link Appendable#append}.
	 */
	public static void appendFixed( @NotNull final Appendable appendable, @Nullable final CharSequence source, final int length, final boolean rightAligned, final char fillChar )
	throws IOException
	{
		if ( length > 0 )
		{
			if ( ( source == null ) || ( source.length() == 0 ) )
			{
				for ( int i = 0; i < length; i++ )
				{
					appendable.append( fillChar );
				}
			}
			else if ( source.length() < length )
			{
				if ( !rightAligned )
				{
					appendable.append( source );
				}

				for ( int i = source.length(); i < length; i++ )
				{
					appendable.append( fillChar );
				}

				if ( rightAligned )
				{
					appendable.append( source );
				}
			}
			else
			{
				for ( int i = 0; i < length; i++ )
				{
					appendable.append( source.charAt( i ) );
				}
			}
		}
	}

	/**
	 * Appends a fixed-length string to a {@link StringBuffer}. Either fills the
	 * missing spaces with spaces, or truncates the string.
	 *
	 * @param sb     {@link StringBuffer} used as destination.
	 * @param source String to fix.
	 * @param length Length of the string to return.
	 */
	public static void appendFixed( @NotNull final StringBuffer sb, @Nullable final CharSequence source, final int length )
	{
		appendFixed( sb, source, length, false, ' ' );
	}

	/**
	 * Appends a fixed-length string to a {@link StringBuffer}. Either fills the
	 * missing spaces with the specified character, or truncates the string.
	 *
	 * @param sb           {@link StringBuffer} used as destination.
	 * @param source       String to fix.
	 * @param length       Length of the string to return.
	 * @param rightAligned Align text to right of resulting string.
	 * @param fillChar     Character to fill with.
	 */
	public static void appendFixed( @NotNull final StringBuffer sb, @Nullable final CharSequence source, final int length, final boolean rightAligned, final char fillChar )
	{
		try
		{
			appendFixed( (Appendable)sb, source, length, rightAligned, fillChar );
		}
		catch ( final IOException e )
		{
			/* impossible */
		}
	}

	/**
	 * Appends a fixed-length string to a {@link StringBuilder}. Either fills
	 * the missing spaces with spaces, or truncates the string.
	 *
	 * @param sb     {@link StringBuilder} used as destination.
	 * @param source String to fix.
	 * @param length Length of the string to return.
	 */
	public static void appendFixed( @NotNull final StringBuilder sb, @Nullable final CharSequence source, final int length )
	{
		appendFixed( sb, source, length, false, ' ' );
	}

	/**
	 * Appends a fixed-length string to a {@link StringBuilder}. Either fills
	 * the missing spaces with the specified character, or truncates the
	 * string.
	 *
	 * @param sb           {@link StringBuilder} used as destination.
	 * @param source       String to fix.
	 * @param length       Length of the string to return.
	 * @param rightAligned Align text to right of resulting string.
	 * @param fillChar     Character to fill with.
	 */
	public static void appendFixed( @NotNull final StringBuilder sb, @Nullable final CharSequence source, final int length, final boolean rightAligned, final char fillChar )
	{
		try
		{
			appendFixed( (Appendable)sb, source, length, rightAligned, fillChar );
		}
		catch ( final IOException e )
		{
			/* impossible */
		}
	}

	/**
	 * Appends spaces to a {@link StringBuffer}.
	 *
	 * @param buffer {@link StringBuffer} used as destination.
	 * @param length Length of the string to return.
	 */
	public static void appendSpace( @NotNull final StringBuffer buffer, final int length )
	{
		appendFixed( buffer, null, length, false, ' ' );
	}

	/**
	 * Appends spaces to a {@link StringBuilder}.
	 *
	 * @param buffer {@link StringBuilder} used as destination.
	 * @param length Length of the string to return.
	 */
	public static void appendSpace( @NotNull final StringBuilder buffer, final int length )
	{
		appendFixed( buffer, null, length, false, ' ' );
	}

	/**
	 * Returns a fixed-length string filled with the specified character.
	 *
	 * @param length   Length of the string to return.
	 * @param fillChar Character to fill with.
	 *
	 * @return Fixed-length {@link String}.
	 */
	public static String getFixed( final int length, final char fillChar )
	{
		return getFixed( null, length, false, fillChar );
	}

	/**
	 * Returns a fixed-length string. Either fills the missing spaces with the
	 * specified character, or truncates the source string.
	 *
	 * @param source       String to fix.
	 * @param length       Length of the string to return.
	 * @param rightAligned Align text to right of resulting string.
	 * @param fillChar     Character to fill with.
	 *
	 * @return Fixed-length {@link String}.
	 */
	@NotNull
	public static String getFixed( @Nullable final String source, final int length, final boolean rightAligned, final char fillChar )
	{
		final String result;

		if ( ( source != null ) && ( source.length() >= length ) )
		{
			result = source.substring( 0, length );
		}
		else // source is absent or too short => need to add fill chars
		{
			final char[] chars = new char[ length ];
			int pos = 0;

			if ( source != null )
			{
				final int len = source.length();

				if ( rightAligned )
				{
					while ( pos < ( length - len ) )
					{
						chars[ pos++ ] = fillChar;
					}
				}

				for ( int i = 0; i < len; i++ )
				{
					chars[ pos++ ] = source.charAt( i );
				}
			}

			while ( pos < length )
			{
				chars[ pos++ ] = fillChar;
			}

			result = new String( chars );
		}

		return result;
	}

	/**
	 * Trim whitespace from {@link StringBuffer}.
	 *
	 * @param sb {@link StringBuffer} to trim.
	 *
	 * @return {@code sb}.
	 */
	@NotNull
	public static StringBuffer trim( @NotNull final StringBuffer sb )
	{
		final int length = sb.length();

		int start = 0;
		while ( ( start < length ) && Character.isWhitespace( sb.charAt( start ) ) )
		{
			start++;
		}

		int end = length;
		while ( ( end > start ) && Character.isWhitespace( sb.charAt( end - 1 ) ) )
		{
			end--;
		}

		if ( start > 0 )
		{
			sb.delete( 0, start );
		}

		if ( end < length )
		{
			sb.setLength( end - start );
		}

		return sb;
	}

	/**
	 * Get trimmed sub-sequence of a character sequence.
	 *
	 * @param source Char sequence to get sub-sequence of.
	 * @param start  Start index of sub-sequence (inclusive).
	 * @param end    End index of sub-sequence (exclusive).
	 *
	 * @return Trimmed sub-sequence.
	 */
	@NotNull
	public static CharSequence getTrimmedSubsequence( @NotNull final CharSequence source, final int start, final int end )
	{
		int trimmedStart = start;
		int trimmedEnd = end;

		if ( ( trimmedStart >= 0 ) && ( trimmedStart < trimmedEnd ) && ( trimmedEnd <= source.length() ) )
		{
			while ( ( trimmedStart < trimmedEnd ) && Character.isWhitespace( source.charAt( trimmedStart ) ) )
			{
				trimmedStart++;
			}

			while ( ( trimmedStart < trimmedEnd ) && Character.isWhitespace( source.charAt( trimmedEnd - 1 ) ) )
			{
				trimmedEnd--;
			}
		}

		return source.subSequence( trimmedStart, trimmedEnd );
	}

	/**
	 * Get trimmed substring.
	 *
	 * @param source String to get substring of.
	 * @param start  Start index of substring (inclusive).
	 * @param end    End index of substring (exclusive).
	 *
	 * @return Trimmed substring.
	 */
	public static String getTrimmedSubstring( @NotNull final CharSequence source, final int start, final int end )
	{
		return (String)getTrimmedSubsequence( source, start, end );
	}

	/**
	 * Convert a plain text string to HTML formatted string. This is most useful
	 * for use in Swing tool tips (this allows you to use multi-line tool tips,
	 * for example).
	 *
	 * @param string Plain text string to convert.
	 *
	 * @return HTML-formatted text (includes '{@code <html>}' tag); {@code
	 * null} if {@code string} is {@code null}.
	 */
	@Nullable
	@Contract( value = "null -> null; !null -> !null", pure = true )
	public static String plainTextToHTML( @Nullable final String string )
	{
		final String result;

		if ( ( string != null ) && !string.isEmpty() && !string.matches( "" ) )
		{
			final int len = string.length();
			final StringBuilder resultBuffer = new StringBuilder( len + 14 );
			final StringBuilder tokenBuffer = new StringBuilder( Math.min( 40, len / 2 ) );

			resultBuffer.append( "" );

			int state = ASCII_HTML_SPACE;
			boolean inPreformattedSection = false;

			for ( int pos = 0; pos < len; pos++ )
			{
				final char ch = string.charAt( pos );

				switch ( state )
				{
					case ASCII_HTML_SPACE:
						//noinspection fallthrough
					case ASCII_HTML_TEXT:
						if ( ch == '<' )
						{
							appendHtmlText( resultBuffer, tokenBuffer, inPreformattedSection );

							tokenBuffer.setLength( 0 );
							tokenBuffer.append( '<' );
							state = ASCII_HTML_TAG;
						}
						else if ( !Character.isWhitespace( ch ) )
						{
							tokenBuffer.append( ch );
							state = ASCII_HTML_TEXT;
						}
						else if ( state == ASCII_HTML_TEXT )
						{
							if ( inPreformattedSection )
							{
								tokenBuffer.append( ch );
							}
							else
							{
								tokenBuffer.append( ' ' );
								state = ASCII_HTML_SPACE;
							}
						}
						break;

					case ASCII_HTML_TAG:
						if ( ch == '>' )
						{
							tokenBuffer.append( '>' );

							if ( inPreformattedSection )
							{
								if ( equals( "

", tokenBuffer ) )
								{
									inPreformattedSection = true;
								}
								else if ( tokenBuffer.charAt( tokenLength - 2 ) == '/' )
								{
									tokenBuffer.delete( tokenLength - 2, tokenLength - 1 );
								}

								resultBuffer.append( tokenBuffer );
								tokenBuffer.setLength( 0 );
								state = ASCII_HTML_TEXT;
							}
						}
						else if ( !Character.isWhitespace( ch ) )
						{
							tokenBuffer.append( ch );
						}
						break;
				}
			}

			appendHtmlText( resultBuffer, tokenBuffer, inPreformattedSection );

//			if ( inPreFormattedSection )
//				resultBuffer.append( "

	 * 00000: 04 d2 29 00 00 01 00 00 00 00 00 01 20 45 47 |..)......... EG|
	 * 00010: 43 45 46 45 45 43 41 43 41 43 41 43 41 43 41 |CEFEECACACACACA|
	 * 00020: 41 43 41 43 41 43 41 43 41 43 41 41 44 00 00 |ACACACACACAAD..|
	 * 00030: 00 01 c0 0c 00 20 00 01 00 00 00 00 00 06 20 |..... ........ |
	 * 00040: ac 22 22 e1                                  |."".           |
	 *