// This Source Code is in the Public Domain per: http://litesoft.org/License.txt
package org.litesoft.core.util;

import java.sql.*;
import java.util.*;
import java.util.Date;

import org.litesoft.charstreams.*;
import org.litesoft.core.simpletypes.nonpublic.*;
import org.litesoft.core.simpletypes.temporal.*;
import org.litesoft.core.simpletypes.temporal.nonpublic.*;
import org.litesoft.core.typeutils.*;
import org.litesoft.core.util.stringmatching.*;

public class UtilsCommon extends EqualSupport
{
    public static final String MUST_BE_POSITIVE = " must be positive";
    public static final String CANNOT_BE_NEGATIVE = " cannot be negative";
    public static final String NOT_ALLOWED_TO_BE_NULL = ": Not allowed to be null";

    public static final String ASCII_127 = "DEL";
    public static final String[] ASCII_LOW_32 = new String[]{"NUL", "SOH", "STX", "ETX", "EOT", "ENQ", "ACK", "BEL", "BS", "HT", "LF", "VT", "FF", "CR", "SO", "SI", "DLE", "DC1", "DC2", "DC3", "DC4", "NAK", "SYN", "ETB", "CAN", "EM", "SUB", "ESC", "FS", "GS", "RS", "US"};


    protected UtilsCommon()
    {
    }

    public static Date now()
    {
        return new Date();
    }

    public static Timestamp nowTS()
    {
        return new Timestamp( now().getTime() );
    }

    public static <T extends Enum<T>> T enumFromString( Class<T> pClass, String pEnumAsString )
    {
        if ( pClass != null )
        {
            if ( null != (pEnumAsString = Strings.noEmpty( pEnumAsString )) )
            {
                try
                {
                    return Enum.valueOf( pClass, pEnumAsString );
                }
                catch ( IllegalArgumentException ex )
                {
                    // Bad String
                }
            }
        }
        return null;
    }

    /**
     * Calculate the new "AccumulatedBitFlags" by Overriding the appropriate bit flags in
     * pPreviousAccumulatedBitFlags (based on the bits in pValidBitsOfNewBitFlags) from the pNewBitFlags.
     *
     * @param pPreviousAccumulatedBitFlags Bit Flags to be selectively overriden.
     * @param pValidBitsOfNewBitFlags      The '1' bits will indicate which bids to override.
     * @param pNewBitFlags                 The source of the override Bit Flags.
     *
     * @return The new "AccumulatedBitFlags".
     */
    public static int mutateAccumulatedBitFlags( int pPreviousAccumulatedBitFlags, int pValidBitsOfNewBitFlags, int pNewBitFlags )
    {
        return (pPreviousAccumulatedBitFlags & (~pValidBitsOfNewBitFlags)) //
               | (pValidBitsOfNewBitFlags & pNewBitFlags);
    }

    public static Boolean toBoolean( String pInput )
    {
        if ( "YES".equalsIgnoreCase( pInput ) || "Y".equalsIgnoreCase( pInput ) || "TRUE".equalsIgnoreCase( pInput ) || "T".equalsIgnoreCase( pInput ) )
        {
            return Boolean.TRUE;
        }
        if ( "NO".equalsIgnoreCase( pInput ) || "N".equalsIgnoreCase( pInput ) || "FALSE".equalsIgnoreCase( pInput ) || "F".equalsIgnoreCase( pInput ) )
        {
            return Boolean.FALSE;
        }
        return null;
    }

    /**
     * Returns a String that represents <i>pThis</i> with english code tail,
     * such as "3rd".<p>
     * <p/>
     * If <i>pThis</i> is non-negative, then append on the appropriate two
     * letter <i>english</i> code:<p>
     * <pre>
     *      st,nd,rd,th
     * </pre><p>
     *
     * @param pThis the int to convert.<p>
     *
     * @return the String representation for <i>pThis</i> and if not negative,
     *         then appended with the appropriate two letter <i>english</i>
     *         junk.<p>
     */
    public static String toNth( int pThis )
    {
        String rv = Integer.toString( pThis );
        if ( pThis < 0 )
        {
            return rv;
        }

        if ( (pThis < 10) || ('1' != rv.charAt( rv.length() - 2 )) ) // not: 10-19 & 110-119, 210-219, ... 1010-1019, ...
        {
            switch ( rv.charAt( rv.length() - 1 ) )
            {
                case '1':
                    return rv + "st";
                case '2':
                    return rv + "nd";
                case '3':
                    return rv + "rd";
                default: // 0th and n0th and 4th - 9th and n4th - n9th
                    break;
            }
        }
        return rv + "th";
    }

    public static String cvtTextForDisplay( String pText )
    {
        if ( pText == null )
        {
            return "[null]";
        }
        int length = pText.length();
        StringBuilder sb = new StringBuilder( length );
        for ( int i = 0; i < length; i++ )
        {
            char c = pText.charAt( i );
            switch ( c )
            {
                case '[':
                case ']':
                case '\\':
                case '"':
                    sb.append( '\\' );
                    sb.append( c );
                    break;
                case '\n':
                    sb.append( "\\n" );
                    break;
                case '\r':
                    sb.append( "\\r" );
                    break;
                case '\t':
                    sb.append( "\\t" );
                    break;
                case '\f':
                    sb.append( "\\f" );
                    break;
                default:
                    if ( (' ' <= c) && (c < 127) )
                    {
                        sb.append( c );
                        break;
                    }
                    sb.append( '[' );
                    sb.append( cvtCharForDisplay( c ) );
                    sb.append( ']' );
                    break;
            }
        }
        return sb.toString();
    }

    private static String cvtCharForDisplay( char pChar )
    {
        if ( pChar < 0 ) // is this even possible?
        {
            return "-" + cvtCharForDisplay( (char) -pChar );
        }
        if ( pChar < ' ' )
        {
            return ASCII_LOW_32[pChar];
        }
        if ( pChar < 127 )
        {
            return String.valueOf( pChar );
        }
        if ( pChar == 127 )
        {
            return ASCII_127;
        }
        if ( pChar < 256 )
        {
            return "HiBit-" + cvtCharForDisplay( (char) (pChar - 128) );
        }

        return "x" + Integer.toString( pChar, 16 ); // toHex
    }

    public static Object[] convert( int pEntries, Enumeration<Object> pEnumeration )
    {
        Object[] them = new Object[pEntries];
        for ( int i = 0; (i < pEntries) && pEnumeration.hasMoreElements(); i++ )
        {
            them[i] = pEnumeration.nextElement();
        }
        return them;
    }

    public static boolean checkIndex( int pIndex, int pMax, boolean pInclusive )
    {
        return ((0 <= pIndex) && (pIndex < pMax)) || (pInclusive && (pIndex == pMax));
    }

    public static void validateIndex( int pIndex, int pMax, boolean pInclusive )
            throws IllegalArgumentException
    {
        if ( !checkIndex( pIndex, pMax, pInclusive ) )
        {
            throw new IllegalArgumentException( "!( 0 <= " + pIndex + " " + (pInclusive ? "<=" : "<") + " " + pMax + " )" );
        }
    }

    /**
     * return pIndex constained between 0 (inclusive) and pMax (pInclusive).  If the effective 'max' is less than 0, then 0 will be returned.
     */
    public static int constrainIndex( int pIndex, int pMax, boolean pInclusive )
    {
        if ( (pMax <= pIndex) || (pInclusive && (pIndex == pMax)) )
        {
            pIndex = pInclusive ? pMax : pMax - 1;
        }
        return (pIndex < 0) ? 0 : pIndex;
    }

    public static char toHexDigit( int pZeroTo15 )
    {
        pZeroTo15 &= 15;
        return (pZeroTo15 < 0) || (15 < pZeroTo15) ? '?' : HEX.charAt( pZeroTo15 );
    }

    /**
     * Attempt to interpret (char) pHex as a Hex Character
     *
     * @return -1 if not a HEX character, otherwise the 0-15
     */
    public static int hexFor( char pHex )
    {
        return HEX.indexOf( Character.toUpperCase( pHex ) );
    }

    public static int fromHexDigit( char pHex )
            throws IllegalArgumentException
    {
        int rv = hexFor( pHex );
        if ( rv == -1 )
        {
            throw new IllegalArgumentException( "Not a Hex digit '" + pHex + "': " + (int) pHex );
        }
        return rv;
    }

