pattern=**\a
* and str=b will yield true.
*
* @param pattern The pattern to match against. Must not be
* null.
* @param str The path to match, as a String. Must not be
* null.
* @return whether or not a given path matches the start of a given
* pattern up to the first "**".
*/
protected static boolean matchPatternStart( String pattern, String str )
{
return SelectorUtils.matchPatternStart( pattern, str );
}
/**
* Tests whether or not a given path matches the start of a given
* pattern up to the first "**".
*
* This is not a general purpose test and should only be used if you
* can live with false positives. For example, pattern=**\a
* and str=b will yield true.
*
* @param pattern The pattern to match against. Must not be
* null.
* @param str The path to match, as a String. Must not be
* null.
* @param isCaseSensitive Whether or not matching should be performed
* case sensitively.
* @return whether or not a given path matches the start of a given
* pattern up to the first "**".
*/
protected static boolean matchPatternStart( String pattern, String str, boolean isCaseSensitive )
{
return SelectorUtils.matchPatternStart( pattern, str, isCaseSensitive );
}
/**
* Tests whether or not a given path matches a given pattern.
*
* @param pattern The pattern to match against. Must not be
* null.
* @param str The path to match, as a String. Must not be
* null.
* @return true if the pattern matches against the string,
* or false otherwise.
*/
protected static boolean matchPath( String pattern, String str )
{
return SelectorUtils.matchPath( pattern, str );
}
/**
* Tests whether or not a given path matches a given pattern.
*
* @param pattern The pattern to match against. Must not be
* null.
* @param str The path to match, as a String. Must not be
* null.
* @param isCaseSensitive Whether or not matching should be performed
* case sensitively.
* @return true if the pattern matches against the string,
* or false otherwise.
*/
protected static boolean matchPath( String pattern, String str, boolean isCaseSensitive )
{
return SelectorUtils.matchPath( pattern, str, isCaseSensitive );
}
/**
* Tests whether or not a string matches against a pattern.
* The pattern may contain two special characters:null.
* @param str The string which must be matched against the pattern.
* Must not be null.
* @return true if the string matches against the pattern,
* or false otherwise.
*/
public static boolean match( String pattern, String str )
{
return SelectorUtils.match( pattern, str );
}
/**
* Tests whether or not a string matches against a pattern.
* The pattern may contain two special characters:null.
* @param str The string which must be matched against the pattern.
* Must not be null.
* @param isCaseSensitive Whether or not matching should be performed
* case sensitively.
* @return true if the string matches against the pattern,
* or false otherwise.
*/
protected static boolean match( String pattern, String str, boolean isCaseSensitive )
{
return SelectorUtils.match( pattern, str, isCaseSensitive );
}
/**
* Sets the list of include patterns to use. All '/' and '\' characters
* are replaced by File.separatorChar, so the separator used
* need not match File.separatorChar.
*
* When a pattern ends with a '/' or '\', "**" is appended.
*
* @param includes A list of include patterns.
* May be null, indicating that all files
* should be included. If a non-null
* list is given, all elements must be
* non-null.
*/
public void setIncludes( String[] includes )
{
if ( includes == null )
{
this.includes = null;
}
else
{
this.includes = new String[includes.length];
for ( int i = 0; i < includes.length; i++ )
{
this.includes[i] = normalizePattern( includes[i] );
}
}
}
/**
* Sets the list of exclude patterns to use. All '/' and '\' characters
* are replaced by File.separatorChar, so the separator used
* need not match File.separatorChar.
*
* When a pattern ends with a '/' or '\', "**" is appended.
*
* @param excludes A list of exclude patterns.
* May be null, indicating that no files
* should be excluded. If a non-null list is
* given, all elements must be non-null.
*/
public void setExcludes( String[] excludes )
{
if ( excludes == null )
{
this.excludes = null;
}
else
{
this.excludes = new String[excludes.length];
for ( int i = 0; i < excludes.length; i++ )
{
this.excludes[i] = normalizePattern( excludes[i] );
}
}
}
/**
* Normalizes the pattern, e.g. converts forward and backward slashes to the platform-specific file separator.
*
* @param pattern The pattern to normalize, must not be null.
* @return The normalized pattern, never null.
*/
private String normalizePattern( String pattern )
{
pattern = pattern.trim();
if ( pattern.startsWith( SelectorUtils.REGEX_HANDLER_PREFIX ) )
{
if ( File.separatorChar == '\\' )
{
pattern = StringUtils.replace( pattern, "/", "\\\\" );
}
else
{
pattern = StringUtils.replace( pattern, "\\\\", "/" );
}
}
else
{
pattern = pattern.replace( File.separatorChar == '/' ? '\\' : '/', File.separatorChar );
if ( pattern.endsWith( File.separator ) )
{
pattern += "**";
}
}
return pattern;
}
/**
* Tests whether or not a name matches against at least one include
* pattern.
*
* @param name The name to match. Must not be null.
* @return true when the name matches against at least one
* include pattern, or false otherwise.
*/
protected boolean isIncluded( String name )
{
return includesPatterns.matches( name, isCaseSensitive );
}
protected boolean isIncluded( String name, String[] tokenizedName )
{
return includesPatterns.matches( name, tokenizedName, isCaseSensitive );
}
/**
* Tests whether or not a name matches the start of at least one include
* pattern.
*
* @param name The name to match. Must not be null.
* @return true when the name matches against the start of at
* least one include pattern, or false otherwise.
*/
protected boolean couldHoldIncluded( String name )
{
return includesPatterns.matchesPatternStart(name, isCaseSensitive);
}
/**
* Tests whether or not a name matches against at least one exclude
* pattern.
*
* @param name The name to match. Must not be null.
* @return true when the name matches against at least one
* exclude pattern, or false otherwise.
*/
protected boolean isExcluded( String name )
{
return excludesPatterns.matches( name, isCaseSensitive );
}
protected boolean isExcluded( String name, String[] tokenizedName )
{
return excludesPatterns.matches( name, tokenizedName, isCaseSensitive );
}
/**
* Adds default exclusions to the current exclusions set.
*/
public void addDefaultExcludes()
{
int excludesLength = excludes == null ? 0 : excludes.length;
String[] newExcludes;
newExcludes = new String[excludesLength + DEFAULTEXCLUDES.length];
if ( excludesLength > 0 )
{
System.arraycopy( excludes, 0, newExcludes, 0, excludesLength );
}
for ( int i = 0; i < DEFAULTEXCLUDES.length; i++ )
{
newExcludes[i + excludesLength] = DEFAULTEXCLUDES[i].replace( '/', File.separatorChar );
}
excludes = newExcludes;
}
protected void setupDefaultFilters()
{
if ( includes == null )
{
// No includes supplied, so set it to 'matches all'
includes = new String[1];
includes[0] = "**";
}
if ( excludes == null )
{
excludes = new String[0];
}
}
protected void setupMatchPatterns()
{
includesPatterns = MatchPatterns.from( includes );
excludesPatterns = MatchPatterns.from( excludes );
}
}
plexus-utils-plexus-utils-3.0.22/src/main/java/org/codehaus/plexus/util/Base64.java 0000664 0000000 0000000 00000040715 12510777323 0030150 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util;
/*
* Copyright The Codehaus Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* Provides Base64 encoding and decoding as defined by RFC 2045.
*
* This class implements section 6.8. Base64 Content-Transfer-Encoding * from RFC 2045 Multipurpose Internet Mail Extensions (MIME) Part One: * Format of Internet Message Bodies by Freed and Borenstein.
* * @see RFC 2045 * @author Apache Software Foundation * @since 1.0-dev * @version $Id$ */ public class Base64 { // // Source Id: Base64.java 161350 2005-04-14 20:39:46Z ggregory // /** * Chunk size per RFC 2045 section 6.8. * *The {@value} character limit does not count the trailing CRLF, but counts * all other characters, including any equal signs.
* * @see RFC 2045 section 6.8 */ static final int CHUNK_SIZE = 76; /** * Chunk separator per RFC 2045 section 2.1. * * @see RFC 2045 section 2.1 */ static final byte[] CHUNK_SEPARATOR = "\r\n".getBytes(); /** * The base length. */ static final int BASELENGTH = 255; /** * Lookup length. */ static final int LOOKUPLENGTH = 64; /** * Used to calculate the number of bits in a byte. */ static final int EIGHTBIT = 8; /** * Used when encoding something which has fewer than 24 bits. */ static final int SIXTEENBIT = 16; /** * Used to determine how many bits data contains. */ static final int TWENTYFOURBITGROUP = 24; /** * Used to get the number of Quadruples. */ static final int FOURBYTE = 4; /** * Used to test the sign of a byte. */ static final int SIGN = -128; /** * Byte used to pad output. */ static final byte PAD = (byte) '='; /** * Contains the Base64 values0 through 63 accessed by using character encodings as
* indices.
*
* For example, base64Alphabet['+'] returns 62.
*
* The value of undefined encodings is -1.
*
* Contains the Base64 encodings A through Z, followed by a through
* z, followed by 0 through 9, followed by +, and
* /.
*
* This array is accessed by using character values as indices. *
*
* For example, lookUpBase64Alphabet[62] returns '+'.
*
octect is in the base 64 alphabet.
*
* @param octect The value to test
* @return true if the value is defined in the the base 64 alphabet, false otherwise.
*/
private static boolean isBase64(byte octect) {
if (octect == PAD) {
return true;
} else if (octect < 0 || base64Alphabet[octect] == -1) {
return false;
} else {
return true;
}
}
/**
* Tests a given byte array to see if it contains
* only valid characters within the Base64 alphabet.
*
* @param arrayOctect byte array to test
* @return true if all bytes are valid characters in the Base64
* alphabet or if the byte array is empty; false, otherwise
*/
public static boolean isArrayByteBase64(byte[] arrayOctect) {
arrayOctect = discardWhitespace(arrayOctect);
int length = arrayOctect.length;
if (length == 0) {
// shouldn't a 0 length array be valid base64 data?
// return false;
return true;
}
for ( byte anArrayOctect : arrayOctect )
{
if ( !isBase64( anArrayOctect ) )
{
return false;
}
}
return true;
}
/**
* Encodes binary data using the base64 algorithm but
* does not chunk the output.
*
* @param binaryData binary data to encode
* @return Base64 characters
*/
public static byte[] encodeBase64(byte[] binaryData) {
return encodeBase64(binaryData, false);
}
/**
* Encodes binary data using the base64 algorithm and chunks
* the encoded output into 76 character blocks
*
* @param binaryData binary data to encode
* @return Base64 characters chunked in 76 character blocks
*/
public static byte[] encodeBase64Chunked(byte[] binaryData) {
return encodeBase64(binaryData, true);
}
/**
* Decodes a byte[] containing containing
* characters in the Base64 alphabet.
*
* @param pArray A byte array containing Base64 character data
* @return a byte array containing binary data
*/
public byte[] decode(byte[] pArray) {
return decodeBase64(pArray);
}
/**
* Encodes binary data using the base64 algorithm, optionally
* chunking the output into 76 character blocks.
*
* @param binaryData Array containing binary data to encode.
* @param isChunked if true this encoder will chunk
* the base64 output into 76 character blocks
* @return Base64-encoded data.
*/
public static byte[] encodeBase64(byte[] binaryData, boolean isChunked) {
int lengthDataBits = binaryData.length * EIGHTBIT;
int fewerThan24bits = lengthDataBits % TWENTYFOURBITGROUP;
int numberTriplets = lengthDataBits / TWENTYFOURBITGROUP;
byte encodedData[] = null;
int encodedDataLength = 0;
int nbrChunks = 0;
if (fewerThan24bits != 0) {
//data not divisible by 24 bit
encodedDataLength = (numberTriplets + 1) * 4;
} else {
// 16 or 8 bit
encodedDataLength = numberTriplets * 4;
}
// If the output is to be "chunked" into 76 character sections,
// for compliance with RFC 2045 MIME, then it is important to
// allow for extra length to account for the separator(s)
if (isChunked) {
nbrChunks =
(CHUNK_SEPARATOR.length == 0 ? 0 : (int) Math.ceil((float) encodedDataLength / CHUNK_SIZE));
encodedDataLength += nbrChunks * CHUNK_SEPARATOR.length;
}
encodedData = new byte[encodedDataLength];
byte k = 0, l = 0, b1 = 0, b2 = 0, b3 = 0;
int encodedIndex = 0;
int dataIndex = 0;
int i = 0;
int nextSeparatorIndex = CHUNK_SIZE;
int chunksSoFar = 0;
//log.debug("number of triplets = " + numberTriplets);
for (i = 0; i < numberTriplets; i++) {
dataIndex = i * 3;
b1 = binaryData[dataIndex];
b2 = binaryData[dataIndex + 1];
b3 = binaryData[dataIndex + 2];
//log.debug("b1= " + b1 +", b2= " + b2 + ", b3= " + b3);
l = (byte) (b2 & 0x0f);
k = (byte) (b1 & 0x03);
byte val1 =
((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);
byte val2 =
((b2 & SIGN) == 0) ? (byte) (b2 >> 4) : (byte) ((b2) >> 4 ^ 0xf0);
byte val3 =
((b3 & SIGN) == 0) ? (byte) (b3 >> 6) : (byte) ((b3) >> 6 ^ 0xfc);
encodedData[encodedIndex] = lookUpBase64Alphabet[val1];
//log.debug( "val2 = " + val2 );
//log.debug( "k4 = " + (k<<4) );
//log.debug( "vak = " + (val2 | (k<<4)) );
encodedData[encodedIndex + 1] =
lookUpBase64Alphabet[val2 | (k << 4)];
encodedData[encodedIndex + 2] =
lookUpBase64Alphabet[(l << 2) | val3];
encodedData[encodedIndex + 3] = lookUpBase64Alphabet[b3 & 0x3f];
encodedIndex += 4;
// If we are chunking, let's put a chunk separator down.
if (isChunked) {
// this assumes that CHUNK_SIZE % 4 == 0
if (encodedIndex == nextSeparatorIndex) {
System.arraycopy(
CHUNK_SEPARATOR,
0,
encodedData,
encodedIndex,
CHUNK_SEPARATOR.length);
chunksSoFar++;
nextSeparatorIndex =
(CHUNK_SIZE * (chunksSoFar + 1)) +
(chunksSoFar * CHUNK_SEPARATOR.length);
encodedIndex += CHUNK_SEPARATOR.length;
}
}
}
// form integral number of 6-bit groups
dataIndex = i * 3;
if (fewerThan24bits == EIGHTBIT) {
b1 = binaryData[dataIndex];
k = (byte) (b1 & 0x03);
//log.debug("b1=" + b1);
//log.debug("b1<<2 = " + (b1>>2) );
byte val1 =
((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);
encodedData[encodedIndex] = lookUpBase64Alphabet[val1];
encodedData[encodedIndex + 1] = lookUpBase64Alphabet[k << 4];
encodedData[encodedIndex + 2] = PAD;
encodedData[encodedIndex + 3] = PAD;
} else if (fewerThan24bits == SIXTEENBIT) {
b1 = binaryData[dataIndex];
b2 = binaryData[dataIndex + 1];
l = (byte) (b2 & 0x0f);
k = (byte) (b1 & 0x03);
byte val1 =
((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);
byte val2 =
((b2 & SIGN) == 0) ? (byte) (b2 >> 4) : (byte) ((b2) >> 4 ^ 0xf0);
encodedData[encodedIndex] = lookUpBase64Alphabet[val1];
encodedData[encodedIndex + 1] =
lookUpBase64Alphabet[val2 | (k << 4)];
encodedData[encodedIndex + 2] = lookUpBase64Alphabet[l << 2];
encodedData[encodedIndex + 3] = PAD;
}
if (isChunked) {
// we also add a separator to the end of the final chunk.
if (chunksSoFar < nbrChunks) {
System.arraycopy(
CHUNK_SEPARATOR,
0,
encodedData,
encodedDataLength - CHUNK_SEPARATOR.length,
CHUNK_SEPARATOR.length);
}
}
return encodedData;
}
/**
* Decodes Base64 data into octects
*
* @param base64Data Byte array containing Base64 data
* @return Array containing decoded data.
*/
public static byte[] decodeBase64(byte[] base64Data) {
// RFC 2045 requires that we discard ALL non-Base64 characters
base64Data = discardNonBase64(base64Data);
// handle the edge case, so we don't have to worry about it later
if (base64Data.length == 0) {
return new byte[0];
}
int numberQuadruple = base64Data.length / FOURBYTE;
byte decodedData[] = null;
byte b1 = 0, b2 = 0, b3 = 0, b4 = 0, marker0 = 0, marker1 = 0;
// Throw away anything not in base64Data
int encodedIndex = 0;
int dataIndex = 0;
{
// this sizes the output array properly - rlw
int lastData = base64Data.length;
// ignore the '=' padding
while (base64Data[lastData - 1] == PAD) {
if (--lastData == 0) {
return new byte[0];
}
}
decodedData = new byte[lastData - numberQuadruple];
}
for (int i = 0; i < numberQuadruple; i++) {
dataIndex = i * 4;
marker0 = base64Data[dataIndex + 2];
marker1 = base64Data[dataIndex + 3];
b1 = base64Alphabet[base64Data[dataIndex]];
b2 = base64Alphabet[base64Data[dataIndex + 1]];
if (marker0 != PAD && marker1 != PAD) {
//No PAD e.g 3cQl
b3 = base64Alphabet[marker0];
b4 = base64Alphabet[marker1];
decodedData[encodedIndex] = (byte) (b1 << 2 | b2 >> 4);
decodedData[encodedIndex + 1] =
(byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
decodedData[encodedIndex + 2] = (byte) (b3 << 6 | b4);
} else if (marker0 == PAD) {
//Two PAD e.g. 3c[Pad][Pad]
decodedData[encodedIndex] = (byte) (b1 << 2 | b2 >> 4);
} else if (marker1 == PAD) {
//One PAD e.g. 3cQ[Pad]
b3 = base64Alphabet[marker0];
decodedData[encodedIndex] = (byte) (b1 << 2 | b2 >> 4);
decodedData[encodedIndex + 1] =
(byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
}
encodedIndex += 3;
}
return decodedData;
}
/**
* Discards any whitespace from a base-64 encoded block.
*
* @param data The base-64 encoded data to discard the whitespace
* from.
* @return The data, less whitespace (see RFC 2045).
*/
static byte[] discardWhitespace(byte[] data) {
byte groomedData[] = new byte[data.length];
int bytesCopied = 0;
for ( byte aData : data )
{
switch ( aData )
{
case (byte) ' ':
case (byte) '\n':
case (byte) '\r':
case (byte) '\t':
break;
default:
groomedData[bytesCopied++] = aData;
}
}
byte packedData[] = new byte[bytesCopied];
System.arraycopy(groomedData, 0, packedData, 0, bytesCopied);
return packedData;
}
/**
* Discards any characters outside of the base64 alphabet, per
* the requirements on page 25 of RFC 2045 - "Any characters
* outside of the base64 alphabet are to be ignored in base64
* encoded data."
*
* @param data The base-64 encoded data to groom
* @return The data, less non-base64 characters (see RFC 2045).
*/
static byte[] discardNonBase64(byte[] data) {
byte groomedData[] = new byte[data.length];
int bytesCopied = 0;
for ( byte aData : data )
{
if ( isBase64( aData ) )
{
groomedData[bytesCopied++] = aData;
}
}
byte packedData[] = new byte[bytesCopied];
System.arraycopy(groomedData, 0, packedData, 0, bytesCopied);
return packedData;
}
/**
* Encodes a byte[] containing binary data, into a byte[] containing
* characters in the Base64 alphabet.
*
* @param pArray a byte array containing binary data
* @return A byte array containing only Base64 character data
*/
public byte[] encode(byte[] pArray) {
return encodeBase64(pArray, false);
}
}
plexus-utils-plexus-utils-3.0.22/src/main/java/org/codehaus/plexus/util/CachedMap.java 0000664 0000000 0000000 00000033711 12510777323 0030727 0 ustar 00root root 0000000 0000000 /*
* J.A.D.E. Java(TM) Addition to Default Environment.
* Latest release available at http://jade.dautelle.com/
* This class is public domain (not copyrighted).
*/
package org.codehaus.plexus.util;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/**
* This class provides cache access to Map collections.
Instance of this class can be used as "proxy" for any collection
* implementing the java.util.Map interface.
Typically, {@link CachedMap} are used to accelerate access to
* large collections when the access to the collection is not evenly
* distributed (associative cache). The performance gain is about
* 50% for the fastest hash map collections (e.g. {@link FastMap}).
* For slower collections such as java.util.TreeMap,
* non-resizable {@link FastMap} (real-time) or database access,
* performance can be of several orders of magnitude.
Note: The keys used to access elements of a {@link CachedMap} do
* not need to be immutable as they are not stored in the cache
* (only keys specified by the {@link #put} method are).
* In other words, access can be performed using mutable keys as long
* as these keys can be compared for equality with the real map's keys
* (e.g. same hashCode values).
This implementation is not synchronized. Multiple threads accessing * or modifying the collection must be synchronized externally.
* *This class is public domain (not copyrighted).
* * @author Jean-Marie Dautelle * @version 5.3, October 30, 2003 */ public final class CachedMap implements Map { /** * Holds the FastMap backing this collection * (null if generic backing map).
*/
private final FastMap _backingFastMap;
/**
* Holds the generic map backing this collection.
*/
private final Map _backingMap;
/**
* Holds the keys of the backing map (key-to-key mapping).
* (null if FastMap backing map).
*/
private final FastMap _keysMap;
/**
* Holds the cache's mask (capacity - 1).
*/
private final int _mask;
/**
* Holds the keys being cached.
*/
private final Object[] _keys;
/**
* Holds the values being cached.
*/
private final Object[] _values;
/**
* Creates a cached map backed by a {@link FastMap}.
* The default cache size and map capacity is set to 256
* entries.
*/
public CachedMap() {
this(256, new FastMap());
}
/**
* Creates a cached map backed by a {@link FastMap} and having the
* specified cache size.
*
* @param cacheSize the cache size, the actual cache size is the
* first power of 2 greater or equal to cacheSize.
* This is also the initial capacity of the backing map.
*/
public CachedMap(int cacheSize) {
this(cacheSize, new FastMap(cacheSize));
}
/**
* Creates a cached map backed by the specified map and having the specified
* cache size. In order to maitain cache veracity, it is critical
* that all update to the backing map is accomplished through the
* {@link CachedMap} instance; otherwise {@link #flush} has to be called.
*
* @param cacheSize the cache size, the actual cache size is the
* first power of 2 greater or equal to cacheSize.
* @param backingMap the backing map to be "wrapped" in a cached map.
*/
public CachedMap(int cacheSize, Map backingMap) {
// Find a power of 2 >= minimalCache
int actualCacheSize = 1;
while (actualCacheSize < cacheSize) {
actualCacheSize <<= 1;
}
// Sets up cache.
_keys = new Object[actualCacheSize];
_values = new Object[actualCacheSize];
_mask = actualCacheSize - 1;
// Sets backing map references.
if (backingMap instanceof FastMap) {
_backingFastMap = (FastMap)backingMap;
_backingMap = _backingFastMap;
_keysMap = null;
} else {
_backingFastMap = null;
_backingMap = backingMap;
_keysMap = new FastMap(backingMap.size());
for ( Object key : backingMap.keySet() )
{
_keysMap.put( key, key );
}
}
}
/**
* Returns the actual cache size.
*
* @return the cache size (power of 2).
*/
public int getCacheSize() {
return _keys.length;
}
/**
* Returns the backing map. If the backing map is modified directly,
* this {@link CachedMap} has to be flushed.
*
* @return the backing map.
* @see #flush
*/
public Map getBackingMap() {
return (_backingFastMap != null) ? _backingFastMap : _backingMap;
}
/**
* Flushes the key/value pairs being cached. This method should be called
* if the backing map is externally modified.
*/
public void flush() {
for (int i=0; i < _keys.length; i++) {
_keys[i] = null;
_values[i] = null;
}
if (_keysMap != null) {
// Re-populates keys from backing map.
for ( Object key : _backingMap.keySet() )
{
_keysMap.put( key, key );
}
}
}
/**
* Returns the value to which this map maps the specified key.
* First, the cache is being checked, then if the cache does not contains
* the specified key, the backing map is accessed and the key/value
* pair is stored in the cache.
*
* @param key the key whose associated value is to be returned.
* @return the value to which this map maps the specified key, or
* null if the map contains no mapping for this key.
* @throws ClassCastException if the key is of an inappropriate type for
* the backing map (optional).
* @throws NullPointerException if the key is null.
*/
public Object get(Object key) {
int index = key.hashCode() & _mask;
return key.equals(_keys[index]) ?
_values[index] : getCacheMissed(key, index);
}
private Object getCacheMissed(Object key, int index) {
if (_backingFastMap != null) {
Map.Entry entry = _backingFastMap.getEntry(key);
if (entry != null) {
_keys[index] = entry.getKey();
Object value = entry.getValue();
_values[index] = value;
return value;
} else {
return null;
}
} else { // Generic backing map.
Object mapKey = _keysMap.get(key);
if (mapKey != null) {
_keys[index] = mapKey;
Object value = _backingMap.get(key);
_values[index] = value;
return value;
} else {
return null;
}
}
}
/**
* Associates the specified value with the specified key in this map.
*
* @param key the key with which the specified value is to be associated.
* @param value the value to be associated with the specified key.
* @return the previous value associated with specified key, or
* null if there was no mapping for the key.
* @throws UnsupportedOperationException if the put operation
* is not supported by the backing map.
* @throws ClassCastException if the class of the specified key or value
* prevents it from being stored in this map.
* @throws IllegalArgumentException if some aspect of this key or value
* prevents it from being stored in this map.
* @throws NullPointerException if the key is null.
*/
public Object put(Object key, Object value) {
// Updates the cache.
int index = key.hashCode() & _mask;
if (key.equals(_keys[index]) ) {
_values[index] = value;
} else if (_keysMap != null) { // Possibly a new key.
_keysMap.put(key, key);
}
// Updates the backing map.
return _backingMap.put(key, value);
}
/**
* Removes the mapping for this key from this map if it is present.
*
* @param key key whose mapping is to be removed from the map.
* @return previous value associated with specified key,
* or null if there was no mapping for key.
* @throws ClassCastException if the key is of an inappropriate type for
* the backing map (optional).
* @throws NullPointerException if the key is null.
* @throws UnsupportedOperationException if the remove method
* is not supported by the backing map.
*/
public Object remove(Object key) {
// Removes from cache.
int index = key.hashCode() & _mask;
if (key.equals(_keys[index]) ) {
_keys[index] = null;
}
// Removes from key map.
if (_keysMap != null) {
_keysMap.remove(key);
}
// Removes from backing map.
return _backingMap.remove(key);
}
/**
* Indicates if this map contains a mapping for the specified key.
*
* @param key the key whose presence in this map is to be tested.
* @return true if this map contains a mapping for the
* specified key; false otherwise.
*/
public boolean containsKey(Object key) {
// Checks the cache.
int index = key.hashCode() & _mask;
if (key.equals(_keys[index]) ) {
return true;
} else { // Checks the backing map.
return _backingMap.containsKey(key);
}
}
/**
* Returns the number of key-value mappings in this map. If the
* map contains more than Integer.MAX_VALUE elements,
* returns Integer.MAX_VALUE.
*
* @return the number of key-value mappings in this map.
*/
public int size() {
return _backingMap.size();
}
/**
* Returns true if this map contains no key-value mappings.
*
* @return true if this map contains no key-value mappings.
*/
public boolean isEmpty() {
return _backingMap.isEmpty();
}
/**
* Returns true if this map maps one or more keys to the
* specified value.
*
* @param value value whose presence in this map is to be tested.
* @return true if this map maps one or more keys to the
* specified value.
* @throws ClassCastException if the value is of an inappropriate type for
* the backing map (optional).
* @throws NullPointerException if the value is null and the
* backing map does not not permit null values.
*/
public boolean containsValue(Object value) {
return _backingMap.containsValue(value);
}
/**
* Copies all of the mappings from the specified map to this map
* (optional operation). This method automatically flushes the cache.
*
* @param map the mappings to be stored in this map.
* @throws UnsupportedOperationException if the putAll method
* is not supported by the backing map.
* @throws ClassCastException if the class of a key or value in the
* specified map prevents it from being stored in this map.
* @throws IllegalArgumentException some aspect of a key or value in the
* specified map prevents it from being stored in this map.
* @throws NullPointerException the specified map is null, or
* if the backing map does not permit null keys or
* values, and the specified map contains null keys or
* values.
*/
public void putAll(Map map) {
_backingMap.putAll(map);
flush();
}
/**
* Removes all mappings from this map (optional operation). This method
* automatically flushes the cache.
*
* @throws UnsupportedOperationException if clear is not supported by the
* backing map.
*/
public void clear() {
_backingMap.clear();
flush();
}
/**
* Returns an unmodifiable view of the keys contained in this
* map.
*
* @return an unmodifiable view of the keys contained in this map.
*/
public Set keySet() {
return Collections.unmodifiableSet(_backingMap.keySet());
}
/**
* Returns an unmodifiable view of the values contained in this map.
*
* @return an unmodifiable view of the values contained in this map.
*/
public Collection values() {
return Collections.unmodifiableCollection(_backingMap.values());
}
/**
* Returns an unmodifiable view of the mappings contained in this
* map. Each element in the returned set is a Map.Entry.
*
* @return an unmodifiable view of the mappings contained in this map.
*/
public Set entrySet() {
return Collections.unmodifiableSet(_backingMap.entrySet());
}
/**
* Compares the specified object with this map for equality. Returns
* true if the given object is also a map and the two Maps
* represent the same mappings.
*
* @param o object to be compared for equality with this map.
* @return true if the specified object is equal to this map.
*/
public boolean equals(Object o) {
return _backingMap.equals(o);
}
/**
* Returns the hash code value for this map.
*
* @return the hash code value for this map.
*/
public int hashCode() {
return _backingMap.hashCode();
}
} plexus-utils-plexus-utils-3.0.22/src/main/java/org/codehaus/plexus/util/CollectionUtils.java 0000664 0000000 0000000 00000017141 12510777323 0032235 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util;
/*
* Copyright The Codehaus Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Set;
/**
* @author olamy
* @version $Id$
*/
public class CollectionUtils
{
// ----------------------------------------------------------------------
// Static methods that can probably be moved to a real util class.
// ----------------------------------------------------------------------
/**
* Take a dominant and recessive Map and merge the key:value
* pairs where the recessive Map may add key:value pairs to the dominant
* Map but may not override any existing key:value pairs.
*
* If we have two Maps, a dominant and recessive, and
* their respective keys are as follows:
*
* dominantMapKeys = { a, b, c, d, e, f }
* recessiveMapKeys = { a, b, c, x, y, z }
*
* Then the result should be the following:
*
* resultantKeys = { a, b, c, d, e, f, x, y, z }
*
* @param dominantMap Dominant Map.
* @param recessiveMap Recessive Map.
* @return The result map with combined dominant and recessive values.
*/
public static Maps and merge
* them where the ordering of the array from 0..n
* is the dominant order.
*
* @param maps An array of Maps to merge.
* @return Map The result Map produced after the merging process.
*/
public static
* The cardinality of each element in the returned {@link Collection}
* will be equal to the minimum of the cardinality of that element
* in the two given {@link Collection}s.
*
* @param a The first collection
* @param b The second collection
* @see Collection#retainAll
* @return The intersection of a and b, never null
*/
public static Returns the names of the files which were selected out and
* therefore not ultimately included. The names are relative to the base directory. This involves
* performing a slow scan if one has not already been completed. Returns the names of the directories which were selected out and
* therefore not ultimately included. The names are relative to the base directory. This involves
* performing a slow scan if one has not already been completed. It doesn't really test for symbolic links but whether the
* canonical and absolute paths of the file are identical - this
* may lead to false positives on some platforms. For java versions prior to 7 It doesn't really test for
* symbolic links but whether the
* canonical and absolute paths of the file are identical - this
* may lead to false positives on some platforms. Adds to the list of method names used in the search for Introspects the specified The method searches for methods with specific names that return a
* In the absence of any such method, the object is inspected for a
* If none of the above is found, returns Introspects the specified Walks through the exception chain to the last element -- the
* "root" of the tree -- using {@link #getCause(Throwable)}, and
* returns that exception. Uses Find a throwable by method name. Find a throwable by field name. Returns the number of Returns the list of Delegates to {@link #indexOfThrowable(Throwable, Class, int)},
* starting the search at the beginning of the exception chain. Returns the (zero based) index, of the first
*
* The method is equivalent to t.printStackTrace() for throwables
* that don't have nested causes.
*/
public static void printRootCauseStackTrace( Throwable t, PrintStream stream )
{
String trace[] = getRootCauseStackTrace( t );
for ( String aTrace : trace )
{
stream.println( aTrace );
}
stream.flush();
}
/**
* Equivalent to printRootCauseStackTrace(t, System.err)
*/
public static void printRootCauseStackTrace( Throwable t )
{
printRootCauseStackTrace( t, System.err );
}
/**
* Same as printRootCauseStackTrace(t, stream), except it takes
* a PrintWriter as an argument.
*/
public static void printRootCauseStackTrace( Throwable t, PrintWriter writer )
{
String trace[] = getRootCauseStackTrace( t );
for ( String aTrace : trace )
{
writer.println( aTrace );
}
writer.flush();
}
/**
* Creates a compact stack trace for the root cause of the supplied
* throwable.
*
* See This class represents a Our benchmark
* indicates that {@link FastMap#put FastMap.put(key, value)} is up to
* 5x faster than {@link FastMap} has a predictable iteration order, which is the order
* in which keys were inserted into the map (similar to
* Applications may change the resizing policy of {@link FastMap}
* by overriding the {@link #sizeChanged} method. For example, to improve
* predictability, automatic resizing can be disabled. This implementation is not synchronized. Multiple threads accessing
* or modifying the collection must be synchronized externally. Note: To avoid dynamic memory allocations, {@link FastMap}
* maintains an internal pool of This class is public domain (not copyrighted). Methods exist to retrieve the components of a typical file path. For example
* File.separator ('/' under UNIX, '\' under Windows).
* For example, "abc/def/ghi/xyz.java" is split up in the segments "abc",
* "def","ghi" and "xyz.java".
* The same is done for the pattern against which should be matched.
*
* The segments of the name and the pattern are then matched against each
* other. When '**' is used for a path segment in the pattern, it matches
* zero or more path segments of the name.
*
* There is a special case regarding the use of File.separators
* at the beginning of the pattern and the string to match:
* When a pattern starts with a File.separator, the string
* to match must also start with a File.separator.
* When a pattern does not start with a File.separator, the
* string to match may not start with a File.separator.
* When one of these rules is not obeyed, the string will not
* match.
*
* When a name path segment is matched against a pattern path segment, the
* following special characters can be used:
* '*' matches zero or more characters
* '?' matches one character.
*
* Examples:
*
* "**\*.class" matches all .class files/dirs in a directory tree.
*
* "test\a??.java" matches all files/dirs which start with an 'a', then two
* more characters and then ".java", in a directory called test.
*
* "**" matches everything in a directory tree.
*
* "**\test\**\XYZ*" matches all files/dirs which start with "XYZ" and where
* there is a parent directory called test (e.g. "abc\test\def\ghi\XYZ123").
*
* Case sensitivity may be turned off if necessary. By default, it is
* turned on.
*
* Example of usage:
*
* String[] includes = {"**\\*.class"};
* String[] excludes = {"modules\\*\\**"};
* ds.setIncludes(includes);
* ds.setExcludes(excludes);
* ds.setBasedir(new File("test"));
* ds.setCaseSensitive(true);
* ds.scan();
*
* System.out.println("FILES:");
* String[] files = ds.getIncludedFiles();
* for (int i = 0; i < files.length; i++) {
* System.out.println(files[i]);
* }
*
* This will scan a directory called test for .class files, but excludes all
* files in all proper subdirectories of a directory called "modules"
*
* @author Arnout J. Kuiper
* ajkuiper@wxs.nl
* @author Magesh Umasankar
* @author Bruce Atherton
* @author Antoine Levy-Lambert
*/
public class DirectoryScanner
extends AbstractScanner
{
/**
* The base directory to be scanned.
*/
protected File basedir;
/**
* The files which matched at least one include and no excludes
* and were selected.
*/
protected VectorFile.separatorChar, so the separator used need not match
* File.separatorChar.
*
* @param basedir The base directory to scan.
* Must not be null.
*/
public void setBasedir( String basedir )
{
setBasedir( new File( basedir.replace( '/', File.separatorChar ).replace( '\\', File.separatorChar ) ) );
}
/**
* Sets the base directory to be scanned. This is the directory which is
* scanned recursively.
*
* @param basedir The base directory for scanning.
* Should not be null.
*/
public void setBasedir( File basedir )
{
this.basedir = basedir;
}
/**
* Returns the base directory to be scanned.
* This is the directory which is scanned recursively.
*
* @return the base directory to be scanned
*/
public File getBasedir()
{
return basedir;
}
/**
* Sets whether or not symbolic links should be followed.
*
* @param followSymlinks whether or not symbolic links should be followed
*/
public void setFollowSymlinks( boolean followSymlinks )
{
this.followSymlinks = followSymlinks;
}
/**
* Returns whether or not the scanner has included all the files or
* directories it has come across so far.
*
* @return true if all files and directories which have
* been found so far have been included.
*/
public boolean isEverythingIncluded()
{
return everythingIncluded;
}
/**
* Scans the base directory for files which match at least one include
* pattern and don't match any exclude patterns. If there are selectors
* then the files must pass muster there, as well.
*
* @throws IllegalStateException if the base directory was set
* incorrectly (i.e. if it is null, doesn't exist,
* or isn't a directory).
*/
public void scan()
throws IllegalStateException
{
if ( basedir == null )
{
throw new IllegalStateException( "No basedir set" );
}
if ( !basedir.exists() )
{
throw new IllegalStateException( "basedir " + basedir + " does not exist" );
}
if ( !basedir.isDirectory() )
{
throw new IllegalStateException( "basedir " + basedir + " is not a directory" );
}
setupDefaultFilters();
setupMatchPatterns();
filesIncluded = new Vectornull.
* @param vpath The path relative to the base directory (needed to
* prevent problems with an absolute path when using
* dir). Must not be null.
* @param fast Whether or not this call is part of a fast scan.
* @see #filesIncluded
* @see #filesNotIncluded
* @see #filesExcluded
* @see #dirsIncluded
* @see #dirsNotIncluded
* @see #dirsExcluded
* @see #slowScan
*/
protected void scandir( File dir, String vpath, boolean fast )
{
String[] newfiles = dir.list();
if ( newfiles == null )
{
/*
* two reasons are mentioned in the API docs for File.list
* (1) dir is not a directory. This is impossible as
* we wouldn't get here in this case.
* (2) an IO error occurred (why doesn't it throw an exception
* then???)
*/
/*
* [jdcasey] (2) is apparently happening to me, as this is killing one of my tests...
* this is affecting the assembly plugin, fwiw. I will initialize the newfiles array as
* zero-length for now.
*
* NOTE: I can't find the problematic code, as it appears to come from a native method
* in UnixFileSystem...
*/
/*
* [bentmann] A null array will also be returned from list() on NTFS when dir refers to a soft link or
* junction point whose target is not existent.
*/
newfiles = new String[0];
// throw new IOException( "IO error scanning directory " + dir.getAbsolutePath() );
}
if ( !followSymlinks )
{
ArrayListfalse when the selectors says that the file
* should not be selected, true otherwise.
*/
protected boolean isSelected( String name, File file )
{
return true;
}
/**
* Returns the names of the files which matched at least one of the
* include patterns and none of the exclude patterns.
* The names are relative to the base directory.
*
* @return the names of the files which matched at least one of the
* include patterns and none of the exclude patterns.
*/
public String[] getIncludedFiles()
{
String[] files = new String[filesIncluded.size()];
filesIncluded.copyInto( files );
return files;
}
/**
* Returns the names of the files which matched none of the include
* patterns. The names are relative to the base directory. This involves
* performing a slow scan if one has not already been completed.
*
* @return the names of the files which matched none of the include
* patterns.
* @see #slowScan
*/
public String[] getNotIncludedFiles()
{
slowScan();
String[] files = new String[filesNotIncluded.size()];
filesNotIncluded.copyInto( files );
return files;
}
/**
* Returns the names of the files which matched at least one of the
* include patterns and at least one of the exclude patterns.
* The names are relative to the base directory. This involves
* performing a slow scan if one has not already been completed.
*
* @return the names of the files which matched at least one of the
* include patterns and at at least one of the exclude patterns.
* @see #slowScan
*/
public String[] getExcludedFiles()
{
slowScan();
String[] files = new String[filesExcluded.size()];
filesExcluded.copyInto( files );
return files;
}
/**
* ExceptionUtils provides utilities for manipulating
* Throwable objects.ExceptionUtils. Protected to
* discourage instantiation.
*/
protected ExceptionUtils()
{
}
/**
* Throwable
* objects.Throwable to obtain the cause.Throwable object. This will pick up most wrapping exceptions,
* including those from JDK 1.4, and
* The method names can be added to using {@link #addCauseMethodName(String)}.
* The default list searched for are:
*
*
* getCause()
* getNextException()
* getTargetException()
* getException()
* getSourceException()
* getRootCause()
* getCausedByException()
* getNested()
* detail field assignable to a Throwable.null.Throwable.
* @throws NullPointerException if the throwable is null
*/
public static Throwable getCause( Throwable throwable )
{
return getCause( throwable, CAUSE_METHOD_NAMES );
}
/**
* Throwable to obtain the cause
* using a supplied array of method names.Throwable.
* @throws NullPointerException if the method names array is null or contains null
* @throws NullPointerException if the throwable is null
*/
public static Throwable getCause( Throwable throwable, String[] methodNames )
{
Throwable cause = getCauseUsingWellKnownTypes( throwable );
if ( cause == null )
{
for ( String methodName : methodNames )
{
cause = getCauseUsingMethodName( throwable, methodName );
if ( cause != null )
{
break;
}
}
if ( cause == null )
{
cause = getCauseUsingFieldName( throwable, "detail" );
}
}
return cause;
}
/**
* Throwable.
*/
public static Throwable getRootCause( Throwable throwable )
{
Throwable cause = getCause( throwable );
if ( cause != null )
{
throwable = cause;
while ( ( throwable = getCause( throwable ) ) != null )
{
cause = throwable;
}
}
return cause;
}
/**
* instanceof checks to examine the exception,
* looking for well known types which could contain chained or
* wrapped exceptions.null if not
* found.
*/
private static Throwable getCauseUsingWellKnownTypes( Throwable throwable )
{
if ( throwable instanceof SQLException )
{
return ( (SQLException) throwable ).getNextException();
}
else if ( throwable instanceof InvocationTargetException )
{
return ( (InvocationTargetException) throwable ).getTargetException();
}
else
{
return null;
}
}
/**
* null if not
* found.
*/
private static Throwable getCauseUsingMethodName( Throwable throwable, String methodName )
{
Method method = null;
try
{
method = throwable.getClass().getMethod( methodName, null );
}
catch ( NoSuchMethodException ignored )
{
}
catch ( SecurityException ignored )
{
}
if ( method != null && Throwable.class.isAssignableFrom( method.getReturnType() ) )
{
try
{
return (Throwable) method.invoke( throwable, new Object[0] );
}
catch ( IllegalAccessException ignored )
{
}
catch ( IllegalArgumentException ignored )
{
}
catch ( InvocationTargetException ignored )
{
}
}
return null;
}
/**
* null if not
* found.
*/
private static Throwable getCauseUsingFieldName( Throwable throwable, String fieldName )
{
Field field = null;
try
{
field = throwable.getClass().getField( fieldName );
}
catch ( NoSuchFieldException ignored )
{
}
catch ( SecurityException ignored )
{
}
if ( field != null && Throwable.class.isAssignableFrom( field.getType() ) )
{
try
{
return (Throwable) field.get( throwable );
}
catch ( IllegalAccessException ignored )
{
}
catch ( IllegalArgumentException ignored )
{
}
}
return null;
}
/**
* Throwable objects in the
* exception chain.Throwable objects in the
* exception chain.Throwable objects.
*/
public static Throwable[] getThrowables( Throwable throwable )
{
ListThrowable that matches the specified type in the
* exception chain of Throwable objects with an index
* greater than or equal to the specified index, or
* -1 if the type is not found.Class to look for
* @param fromIndex the (zero based) index of the starting
* position in the chain to be searched
* @return the first occurrence of the type in the chain, or
* -1 if the type is not found
* @throws IndexOutOfBoundsException If the fromIndex
* argument is negative or not less than the count of
* Throwables in the chain.
*/
public static int indexOfThrowable( Throwable throwable, Class type, int fromIndex )
{
if ( fromIndex < 0 )
{
throw new IndexOutOfBoundsException( "Throwable index out of range: " + fromIndex );
}
Throwable[] throwables = ExceptionUtils.getThrowables( throwable );
if ( fromIndex >= throwables.length )
{
throw new IndexOutOfBoundsException( "Throwable index out of range: " + fromIndex );
}
for ( int i = fromIndex; i < throwables.length; i++ )
{
if ( throwables[i].getClass().equals( type ) )
{
return i;
}
}
return -1;
}
/**
* Prints a compact stack trace for the root cause of a throwable.
* The compact stack trace starts with the root cause and prints
* stack frames up to the place where it was caught and wrapped.
* Then it prints the wrapped exception and continues with stack frames
* until the wrapper exception is caught and wrapped again, etc.
* printRootCauseStackTrace(Throwable t, PrintStream s)
*/
public static String[] getRootCauseStackTrace( Throwable t )
{
Throwable[] throwables = getThrowables( t );
int count = throwables.length;
ArrayListThrowable.
* @return The stack trace as generated by the exception's
* printStackTrace(PrintWriter) method.
*/
public static String getStackTrace( Throwable t )
{
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter( sw, true );
t.printStackTrace( pw );
return sw.getBuffer().toString();
}
/**
* A way to get the entire nested stack-trace of an throwable.
*
* @param t The Throwable.
* @return The nested stack trace, with the root cause first.
*/
public static String getFullStackTrace( Throwable t )
{
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter( sw, true );
Throwable[] ts = getThrowables( t );
for ( Throwable t1 : ts )
{
t1.printStackTrace( pw );
if ( isNestedThrowable( t1 ) )
{
break;
}
}
return sw.getBuffer().toString();
}
/**
* Whether an Throwable is considered nested or not.
*
* @param throwable The Throwable.
* @return boolean true/false
*/
public static boolean isNestedThrowable( Throwable throwable )
{
if ( throwable == null )
{
return false;
}
if ( throwable instanceof SQLException )
{
return true;
}
else if ( throwable instanceof InvocationTargetException )
{
return true;
}
for ( String CAUSE_METHOD_NAME : CAUSE_METHOD_NAMES )
{
try
{
Method method = throwable.getClass().getMethod( CAUSE_METHOD_NAME, null );
if ( method != null )
{
return true;
}
}
catch ( NoSuchMethodException ignored )
{
}
catch ( SecurityException ignored )
{
}
}
try
{
Field field = throwable.getClass().getField( "detail" );
if ( field != null )
{
return true;
}
}
catch ( NoSuchFieldException ignored )
{
}
catch ( SecurityException ignored )
{
}
return false;
}
/**
* Captures the stack trace associated with the specified
* Throwable object, decomposing it into a list of
* stack frames.
*
* @param t The Throwable.
* @return An array of strings describing each stack frame.
*/
public static String[] getStackFrames( Throwable t )
{
return getStackFrames( getStackTrace( t ) );
}
/**
* Functionality shared between the
* getStackFrames(Throwable) methods of this and the
* classes.
*/
static String[] getStackFrames( String stackTrace )
{
String linebreak = System.getProperty( "line.separator" );
StringTokenizer frames = new StringTokenizer( stackTrace, linebreak );
ListMap collection with real-time
* behavior. Unless the map's size exceeds its current capacity,
* no dynamic memory allocation is ever performed and response time is
* extremely fast and consistent.java.util.HashMap.put(key, value).
* This difference is mostly due to the cost of the Map.Entry
* allocations that {@link FastMap} avoids by recycling its entries
* (see note below).java.util.LinkedHashMap collection class).Map.Entry objects. The size
* of the pool is determined by the map's capacity. When an entry is
* removed from the map, it is automatically restored to the pool.256 entries.
*/
public FastMap() {
initialize(256);
}
/**
* Creates a {@link FastMap}, copy of the specified Map.
* If the specified map is not an instance of {@link FastMap}, the
* newly created map has a capacity set to the specified map's size.
* The copy has the same order as the original, regardless of the original
* map's implementation:
* TreeMap dictionary = ...;
* FastMap dictionaryLookup = new FastMap(dictionary);
*
*
* @param map the map whose mappings are to be placed in this map.
*/
public FastMap(Map map) {
int capacity = (map instanceof FastMap) ?
((FastMap)map).capacity() : map.size();
initialize(capacity);
putAll(map);
}
/**
* Creates a {@link FastMap} with the specified capacity. Unless the
* capacity is exceeded, operations on this map do not allocate entries.
* For optimum performance, the capacity should be of the same order
* of magnitude or larger than the expected map's size.
*
* @param capacity the number of buckets in the hash table; it also
* defines the number of pre-allocated entries.
*/
public FastMap(int capacity) {
initialize(capacity);
}
/**
* Returns the number of key-value mappings in this {@link FastMap}.
*
* @return this map's size.
*/
public int size() {
return _size;
}
/**
* Returns the capacity of this {@link FastMap}. The capacity defines
* the number of buckets in the hash table, as well as the maximum number
* of entries the map may contain without allocating memory.
*
* @return this map's capacity.
*/
public int capacity() {
return _capacity;
}
/**
* Indicates if this {@link FastMap} contains no key-value mappings.
*
* @return true if this map contains no key-value mappings;
* false otherwise.
*/
public boolean isEmpty() {
return _size == 0;
}
/**
* Indicates if this {@link FastMap} contains a mapping for the specified
* key.
*
* @param key the key whose presence in this map is to be tested.
* @return true if this map contains a mapping for the
* specified key; false otherwise.
* @throws NullPointerException if the key is null.
*/
public boolean containsKey(Object key) {
EntryImpl entry = _entries[keyHash(key) & _mask];
while (entry != null) {
if (key.equals(entry._key) ) {
return true;
}
entry = entry._next;
}
return false;
}
/**
* Indicates if this {@link FastMap} maps one or more keys to the
* specified value.
*
* @param value the value whose presence in this map is to be tested.
* @return true if this map maps one or more keys to the
* specified value.
* @throws NullPointerException if the key is null.
*/
public boolean containsValue(Object value) {
EntryImpl entry = _mapFirst;
while (entry != null) {
if (value.equals(entry._value) ) {
return true;
}
entry = entry._after;
}
return false;
}
/**
* Returns the value to which this {@link FastMap} maps the specified key.
*
* @param key the key whose associated value is to be returned.
* @return the value to which this map maps the specified key,
* or null if there is no mapping for the key.
* @throws NullPointerException if key is null.
*/
public V get(Object key) {
EntryImplnull if none.
*/
public Map.Entry getEntry(Object key) {
EntryImpl entry = _entries[keyHash(key) & _mask];
while (entry != null) {
if (key.equals(entry._key)) {
return entry;
}
entry = entry._next;
}
return null;
}
/**
* Associates the specified value with the specified key in this
* {@link FastMap}. If the {@link FastMap} previously contained a mapping
* for this key, the old value is replaced.
*
* @param key the key with which the specified value is to be associated.
* @param value the value to be associated with the specified key.
* @return the previous value associated with specified key,
* or null if there was no mapping for key.
* A null return can also indicate that the map
* previously associated null with the specified key.
* @throws NullPointerException if the key is null.
*/
public Object put(Object key, Object value) {
EntryImpl entry = _entries[keyHash(key) & _mask];
while (entry != null) {
if (key.equals(entry._key) ) {
Object prevValue = entry._value;
entry._value = value;
return prevValue;
}
entry = entry._next;
}
// No previous mapping.
addEntry(key, value);
return null;
}
/**
* Copies all of the mappings from the specified map to this
* {@link FastMap}.
*
* @param map the mappings to be stored in this map.
* @throws NullPointerException the specified map is null, or
* the specified map contains null keys.
*/
public void putAll(Map map) {
for ( Entry entry : map.entrySet() )
{
addEntry( entry.getKey(), entry.getValue() );
}
}
/**
* Removes the mapping for this key from this {@link FastMap} if present.
*
* @param key the key whose mapping is to be removed from the map.
* @return previous value associated with specified key,
* or null if there was no mapping for key.
* A null return can also indicate that the map
* previously associated null with the specified key.
* @throws NullPointerException if the key is null.
*/
public V remove(Object key) {
EntryImpltrue if the given object is also a map and the two
* maps represent the same mappings (regardless of collection iteration
* order).
*
* @param obj the object to be compared for equality with this map.
* @return true if the specified object is equal to this map;
* false otherwise.
*/
public boolean equals(Object obj) {
if (obj == this) {
return true;
} else if (obj instanceof Map) {
Map that = (Map) obj;
if (this.size() == that.size()) {
EntryImpl entry = _mapFirst;
while (entry != null) {
if (!that.entrySet().contains(entry)) {
return false;
}
entry = entry._after;
}
return true;
} else {
return false;
}
} else {
return false;
}
}
/**
* Returns the hash code value for this {@link FastMap}.
*
* @return the hash code value for this map.
*/
public int hashCode() {
int code = 0;
EntryImpl entry = _mapFirst;
while (entry != null) {
code += entry.hashCode();
entry = entry._after;
}
return code;
}
/**
* Returns a String representation of this {@link FastMap}.
*
* @return this.entrySet().toString();
*/
public String toString() {
return entrySet().toString();
}
/**
* Returns a collection view of the values contained in this
* {@link FastMap}. The collection is backed by the map, so changes to
* the map are reflected in the collection, and vice-versa.
* The collection supports element removal, which removes the corresponding
* mapping from this map, via the
* Iterator.remove, Collection.remove,
* removeAll, retainAll,
* and clear operations. It does not support the
* add or addAll operations.
*
* @return a collection view of the values contained in this map.
*/
public Collection values() {
return _values;
}
private transient Values _values;
private class Values extends AbstractCollection {
public Iterator iterator() {
return new Iterator() {
EntryImpl after = _mapFirst;
EntryImpl before;
public void remove() {
removeEntry(before);
}
public boolean hasNext() {
return after != null;
}
public Object next() {
before = after;
after = after._after;
return before._value;
}
};
}
public int size() {
return _size;
}
public boolean contains(Object o) {
return containsValue(o);
}
public void clear() {
FastMap.this.clear();
}
}
/**
* Returns a collection view of the mappings contained in this
* {@link FastMap}. Each element in the returned collection is a
* Map.Entry. The collection is backed by the map,
* so changes to the map are reflected in the collection, and vice-versa.
* The collection supports element removal, which removes the corresponding
* mapping from this map, via the
* Iterator.remove, Collection.remove,
* removeAll, retainAll,
* and clear operations. It does not support the
* add or addAll operations.
*
* @return a collection view of the mappings contained in this map.
*/
public Set entrySet() {
return _entrySet;
}
private transient EntrySet _entrySet;
private class EntrySet extends AbstractSet {
public Iterator iterator() {
return new Iterator() {
EntryImpl after = _mapFirst;
EntryImpl before;
public void remove() {
removeEntry(before);
}
public boolean hasNext() {
return after != null;
}
public Object next() {
before = after;
after = after._after;
return before;
}
};
}
public int size() {
return _size;
}
public boolean contains(Object obj) { // Optimization.
if (obj instanceof Map.Entry) {
Map.Entry entry = (Map.Entry) obj;
Map.Entry mapEntry = getEntry(entry.getKey());
return entry.equals(mapEntry);
} else {
return false;
}
}
public boolean remove(Object obj) { // Optimization.
if (obj instanceof Map.Entry) {
Map.Entry entry = (Map.Entry)obj;
EntryImpl mapEntry = (EntryImpl) getEntry(entry.getKey());
if ((mapEntry != null) &&
(entry.getValue()).equals(mapEntry._value)) {
removeEntry(mapEntry);
return true;
}
}
return false;
}
}
/**
* Returns a set view of the keys contained in this {@link FastMap}.
* The set is backed by the map, so changes to the map are reflected
* in the set, and vice-versa. The set supports element removal,
* which removes the corresponding mapping from this map, via the
* Iterator.remove, Collection.remove,
* removeAll, retainAll,
* and clear operations. It does not support the
* add or addAll operations.
*
* @return a set view of the keys contained in this map.
*/
public Set keySet() {
return _keySet;
}
private transient KeySet _keySet;
private class KeySet extends AbstractSet {
public Iterator iterator() {
return new Iterator() {
EntryImpl after = _mapFirst;
EntryImpl before;
public void remove() {
removeEntry(before);
}
public boolean hasNext() {
return after != null;
}
public Object next() {
before = after;
after = after._after;
return before._key;
}
};
}
public int size() {
return _size;
}
public boolean contains(Object obj) { // Optimization.
return FastMap.this.containsKey(obj);
}
public boolean remove(Object obj) { // Optimization.
return FastMap.this.remove(obj) != null;
}
public void clear() { // Optimization.
FastMap.this.clear();
}
}
/**
* This methods is being called when the size of this {@link FastMap}
* has changed. The default behavior is to double the map's capacity
* when the map's size reaches the current map's capacity.
* Sub-class may override this method to implement custom resizing
* policies or to disable automatic resizing. For example:
* Map fixedCapacityMap = new FastMap(256) {
* protected sizeChanged() {
* // Do nothing, automatic resizing disabled.
* }
* };
* @see #setCapacity
*/
protected void sizeChanged() {
if (size() > capacity()) {
setCapacity(capacity() * 2);
}
}
/**
* Returns the hash code for the specified key. The formula being used
* is identical to the formula used by java.util.HashMap
* (ensures similar behavior for ill-conditioned hashcode keys).
*
* @param key the key to calculate the hashcode for.
* @return the hash code for the specified key.
*/
private static int keyHash(Object key) {
// From HashMap.hash(Object) function.
int hashCode = key.hashCode();
hashCode += ~(hashCode << 9);
hashCode ^= (hashCode >>> 14);
hashCode += (hashCode << 4);
hashCode ^= (hashCode >>> 10);
return hashCode;
}
/**
* Adds a new entry for the specified key and value.
* @param key the entry's key.
* @param value the entry's value.
*/
private void addEntry(Object key, Object value) {
EntryImpl entry = _poolFirst;
if (entry != null) {
_poolFirst = entry._after;
entry._after = null;
} else { // Pool empty.
entry = new EntryImpl();
}
// Setup entry paramters.
entry._key = key;
entry._value = value;
int index = keyHash(key) & _mask;
entry._index = index;
// Connects to bucket.
EntryImpl next = _entries[index];
entry._next = next;
if (next != null) {
next._previous = entry;
}
_entries[index] = entry;
// Connects to collection.
if (_mapLast != null) {
entry._before = _mapLast;
_mapLast._after = entry;
} else {
_mapFirst = entry;
}
_mapLast = entry;
// Updates size.
_size++;
sizeChanged();
}
/**
* Removes the specified entry from the map.
*
* @param entry the entry to be removed.
*/
private void removeEntry(EntryImpl entry) {
// Removes from bucket.
EntryImpl previous = entry._previous;
EntryImpl next = entry._next;
if (previous != null) {
previous._next = next;
entry._previous = null;
} else { // First in bucket.
_entries[entry._index] = next;
}
if (next != null) {
next._previous = previous;
entry._next = null;
} // Else do nothing, no last pointer.
// Removes from collection.
EntryImpl before = entry._before;
EntryImpl after = entry._after;
if (before != null) {
before._after = after;
entry._before = null;
} else { // First in collection.
_mapFirst = after;
}
if (after != null) {
after._before = before;
} else { // Last in collection.
_mapLast = before;
}
// Clears value and key.
entry._key = null;
entry._value = null;
// Recycles.
entry._after = _poolFirst;
_poolFirst = entry;
// Updates size.
_size--;
sizeChanged();
}
/**
* Initializes this instance for the specified capacity.
* Once initialized, operations on this map should not create new objects
* (unless the map's size exceeds the specified capacity).
*
* @param capacity the initial capacity.
*/
private void initialize(int capacity) {
// Find a power of 2 >= capacity
int tableLength = 16;
while (tableLength < capacity) {
tableLength <<= 1;
}
// Allocates hash table.
_entries = new EntryImpl[tableLength];
_mask = tableLength - 1;
_capacity = capacity;
_size = 0;
// Allocates views.
_values = new Values();
_entrySet = new EntrySet();
_keySet = new KeySet();
// Resets pointers.
_poolFirst = null;
_mapFirst = null;
_mapLast = null;
// Allocates entries.
for (int i=0; i < capacity; i++) {
EntryImpl entry = new EntryImpl();
entry._after = _poolFirst;
_poolFirst = entry;
}
}
/**
* Requires special handling during de-serialization process.
*
* @param stream the object input stream.
* @throws IOException if an I/O error occurs.
* @throws ClassNotFoundException if the class for the object de-serialized
* is not found.
*/
private void readObject(ObjectInputStream stream)
throws IOException, ClassNotFoundException {
int capacity = stream.readInt();
initialize(capacity);
int size = stream.readInt();
for (int i=0; i < size; i++) {
Object key = stream.readObject();
Object value = stream.readObject();
addEntry(key, value);
}
}
/**
* Requires special handling during serialization process.
*
* @param stream the object output stream.
* @throws IOException if an I/O error occurs.
*/
private void writeObject(ObjectOutputStream stream) throws IOException {
stream.writeInt(_capacity);
stream.writeInt(_size);
int count = 0;
EntryImpl entry = _mapFirst;
while (entry != null) {
stream.writeObject(entry._key);
stream.writeObject(entry._value);
count++;
entry = entry._after;
}
if (count != _size) {
throw new IOException("FastMap Corrupted");
}
}
/**
* This class represents a {@link FastMap} entry.
*/
private static final class EntryImpltrue if both entry are considered equal;
* false otherwise.
*/
public boolean equals(Object that) {
if (that instanceof Map.Entry) {
Map.Entry entry = (Map.Entry) that;
return (_key.equals(entry.getKey())) &&
((_value != null) ?
_value.equals(entry.getValue()) :
(entry.getValue() == null));
} else {
return false;
}
}
/**
* Returns the hash code for this entry.
*
* @return this entry's hash code.
*/
public int hashCode() {
return _key.hashCode() ^ ((_value != null) ? _value.hashCode() : 0);
}
/**
* Returns the text representation of this entry.
*
* @return this entry's textual representation.
*/
public String toString() {
return _key + "=" + _value;
}
}
} plexus-utils-plexus-utils-3.0.22/src/main/java/org/codehaus/plexus/util/FileUtils.java 0000664 0000000 0000000 00000230373 12510777323 0031025 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util;
/* ====================================================================
* The Apache Software License, Version 1.1
*
* Copyright (c) 2001 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The end-user documentation included with the redistribution,
* if any, must include the following acknowledgment:
* "This product includes software developed by the
* Apache Software Foundation (http://www.codehaus.org/)."
* Alternately, this acknowledgment may appear in the software itself,
* if and wherever such third-party acknowledgments normally appear.
*
* 4. The names "Apache" and "Apache Software Foundation" and
* "Apache Turbine" must not be used to endorse or promote products
* derived from this software without prior written permission. For
* written permission, please contact codehaus@codehaus.org.
*
* 5. Products derived from this software may not be called "Apache",
* "Apache Turbine", nor may "Apache" appear in their name, without
* prior written permission of the Apache Software Foundation.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation. For more
* information on the Apache Software Foundation, please see
* Path-related methods
*
* /www/hosted/mysite/index.html, can be broken into:
*
*
* There are also methods to {@link #catPath concatenate two paths}, {@link #resolveFile resolve a
* path relative to a File} and {@link #normalize} a path.
* /www/hosted/mysite/ -- retrievable through {@link #getPath}index.html -- retrievable through {@link #removePath}/www/hosted/mysite/index -- retrievable through {@link #removeExtension}html -- retrievable through {@link #getExtension}File-related methods
*
* There are methods to create a {@link #toFile File from a URL}, copy a
* {@link #copyFileToDirectory File to a directory},
* copy a {@link #copyFile File to another File},
* copy a {@link #copyURLToFile URL's contents to a File},
* as well as methods to {@link #deleteDirectory(File) delete} and {@link #cleanDirectory(File)
* clean} a directory.
*
":", "*", "?", "\"", "<", ">", "|"
*
* @see
* http://support.microsoft.com/?scid=kb%3Ben-us%3B177506&x=12&y=13
*/
private static final String[] INVALID_CHARACTERS_FOR_WINDOWS_FILE_NAME = { ":", "*", "?", "\"", "<", ">", "|" };
/**
* @return the default excludes pattern
* @see DirectoryScanner#DEFAULTEXCLUDES
*/
public static String[] getDefaultExcludes()
{
return DirectoryScanner.DEFAULTEXCLUDES;
}
/**
* @return the default excludes pattern as list.
* @see #getDefaultExcludes()
*/
public static ListFile manager.
*/
public static File getFile( String fileName )
{
return new File( fileName );
}
/**
* Given a directory and an array of extensions return an array of compliant files.
*
* TODO Should an ignore list be passed in?
* TODO Should a recurse flag be passed in?
*
* The given extensions should be like "java" and not like ".java"
*
* @param directory The path of the directory.
* @param extensions an array of expected extensions.
* @return An array of files for the wanted extensions.
*/
public static String[] getFilesFromExtension( String directory, String[] extensions )
{
ListURL to a File.
*
* @param url File URL.
* @return The equivalent File object, or null if the URL's protocol
* is not file
*/
public static File toFile( final URL url )
{
if ( url == null || !url.getProtocol().equalsIgnoreCase( "file" ) )
{
return null;
}
String filename = url.getFile().replace( '/', File.separatorChar );
int pos = -1;
while ( ( pos = filename.indexOf( '%', pos + 1 ) ) >= 0 )
{
if ( pos + 2 < filename.length() )
{
String hexStr = filename.substring( pos + 1, pos + 3 );
char ch = (char) Integer.parseInt( hexStr, 16 );
filename = filename.substring( 0, pos ) + ch + filename.substring( pos + 3 );
}
}
return new File( filename );
}
/**
* Convert the array of Files into a list of URLs.
*
* @param files the array of files
* @return the array of URLs
* @throws IOException if an error occurs
*/
public static URL[] toURLs( final File[] files )
throws IOException
{
final URL[] urls = new URL[files.length];
for ( int i = 0; i < urls.length; i++ )
{
urls[i] = files[i].toURL();
}
return urls;
}
/**
* Remove extension from filename.
* ie
*
* foo.txt --> foo
* a\b\c.jpg --> a\b\c
* a\b\c --> a\b\c
*
*
* @param filename the path of the file
* @return the filename minus extension
*/
public static String removeExtension( final String filename )
{
String ext = extension( filename );
if ( "".equals( ext ) )
{
return filename;
}
final int index = filename.lastIndexOf( ext ) - 1;
return filename.substring( 0, index );
}
/**
* Get extension from filename.
* ie
*
* foo.txt --> "txt"
* a\b\c.jpg --> "jpg"
* a\b\c --> ""
*
*
* @param filename the path of the file
* @return the extension of filename or "" if none
*/
public static String getExtension( final String filename )
{
return extension( filename );
}
/**
* Remove path from filename. Equivalent to the unix command basename
* ie.
*
* a/b/c.txt --> c.txt
* a.txt --> a.txt
*
*
* @param filepath the path of the file
* @return the filename minus path
*/
public static String removePath( final String filepath )
{
return removePath( filepath, File.separatorChar );
}
/**
* Remove path from filename.
* ie.
*
* a/b/c.txt --> c.txt
* a.txt --> a.txt
*
*
* @param filepath the path of the file
* @param fileSeparatorChar the file separator character like / on Unix plateforms.
* @return the filename minus path
*/
public static String removePath( final String filepath, final char fileSeparatorChar )
{
final int index = filepath.lastIndexOf( fileSeparatorChar );
if ( -1 == index )
{
return filepath;
}
return filepath.substring( index + 1 );
}
/**
* Get path from filename. Roughly equivalent to the unix command dirname.
* ie.
*
* a/b/c.txt --> a/b
* a.txt --> ""
*
*
* @param filepath the filepath
* @return the filename minus path
*/
public static String getPath( final String filepath )
{
return getPath( filepath, File.separatorChar );
}
/**
* Get path from filename.
* ie.
*
* a/b/c.txt --> a/b
* a.txt --> ""
*
*
* @param filepath the filepath
* @param fileSeparatorChar the file separator character like / on Unix plateforms.
* @return the filename minus path
*/
public static String getPath( final String filepath, final char fileSeparatorChar )
{
final int index = filepath.lastIndexOf( fileSeparatorChar );
if ( -1 == index )
{
return "";
}
return filepath.substring( 0, index );
}
/**
* Copy file from source to destination. If destinationDirectory does not exist, it
* (and any parent directories) will be created. If a file source in
* destinationDirectory exists, it will be overwritten.
*
* @param source An existing File to copy.
* @param destinationDirectory A directory to copy source into.
* @throws java.io.FileNotFoundException if source isn't a normal file.
* @throws IllegalArgumentException if destinationDirectory isn't a directory.
* @throws IOException if source does not exist, the file in
* destinationDirectory cannot be written to, or an IO error occurs during copying.
*/
public static void copyFileToDirectory( final String source, final String destinationDirectory )
throws IOException
{
copyFileToDirectory( new File( source ), new File( destinationDirectory ) );
}
/**
* Copy file from source to destination only if source is newer than the target file.
* If destinationDirectory does not exist, it
* (and any parent directories) will be created. If a file source in
* destinationDirectory exists, it will be overwritten.
*
* @param source An existing File to copy.
* @param destinationDirectory A directory to copy source into.
* @throws java.io.FileNotFoundException if source isn't a normal file.
* @throws IllegalArgumentException if destinationDirectory isn't a directory.
* @throws IOException if source does not exist, the file in
* destinationDirectory cannot be written to, or an IO error occurs during copying.
*/
public static void copyFileToDirectoryIfModified( final String source, final String destinationDirectory )
throws IOException
{
copyFileToDirectoryIfModified( new File( source ), new File( destinationDirectory ) );
}
/**
* Copy file from source to destination. If destinationDirectory does not exist, it
* (and any parent directories) will be created. If a file source in
* destinationDirectory exists, it will be overwritten.
*
* @param source An existing File to copy.
* @param destinationDirectory A directory to copy source into.
* @throws java.io.FileNotFoundException if source isn't a normal file.
* @throws IllegalArgumentException if destinationDirectory isn't a directory.
* @throws IOException if source does not exist, the file in
* destinationDirectory cannot be written to, or an IO error occurs during copying.
*/
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() ) );
}
/**
* Copy file from source to destination only if source is newer than the target file.
* If destinationDirectory does not exist, it
* (and any parent directories) will be created. If a file source in
* destinationDirectory exists, it will be overwritten.
*
* @param source An existing File to copy.
* @param destinationDirectory A directory to copy source into.
* @throws java.io.FileNotFoundException if source isn't a normal file.
* @throws IllegalArgumentException if destinationDirectory isn't a directory.
* @throws IOException if source does not exist, the file in
* destinationDirectory cannot be written to, or an IO error occurs during copying.
*/
public static void copyFileToDirectoryIfModified( final File source, final File destinationDirectory )
throws IOException
{
if ( destinationDirectory.exists() && !destinationDirectory.isDirectory() )
{
throw new IllegalArgumentException( "Destination is not a directory" );
}
copyFileIfModified( source, new File( destinationDirectory, source.getName() ) );
}
/**
* Creates a number of directories, as delivered from DirectoryScanner
* @param sourceBase The basedir used for the directory scan
* @param dirs The getIncludedDirs from the dirscanner
* @param destination The base dir of the output structure
*/
public static void mkDirs( final File sourceBase, String[] dirs, final File destination )
throws IOException
{
for ( String dir : dirs )
{
File src = new File( sourceBase, dir);
File dst = new File( destination, dir);
if (Java7Detector.isJava7() && NioFiles.isSymbolicLink( src )){
File target = NioFiles.readSymbolicLink( src );
NioFiles.createSymbolicLink( dst, target );
} else {
dst.mkdirs();
}
}
}
/**
* Copy file from source to destination. The directories up to destination will be
* created if they don't already exist. destination will be overwritten if it
* already exists.
*
* @param source An existing non-directory File to copy bytes from.
* @param destination A non-directory File to write bytes to (possibly
* overwriting).
* @throws IOException if source does not exist, destination cannot be
* written to, or an IO error occurs during copying.
* @throws java.io.FileNotFoundException if destination is a directory
* (use {@link #copyFileToDirectory}).
*/
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 );
}
//check source != destination, see PLXUTILS-10
if ( source.getCanonicalPath().equals( destination.getCanonicalPath() ) )
{
//if they are equal, we can exit the method without doing any work
return;
}
mkdirsFor( destination );
doCopyFile( source, destination );
if ( source.length() != destination.length() )
{
String message = "Failed to copy full contents from " + source + " to " + destination;
throw new IOException( message );
}
}
private static void doCopyFile( File source, File destination )
throws IOException
{
FileInputStream fis = null;
FileOutputStream fos = null;
FileChannel input = null;
FileChannel output = null;
try
{
fis = new FileInputStream( source );
fos = new FileOutputStream( destination );
input = fis.getChannel();
output = fos.getChannel();
long size = input.size();
long pos = 0;
long count = 0;
while ( pos < size )
{
count = size - pos > FILE_COPY_BUFFER_SIZE ? FILE_COPY_BUFFER_SIZE : size - pos;
pos += output.transferFrom( input, pos, count );
}
}
finally
{
IOUtil.close( output );
IOUtil.close( fos );
IOUtil.close( input );
IOUtil.close( fis );
}
}
/**
* Copy file from source to destination only if source timestamp is later than the destination timestamp.
* The directories up to destination will be created if they don't already exist.
* destination will be overwritten if it already exists.
*
* @param source An existing non-directory File to copy bytes from.
* @param destination A non-directory File to write bytes to (possibly
* overwriting).
* @return true if no problem occured
* @throws IOException if source does not exist, destination cannot be
* written to, or an IO error occurs during copying.
*/
public static boolean copyFileIfModified( final File source, final File destination )
throws IOException
{
if ( destination.lastModified() < source.lastModified() )
{
copyFile( source, destination );
return true;
}
return false;
}
/**
* Copies bytes from the URL source to a file destination.
* The directories up to destination will be created if they don't already exist.
* destination will be overwritten if it already exists.
*
* @param source A URL to copy bytes from.
* @param destination A non-directory File to write bytes to (possibly
* overwriting).
* @throws IOException if
* source URL cannot be openeddestination cannot be written tosource to a file destination.
* The directories up to destination will be created if they don't already exist.
* destination will be overwritten if it already exists.
*
* @param source An {@link InputStream} to copy bytes from. This stream is
* guaranteed to be closed.
* @param destination A non-directory File to write bytes to (possibly
* overwriting).
* @throws IOException if
* source URL cannot be openeddestination cannot be written tonull if the ..'s went past the
* root.
* Eg:
*
* /foo// --> /foo/
* /foo/./ --> /foo/
* /foo/../bar --> /bar
* /foo/../bar/ --> /bar/
* /foo/../bar/../baz --> /baz
* //foo//./bar --> /foo/bar
* /../ --> null
*
*
* @param path the path to normalize
* @return the normalized String, or null if too many ..'s.
*/
public static String normalize( final String path )
{
String normalized = path;
// Resolve occurrences of "//" in the normalized path
while ( true )
{
int index = normalized.indexOf( "//" );
if ( index < 0 )
{
break;
}
normalized = normalized.substring( 0, index ) + normalized.substring( index + 1 );
}
// Resolve occurrences of "/./" in the normalized path
while ( true )
{
int index = normalized.indexOf( "/./" );
if ( index < 0 )
{
break;
}
normalized = normalized.substring( 0, index ) + normalized.substring( index + 2 );
}
// Resolve occurrences of "/../" in the normalized path
while ( true )
{
int index = normalized.indexOf( "/../" );
if ( index < 0 )
{
break;
}
if ( index == 0 )
{
return null; // Trying to go outside our context
}
int index2 = normalized.lastIndexOf( '/', index - 1 );
normalized = normalized.substring( 0, index2 ) + normalized.substring( index + 3 );
}
// Return the normalized path that we have completed
return normalized;
}
/**
* Will concatenate 2 paths. Paths with .. will be
* properly handled.
* Eg.,
* /a/b/c + d = /a/b/d
* /a/b/c + ../d = /a/d
*
filename to it's canonical form. If filename is
* relative (doesn't start with /), it will be resolved relative to
* baseFile, otherwise it is treated as a normal root-relative path.
*
* @param baseFile Where to resolve filename from, if filename is
* relative.
* @param filename Absolute or relative file path to resolve.
* @return The canonical File of filename.
*/
public static File resolveFile( final File baseFile, String filename )
{
String filenm = filename;
if ( '/' != File.separatorChar )
{
filenm = filename.replace( '/', File.separatorChar );
}
if ( '\\' != File.separatorChar )
{
filenm = filename.replace( '\\', File.separatorChar );
}
// deal with absolute files
if ( filenm.startsWith( File.separator ) || ( Os.isFamily( Os.FAMILY_WINDOWS ) && filenm.indexOf( ":" ) > 0 ) )
{
File file = new File( filenm );
try
{
file = file.getCanonicalFile();
}
catch ( final IOException ioe )
{
// nop
}
return file;
}
// FIXME: I'm almost certain this // removal is unnecessary, as getAbsoluteFile() strips
// them. However, I'm not sure about this UNC stuff. (JT)
final char[] chars = filename.toCharArray();
final StringBuilder sb = new StringBuilder();
//remove duplicate file separators in succession - except
//on win32 at start of filename as UNC filenames can
//be \\AComputer\AShare\myfile.txt
int start = 0;
if ( '\\' == File.separatorChar )
{
sb.append( filenm.charAt( 0 ) );
start++;
}
for ( int i = start; i < chars.length; i++ )
{
final boolean doubleSeparator = File.separatorChar == chars[i] && File.separatorChar == chars[i - 1];
if ( !doubleSeparator )
{
sb.append( chars[i] );
}
}
filenm = sb.toString();
//must be relative
File file = ( new File( baseFile, filenm ) ).getAbsoluteFile();
try
{
file = file.getCanonicalFile();
}
catch ( final IOException ioe )
{
// nop
}
return file;
}
/**
* Delete a file. If file is directory delete it and all sub-directories.
*
* @param file the file path
* @throws IOException if any
*/
public static void forceDelete( final String file )
throws IOException
{
forceDelete( new File( file ) );
}
/**
* Delete a file. If file is directory delete it and all sub-directories.
*
* @param file a file
* @throws IOException if any
*/
public static void forceDelete( final File file )
throws IOException
{
if ( file.isDirectory() )
{
deleteDirectory( file );
}
else
{
/*
* NOTE: Always try to delete the file even if it appears to be non-existent. This will ensure that a
* symlink whose target does not exist is deleted, too.
*/
boolean filePresent = file.getCanonicalFile().exists();
if ( !deleteFile( file ) && filePresent )
{
final String message = "File " + file + " unable to be deleted.";
throw new IOException( message );
}
}
}
/**
* Accommodate Windows bug encountered in both Sun and IBM JDKs.
* Others possible. If the delete does not work, call System.gc(),
* wait a little and try again.
*
* @param file a file
* @throws IOException if any
*/
private static boolean deleteFile( File file )
throws IOException
{
if ( file.isDirectory() )
{
throw new IOException( "File " + file + " isn't a file." );
}
if ( !file.delete() )
{
if ( Os.isFamily( Os.FAMILY_WINDOWS ) )
{
file = file.getCanonicalFile();
System.gc();
}
try
{
Thread.sleep( 10 );
return file.delete();
}
catch ( InterruptedException ignore )
{
return file.delete();
}
}
return true;
}
/**
* Schedule a file to be deleted when JVM exits.
* If file is directory delete it and all sub-directories.
*
* @param file a file
* @throws IOException if any
*/
public static void forceDeleteOnExit( final File file )
throws IOException
{
if ( !file.exists() )
{
return;
}
if ( file.isDirectory() )
{
deleteDirectoryOnExit( file );
}
else
{
file.deleteOnExit();
}
}
/**
* Recursively schedule directory for deletion on JVM exit.
*
* @param directory a directory
* @throws IOException if any
*/
private static void deleteDirectoryOnExit( final File directory )
throws IOException
{
if ( !directory.exists() )
{
return;
}
directory.deleteOnExit(); // The hook reverses the list
cleanDirectoryOnExit( directory );
}
/**
* Clean a directory without deleting it.
*
* @param directory a directory
* @throws IOException if any
*/
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 ( final File file : files )
{
try
{
forceDeleteOnExit( file );
}
catch ( final IOException ioe )
{
exception = ioe;
}
}
if ( null != exception )
{
throw exception;
}
}
/**
* Make a directory.
*
* @param file not null
* @throws IOException If there already exists a file with specified name or
* the directory is unable to be created
* @throws IllegalArgumentException if the file contains illegal Windows characters under Windows OS.
* @see #INVALID_CHARACTERS_FOR_WINDOWS_FILE_NAME
*/
public static void forceMkdir( final File file )
throws IOException
{
if ( Os.isFamily( Os.FAMILY_WINDOWS ) )
{
if ( !isValidWindowsFileName( file ) )
{
throw new IllegalArgumentException(
"The file (" + file.getAbsolutePath() + ") cannot contain any of the following characters: \n"
+ StringUtils.join( INVALID_CHARACTERS_FOR_WINDOWS_FILE_NAME, " " ) );
}
}
if ( file.exists() )
{
if ( file.isFile() )
{
final String message =
"File " + file + " exists and is " + "not a directory. Unable to create directory.";
throw new IOException( message );
}
}
else
{
if ( false == file.mkdirs() )
{
final String message = "Unable to create directory " + file;
throw new IOException( message );
}
}
}
/**
* Recursively delete a directory.
*
* @param directory a directory
* @throws IOException if any
*/
public static void deleteDirectory( final String directory )
throws IOException
{
deleteDirectory( new File( directory ) );
}
/**
* Recursively delete a directory.
*
* @param directory a directory
* @throws IOException if any
*/
public static void deleteDirectory( final File directory )
throws IOException
{
if ( !directory.exists() )
{
return;
}
/* try delete the directory before its contents, which will take
* care of any directories that are really symbolic links.
*/
if ( directory.delete() )
{
return;
}
cleanDirectory( directory );
if ( !directory.delete() )
{
final String message = "Directory " + directory + " unable to be deleted.";
throw new IOException( message );
}
}
/**
* Clean a directory without deleting it.
*
* @param directory a directory
* @throws IOException if any
*/
public static void cleanDirectory( final String directory )
throws IOException
{
cleanDirectory( new File( directory ) );
}
/**
* Clean a directory without deleting it.
*
* @param directory a directory
* @throws IOException if any
*/
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();
if ( files == null )
{
return;
}
for ( final File file : files )
{
try
{
forceDelete( file );
}
catch ( final IOException ioe )
{
exception = ioe;
}
}
if ( null != exception )
{
throw exception;
}
}
/**
* Recursively count size of a directory.
*
* @param directory a directory
* @return size of directory in bytes.
*/
public static long sizeOfDirectory( final String directory )
{
return sizeOfDirectory( new File( directory ) );
}
/**
* Recursively count size of a directory.
*
* @param directory a directory
* @return size of directory in bytes.
*/
public static long sizeOfDirectory( final File directory )
{
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 );
}
long size = 0;
final File[] files = directory.listFiles();
for ( final File file : files )
{
if ( file.isDirectory() )
{
size += sizeOfDirectory( file );
}
else
{
size += file.length();
}
}
return size;
}
/**
* Return the files contained in the directory, using inclusion and exclusion Ant patterns,
* including the directory name in each of the files
*
* @param directory the directory to scan
* @param includes the includes pattern, comma separated
* @param excludes the excludes pattern, comma separated
* @return a list of File objects
* @throws IOException
* @see #getFileNames(File, String, String, boolean)
*/
public static ListsourceDirectory must exists.
* sourceDirectory must exists.
* sourceDirectory must exists.
* This will remove to (if it exists), ensure that
* to's parent directory exists and move
* from, which involves deleting from as
* well.
to may have been deleted already when this happens.
*/
public static void rename( File from, File to )
throws IOException
{
if ( to.exists() && !to.delete() )
{
throw new IOException( "Failed to delete " + to + " while trying to rename " + from );
}
File parent = to.getParentFile();
if ( parent != null && !parent.exists() && !parent.mkdirs() )
{
throw new IOException( "Failed to create directory " + parent + " while trying to rename " + from );
}
if ( !from.renameTo( to ) )
{
copyFile( from, to );
if ( !from.delete() )
{
throw new IOException( "Failed to delete " + from + " while trying to rename it." );
}
}
}
/**
* Create a temporary file in a given directory.
*
* The file denoted by the returned abstract pathname did not * exist before this method was invoked, any subsequent invocation * of this method will yield a different file name.
* * The filename is prefixNNNNNsuffix where NNNN is a random number * *This method is different to {@link File#createTempFile(String, String, File)} of JDK 1.2 * as it doesn't create the file itself. * It uses the location pointed to by java.io.tmpdir * when the parentDir attribute is * null.
*To delete automatically the file created by this method, use the * {@link File#deleteOnExit()} method.
* * @param prefix prefix before the random number * @param suffix file extension; include the '.' * @param parentDir Directory to create the temporary file in-java.io.tmpdir
* used if not specificed
* @return a File reference to the new temporary file.
*/
public static File createTempFile( String prefix, String suffix, File parentDir )
{
File result = null;
String parent = System.getProperty( "java.io.tmpdir" );
if ( parentDir != null )
{
parent = parentDir.getPath();
}
DecimalFormat fmt = new DecimalFormat( "#####" );
SecureRandom secureRandom = new SecureRandom();
long secureInitializer = secureRandom.nextLong();
Random rand = new Random( secureInitializer + Runtime.getRuntime().freeMemory() );
synchronized ( rand )
{
do
{
result = new File( parent, prefix + fmt.format( Math.abs( rand.nextInt() ) ) + suffix );
}
while ( result.exists() );
}
return result;
}
/**
* If wrappers is null or empty, the file will be copy only if to.lastModified() < from.lastModified()
*
* @param from the file to copy
* @param to the destination file
* @param encoding the file output encoding (only if wrappers is not empty)
* @param wrappers array of {@link FilterWrapper}
* @throws IOException if an IO error occurs during copying or filtering
*/
public static void copyFile( File from, File to, String encoding, FilterWrapper[] wrappers )
throws IOException
{
copyFile( from, to, encoding, wrappers, false );
}
public static abstract class FilterWrapper
{
public abstract Reader getReader( Reader fileReader );
}
/**
* If wrappers is null or empty, the file will be copy only if to.lastModified() < from.lastModified() or if overwrite is true
*
* @param from the file to copy
* @param to the destination file
* @param encoding the file output encoding (only if wrappers is not empty)
* @param wrappers array of {@link FilterWrapper}
* @param overwrite if true and f wrappers is null or empty, the file will be copy
* enven if to.lastModified() < from.lastModified()
* @throws IOException if an IO error occurs during copying or filtering
* @since 1.5.2
*/
public static void copyFile( File from, File to, String encoding, FilterWrapper[] wrappers, boolean overwrite )
throws IOException
{
if ( wrappers != null && wrappers.length > 0 )
{
// buffer so it isn't reading a byte at a time!
Reader fileReader = null;
Writer fileWriter = null;
try
{
if ( encoding == null || encoding.length() < 1 )
{
fileReader = new BufferedReader( new FileReader( from ) );
fileWriter = new FileWriter( to );
}
else
{
FileInputStream instream = new FileInputStream( from );
FileOutputStream outstream = new FileOutputStream( to );
fileReader = new BufferedReader( new InputStreamReader( instream, encoding ) );
fileWriter = new OutputStreamWriter( outstream, encoding );
}
Reader reader = fileReader;
for ( FilterWrapper wrapper : wrappers )
{
reader = wrapper.getReader( reader );
}
IOUtil.copy( reader, fileWriter );
}
finally
{
IOUtil.close( fileReader );
IOUtil.close( fileWriter );
}
}
else
{
if ( to.lastModified() < from.lastModified() || overwrite )
{
copyFile( from, to );
}
}
}
/**
* Note: the file content is read with platform encoding
*
* @param file the file
* @return a List containing every every line not starting with # and not empty
* @throws IOException if any
*/
public static List":", "*", "?", "\"", "<", ">", "|"
*
* @param f not null file
* @return false if the file path contains any of forbidden Windows characters,
* true if the Os is not Windows or if the file path respect the Windows constraints.
* @see #INVALID_CHARACTERS_FOR_WINDOWS_FILE_NAME
* @since 1.5.2
*/
public static boolean isValidWindowsFileName( File f )
{
if ( Os.isFamily( Os.FAMILY_WINDOWS ) )
{
if ( StringUtils.indexOfAny( f.getName(), INVALID_CHARACTERS_FOR_WINDOWS_FILE_NAME ) != -1 )
{
return false;
}
File parentFile = f.getParentFile();
if ( parentFile != null )
{
return isValidWindowsFileName( parentFile );
}
}
return true;
}
}
plexus-utils-plexus-utils-3.0.22/src/main/java/org/codehaus/plexus/util/IOUtil.java 0000664 0000000 0000000 00000071306 12510777323 0030271 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util;
/* ====================================================================
* The Apache Software License, Version 1.1
*
* Copyright (c) 2001 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The end-user documentation included with the redistribution,
* if any, must include the following acknowledgment:
* "This product includes software developed by the
* Apache Software Foundation (http://www.codehaus.org/)."
* Alternately, this acknowledgment may appear in the software itself,
* if and wherever such third-party acknowledgments normally appear.
*
* 4. The names "Apache" and "Apache Software Foundation" and
* "Apache Turbine" must not be used to endorse or promote products
* derived from this software without prior written permission. For
* written permission, please contact codehaus@codehaus.org.
*
* 5. Products derived from this software may not be called "Apache",
* "Apache Turbine", nor may "Apache" appear in their name, without
* prior written permission of the Apache Software Foundation.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation. For more
* information on the Apache Software Foundation, please see
*
* This class provides static utility methods for input/output operations, particularly buffered
* copying between sources (InputStream, Reader, String and
* byte[]) and destinations (OutputStream, Writer,
* String and byte[]).
*
Unless otherwise noted, these copy methods do not 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' close() 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 this
* UnixReview article
For each copy 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.
For byte-to-char methods, a copy variant allows the encoding to be selected
* (otherwise the platform default is used).
The copy methods use an internal buffer when copying. It is therefore advisable
* not to deliberately wrap the stream arguments to the copy methods in
* Buffered* streams. For example, don't do the
* following:
copy( new BufferedInputStream( in ), new BufferedOutputStream( out ) );
*
* The rationale is as follows:
* *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 read requests can inexpensively get
* their data (until the buffer runs out).
However, the copy 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).
InputStream to an OutputStream.
*/
public static void copy( final InputStream input, final OutputStream output )
throws IOException
{
copy( input, output, DEFAULT_BUFFER_SIZE );
}
/**
* Copy bytes from an InputStream to an OutputStream.
* @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 Reader to a Writer.
*/
public static void copy( final Reader input, final Writer output )
throws IOException
{
copy( input, output, DEFAULT_BUFFER_SIZE );
}
/**
* Copy chars from a Reader to a Writer.
* @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 InputStream to chars on a
* Writer.
* 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 InputStream to chars on a
* Writer.
* 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 InputStream to chars on a
* Writer, using the specified encoding.
* @param encoding The name of a supported character encoding. See the
* IANA
* Charset Registry 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 InputStream to chars on a
* Writer, using the specified encoding.
* @param encoding The name of a supported character encoding. See the
* IANA
* Charset Registry 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 InputStream 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 InputStream 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 InputStream as a String.
* @param encoding The name of a supported character encoding. See the
* IANA
* Charset Registry 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 InputStream as a String.
* @param encoding The name of a supported character encoding. See the
* IANA
* Charset Registry 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 InputStream as a byte[].
*/
public static byte[] toByteArray( final InputStream input )
throws IOException
{
return toByteArray( input, DEFAULT_BUFFER_SIZE );
}
/**
* Get the contents of an InputStream as a byte[].
* @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 Reader to bytes on an OutputStream, and
* flush the OutputStream.
*/
public static void copy( final Reader input, final OutputStream output )
throws IOException
{
copy( input, output, DEFAULT_BUFFER_SIZE );
}
/**
* Serialize chars from a Reader to bytes on an OutputStream, and
* flush the OutputStream.
* @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 Reader as a String.
*/
public static String toString( final Reader input )
throws IOException
{
return toString( input, DEFAULT_BUFFER_SIZE );
}
/**
* Get the contents of a Reader 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 Reader as a byte[].
*/
public static byte[] toByteArray( final Reader input )
throws IOException
{
return toByteArray( input, DEFAULT_BUFFER_SIZE );
}
/**
* Get the contents of a Reader as a byte[].
* @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 String to bytes on an OutputStream, and
* flush the OutputStream.
*/
public static void copy( final String input, final OutputStream output )
throws IOException
{
copy( input, output, DEFAULT_BUFFER_SIZE );
}
/**
* Serialize chars from a String to bytes on an OutputStream, and
* flush the OutputStream.
* @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 String to a Writer.
*/
public static void copy( final String input, final Writer output )
throws IOException
{
output.write( input );
}
/**
* Copy bytes from an InputStream to an
* OutputStream, 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 String as a byte[].
*/
public static byte[] toByteArray( final String input )
throws IOException
{
return toByteArray( input, DEFAULT_BUFFER_SIZE );
}
/**
* Get the contents of a String as a byte[].
* @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 byte[] to chars on a
* Writer.
* 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 byte[] to chars on a
* Writer.
* 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 byte[] to chars on a
* Writer, using the specified encoding.
* @param encoding The name of a supported character encoding. See the
* IANA
* Charset Registry 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 byte[] to chars on a
* Writer, using the specified encoding.
* @param encoding The name of a supported character encoding. See the
* IANA
* Charset Registry 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 byte[] 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 byte[] 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 byte[] as a String.
* @param encoding The name of a supported character encoding. See the
* IANA
* Charset Registry 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 byte[] as a String.
* @param encoding The name of a supported character encoding. See the
* IANA
* Charset Registry 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 byte[] to an OutputStream.
*/
public static void copy( final byte[] input, final OutputStream output )
throws IOException
{
copy( input, output, DEFAULT_BUFFER_SIZE );
}
/**
* Copy bytes from a byte[] to an OutputStream.
* @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;
}
}
// ----------------------------------------------------------------------
// closeXXX()
// ----------------------------------------------------------------------
/**
* Closes the input stream. The input stream can be null and any IOException's will be swallowed.
*
* @param inputStream The stream to close.
*/
public static void close( InputStream inputStream )
{
if ( inputStream == null )
{
return;
}
try
{
inputStream.close();
}
catch( IOException ex )
{
// ignore
}
}
/**
* Closes a channel. Channel can be null and any IOException's will be swallowed.
*
* @param channel The stream to close.
*/
public static void close( Channel channel )
{
if ( channel == null )
{
return;
}
try
{
channel.close();
}
catch( IOException ex )
{
// ignore
}
}
/**
* Closes the output stream. The output stream can be null and any IOException's will be swallowed.
*
* @param outputStream The stream to close.
*/
public static void close( OutputStream outputStream )
{
if ( outputStream == null )
{
return;
}
try
{
outputStream.close();
}
catch( IOException ex )
{
// ignore
}
}
/**
* Closes the reader. The reader can be null and any IOException's will be swallowed.
*
* @param reader The reader to close.
*/
public static void close( Reader reader )
{
if ( reader == null )
{
return;
}
try
{
reader.close();
}
catch( IOException ex )
{
// ignore
}
}
/**
* Closes the writer. The writer can be null and any IOException's will be swallowed.
*
* @param writer The writer to close.
*/
public static void close( Writer writer )
{
if ( writer == null )
{
return;
}
try
{
writer.close();
}
catch( IOException ex )
{
// ignore
}
}
}
InterpolationFilterReader.java 0000664 0000000 0000000 00000027121 12510777323 0034161 0 ustar 00root root 0000000 0000000 plexus-utils-plexus-utils-3.0.22/src/main/java/org/codehaus/plexus/util /*
* The Apache Software License, Version 1.1
*
* Copyright (c) 2002-2003 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The end-user documentation included with the redistribution, if
* any, must include the following acknowlegement:
* "This product includes software developed by the
* Apache Software Foundation (http://www.codehaus.org/)."
* Alternately, this acknowlegement may appear in the software itself,
* if and wherever such third-party acknowlegements normally appear.
*
* 4. The names "Ant" and "Apache Software
* Foundation" must not be used to endorse or promote products derived
* from this software without prior written permission. For written
* permission, please contact codehaus@codehaus.org.
*
* 5. Products derived from this software may not be called "Apache"
* nor may "Apache" appear in their names without prior written
* permission of the Apache Group.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation. For more
* information on the Apache Software Foundation, please see
* * When a possible keyword token is recognized (by detecting the starting and * ending token delimiters): *
*n is negative.
* @exception IOException If an I/O error occurs
*/
public long skip( long n ) throws IOException
{
if ( n < 0L )
{
throw new IllegalArgumentException( "skip value is negative" );
}
for ( long i = 0; i < n; i++ )
{
if ( read() == -1 )
{
return i;
}
}
return n;
}
/**
* Reads characters into a portion of an array. This method will block
* until some input is available, an I/O error occurs, or the end of the
* stream is reached.
*
* @param cbuf Destination buffer to write characters to.
* Must not be null.
* @param off Offset at which to start storing characters.
* @param len Maximum number of characters to read.
*
* @return the number of characters read, or -1 if the end of the
* stream has been reached
*
* @exception IOException If an I/O error occurs
*/
public int read( char cbuf[],
int off,
int len )
throws IOException
{
for ( int i = 0; i < len; i++ )
{
int ch = read();
if ( ch == -1 )
{
if ( i == 0 )
{
return -1;
}
else
{
return i;
}
}
cbuf[off + i] = (char) ch;
}
return len;
}
/**
* Returns the next character in the filtered stream, replacing tokens
* from the original stream.
*
* @return the next character in the resulting stream, or -1
* if the end of the resulting stream has been reached
*
* @exception IOException if the underlying stream throws an IOException
* during reading
*/
public int read() throws IOException
{
if ( replaceIndex != -1 && replaceIndex < replaceData.length() )
{
int ch = replaceData.charAt( replaceIndex++ );
if ( replaceIndex >= replaceData.length() )
{
replaceIndex = -1;
}
return ch;
}
int ch;
if ( previousIndex != -1 && previousIndex < endTokenLength )
{
ch = endToken.charAt( previousIndex++ );
}
else
{
ch = in.read();
}
if ( ch == beginToken.charAt( 0 ) )
{
StringBuilder key = new StringBuilder();
int beginTokenMatchPos = 1;
do
{
if ( previousIndex != -1 && previousIndex < endTokenLength )
{
ch = endToken.charAt( previousIndex++ );
}
else
{
ch = in.read();
}
if ( ch != -1 )
{
key.append( (char) ch );
if ( ( beginTokenMatchPos < beginTokenLength ) &&
( ch != beginToken.charAt( beginTokenMatchPos++ ) ) )
{
ch = -1; // not really EOF but to trigger code below
break;
}
}
else
{
break;
}
}
while ( ch != endToken.charAt( 0 ) );
// now test endToken
if ( ch != -1 && endTokenLength > 1 )
{
int endTokenMatchPos = 1;
do
{
if ( previousIndex != -1 && previousIndex < endTokenLength )
{
ch = endToken.charAt( previousIndex++ );
}
else
{
ch = in.read();
}
if ( ch != -1 )
{
key.append( (char) ch );
if ( ch != endToken.charAt( endTokenMatchPos++ ) )
{
ch = -1; // not really EOF but to trigger code below
break;
}
}
else
{
break;
}
}
while ( endTokenMatchPos < endTokenLength );
}
// There is nothing left to read so we have the situation where the begin/end token
// are in fact the same and as there is nothing left to read we have got ourselves
// end of a token boundary so let it pass through.
if ( ch == -1 )
{
replaceData = key.toString();
replaceIndex = 0;
return beginToken.charAt( 0 );
}
String variableKey = key.substring( beginTokenLength - 1, key.length() - endTokenLength );
Object o = variables.get(variableKey);
if ( o != null )
{
String value = o.toString();
if ( value.length() != 0 )
{
replaceData = value;
replaceIndex = 0;
}
return read();
}
else
{
previousIndex = 0;
replaceData = key.substring(0, key.length() - endTokenLength );
replaceIndex = 0;
return beginToken.charAt(0);
}
}
return ch;
}
}
plexus-utils-plexus-utils-3.0.22/src/main/java/org/codehaus/plexus/util/Java7Detector.java 0000664 0000000 0000000 00000002117 12510777323 0031560 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util;
/*
* Copyright 2011 The Codehaus Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* Java7 feature detection
*
* @author Kristian Rosenvold
*/
class Java7Detector
{
private static final boolean isJava7;
static
{
boolean isJava7x = true;
try
{
Class.forName( "java.nio.file.Files" );
}
catch ( Exception e )
{
isJava7x = false;
}
isJava7 = isJava7x;
}
public static boolean isJava7()
{
return isJava7;
}
}
LineOrientedInterpolatingReader.java 0000664 0000000 0000000 00000033534 12510777323 0035312 0 ustar 00root root 0000000 0000000 plexus-utils-plexus-utils-3.0.22/src/main/java/org/codehaus/plexus/util package org.codehaus.plexus.util;
/*
* Copyright The Codehaus Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import org.codehaus.plexus.util.reflection.Reflector;
import org.codehaus.plexus.util.reflection.ReflectorException;
import java.io.FilterReader;
import java.io.IOException;
import java.io.PushbackReader;
import java.io.Reader;
import java.util.Collections;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
/**
* A FilterReader which interpolates keyword values into a character stream.
* Keywords are recognized when enclosed between starting and ending delimiter
* strings. The keywords themselves, and their values, are fetched from a Map
* supplied to the constructor.
* * When a possible keyword token is recognized (by detecting the starting and * ending token delimiters): *
** A token in the incoming character stream may be escaped by * prepending an "escape sequence" which is specified to the constructor. An * escaped token is passed through as written, with the escape sequence removed. * This allows things which would look like tokens to be read literally rather * than interpolated. *
* * @author jdcasey Created on Feb 3, 2005 * * @see InterpolationFilterReader * @see org.codehaus.plexus.interpolation */ public class LineOrientedInterpolatingReader extends FilterReader { public static final String DEFAULT_START_DELIM = "${"; public static final String DEFAULT_END_DELIM = "}"; public static final String DEFAULT_ESCAPE_SEQ = "\\"; private static final char CARRIAGE_RETURN_CHAR = '\r'; private static final char NEWLINE_CHAR = '\n'; private final PushbackReader pushbackReader; private final Map$relativePath context variable. The arguments to
* this method may contain either forward or backward slashes as
* file separators. The relative path returned is formed using
* forward slashes as it is expected this path is to be used as a
* link in a web page (again mimicking Anakia's behavior).
*
* This method is thread-safe.
*
* PathTool.getRelativePath( null, null ) = ""
* PathTool.getRelativePath( null, "/usr/local/java/bin" ) = ""
* PathTool.getRelativePath( "/usr/local/", null ) = ""
* PathTool.getRelativePath( "/usr/local/", "/usr/local/java/bin" ) = ".."
* PathTool.getRelativePath( "/usr/local/", "/usr/local/java/bin/java.sh" ) = "../.."
* PathTool.getRelativePath( "/usr/local/java/bin/java.sh", "/usr/local/" ) = ""
*
*
* @param basedir The base directory.
* @param filename The filename that is relative to the base
* directory.
* @return The relative path of the filename from the base
* directory. This value is not terminated with a forward slash.
* A zero-length string is returned if: the filename is not relative to
* the base directory, basedir is null or zero-length,
* or filename is null or zero-length.
*/
public static final String getRelativePath( String basedir, String filename )
{
basedir = uppercaseDrive( basedir );
filename = uppercaseDrive( filename );
/*
* Verify the arguments and make sure the filename is relative
* to the base directory.
*/
if ( basedir == null || basedir.length() == 0 || filename == null || filename.length() == 0
|| !filename.startsWith( basedir ) )
{
return "";
}
/*
* Normalize the arguments. First, determine the file separator
* that is being used, then strip that off the end of both the
* base directory and filename.
*/
String separator = determineSeparator( filename );
basedir = StringUtils.chompLast( basedir, separator );
filename = StringUtils.chompLast( filename, separator );
/*
* Remove the base directory from the filename to end up with a
* relative filename (relative to the base directory). This
* filename is then used to determine the relative path.
*/
String relativeFilename = filename.substring( basedir.length() );
return determineRelativePath( relativeFilename, separator );
}
/**
* Determines the relative path of a filename. This method is
* useful in building relative links within pages of a web site. It
* provides similar functionality to Anakia's
* $relativePath context variable. The argument to
* this method may contain either forward or backward slashes as
* file separators. The relative path returned is formed using
* forward slashes as it is expected this path is to be used as a
* link in a web page (again mimicking Anakia's behavior).
*
* This method is thread-safe.
*
* @param filename The filename to be parsed.
* @return The relative path of the filename. This value is not
* terminated with a forward slash. A zero-length string is
* returned if: filename is null or zero-length.
* @see #getRelativeFilePath(String, String)
*/
public static final String getRelativePath( String filename )
{
filename = uppercaseDrive( filename );
if ( filename == null || filename.length() == 0 )
{
return "";
}
/*
* Normalize the argument. First, determine the file separator
* that is being used, then strip that off the end of the
* filename. Then, if the filename doesn't begin with a
* separator, add one.
*/
String separator = determineSeparator( filename );
filename = StringUtils.chompLast( filename, separator );
if ( !filename.startsWith( separator ) )
{
filename = separator + filename;
}
return determineRelativePath( filename, separator );
}
/**
* Determines the directory component of a filename. This is useful
* within DVSL templates when used in conjunction with the DVSL's
* $context.getAppValue("infilename") to get the
* current directory that is currently being processed.
*
* This method is thread-safe.
*
* PathTool.getDirectoryComponent( null ) = ""
* PathTool.getDirectoryComponent( "/usr/local/java/bin" ) = "/usr/local/java"
* PathTool.getDirectoryComponent( "/usr/local/java/bin/" ) = "/usr/local/java/bin"
* PathTool.getDirectoryComponent( "/usr/local/java/bin/java.sh" ) = "/usr/local/java/bin"
*
*
* @param filename The filename to be parsed.
* @return The directory portion of the filename. If
* the filename does not contain a directory component, "." is
* returned.
*/
public static final String getDirectoryComponent( String filename )
{
if ( filename == null || filename.length() == 0 )
{
return "";
}
String separator = determineSeparator( filename );
String directory = StringUtils.chomp( filename, separator );
if ( filename.equals( directory ) )
{
return ".";
}
return directory;
}
/**
* Calculates the appropriate link given the preferred link and the relativePath of the document.
*
* PathTool.calculateLink( "/index.html", "../.." ) = "../../index.html"
* PathTool.calculateLink( "http://plexus.codehaus.org/plexus-utils/index.html", "../.." ) = "http://plexus.codehaus.org/plexus-utils/index.html"
* PathTool.calculateLink( "/usr/local/java/bin/java.sh", "../.." ) = "../../usr/local/java/bin/java.sh"
* PathTool.calculateLink( "../index.html", "/usr/local/java/bin" ) = "/usr/local/java/bin/../index.html"
* PathTool.calculateLink( "../index.html", "http://plexus.codehaus.org/plexus-utils" ) = "http://plexus.codehaus.org/plexus-utils/../index.html"
*
*
* @param link
* @param relativePath
* @return String
*/
public static final String calculateLink( String link, String relativePath )
{
if ( link == null )
{
link = "";
}
if ( relativePath == null )
{
relativePath = "";
}
//This must be some historical feature
if ( link.startsWith( "/site/" ) )
{
return link.substring( 5 );
}
//Allows absolute links in nav-bars etc
if ( link.startsWith( "/absolute/" ) )
{
return link.substring( 10 );
}
// This traps urls like http://
if ( link.contains( ":" ) )
{
return link;
}
//If relativepath is current directory, just pass the link through
if ( StringUtils.equals( relativePath, "." ) )
{
if ( link.startsWith( "/" ) )
{
return link.substring( 1 );
}
return link;
}
//If we don't do this, you can end up with ..//bob.html rather than ../bob.html
if ( relativePath.endsWith( "/" ) && link.startsWith( "/" ) )
{
return relativePath + "." + link.substring( 1 );
}
if ( relativePath.endsWith( "/" ) || link.startsWith( "/" ) )
{
return relativePath + link;
}
return relativePath + "/" + link;
}
/**
* This method can calculate the relative path between two pathes on a web site.
*
* PathTool.getRelativeWebPath( null, null ) = ""
* PathTool.getRelativeWebPath( null, "http://plexus.codehaus.org/" ) = ""
* PathTool.getRelativeWebPath( "http://plexus.codehaus.org/", null ) = ""
* PathTool.getRelativeWebPath( "http://plexus.codehaus.org/",
* "http://plexus.codehaus.org/plexus-utils/index.html" ) = "plexus-utils/index.html"
* PathTool.getRelativeWebPath( "http://plexus.codehaus.org/plexus-utils/index.html",
* "http://plexus.codehaus.org/" = "../../"
*
*
* @param oldPath
* @param newPath
* @return a relative web path from oldPath.
*/
public static final String getRelativeWebPath( final String oldPath, final String newPath )
{
if ( StringUtils.isEmpty( oldPath ) || StringUtils.isEmpty( newPath ) )
{
return "";
}
String resultPath = buildRelativePath( newPath, oldPath, '/' );
if ( newPath.endsWith( "/" ) && !resultPath.endsWith( "/" ) )
{
return resultPath + "/";
}
return resultPath;
}
/**
* This method can calculate the relative path between two pathes on a file system.
*
* PathTool.getRelativeFilePath( null, null ) = ""
* PathTool.getRelativeFilePath( null, "/usr/local/java/bin" ) = ""
* PathTool.getRelativeFilePath( "/usr/local", null ) = ""
* PathTool.getRelativeFilePath( "/usr/local", "/usr/local/java/bin" ) = "java/bin"
* PathTool.getRelativeFilePath( "/usr/local", "/usr/local/java/bin/" ) = "java/bin"
* PathTool.getRelativeFilePath( "/usr/local/java/bin", "/usr/local/" ) = "../.."
* PathTool.getRelativeFilePath( "/usr/local/", "/usr/local/java/bin/java.sh" ) = "java/bin/java.sh"
* PathTool.getRelativeFilePath( "/usr/local/java/bin/java.sh", "/usr/local/" ) = "../../.."
* PathTool.getRelativeFilePath( "/usr/local/", "/bin" ) = "../../bin"
* PathTool.getRelativeFilePath( "/bin", "/usr/local/" ) = "../usr/local"
*
* Note: On Windows based system, the / character should be replaced by \ character.
*
* @param oldPath
* @param newPath
* @return a relative file path from oldPath.
*/
public static final String getRelativeFilePath( final String oldPath, final String newPath )
{
if ( StringUtils.isEmpty( oldPath ) || StringUtils.isEmpty( newPath ) )
{
return "";
}
// normalise the path delimiters
String fromPath = new File( oldPath ).getPath();
String toPath = new File( newPath ).getPath();
// strip any leading slashes if its a windows path
if ( toPath.matches( "^\\[a-zA-Z]:" ) )
{
toPath = toPath.substring( 1 );
}
if ( fromPath.matches( "^\\[a-zA-Z]:" ) )
{
fromPath = fromPath.substring( 1 );
}
// lowercase windows drive letters.
if ( fromPath.startsWith( ":", 1 ) )
{
fromPath = Character.toLowerCase( fromPath.charAt( 0 ) ) + fromPath.substring( 1 );
}
if ( toPath.startsWith( ":", 1 ) )
{
toPath = Character.toLowerCase( toPath.charAt( 0 ) ) + toPath.substring( 1 );
}
// check for the presence of windows drives. No relative way of
// traversing from one to the other.
if ( ( toPath.startsWith( ":", 1 ) && fromPath.startsWith( ":", 1 ) ) && ( !toPath.substring( 0, 1 ).equals(
fromPath.substring( 0, 1 ) ) ) )
{
// they both have drive path element but they dont match, no
// relative path
return null;
}
if ( ( toPath.startsWith( ":", 1 ) && !fromPath.startsWith( ":", 1 ) ) || ( !toPath.startsWith( ":", 1 )
&& fromPath.startsWith( ":", 1 ) ) )
{
// one has a drive path element and the other doesnt, no relative
// path.
return null;
}
String resultPath = buildRelativePath( toPath, fromPath, File.separatorChar );
if ( newPath.endsWith( File.separator ) && !resultPath.endsWith( File.separator ) )
{
return resultPath + File.separator;
}
return resultPath;
}
// ----------------------------------------------------------------------
// Private methods
// ----------------------------------------------------------------------
/**
* Determines the relative path of a filename. For each separator
* within the filename (except the leading if present), append the
* "../" string to the return value.
*
* @param filename The filename to parse.
* @param separator The separator used within the filename.
* @return The relative path of the filename. This value is not
* terminated with a forward slash. A zero-length string is
* returned if: the filename is zero-length.
*/
private static final String determineRelativePath( String filename, String separator )
{
if ( filename.length() == 0 )
{
return "";
}
/*
* Count the slashes in the relative filename, but exclude the
* leading slash. If the path has no slashes, then the filename
* is relative to the current directory.
*/
int slashCount = StringUtils.countMatches( filename, separator ) - 1;
if ( slashCount <= 0 )
{
return ".";
}
/*
* The relative filename contains one or more slashes indicating
* that the file is within one or more directories. Thus, each
* slash represents a "../" in the relative path.
*/
StringBuilder sb = new StringBuilder();
for ( int i = 0; i < slashCount; i++ )
{
sb.append( "../" );
}
/*
* Finally, return the relative path but strip the trailing
* slash to mimic Anakia's behavior.
*/
return StringUtils.chop( sb.toString() );
}
/**
* Helper method to determine the file separator (forward or
* backward slash) used in a filename. The slash that occurs more
* often is returned as the separator.
*
* @param filename The filename parsed to determine the file
* separator.
* @return The file separator used within filename.
* This value is either a forward or backward slash.
*/
private static final String determineSeparator( String filename )
{
int forwardCount = StringUtils.countMatches( filename, "/" );
int backwardCount = StringUtils.countMatches( filename, "\\" );
return forwardCount >= backwardCount ? "/" : "\\";
}
/**
* Cygwin prefers lowercase drive letters, but other parts of maven use uppercase
*
* @param path
* @return String
*/
static final String uppercaseDrive( String path )
{
if ( path == null )
{
return null;
}
if ( path.length() >= 2 && path.charAt( 1 ) == ':' )
{
path = Character.toUpperCase( path.charAt( 0 ) ) + path.substring( 1 );
}
return path;
}
private static final String buildRelativePath( String toPath, String fromPath, final char separatorChar )
{
// use tokeniser to traverse paths and for lazy checking
StringTokenizer toTokeniser = new StringTokenizer( toPath, String.valueOf( separatorChar ) );
StringTokenizer fromTokeniser = new StringTokenizer( fromPath, String.valueOf( separatorChar ) );
int count = 0;
// walk along the to path looking for divergence from the from path
while ( toTokeniser.hasMoreTokens() && fromTokeniser.hasMoreTokens() )
{
if ( separatorChar == '\\' )
{
if ( !fromTokeniser.nextToken().equalsIgnoreCase( toTokeniser.nextToken() ) )
{
break;
}
}
else
{
if ( !fromTokeniser.nextToken().equals( toTokeniser.nextToken() ) )
{
break;
}
}
count++;
}
// reinitialise the tokenisers to count positions to retrieve the
// gobbled token
toTokeniser = new StringTokenizer( toPath, String.valueOf( separatorChar ) );
fromTokeniser = new StringTokenizer( fromPath, String.valueOf( separatorChar ) );
while ( count-- > 0 )
{
fromTokeniser.nextToken();
toTokeniser.nextToken();
}
String relativePath = "";
// add back refs for the rest of from location.
while ( fromTokeniser.hasMoreTokens() )
{
fromTokeniser.nextToken();
relativePath += "..";
if ( fromTokeniser.hasMoreTokens() )
{
relativePath += separatorChar;
}
}
if ( relativePath.length() != 0 && toTokeniser.hasMoreTokens() )
{
relativePath += separatorChar;
}
// add fwd fills for whatevers left of newPath.
while ( toTokeniser.hasMoreTokens() )
{
relativePath += toTokeniser.nextToken();
if ( toTokeniser.hasMoreTokens() )
{
relativePath += separatorChar;
}
}
return relativePath;
}
}
plexus-utils-plexus-utils-3.0.22/src/main/java/org/codehaus/plexus/util/PropertyUtils.java 0000664 0000000 0000000 00000004352 12510777323 0031766 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util;
/*
* Copyright The Codehaus Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import java.util.Properties;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.IOException;
import java.net.URL;
/**
* Static methods to create Properties loaded from various sources.
*
* @author Jason van Zyl
* @author Michal Maczka
*
* @version $Id$
*/
public class PropertyUtils
{
public static Properties loadProperties( URL url )
{
try
{
return loadProperties( url.openStream() );
}
catch ( Exception e )
{
// ignore
}
return null;
}
public static Properties loadProperties( File file )
{
try
{
return loadProperties( new FileInputStream( file ) );
}
catch ( Exception e )
{
// ignore
}
return null;
}
public static Properties loadProperties( InputStream is )
{
try
{
Properties properties = new Properties();
// Make sure the properties stream is valid
if ( is != null )
{
properties.load( is );
}
return properties;
}
catch ( IOException e )
{
// ignore
}
finally
{
try
{
if ( is != null )
{
is.close();
}
}
catch ( IOException e )
{
// ignore
}
}
return null;
}
}
plexus-utils-plexus-utils-3.0.22/src/main/java/org/codehaus/plexus/util/ReaderFactory.java 0000664 0000000 0000000 00000016524 12510777323 0031657 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util;
/*
* Copyright The Codehaus Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.UnsupportedEncodingException;
import java.net.URL;
import java.nio.charset.Charset;
import org.codehaus.plexus.util.xml.XmlStreamReader;
/**
* Utility to create Readers from streams, with explicit encoding choice: platform default,
* XML, or specified.
*
* @author Herve Boutemy
* @see Charset
* @see Supported encodings
* @version $Id$
* @since 1.4.3
*/
public class ReaderFactory
{
/**
* ISO Latin Alphabet #1, also known as ISO-LATIN-1.
* Every implementation of the Java platform is required to support this character encoding.
* @see Charset
*/
public static final String ISO_8859_1 = "ISO-8859-1";
/**
* Seven-bit ASCII, also known as ISO646-US, also known as the Basic Latin block of the Unicode character set.
* Every implementation of the Java platform is required to support this character encoding.
* @see Charset
*/
public static final String US_ASCII = "US-ASCII";
/**
* Sixteen-bit Unicode Transformation Format, byte order specified by a mandatory initial byte-order mark (either
* order accepted on input, big-endian used on output).
* Every implementation of the Java platform is required to support this character encoding.
* @see Charset
*/
public static final String UTF_16 = "UTF-16";
/**
* Sixteen-bit Unicode Transformation Format, big-endian byte order.
* Every implementation of the Java platform is required to support this character encoding.
* @see Charset
*/
public static final String UTF_16BE = "UTF-16BE";
/**
* Sixteen-bit Unicode Transformation Format, little-endian byte order.
* Every implementation of the Java platform is required to support this character encoding.
* @see Charset
*/
public static final String UTF_16LE = "UTF-16LE";
/**
* Eight-bit Unicode Transformation Format.
* Every implementation of the Java platform is required to support this character encoding.
* @see Charset
*/
public static final String UTF_8 = "UTF-8";
/**
* The file.encoding System Property.
*/
public static final String FILE_ENCODING = System.getProperty( "file.encoding" );
/**
* Create a new Reader with XML encoding detection rules.
*
* @param in not null input stream.
* @return an XML reader instance for the input stream.
* @throws IOException if any.
* @see XmlStreamReader
*/
public static XmlStreamReader newXmlReader( InputStream in )
throws IOException
{
return new XmlStreamReader( in );
}
/**
* Create a new Reader with XML encoding detection rules.
*
* @param file not null file.
* @return an XML reader instance for the input file.
* @throws IOException if any.
* @see XmlStreamReader
*/
public static XmlStreamReader newXmlReader( File file )
throws IOException
{
return new XmlStreamReader( file );
}
/**
* Create a new Reader with XML encoding detection rules.
*
* @param url not null url.
* @return an XML reader instance for the input url.
* @throws IOException if any.
* @see XmlStreamReader
*/
public static XmlStreamReader newXmlReader( URL url )
throws IOException
{
return new XmlStreamReader( url );
}
/**
* Create a new Reader with default plaform encoding.
*
* @param in not null input stream.
* @return a reader instance for the input stream using the default platform charset.
* @see Charset#defaultCharset()
*/
public static Reader newPlatformReader( InputStream in )
{
return new InputStreamReader( in );
}
/**
* Create a new Reader with default plaform encoding.
*
* @param file not null file.
* @return a reader instance for the input file using the default platform charset.
* @throws FileNotFoundException if any.
* @see Charset#defaultCharset()
*/
public static Reader newPlatformReader( File file )
throws FileNotFoundException
{
return new FileReader( file );
}
/**
* Create a new Reader with default plaform encoding.
*
* @param url not null url.
* @return a reader instance for the input url using the default platform charset.
* @throws IOException if any.
* @see Charset#defaultCharset()
*/
public static Reader newPlatformReader( URL url )
throws IOException
{
return new InputStreamReader( url.openStream() );
}
/**
* Create a new Reader with specified encoding.
*
* @param in not null input stream.
* @param encoding not null supported encoding.
* @return a reader instance for the input stream using the given encoding.
* @throws UnsupportedEncodingException if any.
* @see Supported encodings
*/
public static Reader newReader( InputStream in, String encoding )
throws UnsupportedEncodingException
{
return new InputStreamReader( in, encoding );
}
/**
* Create a new Reader with specified encoding.
*
* Note that there is no buffering on this reader, which favours clients that read into large buffers (8K+).
*
* @param file not null file.
* @param encoding not null supported encoding.
* @return a reader instance for the input file using the given encoding.
* @throws FileNotFoundException if any.
* @throws UnsupportedEncodingException if any.
* @see Supported encodings
*/
public static Reader newReader( File file, String encoding )
throws FileNotFoundException, UnsupportedEncodingException
{
return new InputStreamReader( new FileInputStream(file), encoding );
}
/**
* Create a new Reader with specified encoding.
*
* @param url not null url.
* @param encoding not null supported encoding.
* @return a reader instance for the input url using the given encoding.
* @throws IOException if any.
* @see Supported encodings
*/
public static Reader newReader( URL url, String encoding )
throws IOException
{
return new InputStreamReader( url.openStream(), encoding );
}
}
plexus-utils-plexus-utils-3.0.22/src/main/java/org/codehaus/plexus/util/ReflectionUtils.java 0000664 0000000 0000000 00000016177 12510777323 0032244 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util;
/*
* Copyright The Codehaus Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.AccessibleObject;
import java.util.Map;
import java.util.HashMap;
import java.util.List;
import java.util.ArrayList;
import java.util.Arrays;
/**
* Operations on a class' fields and their setters.
*
* @author Michal Maczka
* @author Jesse McConnell
* @author Trygve Laugstøl
* @version $Id$
*/
public final class ReflectionUtils
{
// ----------------------------------------------------------------------
// Field utils
// ----------------------------------------------------------------------
public static Field getFieldByNameIncludingSuperclasses( String fieldName, Class clazz )
{
Field retValue = null;
try
{
retValue = clazz.getDeclaredField( fieldName );
}
catch ( NoSuchFieldException e )
{
Class superclass = clazz.getSuperclass();
if ( superclass != null )
{
retValue = getFieldByNameIncludingSuperclasses( fieldName, superclass );
}
}
return retValue;
}
public static ListFile.separatorChar, so the separator used
* need not match File.separatorChar.
*
* When a pattern ends with a '/' or '\', "**" is appended.
*
* @param includes A list of include patterns.
* May be null, indicating that all files
* should be included. If a non-null
* list is given, all elements must be
* non-null.
*/
void setIncludes(String[] includes);
/**
* Sets the list of exclude patterns to use. All '/' and '\' characters
* are replaced by File.separatorChar, so the separator used
* need not match File.separatorChar.
*
* When a pattern ends with a '/' or '\', "**" is appended.
*
* @param excludes A list of exclude patterns.
* May be null, indicating that no files
* should be excluded. If a non-null list is
* given, all elements must be non-null.
*/
void setExcludes(String[] excludes);
/**
* Adds default exclusions to the current exclusions set.
*/
void addDefaultExcludes();
/**
* Scans the base directory for files which match at least one include
* pattern and don't match any exclude patterns.
*
* @exception IllegalStateException if the base directory was set
* incorrectly (i.e. if it is null, doesn't exist,
* or isn't a directory).
*/
void scan();
/**
* Returns the names of the files which matched at least one of the
* include patterns and none of the exclude patterns.
* The names are relative to the base directory.
*
* @return the names of the files which matched at least one of the
* include patterns and none of the exclude patterns.
*/
String[] getIncludedFiles();
/**
* Returns the names of the directories which matched at least one of the
* include patterns and none of the exclude patterns.
* The names are relative to the base directory.
*
* @return the names of the directories which matched at least one of the
* include patterns and none of the exclude patterns.
*/
String[] getIncludedDirectories();
/**
* Returns the base directory to be scanned.
* This is the directory which is scanned recursively.
*
* @return the base directory to be scanned
*/
File getBasedir();
}
plexus-utils-plexus-utils-3.0.22/src/main/java/org/codehaus/plexus/util/SelectorUtils.java 0000664 0000000 0000000 00000071657 12510777323 0031736 0 ustar 00root root 0000000 0000000 /*
* The Apache Software License, Version 1.1
*
* Copyright (c) 2002-2003 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The end-user documentation included with the redistribution, if
* any, must include the following acknowlegement:
* "This product includes software developed by the
* Apache Software Foundation (http://www.codehaus.org/)."
* Alternately, this acknowlegement may appear in the software itself,
* if and wherever such third-party acknowlegements normally appear.
*
* 4. The names "Ant" and "Apache Software
* Foundation" must not be used to endorse or promote products derived
* from this software without prior written permission. For written
* permission, please contact codehaus@codehaus.org.
*
* 5. Products derived from this software may not be called "Apache"
* nor may "Apache" appear in their names without prior written
* permission of the Apache Group.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation. For more
* information on the Apache Software Foundation, please see
*
This is a utility class used by selectors and DirectoryScanner. The * functionality more properly belongs just to selectors, but unfortunately * DirectoryScanner exposed these as protected methods. Thus we have to * support any subclasses of DirectoryScanner that may access these methods. *
*This is a Singleton.
* * @author Arnout J. Kuiper * ajkuiper@wxs.nl * @author Magesh Umasankar * @author Bruce Atherton * @version $Id$ * @since 1.5 */ public final class SelectorUtils { public static final String PATTERN_HANDLER_PREFIX = "["; public static final String PATTERN_HANDLER_SUFFIX = "]"; public static final String REGEX_HANDLER_PREFIX = "%regex" + PATTERN_HANDLER_PREFIX; public static final String ANT_HANDLER_PREFIX = "%ant" + PATTERN_HANDLER_PREFIX; private static SelectorUtils instance = new SelectorUtils(); /** * Private Constructor */ private SelectorUtils() { } /** * Retrieves the manager of the Singleton. */ public static SelectorUtils getInstance() { return instance; } /** * Tests whether or not a given path matches the start of a given * pattern up to the first "**". * * This is not a general purpose test and should only be used if you * can live with false positives. For example,pattern=**\a
* and str=b will yield true.
*
* @param pattern The pattern to match against. Must not be
* null.
* @param str The path to match, as a String. Must not be
* null.
* @return whether or not a given path matches the start of a given
* pattern up to the first "**".
*/
public static boolean matchPatternStart( String pattern, String str )
{
return matchPatternStart( pattern, str, true );
}
/**
* Tests whether or not a given path matches the start of a given
* pattern up to the first "**".
*
* This is not a general purpose test and should only be used if you
* can live with false positives. For example, pattern=**\a
* and str=b will yield true.
*
* @param pattern The pattern to match against. Must not be
* null.
* @param str The path to match, as a String. Must not be
* null.
* @param isCaseSensitive Whether or not matching should be performed
* case sensitively.
* @return whether or not a given path matches the start of a given
* pattern up to the first "**".
*/
public static boolean matchPatternStart( String pattern, String str, boolean isCaseSensitive )
{
if ( isRegexPrefixedPattern( pattern ) )
{
// FIXME: ICK! But we can't do partial matches for regex, so we have to reserve judgement until we have
// a file to deal with, or we can definitely say this is an exclusion...
return true;
}
else
{
if ( isAntPrefixedPattern( pattern ) )
{
pattern = pattern.substring( ANT_HANDLER_PREFIX.length(),
pattern.length() - PATTERN_HANDLER_SUFFIX.length() );
}
String altStr = str.replace( '\\', '/' );
return matchAntPathPatternStart( pattern, str, File.separator, isCaseSensitive )
|| matchAntPathPatternStart( pattern, altStr, "/", isCaseSensitive );
}
}
static boolean isAntPrefixedPattern( String pattern )
{
return pattern.length() > ( ANT_HANDLER_PREFIX.length() + PATTERN_HANDLER_SUFFIX.length() + 1 )
&& pattern.startsWith( ANT_HANDLER_PREFIX ) && pattern.endsWith( PATTERN_HANDLER_SUFFIX );
}
@SuppressWarnings( "SimplifiableIfStatement" )
static boolean matchAntPathPatternStart( MatchPattern pattern, String str, String separator,
boolean isCaseSensitive )
{
if ( separatorPatternStartSlashMismatch( pattern, str, separator ) )
{
return false;
}
return matchAntPathPatternStart( pattern.getTokenizedPathString(), str, separator, isCaseSensitive );
}
static boolean matchAntPathPatternStart( String pattern, String str, String separator, boolean isCaseSensitive )
{
// When str starts with a File.separator, pattern has to start with a
// File.separator.
// When pattern starts with a File.separator, str has to start with a
// File.separator.
if ( separatorPatternStartSlashMismatch( pattern, str, separator ) )
{
return false;
}
String[] patDirs = tokenizePathToString( pattern, separator );
return matchAntPathPatternStart( patDirs, str, separator, isCaseSensitive );
}
// When str starts with a File.separator, pattern has to start with a
// File.separator.
// When pattern starts with a File.separator, str has to start with a
// File.separator.
private static boolean separatorPatternStartSlashMismatch( String pattern, String str, String separator )
{
return str.startsWith( separator ) != pattern.startsWith( separator );
}
private static boolean separatorPatternStartSlashMismatch( MatchPattern matchPattern, String str, String separator )
{
return str.startsWith( separator ) != matchPattern.startsWith( separator );
}
static boolean matchAntPathPatternStart( String[] patDirs, String str, String separator, boolean isCaseSensitive )
{
String[] strDirs = tokenizePathToString( str, separator );
int patIdxStart = 0;
int patIdxEnd = patDirs.length - 1;
int strIdxStart = 0;
int strIdxEnd = strDirs.length - 1;
// up to first '**'
while ( patIdxStart <= patIdxEnd && strIdxStart <= strIdxEnd )
{
String patDir = patDirs[patIdxStart];
if ( patDir.equals( "**" ) )
{
break;
}
if ( !match( patDir, strDirs[strIdxStart], isCaseSensitive ) )
{
return false;
}
patIdxStart++;
strIdxStart++;
}
return strIdxStart > strIdxEnd || patIdxStart <= patIdxEnd;
}
/**
* Tests whether or not a given path matches a given pattern.
*
* @param pattern The pattern to match against. Must not be
* null.
* @param str The path to match, as a String. Must not be
* null.
* @return true if the pattern matches against the string,
* or false otherwise.
*/
public static boolean matchPath( String pattern, String str )
{
return matchPath( pattern, str, true );
}
/**
* Tests whether or not a given path matches a given pattern.
*
* @param pattern The pattern to match against. Must not be
* null.
* @param str The path to match, as a String. Must not be
* null.
* @param isCaseSensitive Whether or not matching should be performed
* case sensitively.
* @return true if the pattern matches against the string,
* or false otherwise.
*/
public static boolean matchPath( String pattern, String str, boolean isCaseSensitive )
{
return matchPath( pattern, str, File.separator, isCaseSensitive );
}
public static boolean matchPath( String pattern, String str, String separator, boolean isCaseSensitive )
{
if ( isRegexPrefixedPattern( pattern ) )
{
pattern =
pattern.substring( REGEX_HANDLER_PREFIX.length(), pattern.length() - PATTERN_HANDLER_SUFFIX.length() );
return str.matches( pattern );
}
else
{
if ( isAntPrefixedPattern( pattern ) )
{
pattern = pattern.substring( ANT_HANDLER_PREFIX.length(),
pattern.length() - PATTERN_HANDLER_SUFFIX.length() );
}
return matchAntPathPattern( pattern, str, separator, isCaseSensitive );
}
}
static boolean isRegexPrefixedPattern( String pattern )
{
return pattern.length() > ( REGEX_HANDLER_PREFIX.length() + PATTERN_HANDLER_SUFFIX.length() + 1 )
&& pattern.startsWith( REGEX_HANDLER_PREFIX ) && pattern.endsWith( PATTERN_HANDLER_SUFFIX );
}
static boolean matchAntPathPattern( MatchPattern matchPattern, String str, String separator,
boolean isCaseSensitive )
{
if ( separatorPatternStartSlashMismatch( matchPattern, str, separator ) )
{
return false;
}
String[] patDirs = matchPattern.getTokenizedPathString();
String[] strDirs = tokenizePathToString( str, separator );
return matchAntPathPattern( patDirs, strDirs, isCaseSensitive );
}
static boolean matchAntPathPattern( String pattern, String str, String separator, boolean isCaseSensitive )
{
if ( separatorPatternStartSlashMismatch( pattern, str, separator ) )
{
return false;
}
String[] patDirs = tokenizePathToString( pattern, separator );
String[] strDirs = tokenizePathToString( str, separator );
return matchAntPathPattern( patDirs, strDirs, isCaseSensitive );
}
static boolean matchAntPathPattern( String[] patDirs, String[] strDirs, boolean isCaseSensitive )
{
int patIdxStart = 0;
int patIdxEnd = patDirs.length - 1;
int strIdxStart = 0;
int strIdxEnd = strDirs.length - 1;
// up to first '**'
while ( patIdxStart <= patIdxEnd && strIdxStart <= strIdxEnd )
{
String patDir = patDirs[patIdxStart];
if ( patDir.equals( "**" ) )
{
break;
}
if ( !match( patDir, strDirs[strIdxStart], isCaseSensitive ) )
{
return false;
}
patIdxStart++;
strIdxStart++;
}
if ( strIdxStart > strIdxEnd )
{
// String is exhausted
for ( int i = patIdxStart; i <= patIdxEnd; i++ )
{
if ( !patDirs[i].equals( "**" ) )
{
return false;
}
}
return true;
}
else
{
if ( patIdxStart > patIdxEnd )
{
// String not exhausted, but pattern is. Failure.
return false;
}
}
// up to last '**'
while ( patIdxStart <= patIdxEnd && strIdxStart <= strIdxEnd )
{
String patDir = patDirs[patIdxEnd];
if ( patDir.equals( "**" ) )
{
break;
}
if ( !match( patDir, strDirs[strIdxEnd], isCaseSensitive ) )
{
return false;
}
patIdxEnd--;
strIdxEnd--;
}
if ( strIdxStart > strIdxEnd )
{
// String is exhausted
for ( int i = patIdxStart; i <= patIdxEnd; i++ )
{
if ( !patDirs[i].equals( "**" ) )
{
return false;
}
}
return true;
}
while ( patIdxStart != patIdxEnd && strIdxStart <= strIdxEnd )
{
int patIdxTmp = -1;
for ( int i = patIdxStart + 1; i <= patIdxEnd; i++ )
{
if ( patDirs[i].equals( "**" ) )
{
patIdxTmp = i;
break;
}
}
if ( patIdxTmp == patIdxStart + 1 )
{
// '**/**' situation, so skip one
patIdxStart++;
continue;
}
// Find the pattern between padIdxStart & padIdxTmp in str between
// strIdxStart & strIdxEnd
int patLength = ( patIdxTmp - patIdxStart - 1 );
int strLength = ( strIdxEnd - strIdxStart + 1 );
int foundIdx = -1;
strLoop:
for ( int i = 0; i <= strLength - patLength; i++ )
{
for ( int j = 0; j < patLength; j++ )
{
String subPat = patDirs[patIdxStart + j + 1];
String subStr = strDirs[strIdxStart + i + j];
if ( !match( subPat, subStr, isCaseSensitive ) )
{
continue strLoop;
}
}
foundIdx = strIdxStart + i;
break;
}
if ( foundIdx == -1 )
{
return false;
}
patIdxStart = patIdxTmp;
strIdxStart = foundIdx + patLength;
}
for ( int i = patIdxStart; i <= patIdxEnd; i++ )
{
if ( !patDirs[i].equals( "**" ) )
{
return false;
}
}
return true;
}
static boolean matchAntPathPattern( char[][] patDirs, char[][] strDirs, boolean isCaseSensitive )
{
int patIdxStart = 0;
int patIdxEnd = patDirs.length - 1;
int strIdxStart = 0;
int strIdxEnd = strDirs.length - 1;
// up to first '**'
while ( patIdxStart <= patIdxEnd && strIdxStart <= strIdxEnd )
{
char[] patDir = patDirs[patIdxStart];
if ( isDoubleStar( patDir ) )
{
break;
}
if ( !match( patDir, strDirs[strIdxStart], isCaseSensitive ) )
{
return false;
}
patIdxStart++;
strIdxStart++;
}
if ( strIdxStart > strIdxEnd )
{
// String is exhausted
for ( int i = patIdxStart; i <= patIdxEnd; i++ )
{
if ( !isDoubleStar( patDirs[i] ) )
{
return false;
}
}
return true;
}
else
{
if ( patIdxStart > patIdxEnd )
{
// String not exhausted, but pattern is. Failure.
return false;
}
}
// up to last '**'
while ( patIdxStart <= patIdxEnd && strIdxStart <= strIdxEnd )
{
char[] patDir = patDirs[patIdxEnd];
if ( isDoubleStar( patDir ) )
{
break;
}
if ( !match( patDir, strDirs[strIdxEnd], isCaseSensitive ) )
{
return false;
}
patIdxEnd--;
strIdxEnd--;
}
if ( strIdxStart > strIdxEnd )
{
// String is exhausted
for ( int i = patIdxStart; i <= patIdxEnd; i++ )
{
if ( !isDoubleStar( patDirs[i] ) )
{
return false;
}
}
return true;
}
while ( patIdxStart != patIdxEnd && strIdxStart <= strIdxEnd )
{
int patIdxTmp = -1;
for ( int i = patIdxStart + 1; i <= patIdxEnd; i++ )
{
if ( isDoubleStar( patDirs[i] ) )
{
patIdxTmp = i;
break;
}
}
if ( patIdxTmp == patIdxStart + 1 )
{
// '**/**' situation, so skip one
patIdxStart++;
continue;
}
// Find the pattern between padIdxStart & padIdxTmp in str between
// strIdxStart & strIdxEnd
int patLength = ( patIdxTmp - patIdxStart - 1 );
int strLength = ( strIdxEnd - strIdxStart + 1 );
int foundIdx = -1;
strLoop:
for ( int i = 0; i <= strLength - patLength; i++ )
{
for ( int j = 0; j < patLength; j++ )
{
char[] subPat = patDirs[patIdxStart + j + 1];
char[] subStr = strDirs[strIdxStart + i + j];
if ( !match( subPat, subStr, isCaseSensitive ) )
{
continue strLoop;
}
}
foundIdx = strIdxStart + i;
break;
}
if ( foundIdx == -1 )
{
return false;
}
patIdxStart = patIdxTmp;
strIdxStart = foundIdx + patLength;
}
for ( int i = patIdxStart; i <= patIdxEnd; i++ )
{
if ( !isDoubleStar( patDirs[i] ) )
{
return false;
}
}
return true;
}
private static boolean isDoubleStar( char[] patDir )
{
return patDir != null && patDir.length == 2 && patDir[0] == '*' && patDir[1] == '*';
}
/**
* Tests whether or not a string matches against a pattern.
* The pattern may contain two special characters:null.
* @param str The string which must be matched against the pattern.
* Must not be null.
* @return true if the string matches against the pattern,
* or false otherwise.
*/
public static boolean match( String pattern, String str )
{
return match( pattern, str, true );
}
/**
* Tests whether or not a string matches against a pattern.
* The pattern may contain two special characters:null.
* @param str The string which must be matched against the pattern.
* Must not be null.
* @param isCaseSensitive Whether or not matching should be performed
* case sensitively.
* @return true if the string matches against the pattern,
* or false otherwise.
*/
public static boolean match( String pattern, String str, boolean isCaseSensitive )
{
char[] patArr = pattern.toCharArray();
char[] strArr = str.toCharArray();
return match( patArr, strArr, isCaseSensitive);
}
public static boolean match( char[] patArr, char[] strArr, boolean isCaseSensitive )
{
int patIdxStart = 0;
int patIdxEnd = patArr.length - 1;
int strIdxStart = 0;
int strIdxEnd = strArr.length - 1;
char ch;
boolean containsStar = false;
for ( char aPatArr : patArr )
{
if ( aPatArr == '*' )
{
containsStar = true;
break;
}
}
if ( !containsStar )
{
// No '*'s, so we make a shortcut
if ( patIdxEnd != strIdxEnd )
{
return false; // Pattern and string do not have the same size
}
for ( int i = 0; i <= patIdxEnd; i++ )
{
ch = patArr[i];
if ( ch != '?' && !equals( ch, strArr[i], isCaseSensitive ) )
{
return false; // Character mismatch
}
}
return true; // String matches against pattern
}
if ( patIdxEnd == 0 )
{
return true; // Pattern contains only '*', which matches anything
}
// Process characters before first star
while ( ( ch = patArr[patIdxStart] ) != '*' && strIdxStart <= strIdxEnd )
{
if ( ch != '?' && !equals( ch, strArr[strIdxStart], isCaseSensitive ) )
{
return false; // Character mismatch
}
patIdxStart++;
strIdxStart++;
}
if ( strIdxStart > strIdxEnd )
{
// All characters in the string are used. Check if only '*'s are
// left in the pattern. If so, we succeeded. Otherwise failure.
for ( int i = patIdxStart; i <= patIdxEnd; i++ )
{
if ( patArr[i] != '*' )
{
return false;
}
}
return true;
}
// Process characters after last star
while ( ( ch = patArr[patIdxEnd] ) != '*' && strIdxStart <= strIdxEnd )
{
if ( ch != '?' && !equals( ch, strArr[strIdxEnd], isCaseSensitive ) )
{
return false; // Character mismatch
}
patIdxEnd--;
strIdxEnd--;
}
if ( strIdxStart > strIdxEnd )
{
// All characters in the string are used. Check if only '*'s are
// left in the pattern. If so, we succeeded. Otherwise failure.
for ( int i = patIdxStart; i <= patIdxEnd; i++ )
{
if ( patArr[i] != '*' )
{
return false;
}
}
return true;
}
// process pattern between stars. padIdxStart and patIdxEnd point
// always to a '*'.
while ( patIdxStart != patIdxEnd && strIdxStart <= strIdxEnd )
{
int patIdxTmp = -1;
for ( int i = patIdxStart + 1; i <= patIdxEnd; i++ )
{
if ( patArr[i] == '*' )
{
patIdxTmp = i;
break;
}
}
if ( patIdxTmp == patIdxStart + 1 )
{
// Two stars next to each other, skip the first one.
patIdxStart++;
continue;
}
// Find the pattern between padIdxStart & padIdxTmp in str between
// strIdxStart & strIdxEnd
int patLength = ( patIdxTmp - patIdxStart - 1 );
int strLength = ( strIdxEnd - strIdxStart + 1 );
int foundIdx = -1;
strLoop:
for ( int i = 0; i <= strLength - patLength; i++ )
{
for ( int j = 0; j < patLength; j++ )
{
ch = patArr[patIdxStart + j + 1];
if ( ch != '?' && !equals( ch, strArr[strIdxStart + i + j], isCaseSensitive ) )
{
continue strLoop;
}
}
foundIdx = strIdxStart + i;
break;
}
if ( foundIdx == -1 )
{
return false;
}
patIdxStart = patIdxTmp;
strIdxStart = foundIdx + patLength;
}
// All characters in the string are used. Check if only '*'s are left
// in the pattern. If so, we succeeded. Otherwise failure.
for ( int i = patIdxStart; i <= patIdxEnd; i++ )
{
if ( patArr[i] != '*' )
{
return false;
}
}
return true;
}
/**
* Tests whether two characters are equal.
*/
private static boolean equals( char c1, char c2, boolean isCaseSensitive )
{
if ( c1 == c2 )
{
return true;
}
if ( !isCaseSensitive )
{
// NOTE: Try both upper case and lower case as done by String.equalsIgnoreCase()
if ( Character.toUpperCase( c1 ) == Character.toUpperCase( c2 )
|| Character.toLowerCase( c1 ) == Character.toLowerCase( c2 ) )
{
return true;
}
}
return false;
}
private static String[] tokenizePathToString( String path, String separator )
{
Listnull.
*/
public StringInputStream( String source )
{
in = new StringReader( source );
}
/**
* Reads from the Stringreader, returning the same value. Note that
* data will be lost for characters not in ISO Latin 1. Clients
* assuming a return value in the range -1 to 255 may even fail on
* such input.
*
* @return the value of the next character in the StringReader
*
* @exception IOException if the original StringReader fails to be read
*/
public int read() throws IOException
{
return in.read();
}
/**
* Closes the Stringreader.
*
* @exception IOException if the original StringReader fails to be closed
*/
public void close() throws IOException
{
in.close();
}
/**
* Marks the read limit of the StringReader.
*
* @param limit the maximum limit of bytes that can be read before the
* mark position becomes invalid
*/
public synchronized void mark( final int limit )
{
try
{
in.mark( limit );
}
catch ( IOException ioe )
{
throw new RuntimeException( ioe.getMessage() );
}
}
/**
* Resets the StringReader.
*
* @exception IOException if the StringReader fails to be reset
*/
public synchronized void reset() throws IOException
{
in.reset();
}
/**
* @see InputStream#markSupported
*/
public boolean markSupported()
{
return in.markSupported();
}
}
plexus-utils-plexus-utils-3.0.22/src/main/java/org/codehaus/plexus/util/StringOutputStream.java 0000664 0000000 0000000 00000003146 12510777323 0032764 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util;
/*
* Copyright The Codehaus Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import java.io.IOException;
import java.io.OutputStream;
/**
* Wraps a String as an OutputStream.
*
* @author Emmanuel Venisse
* @version $Id$
* @deprecated As of version 1.5.2 this class should no longer be used because it does not properly handle character
* encoding. Instead, use {@link java.io.ByteArrayOutputStream#toString(String)}.
*/
public class StringOutputStream
extends OutputStream
{
private StringBuffer buf = new StringBuffer();
public void write( byte[] b ) throws IOException
{
buf.append( new String( b ) );
}
public void write( byte[] b, int off, int len ) throws IOException
{
buf.append( new String( b, off, len ) );
}
public void write( int b ) throws IOException
{
byte[] bytes = new byte[1];
bytes[0] = (byte)b;
buf.append( new String( bytes ) );
}
public String toString()
{
return buf.toString();
}
}
plexus-utils-plexus-utils-3.0.22/src/main/java/org/codehaus/plexus/util/StringUtils.java 0000664 0000000 0000000 00000227146 12510777323 0031420 0 ustar 00root root 0000000 0000000 /* ====================================================================
* The Apache Software License, Version 1.1
*
* Copyright (c) 2002 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The end-user documentation included with the redistribution, if
* any, must include the following acknowlegement:
* "This product includes software developed by the
* Apache Software Foundation (http://www.codehaus.org/)."
* Alternately, this acknowlegement may appear in the software itself,
* if and wherever such third-party acknowlegements normally appear.
*
* 4. The names "The Jakarta Project", "Commons", and "Apache Software
* Foundation" must not be used to endorse or promote products derived
* from this software without prior written permission. For written
* permission, please contact codehaus@codehaus.org.
*
* 5. Products derived from this software may not be called "Apache"
* nor may "Apache" appear in their names without prior written
* permission of the Apache Software Foundation.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation. For more
* information on the Apache Software Foundation, please see
* Common String manipulation routines.
Originally from * Turbine and the * GenerationJavaCore library.
* * @author Jon S. Stevens * @author Daniel Rall * @author Greg Coladonato * @author Henri Yandell * @author Ed Korthof * @author Rand McNeely * @author Stephen Colebourne * @author Fredrik Westermarck * @author Holger Krauth * @author Alexander Day Chaffee * @author Vincent Siveton * @since 1.0 * @version $Id$ */ public class StringUtils { /** *StringUtils instances should NOT be constructed in
* standard programming. Instead, the class should be used as
* StringUtils.trim(" foo ");.
This constructor is public to permit tools that require a JavaBean * manager to operate.
*/ public StringUtils() { } // Empty //-------------------------------------------------------------------------- /** *Removes control characters, including whitespace, from both
* ends of this String, handling null by returning
* an empty String.
null)
*/
public static String clean( String str )
{
return ( str == null ? "" : str.trim() );
}
/**
* Removes control characters, including whitespace, from both
* ends of this String, handling null by returning
* null.
null)
*/
public static String trim( String str )
{
return ( str == null ? null : str.trim() );
}
/**
* Deletes all whitespaces from a String.
* *Whitespace is defined by * {@link Character#isWhitespace(char)}.
* * @param str String target to delete whitespace from * @return the String without whitespaces * @throws NullPointerException */ public static String deleteWhitespace( String str ) { StringBuilder buffer = new StringBuilder(); int sz = str.length(); for ( int i = 0; i < sz; i++ ) { if ( !Character.isWhitespace( str.charAt( i ) ) ) { buffer.append( str.charAt( i ) ); } } return buffer.toString(); } /** *Checks if a String is non null and is
* not empty (length > 0).
Checks if a (trimmed) String is null or empty.
Note: In future releases, this method will no longer trim the input string such that it works * complementary to {@link #isNotEmpty(String)}. Code that wants to test for whitespace-only strings should be * migrated to use {@link #isBlank(String)} instead.
* * @param str the String to check * @returntrue if the String is null, or
* length zero once trimmed
*/
public static boolean isEmpty( String str )
{
return ( ( str == null ) || ( str.trim().length() == 0 ) );
}
/**
* * Checks if a String is whitespace, empty ("") or null. *
* *
* StringUtils.isBlank(null) = true
* StringUtils.isBlank("") = true
* StringUtils.isBlank(" ") = true
* StringUtils.isBlank("bob") = false
* StringUtils.isBlank(" bob ") = false
*
*
* @param str the String to check, may be null
* @return true if the String is null, empty or whitespace
* @since 1.5.2
*/
public static boolean isBlank( String str )
{
int strLen;
if ( str == null || ( strLen = str.length() ) == 0 )
{
return true;
}
for ( int i = 0; i < strLen; i++ )
{
if ( !Character.isWhitespace( str.charAt( i ) ) )
{
return false;
}
}
return true;
}
/**
* * Checks if a String is not empty (""), not null and not whitespace only. *
* *
* StringUtils.isNotBlank(null) = false
* StringUtils.isNotBlank("") = false
* StringUtils.isNotBlank(" ") = false
* StringUtils.isNotBlank("bob") = true
* StringUtils.isNotBlank(" bob ") = true
*
*
* @param str the String to check, may be null
* @return true if the String is not empty and not null and not whitespace
* @since 1.5.2
*/
public static boolean isNotBlank( String str )
{
return !StringUtils.isBlank( str );
}
// Equals and IndexOf
//--------------------------------------------------------------------------
/**
* Compares two Strings, returning true if they are equal.
nulls are handled without exceptions. Two null
* references are considered to be equal. The comparison is case sensitive.
true if the Strings are equal, case sensitive, or
* both null
*/
public static boolean equals( String str1, String str2 )
{
return ( str1 == null ? str2 == null : str1.equals( str2 ) );
}
/**
* Compares two Strings, returning true if they are equal ignoring
* the case.
Nulls are handled without exceptions. Two null
* references are considered equal. Comparison is case insensitive.
true if the Strings are equal, case insensitive, or
* both null
*/
public static boolean equalsIgnoreCase( String str1, String str2 )
{
return ( str1 == null ? str2 == null : str1.equalsIgnoreCase( str2 ) );
}
/**
* Find the first index of any of a set of potential substrings.
* *null String will return -1.
null
*/
public static int indexOfAny( String str, String[] searchStrs )
{
if ( ( str == null ) || ( searchStrs == null ) )
{
return -1;
}
int sz = searchStrs.length;
// String's can't have a MAX_VALUEth index.
int ret = Integer.MAX_VALUE;
int tmp;
for ( String searchStr : searchStrs )
{
tmp = str.indexOf( searchStr );
if ( tmp == -1 )
{
continue;
}
if ( tmp < ret )
{
ret = tmp;
}
}
return ( ret == Integer.MAX_VALUE ) ? -1 : ret;
}
/**
* Find the latest index of any of a set of potential substrings.
* *null string will return -1.
null
*/
public static int lastIndexOfAny( String str, String[] searchStrs )
{
if ( ( str == null ) || ( searchStrs == null ) )
{
return -1;
}
int ret = -1;
int tmp;
for ( String searchStr : searchStrs )
{
tmp = str.lastIndexOf( searchStr );
if ( tmp > ret )
{
ret = tmp;
}
}
return ret;
}
// Substring
//--------------------------------------------------------------------------
/**
* Gets a substring from the specified string avoiding exceptions.
* *A negative start position can be used to start n
* characters from the end of the String.
Gets a substring from the specified String avoiding exceptions.
* *A negative start position can be used to start/end n
* characters from the end of the String.
Gets the leftmost n characters of a String.
If n characters are not available, or the
* String is null, the String will be returned without
* an exception.
Gets the rightmost n characters of a String.
If n characters are not available, or the String
* is null, the String will be returned without an
* exception.
Gets n characters from the middle of a String.
If n characters are not available, the remainder
* of the String will be returned without an exception. If the
* String is null, null will be returned.
Splits the provided text into a array, using whitespace as the * separator.
* *The separator is not included in the returned String array.
* * @param str the String to parse * @return an array of parsed Strings */ public static String[] split( String str ) { return split( str, null, -1 ); } /** * @see #split(String, String, int) */ public static String[] split( String text, String separator ) { return split( text, separator, -1 ); } /** *Splits the provided text into a array, based on a given separator.
* *The separator is not included in the returned String array. The
* maximum number of splits to perfom can be controlled. A null
* separator will cause parsing to be on whitespace.
This is useful for quickly splitting a String directly into
* an array of tokens, instead of an enumeration of tokens (as
* StringTokenizer does).
null, 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;
if ( separator == null )
{
// Null separator means we're using StringTokenizer's default
// delimiter, which comprises all whitespace characters.
tok = new StringTokenizer( str );
}
else
{
tok = new StringTokenizer( str, separator );
}
int listSize = tok.countTokens();
if ( ( max > 0 ) && ( listSize > max ) )
{
listSize = max;
}
String[] list = new String[listSize];
int i = 0;
int lastTokenBegin;
int lastTokenEnd = 0;
while ( tok.hasMoreTokens() )
{
if ( ( max > 0 ) && ( i == listSize - 1 ) )
{
// In the situation where we hit the max yet have
// tokens left over in our input, the last list
// element gets all remaining text.
String endToken = tok.nextToken();
lastTokenBegin = str.indexOf( endToken, lastTokenEnd );
list[i] = str.substring( lastTokenBegin );
break;
}
else
{
list[i] = tok.nextToken();
lastTokenBegin = str.indexOf( list[i], lastTokenEnd );
lastTokenEnd = lastTokenBegin + list[i].length();
}
i++;
}
return list;
}
// Joining
//--------------------------------------------------------------------------
/**
* Concatenates elements of an array into a single String.
* *The difference from join is that concatenate has no delimiter.
* * @param array the array of values to concatenate. * @return the concatenated string. */ public static String concatenate( Object[] array ) { return join( array, "" ); } /** *Joins the elements of the provided array into a single String * containing the provided list of elements.
* *No delimiter is added before or after the list. A
* null separator is the same as a blank String.
Joins the elements of the provided Iterator into
* a single String containing the provided elements.
No delimiter is added before or after the list. A
* null separator is the same as a blank String.
Iterator of values to join together
* @param separator the separator character to use
* @return the joined String
*/
public static String join( Iterator iterator, String separator )
{
if ( separator == null )
{
separator = "";
}
StringBuilder buf = new StringBuilder( 256 ); // Java default is 16, probably too small
while ( iterator.hasNext() )
{
buf.append( iterator.next() );
if ( iterator.hasNext() )
{
buf.append( separator );
}
}
return buf.toString();
}
// Replacing
//--------------------------------------------------------------------------
/**
* Replace a char with another char inside a larger String, once.
* *A null reference passed to this method is a no-op.
Replace all occurances of a char within another char.
* *A null reference passed to this method is a no-op.
Replace a char with another char inside a larger String,
* for the first max values of the search char.
A null reference passed to this method is a no-op.
-1 if no maximum
* @return the text with any replacements processed
*/
public static String replace( String text, char repl, char with, int max )
{
return replace( text, String.valueOf( repl ), String.valueOf( with ), max );
}
/**
* Replace a String with another String inside a larger String, once.
* *A null reference passed to this method is a no-op.
Replace all occurances of a String within another String.
* *A null reference passed to this method is a no-op.
Replace a String with another String inside a larger String,
* for the first max values of the search String.
A null reference passed to this method is a no-op.
-1 if no maximum
* @return the text with any replacements processed
*/
public static String replace( String text, String repl, String with, int max )
{
if ( ( text == null ) || ( repl == null ) || ( with == null ) || ( repl.length() == 0 ) )
{
return text;
}
StringBuilder buf = new StringBuilder( text.length() );
int start = 0, end;
while ( ( end = text.indexOf( repl, start ) ) != -1 )
{
buf.append( text, start, end ).append( with );
start = end + repl.length();
if ( --max == 0 )
{
break;
}
}
buf.append( text, start, text.length());
return buf.toString();
}
/**
* Overlay a part of a String with another String.
* * @param text String to do overlaying in * @param overlay String to overlay * @param start int to start overlaying at * @param end int to stop overlaying before * @return String with overlayed text * @throws NullPointerException if text or overlay isnull
*/
public static String overlayString( String text, String overlay, int start, int end )
{
return new StringBuffer( start + overlay.length() + text.length() - end + 1 )
.append( text, 0, start )
.append( overlay )
.append( text, end, text.length() )
.toString();
}
// Centering
//--------------------------------------------------------------------------
/**
* Center a String in a larger String of size n.
* *
Uses spaces as the value to buffer the String with.
* Equivalent to center(str, size, " ").
null
*/
public static String center( String str, int size )
{
return center( str, size, " " );
}
/**
* Center a String in a larger String of size n.
Uses a supplied String as the value to buffer the String with.
* * @param str String to center * @param size int size of new String * @param delim String to buffer the new String with * @return String containing centered String * @throws NullPointerException if str or delim isnull
* @throws ArithmeticException if delim is the empty String
*/
public static String center( String str, int size, String delim )
{
int sz = str.length();
int p = size - sz;
if ( p < 1 )
{
return str;
}
str = leftPad( str, sz + p / 2, delim );
str = rightPad( str, size, delim );
return str;
}
// Chomping
//--------------------------------------------------------------------------
/**
* Remove the last newline, and everything after it from a String.
* * @param str String to chomp the newline from * @return String without chomped newline * @throws NullPointerException if str isnull
*/
public static String chomp( String str )
{
return chomp( str, "\n" );
}
/**
* Remove the last value of a supplied String, and everything after * it from a String.
* * @param str String to chomp from * @param sep String to chomp * @return String without chomped ending * @throws NullPointerException if str or sep isnull
*/
public static String chomp( String str, String sep )
{
int idx = str.lastIndexOf( sep );
if ( idx != -1 )
{
return str.substring( 0, idx );
}
else
{
return str;
}
}
/**
* Remove a newline if and only if it is at the end * of the supplied String.
* * @param str String to chomp from * @return String without chomped ending * @throws NullPointerException if str isnull
*/
public static String chompLast( String str )
{
return chompLast( str, "\n" );
}
/**
* Remove a value if and only if the String ends with that value.
* * @param str String to chomp from * @param sep String to chomp * @return String without chomped ending * @throws NullPointerException if str or sep isnull
*/
public static String chompLast( String str, String sep )
{
if ( str.length() == 0 )
{
return str;
}
String sub = str.substring( str.length() - sep.length() );
if ( sep.equals( sub ) )
{
return str.substring( 0, str.length() - sep.length() );
}
else
{
return str;
}
}
/**
* Remove everything and return the last value of a supplied String, and * everything after it from a String.
* * @param str String to chomp from * @param sep String to chomp * @return String chomped * @throws NullPointerException if str or sep isnull
*/
public static String getChomp( String str, String sep )
{
int idx = str.lastIndexOf( sep );
if ( idx == str.length() - sep.length() )
{
return sep;
}
else if ( idx != -1 )
{
return str.substring( idx );
}
else
{
return "";
}
}
/**
* Remove the first value of a supplied String, and everything before it * from a String.
* * @param str String to chomp from * @param sep String to chomp * @return String without chomped beginning * @throws NullPointerException if str or sep isnull
*/
public static String prechomp( String str, String sep )
{
int idx = str.indexOf( sep );
if ( idx != -1 )
{
return str.substring( idx + sep.length() );
}
else
{
return str;
}
}
/**
* Remove and return everything before the first value of a * supplied String from another String.
* * @param str String to chomp from * @param sep String to chomp * @return String prechomped * @throws NullPointerException if str or sep isnull
*/
public static String getPrechomp( String str, String sep )
{
int idx = str.indexOf( sep );
if ( idx != -1 )
{
return str.substring( 0, idx + sep.length() );
}
else
{
return "";
}
}
// Chopping
//--------------------------------------------------------------------------
/**
* Remove the last character from a String.
* *If the String ends in \r\n, then remove both
* of them.
null
*/
public static String chop( String str )
{
if ( "".equals( str ) )
{
return "";
}
if ( str.length() == 1 )
{
return "";
}
int lastIdx = str.length() - 1;
String ret = str.substring( 0, lastIdx );
char last = str.charAt( lastIdx );
if ( last == '\n' )
{
if ( ret.charAt( lastIdx - 1 ) == '\r' )
{
return ret.substring( 0, lastIdx - 1 );
}
}
return ret;
}
/**
* Remove \n from end of a String if it's there.
* If a \r precedes it, then remove that too.
null
*/
public static String chopNewline( String str )
{
int lastIdx = str.length() - 1;
char last = str.charAt( lastIdx );
if ( last == '\n' )
{
if ( str.charAt( lastIdx - 1 ) == '\r' )
{
lastIdx--;
}
}
else
{
lastIdx++;
}
return str.substring( 0, lastIdx );
}
// Conversion
//--------------------------------------------------------------------------
// spec 3.10.6
/**
* Escapes any values it finds into their String form.
* *So a tab becomes the characters '\\' and
* 't'.
null
*/
public static String escape( String str )
{
// improved with code from cybertiger@cyberiantiger.org
// unicode from him, and defaul for < 32's.
int sz = str.length();
StringBuilder buffer = new StringBuilder( 2 * sz );
for ( int i = 0; i < sz; i++ )
{
char ch = str.charAt( i );
// handle unicode
if ( ch > 0xfff )
{
buffer.append( "\\u" + Integer.toHexString( ch ) );
}
else if ( ch > 0xff )
{
buffer.append( "\\u0" + Integer.toHexString( ch ) );
}
else if ( ch > 0x7f )
{
buffer.append( "\\u00" + Integer.toHexString( ch ) );
}
else if ( ch < 32 )
{
switch ( ch )
{
case '\b':
buffer.append( '\\' );
buffer.append( 'b' );
break;
case '\n':
buffer.append( '\\' );
buffer.append( 'n' );
break;
case '\t':
buffer.append( '\\' );
buffer.append( 't' );
break;
case '\f':
buffer.append( '\\' );
buffer.append( 'f' );
break;
case '\r':
buffer.append( '\\' );
buffer.append( 'r' );
break;
default :
if ( ch > 0xf )
{
buffer.append( "\\u00" + Integer.toHexString( ch ) );
}
else
{
buffer.append( "\\u000" + Integer.toHexString( ch ) );
}
break;
}
}
else
{
switch ( ch )
{
case '\'':
buffer.append( '\\' );
buffer.append( '\'' );
break;
case '"':
buffer.append( '\\' );
buffer.append( '"' );
break;
case '\\':
buffer.append( '\\' );
buffer.append( '\\' );
break;
default :
buffer.append( ch );
break;
}
}
}
return buffer.toString();
}
// Padding
//--------------------------------------------------------------------------
/**
* Repeat a String n times to form a
* new string.
repeat < 0
* @throws NullPointerException if str is null
*/
public static String repeat( String str, int repeat )
{
StringBuilder buffer = new StringBuilder( repeat * str.length() );
for ( int i = 0; i < repeat; i++ )
{
buffer.append( str );
}
return buffer.toString();
}
/**
* Right pad a String with spaces.
* *The String is padded to the size of n.
null
*/
public static String rightPad( String str, int size )
{
return rightPad( str, size, " " );
}
/**
* Right pad a String with a specified string.
* *The String is padded to the size of n.
null
* @throws ArithmeticException if delim is the empty String
*/
public static String rightPad( String str, int size, String delim )
{
size = ( size - str.length() ) / delim.length();
if ( size > 0 )
{
str += repeat( delim, size );
}
return str;
}
/**
* Left pad a String with spaces.
* *The String is padded to the size of n.
null
*/
public static String leftPad( String str, int size )
{
return leftPad( str, size, " " );
}
/**
* Left pad a String with a specified string. Pad to a size of n.
*
* @param str String to pad out
* @param size size to pad to
* @param delim String to pad with
* @return left padded String
* @throws NullPointerException if str or delim is null
* @throws ArithmeticException if delim is the empty string
*/
public static String leftPad( String str, int size, String delim )
{
size = ( size - str.length() ) / delim.length();
if ( size > 0 )
{
str = repeat( delim, size ) + str;
}
return str;
}
// Stripping
//--------------------------------------------------------------------------
/**
* Remove whitespace from the front and back of a String.
* * @param str the String to remove whitespace from * @return the stripped String */ public static String strip( String str ) { return strip( str, null ); } /** *Remove a specified String from the front and back of a * String.
* *If whitespace is wanted to be removed, used the * {@link #strip(java.lang.String)} method.
* * @param str the String to remove a string from * @param delim the String to remove at start and end * @return the stripped String */ public static String strip( String str, String delim ) { str = stripStart( str, delim ); return stripEnd( str, delim ); } /** *Strip whitespace from the front and back of every String * in the array.
* * @param strs the Strings to remove whitespace from * @return the stripped Strings */ public static String[] stripAll( String[] strs ) { return stripAll( strs, null ); } /** *Strip the specified delimiter from the front and back of * every String in the array.
* * @param strs the Strings to remove a String from * @param delimiter the String to remove at start and end * @return the stripped Strings */ public static String[] stripAll( String[] strs, String delimiter ) { if ( ( strs == null ) || ( strs.length == 0 ) ) { return strs; } int sz = strs.length; String[] newArr = new String[sz]; for ( int i = 0; i < sz; i++ ) { newArr[i] = strip( strs[i], delimiter ); } return newArr; } /** *Strip any of a supplied String from the end of a String.
* *If the strip String is null, whitespace is
* stripped.
Strip any of a supplied String from the start of a String.
* *If the strip String is null, whitespace is
* stripped.
Convert a String to upper case, null String
* returns null.
Convert a String to lower case, null String
* returns null.
Uncapitalise a String.
* *That is, convert the first character into lower-case.
* null is returned as null.
Capitalise a String.
* *That is, convert the first character into title-case.
* null is returned as null.
Swaps the case of String.
* *Properly looks after making sure the start of words * are Titlecase and not Uppercase.
* *null is returned as null.
Capitalise all the words in a String.
* *Uses {@link Character#isWhitespace(char)} as a * separator between words.
* *null will return null.
Uncapitalise all the words in a string.
* *Uses {@link Character#isWhitespace(char)} as a * separator between words.
* *null will return null.
Get the String that is nested in between two instances of the * same String.
* *If str is null, will
* return null.
null
* @throws NullPointerException if tag is null
*/
public static String getNestedString( String str, String tag )
{
return getNestedString( str, tag, tag );
}
/**
* Get the String that is nested in between two Strings.
* * @param str the String containing nested-string * @param open the String before nested-string * @param close the String after nested-string * @return the String that was nested, ornull
* @throws NullPointerException if open or close is null
*/
public static String getNestedString( String str, String open, String close )
{
if ( str == null )
{
return null;
}
int start = str.indexOf( open );
if ( start != -1 )
{
int end = str.indexOf( close, start + open.length() );
if ( end != -1 )
{
return str.substring( start + open.length(), end );
}
}
return null;
}
/**
* How many times is the substring in the larger String.
* *null returns 0.
null
* @throws NullPointerException if sub is null
*/
public static int countMatches( String str, String sub )
{
if ( sub.equals( "" ) )
{
return 0;
}
if ( str == null )
{
return 0;
}
int count = 0;
int idx = 0;
while ( ( idx = str.indexOf( sub, idx ) ) != -1 )
{
count++;
idx += sub.length();
}
return count;
}
// Character Tests
//--------------------------------------------------------------------------
/**
* Checks if the String contains only unicode letters.
* *null will return false.
* An empty String will return true.
true if only contains letters, and is non-null
*/
public static boolean isAlpha( String str )
{
if ( str == null )
{
return false;
}
int sz = str.length();
for ( int i = 0; i < sz; i++ )
{
if ( Character.isLetter( str.charAt( i ) ) == false )
{
return false;
}
}
return true;
}
/**
* Checks if the String contains only whitespace.
* *null will return false. An
* empty String will return true.
true if only contains whitespace, and is non-null
*/
public static boolean isWhitespace( String str )
{
if ( str == null )
{
return false;
}
int sz = str.length();
for ( int i = 0; i < sz; i++ )
{
if ( ( Character.isWhitespace( str.charAt( i ) ) == false ) )
{
return false;
}
}
return true;
}
/**
* Checks if the String contains only unicode letters and
* space (' ').
null will return false. An
* empty String will return true.
true if only contains letters and space,
* and is non-null
*/
public static boolean isAlphaSpace( String str )
{
if ( str == null )
{
return false;
}
int sz = str.length();
for ( int i = 0; i < sz; i++ )
{
if ( ( Character.isLetter( str.charAt( i ) ) == false ) &&
( str.charAt( i ) != ' ' ) )
{
return false;
}
}
return true;
}
/**
* Checks if the String contains only unicode letters or digits.
* *null will return false. An empty
* String will return true.
true if only contains letters or digits,
* and is non-null
*/
public static boolean isAlphanumeric( String str )
{
if ( str == null )
{
return false;
}
int sz = str.length();
for ( int i = 0; i < sz; i++ )
{
if ( Character.isLetterOrDigit( str.charAt( i ) ) == false )
{
return false;
}
}
return true;
}
/**
* Checks if the String contains only unicode letters, digits
* or space (' ').
null will return false. An empty
* String will return true.
true if only contains letters, digits or space,
* and is non-null
*/
public static boolean isAlphanumericSpace( String str )
{
if ( str == null )
{
return false;
}
int sz = str.length();
for ( int i = 0; i < sz; i++ )
{
if ( ( Character.isLetterOrDigit( str.charAt( i ) ) == false ) &&
( str.charAt( i ) != ' ' ) )
{
return false;
}
}
return true;
}
/**
* Checks if the String contains only unicode digits.
* *null will return false.
* An empty String will return true.
true if only contains digits, and is non-null
*/
public static boolean isNumeric( String str )
{
if ( str == null )
{
return false;
}
int sz = str.length();
for ( int i = 0; i < sz; i++ )
{
if ( Character.isDigit( str.charAt( i ) ) == false )
{
return false;
}
}
return true;
}
/**
* Checks if the String contains only unicode digits or space
* (' ').
null will return false. An empty
* String will return true.
true if only contains digits or space,
* and is non-null
*/
public static boolean isNumericSpace( String str )
{
if ( str == null )
{
return false;
}
int sz = str.length();
for ( int i = 0; i < sz; i++ )
{
if ( ( Character.isDigit( str.charAt( i ) ) == false ) &&
( str.charAt( i ) != ' ' ) )
{
return false;
}
}
return true;
}
// Defaults
//--------------------------------------------------------------------------
/**
* Returns either the passed in Object as a String,
* or, if the Object is null, an empty
* String.
null
*/
public static String defaultString( Object obj )
{
return defaultString( obj, "" );
}
/**
* Returns either the passed in Object as a String,
* or, if the Object is null, a passed
* in default String.
null
* @return the passed in string, or the default if it was
* null
*/
public static String defaultString( Object obj, String defaultString )
{
return ( obj == null ) ? defaultString : obj.toString();
}
// Reversing
//--------------------------------------------------------------------------
/**
* Reverse a String.
* *null String returns null.
Reverses a String that is delimited by a specific character.
* *The Strings between the delimiters are not reversed.
* Thus java.lang.String becomes String.lang.java (if the delimiter
* is '.').
Reverses an array.
* *TAKEN FROM CollectionsUtils.
* * @param array the array to reverse */ private static void reverseArray( Object[] array ) { int i = 0; int j = array.length - 1; Object tmp; while ( j > i ) { tmp = array[j]; array[j] = array[i]; array[i] = tmp; j--; i++; } } // Abbreviating //-------------------------------------------------------------------------- /** * Turn "Now is the time for all good men" into "Now is the time for..." ** Specifically: *
* If str is less than max characters long, return it. * Else abbreviate it to (substring(str, 0, max-3) + "..."). * If maxWidth is less than 3, throw an IllegalArgumentException. * In no case will it return a string of length greater than maxWidth. * * @param maxWidth maximum length of result string **/ public static String abbreviate( String s, int maxWidth ) { return abbreviate( s, 0, maxWidth ); } /** * Turn "Now is the time for all good men" into "...is the time for..." *
* Works like abbreviate(String, int), but allows you to specify a "left edge" * offset. Note that this left edge is not necessarily going to be the leftmost * character in the result, or the first * character following the ellipses, but it will appear somewhere in the result. * In no case will it return a string of length greater than maxWidth. * * @param offset left edge of source string * @param maxWidth maximum length of result string **/ public static String abbreviate( String s, int offset, int maxWidth ) { if ( maxWidth < 4 ) { throw new IllegalArgumentException( "Minimum abbreviation width is 4" ); } if ( s.length() <= maxWidth ) { return s; } if ( offset > s.length() ) { offset = s.length(); } if ( ( s.length() - offset ) < ( maxWidth - 3 ) ) { offset = s.length() - ( maxWidth - 3 ); } if ( offset <= 4 ) { return s.substring( 0, maxWidth - 3 ) + "..."; } if ( maxWidth < 7 ) { throw new IllegalArgumentException( "Minimum abbreviation width with offset is 7" ); } if ( ( offset + ( maxWidth - 3 ) ) < s.length() ) { return "..." + abbreviate( s.substring( offset ), maxWidth - 3 ); } return "..." + s.substring( s.length() - ( maxWidth - 3 ) ); } // Difference //-------------------------------------------------------------------------- /** * Compare two strings, and return the portion where they differ. * (More precisely, return the remainder of the second string, * starting from where it's different from the first.) *
* E.g. strdiff("i am a machine", "i am a robot") -> "robot" * * @return the portion of s2 where it differs from s1; returns the empty string ("") if they are equal **/ public static String difference( String s1, String s2 ) { int at = differenceAt( s1, s2 ); if ( at == -1 ) { return ""; } return s2.substring( at ); } /** * Compare two strings, and return the index at which the strings begin to differ. *
* E.g. strdiff("i am a machine", "i am a robot") -> 7 *
* * @return the index where s2 and s1 begin to differ; -1 if they are equal **/ public static int differenceAt( String s1, String s2 ) { int i; for ( i = 0; ( i < s1.length() ) && ( i < s2.length() ); ++i ) { if ( s1.charAt( i ) != s2.charAt( i ) ) { break; } } if ( ( i < s2.length() ) || ( i < s1.length() ) ) { return i; } return -1; } public static String interpolate( String text, Map namespace ) { Iterator keys = namespace.keySet().iterator(); while ( keys.hasNext() ) { String key = keys.next().toString(); Object obj = namespace.get( key ); if ( obj == null ) { throw new NullPointerException( "The value of the key '" + key + "' is null." ); } String value = obj.toString(); text = replace( text, "${" + key + "}", value ); if ( !key.contains( " " ) ) { text = replace( text, "$" + key, value ); } } return text; } public static String removeAndHump( String data, String replaceThis ) { String temp; StringBuilder out = new StringBuilder(); temp = data; StringTokenizer st = new StringTokenizer( temp, replaceThis ); while ( st.hasMoreTokens() ) { String element = (String) st.nextElement(); out.append( capitalizeFirstLetter( element ) ); } return out.toString(); } public static String capitalizeFirstLetter( String data ) { char firstLetter = Character.toTitleCase( data.substring( 0, 1 ).charAt( 0 ) ); String restLetters = data.substring( 1 ); return firstLetter + restLetters; } public static String lowercaseFirstLetter( String data ) { char firstLetter = Character.toLowerCase( data.substring( 0, 1 ).charAt( 0 ) ); String restLetters = data.substring( 1 ); return firstLetter + restLetters; } public static String addAndDeHump( String view ) { StringBuilder sb = new StringBuilder(); for ( int i = 0; i < view.length(); i++ ) { if ( ( i != 0 ) && Character.isUpperCase( view.charAt( i ) ) ) { sb.append( '-' ); } sb.append( view.charAt( i ) ); } return sb.toString().trim().toLowerCase( Locale.ENGLISH ); } /** *Quote and escape a String with the given character, handling null.
* StringUtils.quoteAndEscape(null, *) = null
* StringUtils.quoteAndEscape("", *) = ""
* StringUtils.quoteAndEscape("abc", '"') = abc
* StringUtils.quoteAndEscape("a\"bc", '"') = "a\"bc"
* StringUtils.quoteAndEscape("a\"bc", '\'') = 'a\"bc'
*
*
* @param source
* @param quoteChar
* @return the String quoted and escaped
* @since 1.5.1
* @see #quoteAndEscape(String, char, char[], char[], char, boolean)
*/
public static String quoteAndEscape( String source,
char quoteChar )
{
return quoteAndEscape( source, quoteChar, new char[]{ quoteChar }, new char[]{ ' ' }, '\\', false );
}
/**
* Quote and escape a String with the given character, handling null.
Checks if String contains a search character, handling null.
* This method uses {@link String#indexOf(int)}.
A null or empty ("") String will return false.
* StringUtils.contains(null, *) = false
* StringUtils.contains("", *) = false
* StringUtils.contains("abc", 'a') = true
* StringUtils.contains("abc", 'z') = false
*
*
* @param str the String to check, may be null
* @param searchChar the character to find
* @return true if the String contains the search character,
* false if not or null string input
* @since 1.5.7
*/
public static boolean contains( String str, char searchChar )
{
if ( isEmpty( str ) )
{
return false;
}
return str.indexOf( searchChar ) >= 0;
}
/**
* Checks if String contains a search String, handling null.
* This method uses {@link String#indexOf(int)}.
A null String will return false.
* StringUtils.contains(null, *) = false
* StringUtils.contains(*, null) = false
* StringUtils.contains("", "") = true
* StringUtils.contains("abc", "") = true
* StringUtils.contains("abc", "a") = true
* StringUtils.contains("abc", "z") = false
*
*
* @param str the String to check, may be null
* @param searchStr the String to find, may be null
* @return true if the String contains the search String,
* false if not or null string input
* @since 1.5.7
*/
public static boolean contains( String str, String searchStr )
{
if ( str == null || searchStr == null )
{
return false;
}
return str.contains( searchStr );
}
}
plexus-utils-plexus-utils-3.0.22/src/main/java/org/codehaus/plexus/util/SweeperPool.java 0000664 0000000 0000000 00000022415 12510777323 0031365 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util;
/*
* Copyright The Codehaus Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import java.util.ArrayList;
/**
* Pools a bunch of objects . Runs a sweeper periodically to
* keep it down to size. The objects in the pool first get disposed first.
*
* @author Bert van Brakel
* @version $Id$
*/
public class SweeperPool
{
/***/
private static final boolean DEBUG = false;
/** Sweeps the pool periodically to trim it's size */
private transient Sweeper sweeper;
/** Absolute maxiumuim size of the pool.*/
private transient int maxSize;
/** The size the pool gets trimmed down to */
private transient int minSize;
/** When the sweeper runs
* and the pool is over this size, then the pool is trimmed */
private int triggerSize;
/** Holds the pooled objects */
private ArrayList