mirror of https://github.com/apache/maven.git
o just packaging up stuff better, removing unused code.
git-svn-id: https://svn.apache.org/repos/asf/maven/components/trunk@163237 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Jason van Zyl
parent
fe59dcf689
commit
51b8ce4f65
|
|
@ -8,7 +8,8 @@ rm -rf ${buildDir} > /dev/null 2>&1
|
|||
|
||||
mkdir -p ${classesDir}
|
||||
|
||||
javac -d ${classesDir} ${srcDir}/*.java
|
||||
#javac -d ${classesDir} ${srcDir}/*.java
|
||||
javac -d ${classesDir} `find ${srcDir} -name '*.java'`
|
||||
|
||||
( cd ${classesDir} ; jar -cfm ../mboot.jar ../../manifest.txt * )
|
||||
|
||||
|
|
|
|||
|
|
@ -1,3 +1,3 @@
|
|||
Manifest-Version: 1.0
|
||||
Created-By: 0.92-gcc
|
||||
Created-By: Grand Master Pooky Mook
|
||||
Main-Class: MBoot
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -1,759 +0,0 @@
|
|||
|
||||
import java.io.BufferedInputStream;
|
||||
import java.io.BufferedOutputStream;
|
||||
import java.io.ByteArrayInputStream;
|
||||
import java.io.ByteArrayOutputStream;
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import java.io.InputStreamReader;
|
||||
import java.io.OutputStream;
|
||||
import java.io.OutputStreamWriter;
|
||||
import java.io.Reader;
|
||||
import java.io.StringReader;
|
||||
import java.io.StringWriter;
|
||||
import java.io.Writer;
|
||||
|
||||
/**
|
||||
* General IO Stream manipulation.
|
||||
* <p/>
|
||||
* This class provides static utility methods for input/output operations, particularly buffered
|
||||
* copying between sources (<code>InputStream</code>, <code>Reader</code>, <code>String</code> and
|
||||
* <code>byte[]</code>) and destinations (<code>OutputStream</code>, <code>Writer</code>,
|
||||
* <code>String</code> and <code>byte[]</code>).
|
||||
* </p>
|
||||
* <p/>
|
||||
* <p>Unless otherwise noted, these <code>copy</code> methods do <em>not</em> flush or close the
|
||||
* streams. Often, doing so would require making non-portable assumptions about the streams' origin
|
||||
* and further use. This means that both streams' <code>close()</code> methods must be called after
|
||||
* copying. if one omits this step, then the stream resources (sockets, file descriptors) are
|
||||
* released when the associated Stream is garbage-collected. It is not a good idea to rely on this
|
||||
* mechanism. For a good overview of the distinction between "memory management" and "resource
|
||||
* management", see <a href="http://www.unixreview.com/articles/1998/9804/9804ja/ja.htm">this
|
||||
* UnixReview article</a></p>
|
||||
* <p/>
|
||||
* <p>For each <code>copy</code> method, a variant is provided that allows the caller to specify the
|
||||
* buffer size (the default is 4k). As the buffer size can have a fairly large impact on speed, this
|
||||
* may be worth tweaking. Often "large buffer -> faster" does not hold, even for large data
|
||||
* transfers.</p>
|
||||
* <p/>
|
||||
* <p>For byte-to-char methods, a <code>copy</code> variant allows the encoding to be selected
|
||||
* (otherwise the platform default is used).</p>
|
||||
* <p/>
|
||||
* <p>The <code>copy</code> methods use an internal buffer when copying. It is therefore advisable
|
||||
* <em>not</em> to deliberately wrap the stream arguments to the <code>copy</code> methods in
|
||||
* <code>Buffered*</code> streams. For example, don't do the
|
||||
* following:</p>
|
||||
* <p/>
|
||||
* <code>copy( new BufferedInputStream( in ), new BufferedOutputStream( out ) );</code>
|
||||
* <p/>
|
||||
* <p>The rationale is as follows:</p>
|
||||
* <p/>
|
||||
* <p>Imagine that an InputStream's read() is a very expensive operation, which would usually suggest
|
||||
* wrapping in a BufferedInputStream. The BufferedInputStream works by issuing infrequent
|
||||
* {@link java.io.InputStream#read(byte[] b, int off, int len)} requests on the underlying InputStream, to
|
||||
* fill an internal buffer, from which further <code>read</code> requests can inexpensively get
|
||||
* their data (until the buffer runs out).</p>
|
||||
* <p>However, the <code>copy</code> methods do the same thing, keeping an internal buffer,
|
||||
* populated by {@link InputStream#read(byte[] b, int off, int len)} requests. Having two buffers
|
||||
* (or three if the destination stream is also buffered) is pointless, and the unnecessary buffer
|
||||
* management hurts performance slightly (about 3%, according to some simple experiments).</p>
|
||||
*
|
||||
* @author <a href="mailto:peter@codehaus.org">Peter Donald</a>
|
||||
* @author <a href="mailto:jefft@codehaus.org">Jeff Turner</a>
|
||||
* @version CVS $Revision$ $Date$
|
||||
* @since 4.0
|
||||
*/
|
||||
|
||||
/*
|
||||
* Behold, intrepid explorers; a map of this class:
|
||||
*
|
||||
* Method Input Output Dependency
|
||||
* ------ ----- ------ -------
|
||||
* 1 copy InputStream OutputStream (primitive)
|
||||
* 2 copy Reader Writer (primitive)
|
||||
*
|
||||
* 3 copy InputStream Writer 2
|
||||
* 4 toString InputStream String 3
|
||||
* 5 toByteArray InputStream byte[] 1
|
||||
*
|
||||
* 6 copy Reader OutputStream 2
|
||||
* 7 toString Reader String 2
|
||||
* 8 toByteArray Reader byte[] 6
|
||||
*
|
||||
* 9 copy String OutputStream 2
|
||||
* 10 copy String Writer (trivial)
|
||||
* 11 toByteArray String byte[] 9
|
||||
*
|
||||
* 12 copy byte[] Writer 3
|
||||
* 13 toString byte[] String 12
|
||||
* 14 copy byte[] OutputStream (trivial)
|
||||
*
|
||||
*
|
||||
* Note that only the first two methods shuffle bytes; the rest use these two, or (if possible) copy
|
||||
* using native Java copy methods. As there are method variants to specify buffer size and encoding,
|
||||
* each row may correspond to up to 4 methods.
|
||||
*
|
||||
*/
|
||||
|
||||
public final class IOUtil
|
||||
{
|
||||
private static final int DEFAULT_BUFFER_SIZE = 1024 * 4;
|
||||
|
||||
/**
|
||||
* Private constructor to prevent instantiation.
|
||||
*/
|
||||
private IOUtil()
|
||||
{
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////
|
||||
// Core copy methods
|
||||
///////////////////////////////////////////////////////////////
|
||||
|
||||
/**
|
||||
* Copy bytes from an <code>InputStream</code> to an <code>OutputStream</code>.
|
||||
*/
|
||||
public static void copy( final InputStream input, final OutputStream output )
|
||||
throws IOException
|
||||
{
|
||||
copy( input, output, DEFAULT_BUFFER_SIZE );
|
||||
}
|
||||
|
||||
/**
|
||||
* Copy bytes from an <code>InputStream</code> to an <code>OutputStream</code>.
|
||||
*
|
||||
* @param bufferSize Size of internal buffer to use.
|
||||
*/
|
||||
public static void copy( final InputStream input,
|
||||
final OutputStream output,
|
||||
final int bufferSize )
|
||||
throws IOException
|
||||
{
|
||||
final byte[] buffer = new byte[bufferSize];
|
||||
int n = 0;
|
||||
while ( -1 != ( n = input.read( buffer ) ) )
|
||||
{
|
||||
output.write( buffer, 0, n );
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Copy chars from a <code>Reader</code> to a <code>Writer</code>.
|
||||
*/
|
||||
public static void copy( final Reader input, final Writer output )
|
||||
throws IOException
|
||||
{
|
||||
copy( input, output, DEFAULT_BUFFER_SIZE );
|
||||
}
|
||||
|
||||
/**
|
||||
* Copy chars from a <code>Reader</code> to a <code>Writer</code>.
|
||||
*
|
||||
* @param bufferSize Size of internal buffer to use.
|
||||
*/
|
||||
public static void copy( final Reader input, final Writer output, final int bufferSize )
|
||||
throws IOException
|
||||
{
|
||||
final char[] buffer = new char[bufferSize];
|
||||
int n = 0;
|
||||
while ( -1 != ( n = input.read( buffer ) ) )
|
||||
{
|
||||
output.write( buffer, 0, n );
|
||||
}
|
||||
output.flush();
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////
|
||||
// Derived copy methods
|
||||
// InputStream -> *
|
||||
///////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////
|
||||
// InputStream -> Writer
|
||||
|
||||
/**
|
||||
* Copy and convert bytes from an <code>InputStream</code> to chars on a
|
||||
* <code>Writer</code>.
|
||||
* The platform's default encoding is used for the byte-to-char conversion.
|
||||
*/
|
||||
public static void copy( final InputStream input, final Writer output )
|
||||
throws IOException
|
||||
{
|
||||
copy( input, output, DEFAULT_BUFFER_SIZE );
|
||||
}
|
||||
|
||||
/**
|
||||
* Copy and convert bytes from an <code>InputStream</code> to chars on a
|
||||
* <code>Writer</code>.
|
||||
* The platform's default encoding is used for the byte-to-char conversion.
|
||||
*
|
||||
* @param bufferSize Size of internal buffer to use.
|
||||
*/
|
||||
public static void copy( final InputStream input, final Writer output, final int bufferSize )
|
||||
throws IOException
|
||||
{
|
||||
final InputStreamReader in = new InputStreamReader( input );
|
||||
copy( in, output, bufferSize );
|
||||
}
|
||||
|
||||
/**
|
||||
* Copy and convert bytes from an <code>InputStream</code> to chars on a
|
||||
* <code>Writer</code>, using the specified encoding.
|
||||
*
|
||||
* @param encoding The name of a supported character encoding. See the
|
||||
* <a href="http://www.iana.org/assignments/character-sets">IANA
|
||||
* Charset Registry</a> for a list of valid encoding types.
|
||||
*/
|
||||
public static void copy( final InputStream input, final Writer output, final String encoding )
|
||||
throws IOException
|
||||
{
|
||||
final InputStreamReader in = new InputStreamReader( input, encoding );
|
||||
copy( in, output );
|
||||
}
|
||||
|
||||
/**
|
||||
* Copy and convert bytes from an <code>InputStream</code> to chars on a
|
||||
* <code>Writer</code>, using the specified encoding.
|
||||
*
|
||||
* @param encoding The name of a supported character encoding. See the
|
||||
* <a href="http://www.iana.org/assignments/character-sets">IANA
|
||||
* Charset Registry</a> for a list of valid encoding types.
|
||||
* @param bufferSize Size of internal buffer to use.
|
||||
*/
|
||||
public static void copy( final InputStream input,
|
||||
final Writer output,
|
||||
final String encoding,
|
||||
final int bufferSize )
|
||||
throws IOException
|
||||
{
|
||||
final InputStreamReader in = new InputStreamReader( input, encoding );
|
||||
copy( in, output, bufferSize );
|
||||
}
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////
|
||||
// InputStream -> String
|
||||
|
||||
/**
|
||||
* Get the contents of an <code>InputStream</code> as a String.
|
||||
* The platform's default encoding is used for the byte-to-char conversion.
|
||||
*/
|
||||
public static String toString( final InputStream input )
|
||||
throws IOException
|
||||
{
|
||||
return toString( input, DEFAULT_BUFFER_SIZE );
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the contents of an <code>InputStream</code> as a String.
|
||||
* The platform's default encoding is used for the byte-to-char conversion.
|
||||
*
|
||||
* @param bufferSize Size of internal buffer to use.
|
||||
*/
|
||||
public static String toString( final InputStream input, final int bufferSize )
|
||||
throws IOException
|
||||
{
|
||||
final StringWriter sw = new StringWriter();
|
||||
copy( input, sw, bufferSize );
|
||||
return sw.toString();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the contents of an <code>InputStream</code> as a String.
|
||||
*
|
||||
* @param encoding The name of a supported character encoding. See the
|
||||
* <a href="http://www.iana.org/assignments/character-sets">IANA
|
||||
* Charset Registry</a> for a list of valid encoding types.
|
||||
*/
|
||||
public static String toString( final InputStream input, final String encoding )
|
||||
throws IOException
|
||||
{
|
||||
return toString( input, encoding, DEFAULT_BUFFER_SIZE );
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the contents of an <code>InputStream</code> as a String.
|
||||
*
|
||||
* @param encoding The name of a supported character encoding. See the
|
||||
* <a href="http://www.iana.org/assignments/character-sets">IANA
|
||||
* Charset Registry</a> for a list of valid encoding types.
|
||||
* @param bufferSize Size of internal buffer to use.
|
||||
*/
|
||||
public static String toString( final InputStream input,
|
||||
final String encoding,
|
||||
final int bufferSize )
|
||||
throws IOException
|
||||
{
|
||||
final StringWriter sw = new StringWriter();
|
||||
copy( input, sw, encoding, bufferSize );
|
||||
return sw.toString();
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////
|
||||
// InputStream -> byte[]
|
||||
|
||||
/**
|
||||
* Get the contents of an <code>InputStream</code> as a <code>byte[]</code>.
|
||||
*/
|
||||
public static byte[] toByteArray( final InputStream input )
|
||||
throws IOException
|
||||
{
|
||||
return toByteArray( input, DEFAULT_BUFFER_SIZE );
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the contents of an <code>InputStream</code> as a <code>byte[]</code>.
|
||||
*
|
||||
* @param bufferSize Size of internal buffer to use.
|
||||
*/
|
||||
public static byte[] toByteArray( final InputStream input, final int bufferSize )
|
||||
throws IOException
|
||||
{
|
||||
final ByteArrayOutputStream output = new ByteArrayOutputStream();
|
||||
copy( input, output, bufferSize );
|
||||
return output.toByteArray();
|
||||
}
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////
|
||||
// Derived copy methods
|
||||
// Reader -> *
|
||||
///////////////////////////////////////////////////////////////
|
||||
|
||||
///////////////////////////////////////////////////////////////
|
||||
// Reader -> OutputStream
|
||||
/**
|
||||
* Serialize chars from a <code>Reader</code> to bytes on an <code>OutputStream</code>, and
|
||||
* flush the <code>OutputStream</code>.
|
||||
*/
|
||||
public static void copy( final Reader input, final OutputStream output )
|
||||
throws IOException
|
||||
{
|
||||
copy( input, output, DEFAULT_BUFFER_SIZE );
|
||||
}
|
||||
|
||||
/**
|
||||
* Serialize chars from a <code>Reader</code> to bytes on an <code>OutputStream</code>, and
|
||||
* flush the <code>OutputStream</code>.
|
||||
*
|
||||
* @param bufferSize Size of internal buffer to use.
|
||||
*/
|
||||
public static void copy( final Reader input, final OutputStream output, final int bufferSize )
|
||||
throws IOException
|
||||
{
|
||||
final OutputStreamWriter out = new OutputStreamWriter( output );
|
||||
copy( input, out, bufferSize );
|
||||
// NOTE: Unless anyone is planning on rewriting OutputStreamWriter, we have to flush
|
||||
// here.
|
||||
out.flush();
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////
|
||||
// Reader -> String
|
||||
/**
|
||||
* Get the contents of a <code>Reader</code> as a String.
|
||||
*/
|
||||
public static String toString( final Reader input )
|
||||
throws IOException
|
||||
{
|
||||
return toString( input, DEFAULT_BUFFER_SIZE );
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the contents of a <code>Reader</code> as a String.
|
||||
*
|
||||
* @param bufferSize Size of internal buffer to use.
|
||||
*/
|
||||
public static String toString( final Reader input, final int bufferSize )
|
||||
throws IOException
|
||||
{
|
||||
final StringWriter sw = new StringWriter();
|
||||
copy( input, sw, bufferSize );
|
||||
return sw.toString();
|
||||
}
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////
|
||||
// Reader -> byte[]
|
||||
/**
|
||||
* Get the contents of a <code>Reader</code> as a <code>byte[]</code>.
|
||||
*/
|
||||
public static byte[] toByteArray( final Reader input )
|
||||
throws IOException
|
||||
{
|
||||
return toByteArray( input, DEFAULT_BUFFER_SIZE );
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the contents of a <code>Reader</code> as a <code>byte[]</code>.
|
||||
*
|
||||
* @param bufferSize Size of internal buffer to use.
|
||||
*/
|
||||
public static byte[] toByteArray( final Reader input, final int bufferSize )
|
||||
throws IOException
|
||||
{
|
||||
ByteArrayOutputStream output = new ByteArrayOutputStream();
|
||||
copy( input, output, bufferSize );
|
||||
return output.toByteArray();
|
||||
}
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////
|
||||
// Derived copy methods
|
||||
// String -> *
|
||||
///////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////
|
||||
// String -> OutputStream
|
||||
|
||||
/**
|
||||
* Serialize chars from a <code>String</code> to bytes on an <code>OutputStream</code>, and
|
||||
* flush the <code>OutputStream</code>.
|
||||
*/
|
||||
public static void copy( final String input, final OutputStream output )
|
||||
throws IOException
|
||||
{
|
||||
copy( input, output, DEFAULT_BUFFER_SIZE );
|
||||
}
|
||||
|
||||
/**
|
||||
* Serialize chars from a <code>String</code> to bytes on an <code>OutputStream</code>, and
|
||||
* flush the <code>OutputStream</code>.
|
||||
*
|
||||
* @param bufferSize Size of internal buffer to use.
|
||||
*/
|
||||
public static void copy( final String input, final OutputStream output, final int bufferSize )
|
||||
throws IOException
|
||||
{
|
||||
final StringReader in = new StringReader( input );
|
||||
final OutputStreamWriter out = new OutputStreamWriter( output );
|
||||
copy( in, out, bufferSize );
|
||||
// NOTE: Unless anyone is planning on rewriting OutputStreamWriter, we have to flush
|
||||
// here.
|
||||
out.flush();
|
||||
}
|
||||
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////
|
||||
// String -> Writer
|
||||
|
||||
/**
|
||||
* Copy chars from a <code>String</code> to a <code>Writer</code>.
|
||||
*/
|
||||
public static void copy( final String input, final Writer output )
|
||||
throws IOException
|
||||
{
|
||||
output.write( input );
|
||||
}
|
||||
|
||||
/**
|
||||
* Copy bytes from an <code>InputStream</code> to an
|
||||
* <code>OutputStream</code>, with buffering.
|
||||
* This is equivalent to passing a
|
||||
* {@link java.io.BufferedInputStream} and
|
||||
* {@link java.io.BufferedOutputStream} to {@link #copy(InputStream, OutputStream)},
|
||||
* and flushing the output stream afterwards. The streams are not closed
|
||||
* after the copy.
|
||||
*
|
||||
* @deprecated Buffering streams is actively harmful! See the class description as to why. Use
|
||||
* {@link #copy(InputStream, OutputStream)} instead.
|
||||
*/
|
||||
public static void bufferedCopy( final InputStream input, final OutputStream output )
|
||||
throws IOException
|
||||
{
|
||||
final BufferedInputStream in = new BufferedInputStream( input );
|
||||
final BufferedOutputStream out = new BufferedOutputStream( output );
|
||||
copy( in, out );
|
||||
out.flush();
|
||||
}
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////
|
||||
// String -> byte[]
|
||||
/**
|
||||
* Get the contents of a <code>String</code> as a <code>byte[]</code>.
|
||||
*/
|
||||
public static byte[] toByteArray( final String input )
|
||||
throws IOException
|
||||
{
|
||||
return toByteArray( input, DEFAULT_BUFFER_SIZE );
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the contents of a <code>String</code> as a <code>byte[]</code>.
|
||||
*
|
||||
* @param bufferSize Size of internal buffer to use.
|
||||
*/
|
||||
public static byte[] toByteArray( final String input, final int bufferSize )
|
||||
throws IOException
|
||||
{
|
||||
ByteArrayOutputStream output = new ByteArrayOutputStream();
|
||||
copy( input, output, bufferSize );
|
||||
return output.toByteArray();
|
||||
}
|
||||
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////
|
||||
// Derived copy methods
|
||||
// byte[] -> *
|
||||
///////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////
|
||||
// byte[] -> Writer
|
||||
|
||||
/**
|
||||
* Copy and convert bytes from a <code>byte[]</code> to chars on a
|
||||
* <code>Writer</code>.
|
||||
* The platform's default encoding is used for the byte-to-char conversion.
|
||||
*/
|
||||
public static void copy( final byte[] input, final Writer output )
|
||||
throws IOException
|
||||
{
|
||||
copy( input, output, DEFAULT_BUFFER_SIZE );
|
||||
}
|
||||
|
||||
/**
|
||||
* Copy and convert bytes from a <code>byte[]</code> to chars on a
|
||||
* <code>Writer</code>.
|
||||
* The platform's default encoding is used for the byte-to-char conversion.
|
||||
*
|
||||
* @param bufferSize Size of internal buffer to use.
|
||||
*/
|
||||
public static void copy( final byte[] input, final Writer output, final int bufferSize )
|
||||
throws IOException
|
||||
{
|
||||
final ByteArrayInputStream in = new ByteArrayInputStream( input );
|
||||
copy( in, output, bufferSize );
|
||||
}
|
||||
|
||||
/**
|
||||
* Copy and convert bytes from a <code>byte[]</code> to chars on a
|
||||
* <code>Writer</code>, using the specified encoding.
|
||||
*
|
||||
* @param encoding The name of a supported character encoding. See the
|
||||
* <a href="http://www.iana.org/assignments/character-sets">IANA
|
||||
* Charset Registry</a> for a list of valid encoding types.
|
||||
*/
|
||||
public static void copy( final byte[] input, final Writer output, final String encoding )
|
||||
throws IOException
|
||||
{
|
||||
final ByteArrayInputStream in = new ByteArrayInputStream( input );
|
||||
copy( in, output, encoding );
|
||||
}
|
||||
|
||||
/**
|
||||
* Copy and convert bytes from a <code>byte[]</code> to chars on a
|
||||
* <code>Writer</code>, using the specified encoding.
|
||||
*
|
||||
* @param encoding The name of a supported character encoding. See the
|
||||
* <a href="http://www.iana.org/assignments/character-sets">IANA
|
||||
* Charset Registry</a> for a list of valid encoding types.
|
||||
* @param bufferSize Size of internal buffer to use.
|
||||
*/
|
||||
public static void copy( final byte[] input,
|
||||
final Writer output,
|
||||
final String encoding,
|
||||
final int bufferSize )
|
||||
throws IOException
|
||||
{
|
||||
final ByteArrayInputStream in = new ByteArrayInputStream( input );
|
||||
copy( in, output, encoding, bufferSize );
|
||||
}
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////
|
||||
// byte[] -> String
|
||||
|
||||
/**
|
||||
* Get the contents of a <code>byte[]</code> as a String.
|
||||
* The platform's default encoding is used for the byte-to-char conversion.
|
||||
*/
|
||||
public static String toString( final byte[] input )
|
||||
throws IOException
|
||||
{
|
||||
return toString( input, DEFAULT_BUFFER_SIZE );
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the contents of a <code>byte[]</code> as a String.
|
||||
* The platform's default encoding is used for the byte-to-char conversion.
|
||||
*
|
||||
* @param bufferSize Size of internal buffer to use.
|
||||
*/
|
||||
public static String toString( final byte[] input, final int bufferSize )
|
||||
throws IOException
|
||||
{
|
||||
final StringWriter sw = new StringWriter();
|
||||
copy( input, sw, bufferSize );
|
||||
return sw.toString();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the contents of a <code>byte[]</code> as a String.
|
||||
*
|
||||
* @param encoding The name of a supported character encoding. See the
|
||||
* <a href="http://www.iana.org/assignments/character-sets">IANA
|
||||
* Charset Registry</a> for a list of valid encoding types.
|
||||
*/
|
||||
public static String toString( final byte[] input, final String encoding )
|
||||
throws IOException
|
||||
{
|
||||
return toString( input, encoding, DEFAULT_BUFFER_SIZE );
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the contents of a <code>byte[]</code> as a String.
|
||||
*
|
||||
* @param encoding The name of a supported character encoding. See the
|
||||
* <a href="http://www.iana.org/assignments/character-sets">IANA
|
||||
* Charset Registry</a> for a list of valid encoding types.
|
||||
* @param bufferSize Size of internal buffer to use.
|
||||
*/
|
||||
public static String toString( final byte[] input,
|
||||
final String encoding,
|
||||
final int bufferSize )
|
||||
throws IOException
|
||||
{
|
||||
final StringWriter sw = new StringWriter();
|
||||
copy( input, sw, encoding, bufferSize );
|
||||
return sw.toString();
|
||||
}
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////
|
||||
// byte[] -> OutputStream
|
||||
|
||||
/**
|
||||
* Copy bytes from a <code>byte[]</code> to an <code>OutputStream</code>.
|
||||
*/
|
||||
public static void copy( final byte[] input, final OutputStream output )
|
||||
throws IOException
|
||||
{
|
||||
copy( input, output, DEFAULT_BUFFER_SIZE );
|
||||
}
|
||||
|
||||
/**
|
||||
* Copy bytes from a <code>byte[]</code> to an <code>OutputStream</code>.
|
||||
*
|
||||
* @param bufferSize Size of internal buffer to use.
|
||||
*/
|
||||
public static void copy( final byte[] input,
|
||||
final OutputStream output,
|
||||
final int bufferSize )
|
||||
throws IOException
|
||||
{
|
||||
output.write( input );
|
||||
}
|
||||
|
||||
/**
|
||||
* Compare the contents of two Streams to determine if they are equal or not.
|
||||
*
|
||||
* @param input1 the first stream
|
||||
* @param input2 the second stream
|
||||
* @return true if the content of the streams are equal or they both don't exist, false otherwise
|
||||
*/
|
||||
public static boolean contentEquals( final InputStream input1,
|
||||
final InputStream input2 )
|
||||
throws IOException
|
||||
{
|
||||
final InputStream bufferedInput1 = new BufferedInputStream( input1 );
|
||||
final InputStream bufferedInput2 = new BufferedInputStream( input2 );
|
||||
|
||||
int ch = bufferedInput1.read();
|
||||
while ( -1 != ch )
|
||||
{
|
||||
final int ch2 = bufferedInput2.read();
|
||||
if ( ch != ch2 )
|
||||
{
|
||||
return false;
|
||||
}
|
||||
ch = bufferedInput1.read();
|
||||
}
|
||||
|
||||
final int ch2 = bufferedInput2.read();
|
||||
if ( -1 != ch2 )
|
||||
{
|
||||
return false;
|
||||
}
|
||||
else
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////
|
||||
// close()
|
||||
|
||||
/**
|
||||
* A IOException ignoring method that simply closes the stream.
|
||||
*
|
||||
* @param inputStream The stream to close.
|
||||
*/
|
||||
public static void close( InputStream inputStream )
|
||||
{
|
||||
try
|
||||
{
|
||||
inputStream.close();
|
||||
}
|
||||
catch ( IOException ex )
|
||||
{
|
||||
// ignore
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* A IOException ignoring method that simply closes the stream.
|
||||
*
|
||||
* @param outputStream The stream to close.
|
||||
*/
|
||||
public static void close( OutputStream outputStream )
|
||||
{
|
||||
try
|
||||
{
|
||||
outputStream.close();
|
||||
}
|
||||
catch ( IOException ex )
|
||||
{
|
||||
// ignore
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* A IOException ignoring method that simply closes the reader.
|
||||
*
|
||||
* @param reader The reader to close.
|
||||
*/
|
||||
public static void close( Reader reader )
|
||||
{
|
||||
try
|
||||
{
|
||||
reader.close();
|
||||
}
|
||||
catch ( IOException ex )
|
||||
{
|
||||
// ignore
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* A IOException ignoring method that simply closes the stream.
|
||||
*
|
||||
* @param wrtier The writer to close.
|
||||
*/
|
||||
public static void close( Writer writer )
|
||||
{
|
||||
try
|
||||
{
|
||||
writer.close();
|
||||
}
|
||||
catch ( IOException ex )
|
||||
{
|
||||
// ignore
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1,9 +1,17 @@
|
|||
|
||||
import compile.JavacCompiler;
|
||||
import download.ArtifactDownloader;
|
||||
import jar.JarMojo;
|
||||
import org.xml.sax.Attributes;
|
||||
import org.xml.sax.InputSource;
|
||||
import org.xml.sax.SAXException;
|
||||
import org.xml.sax.SAXParseException;
|
||||
import org.xml.sax.helpers.DefaultHandler;
|
||||
import test.SurefirePlugin;
|
||||
import util.Commandline;
|
||||
import util.FileUtils;
|
||||
import util.IsolatedClassLoader;
|
||||
import util.Os;
|
||||
|
||||
import javax.xml.parsers.SAXParser;
|
||||
import javax.xml.parsers.SAXParserFactory;
|
||||
|
|
@ -282,7 +290,7 @@ public class MBoot
|
|||
|
||||
FileUtils.copyFileToDirectory( new File( basedir, "maven-core/src/bin/m2.bat" ).getAbsolutePath(), bin );
|
||||
|
||||
FileUtils.copyFileToDirectory( new File( basedir, "maven-core/src/bin/classworlds.conf" ).getAbsolutePath(), bin );
|
||||
FileUtils.copyFileToDirectory( new File( basedir, "maven-core/src/bin/m2.conf" ).getAbsolutePath(), bin );
|
||||
|
||||
if ( Os.isFamily( "unix" ) )
|
||||
{
|
||||
|
|
|
|||
|
|
@ -1,3 +1,6 @@
|
|||
package compile;
|
||||
|
||||
import util.DirectoryScanner;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.IOException;
|
||||
|
|
@ -1,3 +1,4 @@
|
|||
package compile;
|
||||
|
||||
/**
|
||||
* This class encapsulates an error message produced by a programming language
|
||||
|
|
@ -1,3 +1,6 @@
|
|||
package compile;
|
||||
|
||||
import util.IsolatedClassLoader;
|
||||
|
||||
import java.io.BufferedReader;
|
||||
import java.io.ByteArrayInputStream;
|
||||
|
|
@ -1,14 +1,12 @@
|
|||
package download;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.FileNotFoundException;
|
||||
import java.io.FileWriter;
|
||||
import java.io.Writer;
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashSet;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
import java.util.StringTokenizer;
|
||||
import java.util.Set;
|
||||
import java.util.HashSet;
|
||||
|
||||
public class ArtifactDownloader
|
||||
{
|
||||
|
|
@ -1,3 +1,5 @@
|
|||
package download;
|
||||
|
||||
/*
|
||||
* ====================================================================
|
||||
* Copyright 2001-2004 The Apache Software Foundation.
|
||||
|
|
@ -1,3 +1,5 @@
|
|||
package download;
|
||||
|
||||
/* ====================================================================
|
||||
* Copyright 2001-2004 The Apache Software Foundation.
|
||||
*
|
||||
|
|
@ -1,3 +1,7 @@
|
|||
package jar;
|
||||
|
||||
import util.DirectoryScanner;
|
||||
import util.StringUtils;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.FileInputStream;
|
||||
|
|
@ -1,3 +1,7 @@
|
|||
package test;
|
||||
|
||||
import util.IsolatedClassLoader;
|
||||
|
||||
import java.io.BufferedReader;
|
||||
import java.io.File;
|
||||
import java.io.FileReader;
|
||||
|
|
@ -7,7 +11,8 @@ import java.util.Iterator;
|
|||
import java.util.List;
|
||||
import java.util.StringTokenizer;
|
||||
|
||||
public class SurefireBooter
|
||||
public class
|
||||
SurefireBooter
|
||||
{
|
||||
private List batteries = new ArrayList();
|
||||
|
||||
|
|
@ -1,3 +1,5 @@
|
|||
package test;
|
||||
|
||||
import java.io.File;
|
||||
import java.util.List;
|
||||
|
||||
|
|
@ -1,7 +1,7 @@
|
|||
package util;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.IOException;
|
||||
import java.util.Enumeration;
|
||||
import java.util.StringTokenizer;
|
||||
import java.util.Vector;
|
||||
|
||||
|
|
@ -189,40 +189,7 @@ public class Commandline implements Cloneable
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* <p>Gets the shell or command-line interpretor for the detected operating system,
|
||||
* and the shell arguments.</p>
|
||||
*/
|
||||
private String getDefaultShell()
|
||||
{
|
||||
if ( shell != null )
|
||||
{
|
||||
String args = "";
|
||||
for (Enumeration enums = shellArgs.elements(); enums.hasMoreElements(); )
|
||||
{
|
||||
args += (String)enums.nextElement();
|
||||
if (enums.hasMoreElements())
|
||||
{
|
||||
args += " ";
|
||||
}
|
||||
}
|
||||
|
||||
if (args.length() > 0)
|
||||
{
|
||||
return shell + " " + args;
|
||||
}
|
||||
else
|
||||
{
|
||||
return shell;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
return "";
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Creates an argument object.
|
||||
*
|
||||
|
|
@ -1,3 +1,4 @@
|
|||
package util;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.IOException;
|
||||
|
|
@ -0,0 +1,330 @@
|
|||
package util;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.FileInputStream;
|
||||
import java.io.FileOutputStream;
|
||||
import java.io.IOException;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
|
||||
public class FileUtils
|
||||
{
|
||||
public static final int ONE_KB = 1024;
|
||||
|
||||
public static final int ONE_MB = ONE_KB * ONE_KB;
|
||||
|
||||
public static final int ONE_GB = ONE_KB * ONE_MB;
|
||||
|
||||
public static String extension( String filename )
|
||||
{
|
||||
int lastDot = filename.lastIndexOf( '.' );
|
||||
|
||||
if ( lastDot >= 0 )
|
||||
{
|
||||
return filename.substring( lastDot + 1 );
|
||||
}
|
||||
else
|
||||
{
|
||||
return "";
|
||||
}
|
||||
}
|
||||
|
||||
public static void mkdir( String dir )
|
||||
{
|
||||
File file = new File( dir );
|
||||
if ( !file.exists() )
|
||||
{
|
||||
file.mkdirs();
|
||||
}
|
||||
}
|
||||
|
||||
public static void copyFileToDirectory( final String source,
|
||||
final String destinationDirectory )
|
||||
throws IOException
|
||||
{
|
||||
copyFileToDirectory( new File( source ),
|
||||
new File( destinationDirectory ) );
|
||||
}
|
||||
|
||||
public static void copyFileToDirectory( final File source,
|
||||
final File destinationDirectory )
|
||||
throws IOException
|
||||
{
|
||||
if ( destinationDirectory.exists() && !destinationDirectory.isDirectory() )
|
||||
{
|
||||
throw new IllegalArgumentException( "Destination is not a directory" );
|
||||
}
|
||||
|
||||
copyFile( source, new File( destinationDirectory, source.getName() ) );
|
||||
}
|
||||
|
||||
public static void copyFile( final File source, final File destination )
|
||||
throws IOException
|
||||
{
|
||||
//check source exists
|
||||
if ( !source.exists() )
|
||||
{
|
||||
final String message = "File " + source + " does not exist";
|
||||
throw new IOException( message );
|
||||
}
|
||||
|
||||
//does destinations directory exist ?
|
||||
if ( destination.getParentFile() != null &&
|
||||
!destination.getParentFile().exists() )
|
||||
{
|
||||
destination.getParentFile().mkdirs();
|
||||
}
|
||||
|
||||
//make sure we can write to destination
|
||||
if ( destination.exists() && !destination.canWrite() )
|
||||
{
|
||||
final String message = "Unable to open file " +
|
||||
destination + " for writing.";
|
||||
throw new IOException( message );
|
||||
}
|
||||
|
||||
final FileInputStream input = new FileInputStream( source );
|
||||
final FileOutputStream output = new FileOutputStream( destination );
|
||||
IOUtil.copy( input, output );
|
||||
|
||||
input.close();
|
||||
output.close();
|
||||
|
||||
if ( source.length() != destination.length() )
|
||||
{
|
||||
final String message = "Failed to copy full contents from " + source +
|
||||
" to " + destination;
|
||||
throw new IOException( message );
|
||||
}
|
||||
}
|
||||
|
||||
public static void forceDelete( final String file )
|
||||
throws IOException
|
||||
{
|
||||
forceDelete( new File( file ) );
|
||||
}
|
||||
|
||||
public static void forceDelete( final File file )
|
||||
throws IOException
|
||||
{
|
||||
if ( ! file.exists() )
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if ( file.isDirectory() )
|
||||
{
|
||||
deleteDirectory( file );
|
||||
}
|
||||
else
|
||||
{
|
||||
if ( !file.delete() )
|
||||
{
|
||||
final String message =
|
||||
"File " + file + " unable to be deleted.";
|
||||
throw new IOException( message );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static void forceDeleteOnExit( final File file )
|
||||
throws IOException
|
||||
{
|
||||
if ( ! file.exists() )
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if ( file.isDirectory() )
|
||||
{
|
||||
deleteDirectoryOnExit( file );
|
||||
}
|
||||
else
|
||||
{
|
||||
file.deleteOnExit();
|
||||
}
|
||||
}
|
||||
|
||||
private static void deleteDirectoryOnExit( final File directory )
|
||||
throws IOException
|
||||
{
|
||||
if ( !directory.exists() )
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
cleanDirectoryOnExit( directory );
|
||||
directory.deleteOnExit();
|
||||
}
|
||||
|
||||
private static void cleanDirectoryOnExit( final File directory )
|
||||
throws IOException
|
||||
{
|
||||
if ( !directory.exists() )
|
||||
{
|
||||
final String message = directory + " does not exist";
|
||||
throw new IllegalArgumentException( message );
|
||||
}
|
||||
|
||||
if ( !directory.isDirectory() )
|
||||
{
|
||||
final String message = directory + " is not a directory";
|
||||
throw new IllegalArgumentException( message );
|
||||
}
|
||||
|
||||
IOException exception = null;
|
||||
|
||||
final File[] files = directory.listFiles();
|
||||
for ( int i = 0; i < files.length; i++ )
|
||||
{
|
||||
final File file = files[i];
|
||||
try
|
||||
{
|
||||
forceDeleteOnExit( file );
|
||||
}
|
||||
catch ( final IOException ioe )
|
||||
{
|
||||
exception = ioe;
|
||||
}
|
||||
}
|
||||
|
||||
if ( null != exception )
|
||||
{
|
||||
throw exception;
|
||||
}
|
||||
}
|
||||
|
||||
public static void deleteDirectory( final File directory )
|
||||
throws IOException
|
||||
{
|
||||
if ( !directory.exists() )
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
cleanDirectory( directory );
|
||||
if ( !directory.delete() )
|
||||
{
|
||||
final String message =
|
||||
"Directory " + directory + " unable to be deleted.";
|
||||
throw new IOException( message );
|
||||
}
|
||||
}
|
||||
|
||||
public static void cleanDirectory( final File directory )
|
||||
throws IOException
|
||||
{
|
||||
if ( !directory.exists() )
|
||||
{
|
||||
final String message = directory + " does not exist";
|
||||
throw new IllegalArgumentException( message );
|
||||
}
|
||||
|
||||
if ( !directory.isDirectory() )
|
||||
{
|
||||
final String message = directory + " is not a directory";
|
||||
throw new IllegalArgumentException( message );
|
||||
}
|
||||
|
||||
IOException exception = null;
|
||||
|
||||
final File[] files = directory.listFiles();
|
||||
for ( int i = 0; i < files.length; i++ )
|
||||
{
|
||||
final File file = files[i];
|
||||
try
|
||||
{
|
||||
forceDelete( file );
|
||||
}
|
||||
catch ( final IOException ioe )
|
||||
{
|
||||
exception = ioe;
|
||||
}
|
||||
}
|
||||
|
||||
if ( null != exception )
|
||||
{
|
||||
throw exception;
|
||||
}
|
||||
}
|
||||
|
||||
public static List getFiles( File directory, String includes, String excludes )
|
||||
throws IOException
|
||||
{
|
||||
return getFiles( directory, includes, excludes, true );
|
||||
}
|
||||
|
||||
public static List getFiles( File directory, String includes, String excludes, boolean includeBasedir )
|
||||
throws IOException
|
||||
{
|
||||
List fileNames = getFileNames( directory, includes, excludes, includeBasedir );
|
||||
|
||||
List files = new ArrayList();
|
||||
|
||||
for ( Iterator i = fileNames.iterator(); i.hasNext(); )
|
||||
{
|
||||
files.add( new File( (String) i.next() ) );
|
||||
}
|
||||
|
||||
return files;
|
||||
}
|
||||
|
||||
public static String FS = System.getProperty( "file.separator" );
|
||||
|
||||
public static List getFileNames( File directory, String includes, String excludes, boolean includeBasedir )
|
||||
throws IOException
|
||||
{
|
||||
DirectoryScanner scanner = new DirectoryScanner();
|
||||
|
||||
scanner.setBasedir( directory );
|
||||
|
||||
if ( includes != null )
|
||||
{
|
||||
scanner.setIncludes( StringUtils.split( includes, "," ) );
|
||||
}
|
||||
|
||||
if ( excludes != null )
|
||||
{
|
||||
scanner.setExcludes( StringUtils.split( excludes, "," ) );
|
||||
}
|
||||
|
||||
scanner.scan();
|
||||
|
||||
String[] files = scanner.getIncludedFiles();
|
||||
|
||||
List list = new ArrayList();
|
||||
|
||||
for ( int i = 0; i < files.length; i++ )
|
||||
{
|
||||
if ( includeBasedir )
|
||||
{
|
||||
list.add( directory + FS + files[i] );
|
||||
}
|
||||
else
|
||||
{
|
||||
list.add( files[i] );
|
||||
}
|
||||
}
|
||||
|
||||
return list;
|
||||
}
|
||||
|
||||
public static void copyDirectory( File sourceDirectory, File destinationDirectory )
|
||||
throws IOException
|
||||
{
|
||||
if ( !sourceDirectory.exists() )
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
List files = getFiles( sourceDirectory, "**", null );
|
||||
|
||||
for ( Iterator i = files.iterator(); i.hasNext(); )
|
||||
{
|
||||
File file = (File) i.next();
|
||||
|
||||
copyFileToDirectory( file, destinationDirectory );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,68 @@
|
|||
package util;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import java.io.InputStreamReader;
|
||||
import java.io.OutputStream;
|
||||
import java.io.Reader;
|
||||
import java.io.Writer;
|
||||
|
||||
public final class IOUtil
|
||||
{
|
||||
private static final int DEFAULT_BUFFER_SIZE = 1024 * 4;
|
||||
|
||||
public static void copy( final InputStream input, final OutputStream output )
|
||||
throws IOException
|
||||
{
|
||||
copy( input, output, DEFAULT_BUFFER_SIZE );
|
||||
}
|
||||
|
||||
public static void copy( final InputStream input,
|
||||
final OutputStream output,
|
||||
final int bufferSize )
|
||||
throws IOException
|
||||
{
|
||||
final byte[] buffer = new byte[bufferSize];
|
||||
int n = 0;
|
||||
while ( -1 != ( n = input.read( buffer ) ) )
|
||||
{
|
||||
output.write( buffer, 0, n );
|
||||
}
|
||||
}
|
||||
|
||||
public static void copy( final Reader input, final Writer output )
|
||||
throws IOException
|
||||
{
|
||||
copy( input, output, DEFAULT_BUFFER_SIZE );
|
||||
}
|
||||
|
||||
/**
|
||||
* Copy chars from a <code>Reader</code> to a <code>Writer</code>.
|
||||
*
|
||||
* @param bufferSize Size of internal buffer to use.
|
||||
*/
|
||||
public static void copy( final Reader input, final Writer output, final int bufferSize )
|
||||
throws IOException
|
||||
{
|
||||
final char[] buffer = new char[bufferSize];
|
||||
int n = 0;
|
||||
while ( -1 != ( n = input.read( buffer ) ) )
|
||||
{
|
||||
output.write( buffer, 0, n );
|
||||
}
|
||||
output.flush();
|
||||
}
|
||||
|
||||
public static void copy( final InputStream input, final Writer output )
|
||||
throws IOException
|
||||
{
|
||||
copy( input, output, DEFAULT_BUFFER_SIZE );
|
||||
}
|
||||
|
||||
public static void copy( final InputStream input, final Writer output, final int bufferSize )
|
||||
throws IOException
|
||||
{
|
||||
final InputStreamReader in = new InputStreamReader( input );
|
||||
copy( in, output, bufferSize );
|
||||
}
|
||||
}
|
||||
|
|
@ -1,6 +1,7 @@
|
|||
package util;
|
||||
|
||||
import java.net.URLClassLoader;
|
||||
import java.net.URL;
|
||||
import java.net.URLClassLoader;
|
||||
|
||||
public class IsolatedClassLoader
|
||||
extends URLClassLoader
|
||||
|
|
@ -1,3 +1,5 @@
|
|||
package util;
|
||||
|
||||
import java.util.Locale;
|
||||
|
||||
/**
|
||||
|
|
@ -1,3 +1,4 @@
|
|||
package util;
|
||||
|
||||
import java.io.File;
|
||||
import java.util.StringTokenizer;
|
||||
|
|
@ -1,28 +1,9 @@
|
|||
package util;
|
||||
|
||||
import java.util.Iterator;
|
||||
import java.util.Map;
|
||||
import java.util.StringTokenizer;
|
||||
|
||||
/**
|
||||
* <p>Common <code>String</code> manipulation routines.</p>
|
||||
* <p/>
|
||||
* <p>Originally from
|
||||
* <a href="http://jakarta.codehaus.org/turbine/">Turbine</a> and the
|
||||
* GenerationJavaCore library.</p>
|
||||
*
|
||||
* @author <a href="mailto:jon@latchkey.com">Jon S. Stevens</a>
|
||||
* @author <a href="mailto:dlr@finemaltcoding.com">Daniel Rall</a>
|
||||
* @author <a href="mailto:gcoladonato@yahoo.com">Greg Coladonato</a>
|
||||
* @author <a href="mailto:bayard@generationjava.com">Henri Yandell</a>
|
||||
* @author <a href="mailto:ed@codehaus.org">Ed Korthof</a>
|
||||
* @author <a href="mailto:rand_mcneely@yahoo.com">Rand McNeely</a>
|
||||
* @author Stephen Colebourne
|
||||
* @author <a href="mailto:fredrik@westermarck.com">Fredrik Westermarck</a>
|
||||
* @author Holger Krauth
|
||||
* @author <a href="mailto:alex@purpletech.com">Alexander Day Chaffee</a>
|
||||
* @version $Id$
|
||||
* @since 1.0
|
||||
*/
|
||||
public class StringUtils
|
||||
{
|
||||
public static String[] split( String str )
|
||||
|
|
@ -35,24 +16,6 @@ public class StringUtils
|
|||
return split( text, separator, -1 );
|
||||
}
|
||||
|
||||
/**
|
||||
* <p>Splits the provided text into a array, based on a given separator.</p>
|
||||
* <p/>
|
||||
* <p>The separator is not included in the returned String array. The
|
||||
* maximum number of splits to perfom can be controlled. A <code>null</code>
|
||||
* separator will cause parsing to be on whitespace.</p>
|
||||
* <p/>
|
||||
* <p>This is useful for quickly splitting a String directly into
|
||||
* an array of tokens, instead of an enumeration of tokens (as
|
||||
* <code>StringTokenizer</code> does).</p>
|
||||
*
|
||||
* @param str The string to parse.
|
||||
* @param separator Characters used as the delimiters. If
|
||||
* <code>null</code>, splits on whitespace.
|
||||
* @param max The maximum number of elements to include in the
|
||||
* array. A zero or negative value implies no limit.
|
||||
* @return an array of parsed Strings
|
||||
*/
|
||||
public static String[] split( String str, String separator, int max )
|
||||
{
|
||||
StringTokenizer tok = null;
|
||||
|
|
@ -133,8 +96,6 @@ public class StringUtils
|
|||
return buf.toString();
|
||||
}
|
||||
|
||||
|
||||
|
||||
public static String interpolate( String text, Map namespace )
|
||||
{
|
||||
Iterator keys = namespace.keySet().iterator();
|
||||
Loading…
Reference in New Issue