    private static final String HEX = "0123456789ABCDEF";

    public static char[] charToHex( char c )
    {
        char[] rv = new char[4];
        int cv = c;
        for ( int i = 3; i >= 0; i-- )
        {
            rv[i] = toHexDigit( cv );
            cv /= 16;
        }
        return rv;
    }

    public static char charFromHex( char[] pHex )
            throws IllegalArgumentException
    {
        int rv = 0;
        for ( char c : pHex )
        {
            rv = (rv * 16) + fromHexDigit( c );
        }
        return (char) rv;
    }

    public static String toHex( byte[] pBytes )
    {
        if ( pBytes == null )
        {
            return null;
        }
        StringBuilder sb = new StringBuilder( pBytes.length + pBytes.length );
        for ( byte zByte : pBytes )
        {
            sb.append( toHexDigit( zByte >>> 4 ) );
            sb.append( toHexDigit( zByte ) );
        }
        return sb.toString();
    }

    public static byte[] fromHex( String pString )
    {
        if ( pString == null )
        {
            return null;
        }
        if ( (pString.length() & 1) == 1 )
        {
            throw new IllegalArgumentException( "Can't be HEX as it is 'Odd' Length: '" + pString + "'" );
        }
        int zCharAt = 0;
        byte[] zBytes = new byte[pString.length() / 2];
        for ( int i = 0; i < zBytes.length; i++ )
        {
            int z1st = fromHexDigit( pString.charAt( zCharAt++ ) );
            int z2nd = fromHexDigit( pString.charAt( zCharAt++ ) );
            zBytes[i] = (byte) ((z1st << 4) + z2nd);
        }
        return zBytes;
    }

    public static String getMax2PlacePercentage( int pPortions )
    {
        if ( pPortions == 0 )
        {
            return null;
        }
        int portion = 10000 / pPortions;
        String s = "" + portion;
        while ( s.length() < 3 )
        {
            s = "0" + s;
        }
        int wholeLen = s.length() - 2;
        s = s.substring( 0, wholeLen ) + "." + s.substring( wholeLen );
        while ( s.charAt( s.length() - 1 ) == '0' )
        {
            s = s.substring( 0, s.length() - 1 );
        }
        if ( s.charAt( s.length() - 1 ) == '.' )
        {
            s = s.substring( 0, s.length() - 1 );
        }
        return s + "%";
    }

    public static String appendNonEmpties( String pExisting, String pSeparator, String pToAppend )
    {
        if ( Strings.isNullOrEmpty( pToAppend ) )
        {
            return Strings.deNull( pExisting ).trim();
        }
        if ( Strings.isNullOrEmpty( pExisting ) )
        {
            return pToAppend.trim();
        }
        return pExisting.trim() + Strings.deNull( pSeparator ) + pToAppend.trim();
    }

    public static boolean areNonArraysEqual( boolean pThis, boolean pThat )
    {
        return (pThis == pThat);
    }

    public static boolean areNonArraysEqual( int pThis, int pThat )
    {
        return (pThis == pThat);
    }

    public static boolean isEmptyString( Object pObject )
    {
        return pObject == null || ((pObject instanceof String) && Strings.isBlank( (String) pObject ));
    }

    public static boolean areBothEmptyStrings( Object pThis, Object pThat )
    {
        return isEmptyString( pThis ) && isEmptyString( pThat );
    }

    public static boolean isBooleanNotTrue( Object pObject )
    {
        return pObject == null || Boolean.FALSE.equals( pObject );
    }

    public static boolean areBothBooleanNotTrue( Object pThis, Object pThat )
    {
        return isBooleanNotTrue( pThis ) && isBooleanNotTrue( pThat );
    }

    public static boolean isNullEquivalent( Object pObject )
    {
        return isEmptyString( pObject ) || isBooleanNotTrue( pObject );
    }

    public static boolean areBothNullEquivalent( Object pThis, Object pThat )
    {
        return isNullEquivalent( pThis ) && isNullEquivalent( pThat );
    }

    public static boolean areEqual( Object pThis, Object pThat )
    {
        if ( Objects.areNonArraysEqual( pThis, pThat ) )
        {
            return true;
        }
        // Both CAN'T be null
        if ( (pThis instanceof Object[]) && (pThat instanceof Object[]) )
        {
            return areArraysEqual( (Object[]) pThis, (Object[]) pThat );
        }
        return (pThis instanceof int[]) && (pThat instanceof int[]) && areArraysEqual( (int[]) pThis, (int[]) pThat );
    }

    public static int insureNonNegative( int pValue )
    {
        return (pValue < 0) ? 0 : pValue;
    }

    public static <K, V> Map<K, V> deNull( Map<K, V> pToCheck )
    {
        if ( pToCheck == null )
        {
            pToCheck = Collections.emptyMap();
        }
        return pToCheck;
    }

    public static <T> List<T> deNull( List<T> pToCheck )
    {
        if ( pToCheck == null )
        {
            pToCheck = Collections.emptyList();
        }
        return pToCheck;
    }

    public static <T> Set<T> deNull( Set<T> pToCheck )
    {
        if ( pToCheck == null )
        {
            pToCheck = Collections.emptySet();
        }
        return pToCheck;
    }

    public static <T> Collection<T> deNull( Collection<T> pToCheck )
    {
        if ( pToCheck == null )
        {
            pToCheck = Collections.emptyList();
        }
        return pToCheck;
    }

    public static String deNullToString( Object value, Object defaultValue )
    {
        return Strings.deNull( noEmptyToString( value ), noEmptyToString( defaultValue ) );
    }

    public static String noEmptyToString( Object value )
    {
        return Strings.noEmpty( Strings.nullOKtoString( value ) );
    }

    public static int intValue( Integer pInteger, int pDefault )
    {
        return (pInteger != null) ? pInteger : pDefault;
    }

    public static String trimToLength( String pSource, int pMaxAcceptableLength )
            throws IllegalArgumentException
    {
        pMaxAcceptableLength = assertNotNegative( "MaxAcceptableLength", pMaxAcceptableLength );
        return ((pSource = Strings.deNull( pSource )).length() <= pMaxAcceptableLength) ? pSource : pSource.substring( 0, pMaxAcceptableLength );
    }

    public static String trimToLength( String pSource, int pMaxAcceptableLength, String pTrimmedSuffix )
            throws IllegalArgumentException
    {
        pMaxAcceptableLength = assertNotNegative( "MaxAcceptableLength", pMaxAcceptableLength );
        if ( (pSource = Strings.deNull( pSource )).length() <= pMaxAcceptableLength )
        {
            return pSource;
        }
        int zSuffixLength = (pTrimmedSuffix = Strings.deNull( pTrimmedSuffix )).length();
        if ( zSuffixLength == 0 )
        {
            return pSource.substring( 0, pMaxAcceptableLength );
        }
        if ( pMaxAcceptableLength < zSuffixLength )
        {
            pTrimmedSuffix = pTrimmedSuffix.substring( 0, zSuffixLength = pMaxAcceptableLength );
        }
        pMaxAcceptableLength -= zSuffixLength;
        return pSource.substring( 0, pMaxAcceptableLength ) + pTrimmedSuffix;
    }

    public static String combineAsLines( String... pStrings )
    {
        StringBuilder sb = new StringBuilder();
        if ( pStrings != null )
        {
            for ( String s : pStrings )
            {
                sb.append( s );
                sb.append( '\n' );
            }
        }
        return sb.toString();
    }

    public static String[] splitLines( String pString )
    {
        pString = Strings.normalizeNewLines( pString );

        return Strings.parseChar( pString, '\n' );
    }

    public static String combine( String pSeparator, Object... pObjects )
    {
        if ( isNullOrEmpty( pObjects ) )
        {
            return null;
        }
        StringBuilder sb = new StringBuilder();

        sb.append( pObjects[0] );

        for ( int i = 1; i < pObjects.length; i++ )
        {
            sb.append( pSeparator );
            sb.append( pObjects[i] );
        }
        return sb.toString();
    }

