* The format of the returned String is the same as
* AbstractCollection.toString:
*
aArray is a possibly-null array whose elements are primitives or objects; arrays
* of arrays are also valid, in which case aArray is rendered in a nested,
* recursive fashion.
*
* @author Jerome Lacoste
* @author www.javapractices.com
*/
static public String arrayToString( Object aArray ) {
if ( aArray == null ) {
return fNULL;
}
checkObjectIsArray( aArray );
StringBuilder result = new StringBuilder( fSTART_CHAR );
int length = Array.getLength( aArray );
for ( int idx = 0 ; idx < length ; ++idx ) {
Object item = Array.get( aArray , idx );
if ( isNonNullArray( item ) ) {
// recursive call!
result.append( arrayToString( item ) );
} else {
result.append( item );
}
if ( !isLastItem( idx , length ) ) {
result.append( fSEPARATOR );
}
}
result.append( fEND_CHAR );
return result.toString( );
}
// PRIVATE //
private static final String fSTART_CHAR = "[";
private static final String fEND_CHAR = "]";
private static final String fSEPARATOR = ", ";
private static final String fNULL = "null";
private static void checkObjectIsArray( Object aArray ) {
if ( !aArray.getClass( ).isArray( ) ) {
throw new IllegalArgumentException( "Object is not an array." );
}
}
private static boolean isNonNullArray( Object aItem ) {
return aItem != null && aItem.getClass( ).isArray( );
}
private static boolean isLastItem( int aIdx , int aLength ) {
return ( aIdx == aLength - 1 );
}
protected static String formatGetClass( Class< ? > c ) {
if ( c == null )
return null;
final String pattern = "class ";
return c.toString( ).startsWith( pattern ) ? c.toString( ).substring( pattern.length( ) ) : c.toString( );
}
static public boolean inside( int[] theRect , float theX , float theY ) {
if ( theRect.length == 4 ) {
return ( theX > theRect[ 0 ] && theX < theRect[ 2 ] && theY > theRect[ 1 ] && theY < theRect[ 3 ] );
} else {
return false;
}
}
/* Base64 static methods to encode and decode
* bytes into a String and back
*
* from
* http://examples.oreilly.com/javacrypt/files/oreilly/jonathan/util/
* http://oreilly.com/catalog/javacrypt/chapter/ch06.html */
static public String encodeBase64( byte[] raw ) {
StringBuffer encoded = new StringBuffer( );
for ( int i = 0 ; i < raw.length ; i += 3 ) {
encoded.append( encodeBlock( raw , i ) );
}
return encoded.toString( );
}
protected static char[] encodeBlock( byte[] raw , int offset ) {
int block = 0;
int slack = raw.length - offset - 1;
int end = ( slack >= 2 ) ? 2 : slack;
for ( int i = 0 ; i <= end ; i++ ) {
byte b = raw[ offset + i ];
int neuter = ( b < 0 ) ? b + 256 : b;
block += neuter << ( 8 * ( 2 - i ) );
}
char[] base64 = new char[ 4 ];
for ( int i = 0 ; i < 4 ; i++ ) {
int sixbit = ( block >>> ( 6 * ( 3 - i ) ) ) & 0x3f;
base64[ i ] = getBase64Char( sixbit );
}
if ( slack < 1 )
base64[ 2 ] = '=';
if ( slack < 2 )
base64[ 3 ] = '=';
return base64;
}
static char getBase64Char( int sixBit ) {
if ( sixBit >= 0 && sixBit <= 25 )
return ( char ) ( 'A' + sixBit );
if ( sixBit >= 26 && sixBit <= 51 )
return ( char ) ( 'a' + ( sixBit - 26 ) );
if ( sixBit >= 52 && sixBit <= 61 )
return ( char ) ( '0' + ( sixBit - 52 ) );
if ( sixBit == 62 )
return '+';
if ( sixBit == 63 )
return '/';
return '?';
}
static public byte[] decodeBase64( String base64 ) {
int pad = 0;
for ( int i = base64.length( ) - 1 ; base64.charAt( i ) == '=' ; i-- )
pad++;
int length = base64.length( ) * 6 / 8 - pad;
byte[] raw = new byte[ length ];
int rawIndex = 0;
for ( int i = 0 ; i < base64.length( ) ; i += 4 ) {
int block = ( getBase64Value( base64.charAt( i ) ) << 18 ) + ( getBase64Value( base64.charAt( i + 1 ) ) << 12 ) + ( getBase64Value( base64.charAt( i + 2 ) ) << 6 ) + ( getBase64Value( base64.charAt( i + 3 ) ) );
for ( int j = 0 ; j < 3 && rawIndex + j < raw.length ; j++ )
raw[ rawIndex + j ] = ( byte ) ( ( block >> ( 8 * ( 2 - j ) ) ) & 0xff );
rawIndex += 3;
}
return raw;
}
static int getBase64Value( char c ) {
if ( c >= 'A' && c <= 'Z' )
return c - 'A';
if ( c >= 'a' && c <= 'z' )
return c - 'a' + 26;
if ( c >= '0' && c <= '9' )
return c - '0' + 52;
if ( c == '+' )
return 62;
if ( c == '/' )
return 63;
if ( c == '=' )
return 0;
return -1;
}
static public int getBit( int theByte , int theIndex ) {
int bitmask = 1 << theIndex;
return ( ( theByte & bitmask ) > 0 ) ? 1 : 0;
}
static public byte setHigh( byte theByte , int theIndex ) {
return ( byte ) ( theByte | ( 1 << theIndex ) );
}
static public byte setLow( byte theByte , int theIndex ) {
return ( byte ) ( theByte & ~ ( 1 << theIndex ) );
}
static public byte[] intToByteArray( int a ) {
byte[] ret = new byte[ 2 ];
ret[ 1 ] = ( byte ) ( a & 0xFF );
ret[ 0 ] = ( byte ) ( ( a >> 8 ) & 0xFF );
//ret[0] = (byte) ((a >> 16) & 0xFF);
//ret[0] = (byte) ((a >> 24) & 0xFF);
return ret;
}
static public int byteArrayToInt( byte[] b ) {
int value = 0;
for ( int i = 0 ; i < 2 ; i++ ) {
int shift = ( 2 - 1 - i ) * 8;
value += ( b[ i ] & 0x00FF ) << shift;
}
return value;
}
static String join( List< String > list , String delimiter ) {
StringBuilder b = new StringBuilder( );
for ( String item : list ) {
b.append( item ).append( delimiter );
}
return b.toString( );
}
}