[marf-cvs] marf/src/marf/util Arrays.java,1.17,1.18

[Susan <sus...@us...>]

Update of /cvsroot/marf/marf/src/marf/util
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv19298

Modified Files:
	Arrays.java 
Log Message:
Using wrapper call to give copy() methods different parameters; add comments according to Java Doc comments.

Index: Arrays.java
===================================================================
RCS file: /cvsroot/marf/marf/src/marf/util/Arrays.java,v
retrieving revision 1.17
retrieving revision 1.18
diff -C2 -d -r1.17 -r1.18
*** Arrays.java	16 Jun 2005 19:58:58 -0000	1.17
--- Arrays.java	16 Jun 2005 20:24:22 -0000	1.18
***************
*** 94,103 ****
  	}
  
! /*
! TODO:
! 	static void copy(boolean[]...)
! 	static void copy(byte[]...)
! 	static void copy(char[]...)
! */
  
  	/**
--- 94,295 ----
  	}
  
!     /**
! 	 * Copies N boolean elements from source to destination starting at certain index in the <b>destination</b>.
! 	 * A wrapper call to <code>System.arraycopy()</code>.
! 	 *
! 	 * @param pabDestination array to copy to
! 	 * @param piDestinationStartIndex starting index in the destination to start copying to
! 	 * @param pabSource array of booleans to copy from
! 	 * @param piSourceStartIndex starting index in the source to start copying from
! 	 * @param piHowMany N; the number of elements to copy from the source to the destination
! 	 */
! 	public static void copy
! 	(
! 		boolean[] pabDestination,
! 		final int piDestinationStartIndex,
! 		boolean[] pabSource,
! 		final int piSourceStartIndex,
! 		final int piHowMany
! 	)
! 	{
! 		System.arraycopy
! 		(
! 			pabSource,
! 			piSourceStartIndex,
! 			pabDestination,
! 			piDestinationStartIndex,
! 			piHowMany
! 		);
! 	}
!     /**
! 	 * Copies N byte elements from source to destination starting at certain index in the <b>destination</b>.
! 	 * A wrapper call to <code>System.arraycopy()</code>.
! 	 *
! 	 * @param patDestination array to copy to
! 	 * @param piDestinationStartIndex starting index in the destination to start copying to
! 	 * @param patSource array of bytes to copy from
! 	 * @param piSourceStartIndex starting index in the source to start copying from
! 	 * @param piHowMany N; the number of elements to copy from the source to the destination
! 	 */
! 	public static void copy
! 	(
! 		byte[] patDestination,
! 		final int piDestinationStartIndex,
! 		byte[] patSource,
! 		final int piSourceStartIndex,
! 		final int piHowMany
! 	)
! 	{
! 		System.arraycopy
! 		(
! 			patSource,
! 			piSourceStartIndex,
! 			patDestination,
! 			piDestinationStartIndex,
! 			piHowMany
! 		);
! 	}
!     /**
! 	 * Copies N character elements from source to destination starting at certain index in the <b>destination</b>.
! 	 * A wrapper call to <code>System.arraycopy()</code>.
! 	 *
! 	 * @param pacDestination array to copy to
! 	 * @param piDestinationStartIndex starting index in the destination to start copying to
! 	 * @param pacSource array of characters to copy from
! 	 * @param piSourceStartIndex starting index in the source to start copying from
! 	 * @param piHowMany N; the number of elements to copy from the source to the destination
! 	 */
! 	public static void copy
! 	(
! 		char[] pacDestination,
! 		final int piDestinationStartIndex,
! 		char[] pacSource,
! 		final int piSourceStartIndex,
! 		final int piHowMany
! 	)
! 	{
! 		System.arraycopy
! 		(
! 			pacSource,
! 			piSourceStartIndex,
! 			pacDestination,
! 			piDestinationStartIndex,
! 			piHowMany
! 		);
! 	}
! 
! 
!     /**
! 	 * Copies N integer elements from source to destination starting at certain index in the <b>destination</b>.
! 	 * A wrapper call to <code>System.arraycopy()</code>.
! 	 *
! 	 * @param paiDestination array to copy to
! 	 * @param piDestinationStartIndex starting index in the destination to start copying to
! 	 * @param paiSource array of integers to copy from
! 	 * @param piSourceStartIndex starting index in the source to start copying from
! 	 * @param piHowMany N; the number of elements to copy from the source to the destination
! 	 */
! 	public static void copy
! 	(
! 		int[] paiDestination,
! 		final int piDestinationStartIndex,
! 		int[] paiSource,
! 		final int piSourceStartIndex,
! 		final int piHowMany
! 	)
! 	{
! 		System.arraycopy
! 		(
! 			paiSource,
! 			piSourceStartIndex,
! 			paiDestination,
! 			piDestinationStartIndex,
! 			piHowMany
! 		);
! 	}
!     /**
! 	 * Copies N short elements from source to destination starting at certain index in the <b>destination</b>.
! 	 * A wrapper call to <code>System.arraycopy()</code>.
! 	 *
! 	 * @param pasDestination array to copy to
! 	 * @param piDestinationStartIndex starting index in the destination to start copying to
! 	 * @param pasSource array of shorts to copy from
! 	 * @param piSourceStartIndex starting index in the source to start copying from
! 	 * @param piHowMany N; the number of elements to copy from the source to the destination
! 	 */
! 	public static void copy
! 	(
! 		short[] pasDestination,
! 		final int piDestinationStartIndex,
! 		short[] pasSource,
! 		final int piSourceStartIndex,
! 		final int piHowMany
! 	)
! 	{
! 		System.arraycopy
! 		(
! 			pasSource,
! 			piSourceStartIndex,
! 			pasDestination,
! 			piDestinationStartIndex,
! 			piHowMany
! 		);
! 	}
!     /**
! 	 * Copies N long elements from source to destination starting at certain index in the <b>destination</b>.
! 	 * A wrapper call to <code>System.arraycopy()</code>.
! 	 *
! 	 * @param palDestination array to copy to
! 	 * @param piDestinationStartIndex starting index in the destination to start copying to
! 	 * @param palSource array of longs to copy from
! 	 * @param piSourceStartIndex starting index in the source to start copying from
! 	 * @param piHowMany N; the number of elements to copy from the source to the destination
! 	 */
! 	public static void copy
! 	(
! 		long[] palDestination,
! 		final int piDestinationStartIndex,
! 		long[] palSource,
! 		final int piSourceStartIndex,
! 		final int piHowMany
! 	)
! 	{
! 		System.arraycopy
! 		(
! 			palSource,
! 			piSourceStartIndex,
! 			palDestination,
! 			piDestinationStartIndex,
! 			piHowMany
! 		);
! 	}
!     /**
! 	 * Copies N float elements from source to destination starting at certain index in the <b>destination</b>.
! 	 * A wrapper call to <code>System.arraycopy()</code>.
! 	 *
! 	 * @param pafDestination array to copy to
! 	 * @param piDestinationStartIndex starting index in the destination to start copying to
! 	 * @param pafSource array of float to copy from
! 	 * @param piSourceStartIndex starting index in the source to start copying from
! 	 * @param piHowMany N; the number of elements to copy from the source to the destination
! 	 */
! 	public static void copy
! 	(
! 		float[] pafDestination,
! 		final int piDestinationStartIndex,
! 		float[] pafSource,
! 		final int piSourceStartIndex,
! 		final int piHowMany
! 	)
! 	{
! 		System.arraycopy
! 		(
! 			pafSource,
! 			piSourceStartIndex,
! 			pafDestination,
! 			piDestinationStartIndex,
! 			piHowMany
! 		);
! 	}
  
  	/**
***************
*** 130,135 ****
--- 322,437 ----
  	}
  
+     /**
+ 	 * Generic <code>copy()</code> routine based on <code>System.arraycopy()</code>.
+ 	 *
+ 	 * @param poDestination destination array of copy
+ 	 * @param piStartIndex where in the destination array start placing the values
+ 	 * @param poSource source of elements
+ 	 * @param piHowMany how many elements should be copied from the source to destination
+ 	 */
+ 	public static void copy(Object poDestination, final int piStartIndex, Object poSource, final int piHowMany)
+ 	{
+ 		copy(poDestination, piStartIndex, poSource, 0, piHowMany);
+ 	}
+     /**
+      * Generic <code>copy()</code> routine based on <code>System.arraycopy()</code>
+ 	 * for Object arrays.
+ 	 *
+ 	 * @param paoDestination destination array of objects to copy to
+ 	 * @param piStartIndex where in the destination array start placing the values
+ 	 * @param paoSource source of Object elements
+ 	 * @param piHowMany how many elements should be copied from the source to destination
+ 	 */
+ 	public static void copy(Object[] paoDestination, final int piStartIndex, Object[] paoSource, final int piHowMany)
+ 	{
+ 		copy(paoDestination, piStartIndex, paoSource, 0, piHowMany);
+ 	}
+     /**
+ 	 * Copies N character elements from source to destination starting at certain index in the <b>destination</b>.
+ 	 *
+ 	 * @param pacDestination array to copy to
+ 	 * @param piStartIndex starting index in the destination to start copying to
+ 	 * @param pacSource array of characters to copy from
+ 	 * @param piHowMany N; the number of elements to copy from the source to the destination
+ 	 */
+ 	public static void copy(char[] pacDestination, final int piStartIndex, char[] pacSource, final int piHowMany)
+ 	{
+ 		copy(pacDestination, piStartIndex, pacSource, 0, piHowMany);
+ 	}
+     /**
+ 	 * Copies N boolean elements from source to destination starting at certain index in the <b>destination</b>.
+ 	 *
+ 	 * @param pabDestination array to copy to
+ 	 * @param piStartIndex starting index in the destination to start copying to
+ 	 * @param pabSource array of booleans to copy from
+ 	 * @param piHowMany N; the number of elements to copy from the source to the destination
+ 	 */
+ 	public static void copy(boolean[] pabDestination, final int piStartIndex, boolean[] pabSource, final int piHowMany)
+ 	{
+ 		copy(pabDestination, piStartIndex, pabSource, 0, piHowMany);
+ 	}
+     /**
+ 	 * Copies N byte elements from source to destination starting at certain index in the <b>destination</b>.
+ 	 *
+ 	 * @param patDestination array to copy to
+ 	 * @param piStartIndex starting index in the destination to start copying to
+ 	 * @param patSource array of bytes to copy from
+ 	 * @param piHowMany N; the number of elements to copy from the source to the destination
+ 	 */
+ 	public static void copy(byte[] patDestination, final int piStartIndex, byte[] patSource, final int piHowMany)
+ 	{
+ 		copy(patDestination, piStartIndex, patSource, 0, piHowMany);
+ 	}
+     /**
+ 	 * Copies N integer elements from source to destination starting at certain index in the <b>destination</b>.
+ 	 *
+ 	 * @param paiDestination array to copy to
+ 	 * @param piStartIndex starting index in the destination to start copying to
+ 	 * @param paiSource array of integers to copy from
+ 	 * @param piHowMany N; the number of elements to copy from the source to the destination
+ 	 */
+ 	public static void copy(int[] paiDestination, final int piStartIndex, int[] paiSource, final int piHowMany)
+ 	{
+ 		copy(paiDestination, piStartIndex, paiSource, 0, piHowMany);
+ 	}
+     /**
+ 	 * Copies N short elements from source to destination starting at certain index in the <b>destination</b>.
+ 	 *
+ 	 * @param pasDestination array to copy to
+ 	 * @param piStartIndex starting index in the destination to start copying to
+ 	 * @param pasSource array of shorts to copy from
+ 	 * @param piHowMany N; the number of elements to copy from the source to the destination
+ 	 */
+ 	public static void copy(short[] pasDestination, final int piStartIndex, short[] pasSource, final int piHowMany)
+ 	{
+ 		copy(pasDestination, piStartIndex, pasSource, 0, piHowMany);
+ 	}
+     /**
+ 	 * Copies N long elements from source to destination starting at certain index in the <b>destination</b>.
+ 	 *
+ 	 * @param palDestination array to copy to
+ 	 * @param piStartIndex starting index in the destination to start copying to
+ 	 * @param palSource array of longs to copy from
+ 	 * @param piHowMany N; the number of elements to copy from the source to the destination
+ 	 */
+ 	public static void copy(long[] palDestination, final int piStartIndex, long[] palSource, final int piHowMany)
+ 	{
+ 		copy(palDestination, piStartIndex, palSource, 0, piHowMany);
+ 	}
+     /**
+ 	 * Copies N float elements from source to destination starting at certain index in the <b>destination</b>.
+ 	 *
+ 	 * @param pafDestination array to copy to
+ 	 * @param piStartIndex starting index in the destination to start copying to
+ 	 * @param pafSource array of floats to copy from
+ 	 * @param piHowMany N; the number of elements to copy from the source to the destination
+ 	 */
+ 	public static void copy(float[] pafDestination, final int piStartIndex, float[] pafSource, final int piHowMany)
+ 	{
+ 		copy(pafDestination, piStartIndex, pafSource, 0, piHowMany);
+ 	}
  	/**
  	 * Copies N double elements from source to destination starting at certain index in the <b>destination</b>.
+ 	 *
  	 * @param padDestination array to copy to
  	 * @param piStartIndex starting index in the destination to start copying to
***************
*** 142,147 ****
--- 444,541 ----
  	}
  
+ 
+     /**
+      * Generic <code>copy()</code> routine based on <code>System.arraycopy()</code>
+ 	 * for Object arrays.
+ 	 *
+ 	 * @param paoDestination destination array of objects to copy to
+ 	 * @param piStartIndex starting index in the destination to start copying to
+ 	 * @param paoSource source of object elements
+ 	 */
+ 	public static void copy(Object[] paoDestination, final int piStartIndex, Object[] paoSource)
+ 	{
+ 		copy(paoDestination, piStartIndex, paoSource, paoSource.length);
+ 	}
+     /**
+ 	 * Copies source to destination starting at certain index in the <b>destination</b>.
+ 	 *
+ 	 * @param pabDestination array to copy to
+ 	 * @param piStartIndex starting index in the destination to start copying to
+ 	 * @param pabSource array of booleans to copy from
+ 	 */
+ 	public static void copy(boolean[] pabDestination, final int piStartIndex, boolean[] pabSource)
+ 	{
+ 		copy(pabDestination, piStartIndex, pabSource, pabSource.length);
+ 	}
+     /**
+ 	 * Copies source to destination starting at certain index in the <b>destination</b>.
+ 	 *
+ 	 * @param pabyDestination array to copy to
+ 	 * @param piStartIndex starting index in the destination to start copying to
+ 	 * @param pabySource array of bytes to copy from
+ 	 */
+ 	public static void copy(byte[] patDestination, final int piStartIndex, byte[] patSource)
+ 	{
+ 		copy(patDestination, piStartIndex, patSource, patSource.length);
+ 	}
+     /**
+ 	 * Copies source to destination starting at certain index in the <b>destination</b>.
+ 	 *
+ 	 * @param pacDestination array to copy to
+ 	 * @param piStartIndex starting index in the destination to start copying to
+ 	 * @param pacSource array of characters to copy from
+ 	 */
+ 	public static void copy(char[] pacDestination, final int piStartIndex, char[] pacSource)
+ 	{
+ 		copy(pacDestination, piStartIndex, pacSource, pacSource.length);
+ 	}
+     /**
+ 	 * Copies source to destination starting at certain index in the <b>destination</b>.
+ 	 *
+ 	 * @param paiDestination array to copy to
+ 	 * @param piStartIndex starting index in the destination to start copying to
+ 	 * @param paiSource array of integers to copy from
+ 	 */
+ 	public static void copy(int[] paiDestination, final int piStartIndex, int[] paiSource)
+ 	{
+ 		copy(paiDestination, piStartIndex, paiSource, paiSource.length);
+ 	}
+     /**
+ 	 * Copies source to destination starting at certain index in the <b>destination</b>.
+ 	 *
+ 	 * @param pasDestination array to copy to
+ 	 * @param piStartIndex starting index in the destination to start copying to
+ 	 * @param pasSource array of shorts to copy from
+ 	 */
+ 	public static void copy(short[] pasDestination, final int piStartIndex, short[] pasSource)
+ 	{
+ 		copy(pasDestination, piStartIndex, pasSource, pasSource.length);
+ 	}
+     /**
+ 	 * Copies source to destination starting at certain index in the <b>destination</b>.
+ 	 *
+ 	 * @param palDestination array to copy to
+ 	 * @param piStartIndex starting index in the destination to start copying to
+ 	 * @param palSource array of longs to copy from
+ 	 */
+ 	public static void copy(long[] palDestination, final int piStartIndex, long[] palSource)
+ 	{
+ 		copy(palDestination, piStartIndex, palSource, palSource.length);
+ 	}
+     /**
+ 	 * Copies source to destination starting at certain index in the <b>destination</b>.
+ 	 *
+ 	 * @param pafDestination array to copy to
+ 	 * @param piStartIndex starting index in the destination to start copying to
+ 	 * @param pafSource array of floats to copy from
+ 	 */
+ 	public static void copy(float[] pafDestination, final int piStartIndex, float[] pafSource)
+ 	{
+ 		copy(pafDestination, piStartIndex, pafSource, pafSource.length);
+ 	}
+ 
  	/**
  	 * Copies source to destination starting at certain index in the <b>destination</b>.
+ 	 *
  	 * @param padDestination array to copy to
  	 * @param piStartIndex starting index in the destination to start copying to
***************
*** 153,158 ****
--- 547,643 ----
  	}
  
+     /**
+      * Generic <code>copy()</code> routine based on <code>System.arraycopy()</code>.
+ 	 *
+ 	 * @param poDestination destination array of copy
+ 	 * @param poSource source of elements
+ 	 * @param piHowMany N; the number of elements to copy from the source to the destination
+ 	 */
+ 	public static void copy(Object poDestination, Object poSource, final int piHowMany)
+ 	{
+ 		copy(poDestination, 0, poSource, piHowMany);
+ 	}
+     /**
+      * Generic <code>copy()</code> routine based on <code>System.arraycopy()</code>
+ 	 * for Object arrays.
+ 	 *
+ 	 * @param paoDestination array to copy to
+ 	 * @param paoSource source of object elements
+ 	 * @param piHowMany N; the number of elements to copy from the source to the destination
+ 	 */
+ 	public static void copy(Object[] paoDestination, Object[] paoSource, final int piHowMany)
+ 	{
+ 		copy(paoDestination, 0, paoSource, piHowMany);
+ 	}
+     /**
+ 	 * Copies N character elements from source to destination.
+ 	 *
+ 	 * @param pacDestination array to copy to
+ 	 * @param pacSource array of characters to copy from
+ 	 * @param piHowMany N; the number of elements to copy from the source to the destination
+ 	 */
+ 	public static void copy(char[] pacDestination, char[] pacSource, final int piHowMany)
+ 	{
+ 		copy(pacDestination, 0, pacSource, piHowMany);
+ 	}
+     /**
+ 	 * Copies N boolean elements from source to destination.
+ 	 *
+ 	 * @param pabDestination array to copy to
+ 	 * @param pabSource array of boolean to copy from
+ 	 * @param piHowMany N; the number of elements to copy from the source to the destination
+ 	 */
+ 	public static void copy(boolean[] pabDestination, boolean[] pabSource, final int piHowMany)
+ 	{
+ 		copy(pabDestination, 0, pabSource, piHowMany);
+ 	}
+     /**
+ 	 * Copies N byte elements from source to destination.
+ 	 *
+ 	 * @param patDestination array to copy to
+ 	 * @param patSource array of bytes to copy from
+ 	 * @param piHowMany N; the number of elements to copy from the source to the destination
+ 	 */
+ 	public static void copy(byte[] patDestination, byte[] patSource, final int piHowMany)
+ 	{
+ 		copy(patDestination, 0, patSource, piHowMany);
+ 	}
+     /**
+ 	 * Copies N short elements from source to destination.
+ 	 *
+ 	 * @param pasDestination array to copy to
+ 	 * @param pasSource array of shorts to copy from
+ 	 * @param piHowMany N; the number of elements to copy from the source to the destination
+ 	 */
+ 	public static void copy(short[] pasDestination, short[] pasSource, final int piHowMany)
+ 	{
+ 		copy(pasDestination, 0, pasSource, piHowMany);
+ 	}
+     /**
+ 	 * Copies N long elements from source to destination.
+ 	 *
+ 	 * @param palDestination array to copy to
+ 	 * @param palSource array of longs to copy from
+ 	 * @param piHowMany N; the number of elements to copy from the source to the destination
+ 	 */
+ 	public static void copy(long[] palDestination, long[] palSource, final int piHowMany)
+ 	{
+ 		copy(palDestination, 0, palSource, piHowMany);
+ 	}
+     /**
+ 	 * Copies N float elements from source to destination.
+ 	 *
+ 	 * @param pafDestination array to copy to
+ 	 * @param pafSource array of floats to copy from
+ 	 * @param piHowMany N; the number of elements to copy from the source to the destination
+ 	 */
+ 	public static void copy(float[] pafDestination, float[] pafSource, final int piHowMany)
+ 	{
+ 		copy(pafDestination, 0, pafSource, piHowMany);
+ 	}
+ 
  	/**
  	 * Copies N double elements from source to destination.
+ 	 *
  	 * @param padDestination array to copy to
  	 * @param padSource array of doubles to copy from
***************
*** 166,169 ****
--- 651,655 ----
  	/**
  	 * Copies N int elements from source to destination.
+ 	 *
  	 * @param paiDestination array to copy to
  	 * @param paiSource array of ints to copy from
***************
*** 175,188 ****
  	}
  
- /*
- TODO:
- 	static void copy(float[]...)
- 	static void copy(int[]...)
- 	static void copy(long[]...)
- 	static void copy(Object[]...)
- 	static void copy(short[]...)
- */
- 
- 
  	public static boolean equals(boolean[] a, boolean[] a2)
  	{
--- 661,664 ----
***************
*** 326,329 ****
--- 802,806 ----
  	/**
  	 * A wrapper of java.util.Arrays.sort(Object[], Comparator).
+ 	 *
  	 * @param paoArrayToSort array of objects to sort
  	 * @param poComparator comparator object to use while sorting
***************
*** 336,339 ****
--- 813,817 ----
  	/**
  	 * A wrapper of java.util.Arrays.sort(double[]).
+ 	 *
  	 * @param padArrayToSort array of doubles to sort
  	 */
***************
*** 349,352 ****
--- 827,831 ----
  	/**
  	 * Converts array of doubles to Vector.
+ 	 *
  	 * @param padData array of double data
  	 * @return equivalent collection of Double objects
***************
*** 355,367 ****
  	{
  		Vector oVector = new Vector(padData.length);
! 		
  		for(int i = 0; i < padData.length; i++)
  			oVector.add(new Double(padData[i]));
! 		
  		return oVector;
  	}
! 	
  	/**
  	 * Converts array of ints to Vector.
  	 * @param paiData array of int data
  	 * @return equivalent collection of Integer objects
--- 834,847 ----
  	{
  		Vector oVector = new Vector(padData.length);
! 
  		for(int i = 0; i < padData.length; i++)
  			oVector.add(new Double(padData[i]));
! 
  		return oVector;
  	}
! 
  	/**
  	 * Converts array of ints to Vector.
+ 	 *
  	 * @param paiData array of int data
  	 * @return equivalent collection of Integer objects
***************
*** 370,383 ****
  	{
  		Vector oVector = new Vector(paiData.length);
! 		
  		for(int i = 0; i < paiData.length; i++)
  			oVector.add(new Integer(paiData[i]));
! 		
  		return oVector;
  	}
! 	
  	/**
  	 * Provides an array-of-objects-to-List bridge.
  	 * Wraps <code>java.util.Arrays.asList()</code>.
  	 * @param paoObjects array of objects
  	 * @return corresponding List collection
--- 850,864 ----
  	{
  		Vector oVector = new Vector(paiData.length);
! 
  		for(int i = 0; i < paiData.length; i++)
  			oVector.add(new Integer(paiData[i]));
! 
  		return oVector;
  	}
! 
  	/**
  	 * Provides an array-of-objects-to-List bridge.
  	 * Wraps <code>java.util.Arrays.asList()</code>.
+ 	 *
  	 * @param paoObjects array of objects
  	 * @return corresponding List collection
***************
*** 394,397 ****
--- 875,879 ----
  	/**
  	 * Returns source code revision information.
+ 	 *
  	 * @return revision string
  	 */