    public static String combine( char pSeparator, String... pStrings )
    {
        if ( isNullOrEmpty( pStrings ) )
        {
            return null;
        }
        StringBuilder sb = new StringBuilder();

        sb.append( pStrings[0] );

        for ( int i = 1; i < pStrings.length; i++ )
        {
            sb.append( pSeparator );
            sb.append( pStrings[i] );
        }
        return sb.toString();
    }

    public static void assertAll7BitAsciiAlpha( String pObjectName, String pToBeAssert )
            throws IllegalArgumentException
    {
        Objects.assertNotNull( pObjectName, pToBeAssert );
        for ( int i = 0; i < pToBeAssert.length(); i++ )
        {
            char c = pToBeAssert.charAt( i );
            if ( !(is7BitAsciiAlpha( c )) )
            {
                throw new IllegalArgumentException( pObjectName + ": '" + c + "' Not a 7 Bit Ascii Alpha at: " + i );
            }
        }
    }

    public static void assertNotEqual( String pObjectName, long pNotExpected, long pActual )
            throws IllegalArgumentException
    {
        if ( pNotExpected == pActual )
        {
            throw new IllegalArgumentException( pObjectName + ": '" + pNotExpected + "' Not allowed" );
        }
    }

    public static void assertTrue( String pValueDescription, boolean pActual )
            throws IllegalArgumentException
    {
        if ( !pActual )
        {
            throw new IllegalArgumentException( pValueDescription + ": Expected to be true" );
        }
    }

    public static void assertNotEmptyIfNotNull( String pParamName, String pToBeAsserted )
            throws IllegalArgumentException
    {
        if ( (pToBeAsserted != null) && (pToBeAsserted.length() == 0) )
        {
            throw new IllegalArgumentException( pParamName + ": Not allowed to be empty ('')" );
        }
    }

    public static void assertNotNullNotEmptyNoSpaces( String pErrorMessage, String pStringToAssert )
            throws IllegalArgumentException
    {
        if ( Strings.isNullOrEmptyOrSpaces( pStringToAssert ) )
        {
            Strings.nullOrEmptyOrSpace( pErrorMessage, "String" );
        }
    }

    public static String assertNotNullNotEmpty( String pErrorMessage, String pStringToAssert )
            throws IllegalArgumentException
    {
        String rv = Strings.noEmpty( pStringToAssert );
        if ( rv == null )
        {
            Strings.nullOrEmpty( pErrorMessage, "String" );
        }
        return rv;
    }

    public static void assertNotNullNotEmpty( String pErrorMessage, Collection pCollectionToAssert )
            throws IllegalArgumentException
    {
        if ( isNullOrEmpty( pCollectionToAssert ) )
        {
            Strings.nullOrEmpty( pErrorMessage, "Collection" );
        }
    }

    public static String assertNoLeadingOrTrailingWhiteSpace( String pErrorMessage, String pStringToAssert )
            throws IllegalArgumentException
    {
        if ( pStringToAssert != null )
        {
            String rv = pStringToAssert.trim();
            if ( pStringToAssert.length() != rv.length() )
            {
                Strings.error( "String", pErrorMessage, "No Leading or trailing whitespace allowed" );
            }
        }
        return pStringToAssert;
    }

    public static String[] assertNotNullNotEmptyAndNoNullsOrEmptiesAndTrim( String pErrorMessage, String[] pStringArrayToAssert )
            throws IllegalArgumentException
    {
        assertNotNullNotEmpty( pErrorMessage, pStringArrayToAssert );
        return assertNoNullsOrEmptiesAndTrim( pErrorMessage, pStringArrayToAssert );
    }

    public static void assertNotNullNotEmpty( String pErrorMessage, String[] pStringArrayToAssert )
            throws IllegalArgumentException
    {
        if ( isNullOrEmpty( pStringArrayToAssert ) )
        {
            Strings.nullOrEmpty( pErrorMessage, "String[]" );
        }
    }

    public static String[] assertNoNullsOrEmptiesAndTrim( String pErrorMessage, String[] pStringArrayToAssert )
            throws IllegalArgumentException
    {
        String[] rv = new String[pStringArrayToAssert.length];
        for ( int i = 0; i < pStringArrayToAssert.length; i++ )
        {
            String s = Strings.noEmpty( pStringArrayToAssert[i] );
            if ( s == null )
            {
                Strings.nullOrEmpty( pErrorMessage + "[" + i + "]", "String[]" );
            }
            rv[i] = s;
        }
        return rv;
    }

    /**
     * Assert that "value" is not null or when converted to a String is not
     * empty and then return resulting "value" trimmed.
     *
     * @param what  "field" was the problem on
     * @param value to check
     *
     * @return value converted to a String minus any leading and trailing spaces
     */
    public static String assertNoEmptyToString( String what, Object value )
    {
        String strValue = noEmptyToString( value );
        if ( strValue == null )
        {
            Strings.nullOrEmpty( what, String.valueOf( justClassNameOf( value ) ) );
        }
        return strValue;
    }

    /**
     * Assert that "value" is not null or empty (if it is a String) and return
     * "value" trimmed (if it is a String).
     *
     * @param what  "field" was the problem on
     * @param value to check
     *
     * @return value minus any leading and trailing spaces
     */
    public static <T> T assertNotNullOrEmpty( String what, T value )
    {
        if ( value == null )
        {
            Strings.nullOrEmpty( what, String.valueOf( justClassNameOf( value ) ) );
        }
        if ( value instanceof String )
        {
            value = cast( assertNotNullNotEmpty( what, value.toString() ) );
        }
        return value;
    }

    public static Long assertNotNegative( String pName, Long pValue )
            throws IllegalArgumentException
    {
        if ( pValue != null )
        {
            assertNotNegative( pName, pValue.longValue() );
        }
        return pValue;
    }

    public static long assertNotNegative( String pName, long pValue )
            throws IllegalArgumentException
    {
        if ( pValue < 0 )
        {
            throw new IllegalArgumentException( pName + CANNOT_BE_NEGATIVE );
        }
        return pValue;
    }

    public static Integer assertNotNegative( String pName, Integer pValue )
            throws IllegalArgumentException
    {
        if ( pValue != null )
        {
            assertNotNegative( pName, pValue.intValue() );
        }
        return pValue;
    }

    public static int assertNotNegative( String pName, int pValue )
            throws IllegalArgumentException
    {
        if ( pValue < 0 )
        {
            throw new IllegalArgumentException( pName + CANNOT_BE_NEGATIVE );
        }
        return pValue;
    }

    public static int assertPositive( String pName, int pValue )
            throws IllegalArgumentException
    {
        if ( pValue <= 0 )
        {
            throw new IllegalArgumentException( pName + MUST_BE_POSITIVE );
        }
        return pValue;
    }

    public static String displayFormatFlag( boolean pFlag, String pTrueString )
    {
        return pFlag ? pTrueString : "";
    }

    public static boolean endsWithPathSep( String pPath )
    {
        return (pPath != null) && isPathSep( pPath.charAt( pPath.length() - 1 ) );
    }

    public static int lastPathSepAt( String pPath )
    {
        if ( pPath != null )
        {
            for ( int at = pPath.length(); --at >= 0; )
            {
                if ( isPathSep( pPath.charAt( at ) ) )
                {
                    return at;
                }
            }
        }
        return -1;
    }

    public static boolean isPathSep( char pChar )
    {
        return (pChar == '/') || (pChar == '\\') || (pChar == ':');
    }

    public static String forwardSlashPath( String pPath )
    {
        return pPath.replace( '\\', '/' );
    }

    public static String multiLineHelper( String pLine, String pAppend )
    {
        return Strings.isNullOrEmpty( pLine ) ? "" : (pLine + pAppend);
    }

    /**
     * Compares pA object with the pB object for order.  Nulls rise!<p>
     *
     * @return a negative integer, zero, or a positive integer as the pA object
     *         is less than, equal to, or greater than the pB object.
     *
     * @throws ClassCastException if the specified object's type prevents it
     *                            from being compared to this Object.
     */
    public static int compareNullsOK( Comparable pThis, Comparable pThem )
    {
        return Compare.firstNullsOK( pThis, pThem ).result();
    }

    /**
     * Compares pA object with the pB object for Ascending Order.  Nulls rise!<p>
     *
     * @return a negative integer, zero, or a positive integer as the pA object
     *         is less than, equal to, or greater than the pB object.
     *
     * @throws ClassCastException if the specified object's type prevents it
     *                            from being compared to this Object.
     */
    public static int compareToAscending( Comparable pThis, Comparable pThem )
    {
        return Compare.firstNullsOK( pThis, pThem ).result();
    }

    /**
     * Compares pA object with the pB object for Descending Order.  Nulls sink!<p>
     *
     * @return a negative integer, zero, or a positive integer as the pA object
     *         is greater than, equal to, or less than the pB object.
     *
     * @throws ClassCastException if the specified object's type prevents it
     *                            from being compared to this Object.
     */
    public static int compareToDescending( Comparable pThis, Comparable pThem )
    {
        return compareToAscending( pThem, pThis ); // Note param flipped order!
    }

    public static boolean firstLessThanSecond( Comparable pFirst, Comparable pSecond )
    {
        //noinspection unchecked
        return pFirst.compareTo( pSecond ) < 0;
    }

    public static boolean firstGreaterThanSecond( Comparable pFirst, Comparable pSecond )
    {
        //noinspection unchecked
        return pFirst.compareTo( pSecond ) > 0;
    }

    // Groups

    // Primitives:

    // int Group:

    public static String zeroPadIt( int pMinDesiredLength, int pIt )
    {
        String rv = String.valueOf( pIt );
        while ( rv.length() < pMinDesiredLength )
        {
            rv = "0" + rv;
        }
        return rv;
    }

    public static String padIt( int pMinDesiredLength, int pIt )
    {
        return padIt( pMinDesiredLength, "" + pIt );
    }

    public static String iTpad( int pIt, int pMinDesiredLength )
    {
        return iTpad( "" + pIt, pMinDesiredLength );
    }

    public static boolean isNullOrEmpty( int[] pArrayToCheck )
    {
        return (pArrayToCheck == null || pArrayToCheck.length == 0);
    }

    public static boolean isNullOrEmpty( Collection pCollectionToCheck )
    {
        return (pCollectionToCheck == null || pCollectionToCheck.isEmpty());
    }

    public static boolean isNotNullOrEmpty( Collection pCollectionToCheck )
    {
        return (pCollectionToCheck != null && !pCollectionToCheck.isEmpty());
    }

    public static boolean areArraysEqual( byte[] pThis, byte[] pThat )
    {
        if ( pThis == pThat ) // handles if both are null
        {
            return true;
        }
        if ( (pThis != null) && (pThat != null) && (pThis.length == pThat.length) )
        {
            for ( int i = pThis.length; --i >= 0; )
            {
                if ( pThis[i] != pThat[i] )
                {
                    return false;
                }
            }
            return true;
        }
        return false;
    }

    public static boolean areArraysEqual( int[] pThis, int[] pThat )
    {
        if ( pThis == pThat ) // handles if both are null
        {
            return true;
        }
        if ( (pThis != null) && (pThat != null) && (pThis.length == pThat.length) )
        {
            for ( int i = pThis.length; --i >= 0; )
            {
                if ( pThis[i] != pThat[i] )
                {
                    return false;
                }
            }
            return true;
        }
        return false;
    }

    // Objects:

    // Object Group:

    public static String padIt( int pMinDesiredLength, Object pIt )
    {
        return padIt( pMinDesiredLength, "" + pIt );
    }

    public static String iTpad( Object pIt, int pMinDesiredLength )
    {
        return iTpad( "" + pIt, pMinDesiredLength );
    }

    private static void assertElementsNotNull( String pErrorMessage, Object[] pArrayToAssert )
            throws IllegalArgumentException
    {
        for ( int i = pArrayToAssert.length; --i >= 0; )
        {
            if ( pArrayToAssert[i] == null )
            {
                Strings.nullOrEmpty( pErrorMessage, "Object[" + i + "]" );
            }
        }
    }

    public static void assertNotNullAndElementsNotNull( String pErrorMessage, Object[] pArrayToAssert )
            throws IllegalArgumentException
    {
        if ( pArrayToAssert == null )
        {
            Strings.nullOrEmpty( pErrorMessage, "Object[]" );
        }
        assertElementsNotNull( pErrorMessage, pArrayToAssert );
    }

    public static void assertNotNullNotEmptyAndElementsNotNull( String pErrorMessage, Object[] pArrayToAssert )
            throws IllegalArgumentException
    {
        assertNotNullNotEmpty( pErrorMessage, pArrayToAssert );
        assertElementsNotNull( pErrorMessage, pArrayToAssert );
    }

    public static void assertNotNullNotEmpty( String pErrorMessage, Object[] pArrayToAssert )
            throws IllegalArgumentException
    {
        if ( isNullOrEmpty( pArrayToAssert ) )
        {
            Strings.nullOrEmpty( pErrorMessage, "Object[]" );
        }
    }

    public static boolean isNotNull( Object pToCheck )
    {
        return (pToCheck != null);
    }

    public static int getNonNullEntryCount( Object[] pArrayToCheck )
    {
        int rv = 0;
        if ( pArrayToCheck != null )
        {
            for ( int i = pArrayToCheck.length; --i >= 0; )
            {
                if ( pArrayToCheck[i] != null )
                {
                    rv++;
                }
            }
        }
        return rv;
    }

    public static boolean hasEntries( Object[] pArrayToCheck )
    {
        if ( pArrayToCheck != null )
        {
            for ( int i = pArrayToCheck.length; --i >= 0; )
            {
                if ( pArrayToCheck[i] != null )
                {
                    return true;
                }
            }
        }
        return false;
    }

    public static boolean isNotNullOrEmpty( Object[] pArrayToCheck )
    {
        return ((pArrayToCheck != null) && (pArrayToCheck.length != 0));
    }

    public static boolean isNullOrEmpty( Object[] pArrayToCheck )
    {
        return ((pArrayToCheck == null) || (pArrayToCheck.length == 0));
    }

    public static boolean areArraysEqual( Object[] pThis, Object[] pThat )
    {
        if ( pThis == pThat ) // handles if both are null
        {
            return true;
        }
        if ( (pThis != null) && (pThat != null) && (pThis.length == pThat.length) )
        {
            for ( int i = pThis.length; --i >= 0; )
            {
                if ( !areEqual( pThis[i], pThat[i] ) )
                {
                    return false;
                }
            }
            return true;
        }
        return false;
    }

    public static boolean isAnyTrue( Boolean... pToSearch )
    {
        if ( pToSearch != null )
        {
            for ( Boolean zBoolean : pToSearch )
            {
                if ( Boolean.TRUE.equals( zBoolean ) )
                {
                    return true;
                }
            }
        }
        return false;
    }

    public static boolean isOneOf( String pToFind, String[] pToSearch )
    {
        return isObjectOneOf( pToFind, pToSearch );
    }

    public static boolean isOneOf( Object pToFind, Object[] pToSearch )
    {
        return isObjectOneOf( pToFind, pToSearch );
    }

    private static boolean isObjectOneOf( Object pToFind, Object[] pToSearch )
    {
        if ( pToSearch != null )
        {
            for ( int i = pToSearch.length; --i >= 0; )
            {
                if ( areEqual( pToFind, pToSearch[i] ) )
                {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * Is the string 'pInQuestion' made up of the 'pParts' where if only 1, then must be equal, otherwise
     * the pInQuestion.startsWith(first) && pInQuestion.endsWith(last) && the middle must be found in
     * order with no overlap between.
     *
     * @param pInQuestion - null will always return false
     * @param pParts      - Null treated as empty & Null Elements treated as ""
     */
    public static boolean isMadeUpFromParts( String pInQuestion, String[] pParts )
    {
        StringMatcher zSM = StringMatcherFactory.createEquals( pParts );
        return (zSM != null) && zSM.matches( pInQuestion );
    }

    public static int indexOfOrLength( String pToSearch, char pToFind )
    {
        return helperIndexOfOrLength( pToSearch, pToSearch.indexOf( pToFind ) );
    }

    public static int indexOfOrLength( String pToSearch, String pToFind )
    {
        return helperIndexOfOrLength( pToSearch, pToSearch.indexOf( pToFind ) );
    }

    private static int helperIndexOfOrLength( String pToSearch, int pAt )
    {
        return (pAt != -1) ? pAt : pToSearch.length();
    }

    // String Group

    public static String[] removeStringFromArray( String[] pArray, int pIndexToRemove )
    {
        if ( isNullOrEmpty( pArray ) || (pIndexToRemove < 0) || (pArray.length <= pIndexToRemove) )
        {
            return pArray;
        }
        int zNewLength = pArray.length - 1;
        String[] zNewArray = new String[zNewLength];
        if ( pIndexToRemove != 0 )
        {
            System.arraycopy( pArray, 0, zNewArray, 0, pIndexToRemove );
        }
        if ( pIndexToRemove != zNewLength )
        {
            System.arraycopy( pArray, pIndexToRemove + 1, zNewArray, pIndexToRemove, zNewLength - pIndexToRemove );
        }
        return zNewArray;
    }

    public static String[] appendStringArrays( String[] pArray1, String[] pArray2 )
    {
        if ( isNullOrEmpty( pArray2 ) )
        {
            return pArray1;
        }
        if ( isNullOrEmpty( pArray1 ) )
        {
            return pArray2;
        }
        String[] joined = new String[pArray1.length + pArray2.length];
        System.arraycopy( pArray1, 0, joined, 0, pArray1.length );
        System.arraycopy( pArray2, 0, joined, pArray1.length, pArray2.length );
        return joined;
    }

    public static String[] prependString( String pNewFirst, String[] pTheRest )
    {
        return appendStringArrays( new String[]{pNewFirst}, pTheRest );
    }

    public static String[] appendString( String[] pCurArray, String pNewLast )
    {
        return appendStringArrays( pCurArray, new String[]{pNewLast} );
    }

    public static String noSpaces( String pSource )
    {
        if ( (pSource == null) || (pSource.length() == 0) || (pSource.indexOf( ' ' ) == -1) )
        {
            return pSource;
        }
        StringBuilder sb = new StringBuilder( pSource );
        for ( int i = pSource.length(); --i >= 0; )
        {
            if ( sb.charAt( i ) == ' ' )
            {
                sb.deleteCharAt( i );
            }
        }
        return sb.toString();
    }

    public static String padIt( int pMinDesiredLength, String pIt )
    {
        String rv = Strings.deNull( pIt );
        int padBy = pMinDesiredLength - rv.length();
        return (padBy <= 0) ? rv : (Strings.spaces( padBy ) + rv);
    }

    public static String iTpad( String pIt, int pMinDesiredLength )
    {
        String rv = Strings.deNull( pIt );
        int padBy = pMinDesiredLength - rv.length();
        return (padBy <= 0) ? rv : (rv + Strings.spaces( padBy ));
    }

    public static boolean containsAnyOf( String pToCheck, String pCharsToCheckFor )
    {
        if ( (pToCheck != null) && (pToCheck.length() > 0) && //
             (pCharsToCheckFor != null) && (pCharsToCheckFor.length() > 0) )
        {
            for ( int i = 0; i < pCharsToCheckFor.length(); i++ )
            {
                if ( -1 != pToCheck.indexOf( pCharsToCheckFor.charAt( i ) ) )
                {
                    return true;
                }
            }
        }
        return false;
    }

    public static String getCommonTail( String pStr1, String pStr2 )
    {
        // Binary Search
        int goodTailLength = 0;
        for ( int potentialLength = Math.min( pStr1.length(), pStr2.length() ); potentialLength > goodTailLength; )
        {
            int mid = (goodTailLength + potentialLength + 1) / 2;
            String tail = pStr1.substring( pStr1.length() - mid );
            if ( pStr2.endsWith( tail ) )
            {
                goodTailLength = mid;
            }
            else
            {
                potentialLength = mid - 1;
            }
        }
        return (goodTailLength == 0) ? "" : pStr1.substring( pStr1.length() - goodTailLength );
    }

    public static String toStringNullToEmpty( Object pObject )
    {
        if ( pObject != null )
        {
            String rv = pObject.toString();
            if ( rv != null )
            {
                return rv;
            }
        }
        return "";
    }

    public static String toStringOrNull( Object pObject )
    {
        return Strings.noEmpty( (pObject != null) ? pObject.toString() : null );
    }

    public static String toString( Object pObject )
    {
        if ( pObject != null )
        {
            String rv = pObject.toString();
            if ( rv != null )
            {
                return rv;
            }
        }
        return null;
    }

    public static String optionsToString( Object[] pObjects )
    {
        if ( pObjects == null )
        {
            return "No Options Available";
        }
        StringBuilder sb = new StringBuilder( "Valid Options are" );
        String prefix = ": ";
        //noinspection ForLoopReplaceableByForEach
        for ( int i = 0; i < pObjects.length; i++ )
        {
            sb.append( prefix ).append( pObjects[i] );
            prefix = ", ";
        }
        return sb.toString();
    }

    public static String toString( Object[] pObjects )
    {
        if ( pObjects == null )
        {
            return "null";
        }
        return new StringBuilder().append( '<' ).append( pObjects.length ).append( ':' ).append( toString( pObjects, "," ) ).append( '>' ).toString();
    }

    public static String toString( Object[] pObjects, String separator )
    {
        if ( pObjects == null )
        {
            return "null";
        }
        StringBuilder sb = new StringBuilder();
        if ( pObjects.length > 0 )
        {
            sb.append( pObjects[0] );
            //noinspection ForLoopReplaceableByForEach
            for ( int i = 1; i < pObjects.length; i++ )
            {
                sb.append( separator ).append( pObjects[i] );
            }
        }
        return sb.toString();
    }

    public static Map<String, String> createHashMap( String... pKeyValuePairs )
            throws IllegalArgumentException
    {
        return populate( new HashMap<String, String>(), pKeyValuePairs );
    }

    public static Map<String, String> populate( Map<String, String> pToPopulate, String... pNameValuePairs )
            throws IllegalArgumentException
    {
        if ( pNameValuePairs != null )
        {
            if ( (pNameValuePairs.length & 1) == 1 )
            {
                throw new IllegalArgumentException( "NameValuePairs not paired" );
            }
            for ( int i = 0; i < pNameValuePairs.length; )
            {
                String name = pNameValuePairs[i++];
                String value = pNameValuePairs[i++];
                // noinspection unchecked
                pToPopulate.put( name, value );
            }
        }
        return pToPopulate;
    }

    public static void populate( Map pToPopulate, Map pNewContents )
    {
        if ( pNewContents != null )
        {
            //noinspection unchecked
            pToPopulate.putAll( pNewContents );
        }
    }

    public static String[] getSortedKeysAsStrings( Map pMap )
    {
        String[] names = toStringArray( pMap.keySet().toArray() );
        Arrays.sort( names );
        return names;
    }

    public static String[] arrayOfOne( String pString )
    {
        return new String[]{pString};
    }

    public static String[] toStringArray( Collection pCollection )
    {
        return (pCollection == null) ? null : toStringArray( pCollection.toArray() );
    }

    public static String[] toStringArray( Object[] pObjects )
    {
        if ( pObjects == null )
        {
            return null;
        }
        String[] strings = new String[pObjects.length];
        for ( int i = 0; i < pObjects.length; i++ )
        {
            Object o = pObjects[i];
            strings[i] = (o == null) ? null : o.toString();
        }
        return strings;
    }

    public static List<String> toStringList( Collection pCollection )
    {
        return (pCollection == null) ? null : toStringList( pCollection.toArray() );
    }

    public static List<String> toStringList( Object[] pObjects )
    {
        if ( pObjects == null )
        {
            return null;
        }
        List<String> strings = new ArrayList<String>( pObjects.length );
        for ( Object o : pObjects )
        {
            strings.add( (o == null) ? null : o.toString() );
        }
        return strings;
    }

    public static Map<String, String> addPropertiesTo( Map<String, String> pMap, String... pProperty_NameValues )
            throws IllegalArgumentException
    {
        if ( isNotNullOrEmpty( pProperty_NameValues ) )
        {
            if ( (pProperty_NameValues.length & 1) != 0 )
            {
                throw new IllegalArgumentException( "Attempt to add Properties that were NOT Name/Value pairs" );
            }
            for ( int i = 0; i < pProperty_NameValues.length; i += 2 )
            {
                pMap.put( pProperty_NameValues[i], pProperty_NameValues[i + 1] );
            }
        }
        return pMap;
    }

    public static String[] stringMapToStringArray( Map<String, String> pMap )
    {
        if ( pMap == null || pMap.isEmpty() )
        {
            return Strings.EMPTY_ARRAY;
        }
        String[] rv = new String[pMap.size() * 2];
        int i = 0;
        for ( Map.Entry<String, String> zEntry : pMap.entrySet() )
        {
            rv[i++] = zEntry.getKey();
            rv[i++] = zEntry.getValue();
        }
        return rv;
    }

    public static boolean isAll7BitAsciiAlpha( String pString, int pMinLength )
    {
        if ( (pString == null) || (pString.length() < pMinLength) )
        {
            return false;
        }
        for ( int i = 0; i < pString.length(); i++ )
        {
            if ( !is7BitAsciiAlpha( pString.charAt( i ) ) )
            {
                return false;
            }
        }
        return true;
    }

    public static boolean isAlphaNumeric( String pString, int pMinLength )
    {
        if ( (pString == null) || (pString.length() < pMinLength) )
        {
            return false;
        }
        for ( int i = 0; i < pString.length(); i++ )
        {
            if ( !isAlphaNumeric( pString.charAt( i ) ) )
            {
                return false;
            }
        }
        return true;
    }

    public static boolean isNumeric( String pString, int pMinLength )
    {
        if ( (pString == null) || (pString.length() < pMinLength) )
        {
            return false;
        }
        for ( int i = 0; i < pString.length(); i++ )
        {
            if ( !isNumeric( pString.charAt( i ) ) )
            {
                return false;
            }
        }
        return true;
    }

    public static boolean isValidAttributeIdentifier( String pIdentifier )
    {
        return isValidAttributeIdentifier( pIdentifier, 2 );
    }

    public static boolean isValidAttributeIdentifier( String pIdentifier, int pMinLength )
    {
        if ( (pIdentifier == null) || (pIdentifier.length() < pMinLength) )
        {
            return false;
        }

        if ( !isValidAttributeIdentifierStartCharacter( pIdentifier.charAt( 0 ) ) )
        {
            return false;
        }
        for ( int i = 1; i < pIdentifier.length(); i++ )
        {
            if ( !isValidAttributeIdentifierRestCharacter( pIdentifier.charAt( i ) ) )
            {
                return false;
            }
        }
        return true;
    }

    private static boolean isValidAttributeIdentifierStartCharacter( char pChar )
    {
//        return Character.isJavaIdentifierStart( pChar );
        return (('A' <= pChar) && (pChar <= 'Z'));
    }

    private static boolean isValidAttributeIdentifierRestCharacter( char pChar )
    {
//        return Character.isJavaIdentifierPart( pChar );
        return isAlphaNumeric( pChar );
    }

    public static boolean isAlphaNumeric( char pChar )
    {
        return isAlpha( pChar ) || isNumeric( pChar );
    }

    public static boolean isAlpha( char pChar )
    {
        return is7BitAsciiAlpha( pChar );
    }

    public static boolean isNumeric( char pChar )
    {
        return ('0' <= pChar) && (pChar <= '9');
    }

    public static boolean is7BitAsciiAlpha( char pChar )
    {
        return (('A' <= pChar) && (pChar <= 'Z')) || (('a' <= pChar) && (pChar <= 'z'));
    }

    @SuppressWarnings({"unchecked", "ManualArrayToCollectionCopy", "MismatchedQueryAndUpdateOfCollection"})
    public static <T> Collection<T> convert( Collection<T> pCollectionToFill, Object[] pObjects )
    {
        Collection<Object> toFill = (Collection<Object>) pCollectionToFill;
        for ( Object object : pObjects )
        {
            toFill.add( object );
        }
        return pCollectionToFill;
    }

    /**
     * This method strips the package name off the fully qualified class name of the pObject returning just the substring
     * beginning one character beyond the last "." (And removes the wrapping Class names if Any).
     *
     * @return the substring beginning one character beyond the last "$"; null or no "$" just returns justClassName( pFullyQualifiedClassName )
     */
    public static String justSimpleName( Object pObject )
    {
        return justSimpleName( (pObject != null) ? pObject.getClass() : null );
    }

    /**
     * This method strips the package name off the fully qualified class name of the pObject returning just the substring
     * beginning one character beyond the last "." (And removes the wrapping Class names if Any).
     *
     * @return the substring beginning one character beyond the last "$"; null or no "$" just returns justClassName( pFullyQualifiedClassName )
     */
    public static String justSimpleName( Class pClass )
    {
        return justSimpleName( (pClass != null) ? pClass.getName() : null );
    }

    /**
     * This method strips the package name off a fully qualified class name returning just the substring
     * beginning one character beyond the last "." (And removes the wrapping Class names if Any).
     *
     * @return the substring beginning one character beyond the last "$"; null or no "$" just returns justClassName( pFullyQualifiedClassName )
     */
    public static String justSimpleName( String pFullyQualifiedClassName )
    {
        int zAt = (pFullyQualifiedClassName != null) ? pFullyQualifiedClassName.lastIndexOf( '$' ) : -1;
        return (zAt != -1) ? pFullyQualifiedClassName.substring( zAt + 1 ) : justClassName( pFullyQualifiedClassName );
    }

    /**
     * This method strips the package name off a fully qualified class name returning just the substring
     * beginning one character beyond the last ".".
     *
     * @return the substring beginning one character beyond the last "."; null or no "." just returns pFullyQualifiedClassName
     */
    public static String justClassName( String pFullyQualifiedClassName )
    {
        int zAt = (pFullyQualifiedClassName != null) ? pFullyQualifiedClassName.lastIndexOf( '.' ) : -1;
        return (zAt != -1) ? pFullyQualifiedClassName.substring( zAt + 1 ) : pFullyQualifiedClassName;
    }

    /**
     * This method strips the package name off a fully qualified class name returning just the substring
     * beginning one character beyond the last ".".
     *
     * @return the substring beginning one character beyond the last "."; null or no "." just returns
     */
    public static String justClassName( Class<?> pClass )
    {
        return (pClass != null) ? justClassName( pClass.getName() ) : null;
    }

    /**
     * This method strips the package name off the class name of the pObject returning just the substring
     * beginning one character beyond the last ".".
     *
     * @see #justClassName(Class)
     */
    public static String justClassNameOf( Object pObject )
    {
        return (pObject != null) ? justClassName( pObject.getClass() ) : null;
    }

    /**
     * This method strips the package name off the class name of the pObject returning just the substring
     * beginning one character beyond the last ".", and if it ends with "Impl" remove that.
     *
     * @see #justClassName(Class)
     */
    public static String justClassNameNoImplOf( Object pObject )
    {
        String zName = justClassNameOf( pObject );
        return ((zName != null) && zName.endsWith( "Impl" )) ? zName.substring( 0, zName.length() - 4 ) : zName;
    }

    public static String justClassNameIfPackage( Class<?> pClass, String pPackage )
    {
        return (pClass != null) ? justClassNameIfPackage( pClass.getName(), pPackage ) : null;
    }

    public static String justClassNameIfPackage( String pClassName, String pPackage )
    {
        if ( pClassName != null )
        {
            if ( (pPackage != null) && pPackage.endsWith( "." ) && (pPackage.length() < pClassName.length()) )
            {
                String zSimpleName = justClassName( pClassName );
                if ( pClassName.equals( pPackage + zSimpleName ) )
                {
                    return zSimpleName;
                }
            }
        }
        return pClassName;
    }

    public static String classNameOf( Object pObject )
    {
        return (pObject != null) ? pObject.getClass().getName() : null;
    }

    public static void appendClassName( StringBuilder pBuffer, int pTabLevel, String pLabel, Object pValue )
    {
        append( pBuffer, pTabLevel, pLabel, (pValue == null) ? null : pValue.getClass().getName() );
    }

    public static void append( StringBuilder pBuffer, int pTabLevel, String pLabel, Object pValue )
    {
        append( pBuffer, pTabLevel, pLabel );
        pBuffer.append( ':' );
        pBuffer.append( (pValue == null) ? "null" : pValue.toString() );
    }

    public static void append( StringBuilder pBuffer, int pTabLevel, String pValue )
    {
        pBuffer.append( '\n' );
        while ( pTabLevel-- >= 1 )
        {
            pBuffer.append( '\t' );
        }
        pBuffer.append( (pValue == null) ? "null" : pValue );
    }

    public static <T> List<T> convert( Enumeration<T> pEnumeration )
    {
        ArrayList<T> rv = new ArrayList<T>();
        while ( pEnumeration.hasMoreElements() )
        {
            rv.add( pEnumeration.nextElement() );
        }
        return rv;
    }

    /**
     * @param pTo - is NOT extended
     *
     * @return pTo
     */
    public static Object[] copyArrayTo( Object[] pFrom, Object[] pTo )
    {
        if ( (pFrom != null) && (pTo != null) )
        {
            copySubArrayTo( Math.min( pFrom.length, pTo.length ), pFrom, 0, pTo, 0 );
        }
        return pTo;
    }

    /**
     * @param pTo      - is NOT extended
     * @param pToIndex - 0 based, < 0 indicates from end (eg -1 == Last)
     *
     * @return pTo
     */
    public static Object[] copyArrayTo( Object[] pFrom, Object[] pTo, int pToIndex )
    {
        if ( (pFrom != null) && (pTo != null) )
        {
            copySubArrayTo( Math.min( pFrom.length, pTo.length - pToIndex ), pFrom, 0, pTo, pToIndex );
        }
        return pTo;
    }

    /**
     * @param pCount     - < 1 means copy nothing
     * @param pTo        - is NOT extended
     * @param pFromIndex - 0 based, < 0 indicates from end (eg -1 == Last)
     * @param pToIndex   - 0 based, < 0 indicates from end (eg -1 == Last)
     *
     * @return pTo
     */
    public static Object[] copySubArrayTo( int pCount, //
                                           Object[] pFrom, int pFromIndex, //
                                           Object[] pTo, int pToIndex )
    {
        if ( (pCount > 0) && //
             isNotNullOrEmpty( pFrom ) && (pFromIndex < pFrom.length) && //
             isNotNullOrEmpty( pTo ) && (pToIndex < pTo.length) )
        {
            pCount = lesserOf( pCount, pTo, pToIndex = unNegateIndex( pTo, pToIndex ) );
            pCount = lesserOf( pCount, pFrom, pFromIndex = unNegateIndex( pFrom, pFromIndex ) );
            while ( pCount-- > 0 )
            {
                pTo[pToIndex++] = pFrom[pFromIndex++];
            }
        }
        return pTo;
    }

    private static int lesserOf( int pCount, Object[] pObjects, int pIndex )
    {
        if ( pCount > 0 )
        {
            int zMoveLen = pObjects.length - pIndex;
            if ( zMoveLen < pCount )
            {
                return zMoveLen;
            }
        }
        return pCount;
    }

    private static int unNegateIndex( Object[] pFrom, int pFromIndex )
    {
        if ( pFromIndex < 0 )
        {
            if ( (pFromIndex = pFrom.length - pFromIndex) < 0 )
            {
                pFromIndex = 0;
            }
        }
        return pFromIndex;
    }

    public static String[] parseOptions( String pOptionsAsString )
            throws IllegalArgumentException
    {
        if ( null == (pOptionsAsString = Strings.noEmpty( pOptionsAsString )) )
        {
            return null;
        }
        char sep = pOptionsAsString.charAt( 0 );
        return Character.isLetterOrDigit( sep ) ? //
               parseOptions( pOptionsAsString, ',' ) : //
               parseOptions( pOptionsAsString.substring( 1 ).trim(), sep );
    }

    private static String[] parseOptions( String pStringToParse, char pSeparator )
            throws IllegalArgumentException
    {
        List<String> zParts = new ArrayList<String>();
        int from = 0;
        for ( int at; -1 != (at = pStringToParse.indexOf( pSeparator, from )); from = at + 1 )
        {
            addNotEmpty( zParts, pStringToParse.substring( from, at ) );
        }
        addNotEmpty( zParts, pStringToParse.substring( from ) );
        if ( zParts.size() < 2 )
        {
            throw new IllegalArgumentException( "Not TWO options, given: " + pStringToParse );
        }
        return toStringArray( zParts );
    }

    private static void addNotEmpty( List<String> pParts, String pPart )
    {
        if ( (pPart = pPart.trim()).length() != 0 )
        {
            pParts.add( pPart );
        }
    }

    public static String printStackTraceToString( Throwable pThrowable )
    {
        ExceptionStackTracePrintStream ps = new ExceptionStackTracePrintStream();
        pThrowable.printStackTrace( ps );
        return ps.toString();
    }

    public static String normalizeCtrlChars( String pText )
    {
        if ( pText != null )
        {
            for ( int i = pText.length(); i-- > 0; )
            {
                if ( pText.charAt( i ) < ' ' )
                {
                    StringBuilder sb = new StringBuilder( pText );
                    for (; i >= 0; i-- )
                    {
                        char c = sb.charAt( i );
                        if ( c < ' ' )
                        {
                            switch ( c )
                            {
                                case '\n':
                                case '\r':
                                case '\f':
                                    break;
                                case '\t':
                                    sb.setCharAt( i, ' ' );
                                    break;
                                default:
                                    sb.setCharAt( i, '.' );
                                    break;
                            }
                        }
                        pText = sb.toString();
                    }
                    break;
                }
            }
        }
        return pText;
    }

    /**
     * Given path(s) that may be system dependent, create a path
     * that is converted to a system independent form (forward Slashes).
     * Note: Ignore null entries (null, or all nulls returns null).
     */
    public static String forwardSlashPath( String... pPaths )
    {
        StringBuilder sb = null;
        if ( pPaths != null )
        {
            for ( String path : pPaths )
            {
                if ( path != null )
                {
                    if ( sb == null )
                    {
                        sb = new StringBuilder();
                    }
                    if ( path.length() != 0 )
                    {
                        String fsp = forwardSlashPath( path );
                        if ( sb.length() == 0 )
                        {
                            sb.append( fsp );
                        }
                        else
                        {
                            boolean pStartsWithSlash = (fsp.charAt( 0 ) == '/');
                            if ( sb.charAt( sb.length() - 1 ) == '/' )
                            {
                                sb.append( pStartsWithSlash ? fsp.substring( 1 ) : fsp );
                            }
                            else
                            {
                                if ( !pStartsWithSlash )
                                {
                                    sb.append( '/' );
                                }
                                sb.append( fsp );
                            }
                        }
                    }
                }
            }
        }
        return (sb == null) ? null : sb.toString();
    }

    /**
     * @param pText !null
     */
    public static void formatToJavaSourceString( StringBuilder pSB, String pText )
    {
        LowLevelEncode( pSB, new CharSourceFromSequence( pText ), true );
    }

    public static String encodeToConstrainedASCII( String pText )
    {
        if ( Strings.isNullOrEmpty( pText ) )
        {
            return pText;
        }
        return LowLevelEncode( new StringBuilder(), new CharSourceFromSequence( pText, 0 ), true ).toString();
    }

    public static String decodeFromConstrainedASCII( String pText )
    {
        if ( Strings.isNullOrEmpty( pText ) )
        {
            return pText;
        }
        return LowLevelDecode( new StringBuilder(), new CharSourceFromSequence( pText, 0 ), false ).toString();
    }

    private static StringBuilder LowLevelEncode( StringBuilder pSB, CharSource pSource, boolean pDoubleQuoteSpecial )
    {
        for ( int c; -1 != (c = pSource.get()); )
        {
            if ( pDoubleQuoteSpecial && (c == '"') )
            {
                pSB.append( '\\' );
                pSB.append( (char) c );
            }
            else
            {
                switch ( c )
                {
                    case '\\':
                        pSB.append( '\\' );
                        pSB.append( '\\' );
                        break;
                    case '\n':
                        pSB.append( '\\' );
                        pSB.append( 'n' );
                        break;
                    case '\r':
                        pSB.append( '\\' );
                        pSB.append( 'r' );
                        break;
                    case '\t':
                        pSB.append( '\\' );
                        pSB.append( 't' );
                        break;
                    default:
                        if ( (' ' <= c) && (c < 127) )
                        {
                            pSB.append( (char) c );
                            break;
                        }
                        pSB.append( '\\' );
                        pSB.append( 'x' );
                        pSB.append( toHexDigit( c >> 24 ) );
                        pSB.append( toHexDigit( c >> 16 ) );
                        pSB.append( toHexDigit( c >> 8 ) );
                        pSB.append( toHexDigit( c ) );
                        break;
                }
            }
        }
        return pSB;
    }

    private static StringBuilder LowLevelDecode( StringBuilder pSB, CharSource pSource, boolean pDoubleQuoteSpecial )
    {
        for ( int c; -1 != (c = pSource.get()); )
        {
            if ( (c < ' ') || (127 <= c) )
            {
                throw new IllegalArgumentException( "Decoding Error: Char[" + pSource.getLastOffset() + "] Not between ' ' & Ascii 126 (inclusive)" );
            }
            if ( c != '\\' )
            {
                pSB.append( (char) c );
                continue;
            }
            if ( -1 == (c = pSource.get()) )
            {
                throw new IllegalArgumentException( "Decoding Error: No Char after escape \\" );
            }
            if ( pDoubleQuoteSpecial && (c == '"') )
            {
                pSB.append( (char) c );
            }
            else
            {
                switch ( c )
                {
                    case '\\':
                        pSB.append( (char) c );
                        break;
                    case 'n':
                        pSB.append( '\n' );
                        break;
                    case 'r':
                        pSB.append( '\r' );
                        break;
                    case 't':
                        pSB.append( '\t' );
                        break;
                    case 'x':
                        int c1 = pSource.get();
                        int c2 = pSource.get();
                        int c3 = pSource.get();
                        int c4 = pSource.get();
                        if ( c4 == -1 )
                        {
                            throw new IllegalArgumentException( "Decoding Error: Not enough Chars after \\x" );
                        }
                        try
                        {
                            int zChar = (fromHexDigit( (char) c1 ) << 24) + //
                                        (fromHexDigit( (char) c2 ) << 16) + //
                                        (fromHexDigit( (char) c3 ) << 8) + //
                                        fromHexDigit( (char) c4 );
                            pSB.append( (char) zChar );
                        }
                        catch ( IllegalArgumentException e )
                        {
                            throw new IllegalArgumentException( "Decoding Error: After \\x expected 4 hex digits: " + e.getMessage() );
                        }
                        break;
                    default:
                        throw new IllegalArgumentException( "Decoding Error: Invalid Char '" + c + "' after escape \\" );
                }
            }
        }
        return pSB;
    }

    // Array / varArgs

    public static String combineAsLines( List<String> pStrings )
    {
        return combineAsLines( (pStrings == null) ? null : pStrings.toArray( new String[pStrings.size()] ) );
    }

    public static String combine( String pSeparator, List<String> pStrings )
    {
        //noinspection SuspiciousToArrayCall
        return combine( pSeparator, (Object[]) pStrings.toArray( new String[pStrings.size()] ) );
    }

    public static String combineObjects( String pSeparator, List<?> pObjects )
    {
        return combine( pSeparator, pObjects.toArray() );
    }

    public static String[] removeAllBlankOrCommentLines( String[] pLines )
    {
        List<String> lines = new LinkedList<String>();

        for ( String line : Strings.deNull( pLines ) )
        {
            String s = line.trim();
            if ( (s.length() != 0) && !(s.startsWith( "#" ) || s.startsWith( "//" )) )
            {
                lines.add( line );
            }
        }
        return lines.toArray( new String[lines.size()] );
    }

    // Objects:

    // Object Group:

    public static boolean areNotNull( Object... pToChecks )
    {
        if ( pToChecks == null )
        {
            return false;
        }
        for ( Object toCheck : pToChecks )
        {
            if ( toCheck == null )
            {
                return false;
            }
        }
        return true;
    }

    public static String merge( String[] pLines )
    {
        if ( (pLines == null) || (pLines.length == 0) )
        {
            return "";
        }
        if ( pLines.length == 1 )
        {
            return pLines[0];
        }
        int length = 0;
        for ( String line : pLines )
        {
            if ( line != null )
            {
                length += line.length() + 2;
            }
        }
        StringBuilder sb = new StringBuilder( length );
        for ( String line : pLines )
        {
            if ( line != null )
            {
                sb.append( line ).append( '\r' ).append( '\n' );
            }
        }
        return sb.toString();
    }

    public static boolean isAllUppercaseOrSpaces( String pToTest )
    {
        if ( Strings.isNotNullOrEmpty( pToTest ) )
        {
            for ( int i = 0; i < pToTest.length(); i++ )
            {
                char c = pToTest.charAt( i );
                if ( (c != ' ') && !Character.isUpperCase( c ) )
                {
                    return false;
                }
            }
        }
        return true;
    }

    public static boolean isAllUppercase( String pToTest )
    {
        if ( Strings.isNotNullOrEmpty( pToTest ) )
        {
            for ( int i = 0; i < pToTest.length(); i++ )
            {
                if ( !Character.isUpperCase( pToTest.charAt( i ) ) )
                {
                    return false;
                }
            }
        }
        return true;
    }

    public static boolean isAsciiIdentifier( String pToTest )
    {
        if ( !Strings.isNullOrEmpty( pToTest ) )
        {
            if ( isFirstCharAsciiIdentifier( pToTest.charAt( 0 ) ) )
            {
                for ( int i = 1; i < pToTest.length(); i++ )
                {
                    if ( !isNonFirstCharAsciiIdentifier( pToTest.charAt( i ) ) )
                    {
                        return false;
                    }
                }
                return true;
            }
        }
        return false;
    }

    public static boolean isFirstCharAsciiIdentifier( char pToTest )
    {
        return isAsciiLetter( pToTest ) || (pToTest == '_');
    }

    public static boolean isNonFirstCharAsciiIdentifier( char pToTest )
    {
        return isAsciiLetter( pToTest ) || (pToTest == '_') || Character.isDigit( pToTest );
    }

    public static boolean isAsciiLetter( char pToTest )
    {
        return (('A' <= pToTest) && (pToTest <= 'Z')) || (('a' <= pToTest) && (pToTest <= 'z'));
    }

    public static boolean isNoSpaceAscii( String pToTest )
    {
        if ( !Strings.isNullOrEmpty( pToTest ) )
        {
            for ( int i = 0; i < pToTest.length(); i++ )
            {
                if ( !isNoSpaceAscii( pToTest.charAt( i ) ) )
                {
                    return false;
                }
            }
            return true;
        }
        return false;
    }

    public static boolean isNoSpaceAscii( char pToTest )
    {
        return ((' ' < pToTest) && (pToTest < 127));
    }

    public static boolean isNoCtrlAscii( String pToTest )
    {
        if ( pToTest != null )
        {
            for ( int i = 0; i < pToTest.length(); i++ )
            {
                if ( !isNoCtrlAscii( pToTest.charAt( i ) ) )
                {
                    return false;
                }
            }
            return true;
        }
        return false;
    }

    public static boolean isNoCtrlAscii( char pToTest )
    {
        return ((' ' <= pToTest) && (pToTest < 127));
    }

    public static boolean hasText( Object pValue )
    {
        return (pValue != null) && (pValue.toString().trim().length() != 0);
    }

    public static SimpleDate forceEndOfMonth( SimpleDate pSimpleDate )
    {
        if ( pSimpleDate != null )
        {
            int zDaysInMonth = CalendarSupport.daysInMonth( pSimpleDate.getYear(), pSimpleDate.getMonth() );
            if ( pSimpleDate.getDay() != zDaysInMonth )
            {
                pSimpleDate.setDay( zDaysInMonth );
            }
        }
        return pSimpleDate;
    }

    public static String singleQuoteToString( List<String> pStrings )
    {
        StringBuilder sb = new StringBuilder();
        if ( pStrings != null )
        {
            char prefix = '[';
            if ( pStrings.size() == 0 )
            {
                sb.append( prefix );
            }
            else
            {
                for ( String zString : pStrings )
                {
                    sb.append( prefix );
                    sb.append( '\'' );
                    sb.append( zString );
                    sb.append( '\'' );
                    prefix = ',';
                }
            }
            sb.append( ']' );
        }
        return sb.toString();
    }

    @SuppressWarnings({"unchecked"})
    public static <T> T cast( Object o )
    {
        return (T) o;
    }
}