/ - Diff - | gvSIG desktop 1 - gvSIG

Revision 20887

     package freenet.support;
     import java.util.BitSet;
     /**
      * Number in hexadecimal format are used throughout Freenet.
+     *
      * <p>Unless otherwise stated, the conventions follow the rules outlined in the
      * Java Language Specification.</p>
+     *
      * @author syoung
      */
     public class HexUtil {
     	private HexUtil() {
+    	}
     	/**
     	 * Converts a byte array into a string of upper case hex chars.
+    	 *
     	 * @param bs
     	 *            A byte array
     	 * @param off
     	 *            The index of the first byte to read
     	 * @param length
     	 *            The number of bytes to read.
     	 * @return the string of hex chars.
     	 */
     	public static final String bytesToHex(byte[] bs, int off, int length) {
     		StringBuffer sb = new StringBuffer(length * 2);
     		bytesToHexAppend(bs, off, length, sb);
     		return sb.toString();
+    	}
     	public static final void bytesToHexAppend(
     		byte[] bs,
     		int off,
     		int length,
     		StringBuffer sb) {
     		sb.ensureCapacity(sb.length() + length * 2);
     		for (int i = off; i < (off + length) && i < bs.length; i++) {
     			sb.append(Character.forDigit((bs[i] >>> 4) & 0xf, 16));
     			sb.append(Character.forDigit(bs[i] & 0xf, 16));
+    		}
+    	}
     	public static final String bytesToHex(byte[] bs) {
     		return bytesToHex(bs, 0, bs.length);
+    	}
     	public static final byte[] hexToBytes(String s) {
     		return hexToBytes(s, 0);
+    	}
     	public static final byte[] hexToBytes(String s, int off) {
     		byte[] bs = new byte[off + (1 + s.length()) / 2];
     		hexToBytes(s, bs, off);
     		return bs;
+    	}
     	/**
     	 * Converts a String of hex characters into an array of bytes.
+    	 *
     	 * @param s
     	 *            A string of hex characters (upper case or lower) of even
     	 *            length.
     	 * @param out
     	 *            A byte array of length at least s.length()/2 + off
     	 * @param off
     	 *            The first byte to write of the array
     	 */
     	public static final void hexToBytes(String s, byte[] out, int off)
     		throws NumberFormatException, IndexOutOfBoundsException {
     		int slen = s.length();
     		if ((slen % 2) != 0) {
     			s = '0' + s;
+    		}
     		if (out.length < off + slen / 2) {
     			throw new IndexOutOfBoundsException(
     				"Output buffer too small for input ("
     					+ out.length
     					+ "<"
     					+ off
     					+ slen / 2
     					+ ")");
+    		}
     		// Safe to assume the string is even length
     		byte b1, b2;
     		for (int i = 0; i < slen; i += 2) {
     			b1 = (byte) Character.digit(s.charAt(i), 16);
     			b2 = (byte) Character.digit(s.charAt(i + 1), 16);
     			if (b1 < 0 || b2 < 0) {
     				throw new NumberFormatException();
+    			}
     			out[off + i / 2] = (byte) (b1 << 4 | b2);
+    		}
+    	}
     	/**
     	 * Pack the bits in ba into a byte[].
     	 */
     	public final static byte[] bitsToBytes(BitSet ba, int size) {
     		int bytesAlloc = countBytesForBits(size);
     		byte[] b = new byte[bytesAlloc];
     		StringBuffer sb = new StringBuffer();
     		for(int i=0;i<b.length;i++) {
     			short s = 0;
     			for(int j=0;j<8;j++) {
     				int idx = i*8+j;
     				boolean val =
     					idx > size ? false :
     						ba.get(idx);
     				s |= val ? (1<<j) : 0;
     				sb.append(val ? '1' : '0');
+    			}
     			if(s > 255) throw new IllegalStateException("WTF? s = "+s);
     			b[i] = (byte)s;
+    		}
     		return b;
+    	}
     	/**
     	 * Pack the bits in ba into a byte[] then convert that
     	 * to a hex string and return it.
     	 */
     	public final static String bitsToHexString(BitSet ba, int size) {
     		return bytesToHex(bitsToBytes(ba, size));
+    	}
     	/**
     	 * @return the number of bytes required to represent the
     	 * bitset
     	 */
     	public static int countBytesForBits(int size) {
     		// Brackets matter here! == takes precedence over the rest
     		return (size/8) + ((size % 8) == 0 ? 0:1);
+    	}
     	/**
     	 * Read bits from a byte array into a bitset
     	 * @param b the byte[] to read from
     	 * @param ba the bitset to write to
     	 */
     	public static void bytesToBits(byte[] b, BitSet ba, int maxSize) {
     		int x = 0;
     		for(int i=0;i<b.length;i++) {
     			for(int j=0;j<8;j++) {
     				if(x > maxSize) break;
     				int mask = 1 << j;
     				boolean value = (mask & b[i]) != 0;
     				ba.set(x, value);
     				x++;
+    			}
+    		}
+    	}
     	/**
     	 * Read a hex string of bits and write it into a bitset
     	 * @param s hex string of the stored bits
     	 * @param ba the bitset to store the bits in
     	 * @param length the maximum number of bits to store
     	 */
     	public static void hexToBits(String s, BitSet ba, int length) {
     		byte[] b = hexToBytes(s);
     		bytesToBits(b, ba, length);
+    	}
+    }

     /* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana
+     *
      * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.
+     *
      * This program is free software; you can redistribute it and/or
      * modify it under the terms of the GNU General Public License
      * as published by the Free Software Foundation; either version 2
      * of the License, or (at your option) any later version.
+     *
      * This program is distributed in the hope that it will be useful,
      * but WITHOUT ANY WARRANTY; without even the implied warranty of
      * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      * GNU General Public License for more details.
+     *
      * You should have received a copy of the GNU General Public License
      * along with this program; if not, write to the Free Software
      * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.
+     *
      * For more information, contact:
+     *
      *  Generalitat Valenciana
      *   Conselleria d'Infraestructures i Transport
      *   Av. Blasco Ib??ez, 50
      *   46010 VALENCIA
      *   SPAIN
+     *
      *      +34 963862235
      *   gvsig@gva.es
      *      www.gvsig.gva.es
+     *
      *    or
+     *
      *   IVER T.I. S.A
      *   Salamanca 50
      *   46005 Valencia
      *   Spain
+     *
      *   +34 963163400
      *   dac@iver.es
      */
     package com.iver.cit.gvsig.fmap.drivers.dgn;
     import java.math.BigInteger;
     /**
      * Clase que engloba m?todos para trabajar con bytes.
+     *
      * @author Vicente Caballero Navarro
      */
     public class ByteUtils {
     	public static final int SIZE_BOOL = 1;
     	public static final int SIZE_SHORT = 2;
     	public static final int SIZE_INT = 4;
     	public static final int SIZE_LONG = 8;
     	public static final int SIZE_DOUBLE = 8;
     	/** A nibble->char mapping for printing out bytes. */
     	public static final char[] digits = {
     			'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd',
     			'e', 'f'
     		};
     	/**
     	 * Return the <code>int</code> represented by the bytes in
     	 * <code>data</code> staring at offset <code>offset[0]</code>.
+    	 *
     	 * @param data the array from which to read
     	 * @param offset A single element array whose first element is the index in
     	 * 		  data from which to begin reading on function entry, and which on
     	 * 		  function exit has been incremented by the number of bytes read.
+    	 *
     	 * @return the value of the <code>int</code> decoded
     	 */
     	public static final int bytesToInt(byte[] data, int[] offset) {
     		/**
     		 * TODO: We use network-order within OceanStore, but temporarily
     		 * supporting intel-order to work with some JNI code until JNI code is
     		 * set to interoperate with network-order.
     		 */
     		int result = 0;
     		for (int i = 0; i < SIZE_INT; ++i) {
     			result <<= 8;
     			result |= byteToUnsignedInt(data[offset[0]++]);
+    		}
     		return result;
+    	}
     	/**
     	 * Write the bytes representing <code>i</code> into the byte array
     	 * <code>data</code>, starting at index <code>offset [0]</code>, and
     	 * increment <code>offset [0]</code> by the number of bytes written; if
     	 * <code>data == null</code>, increment <code>offset [0]</code> by the
     	 * number of bytes that would have been written otherwise.
+    	 *
     	 * @param i the <code>int</code> to encode
     	 * @param data The byte array to store into, or <code>null</code>.
     	 * @param offset A single element array whose first element is the index in
     	 * 		  data to begin writing at on function entry, and which on
     	 * 		  function exit has been incremented by the number of bytes
     	 * 		  written.
     	 */
     	public static final void intToBytes(int i, byte[] data, int[] offset) {
     		/**
     		 * TODO: We use network-order within OceanStore, but temporarily
     		 * supporting intel-order to work with some JNI code until JNI code is
     		 * set to interoperate with network-order.
     		 */
     		if (data != null) {
     			for (int j = (offset[0] + SIZE_INT) - 1; j >= offset[0]; --j) {
     				data[j] = (byte) i;
     				i >>= 8;
+    			}
+    		}
     		offset[0] += SIZE_INT;
+    	}
     	/**
     	 * Return the <code>short</code> represented by the bytes in
     	 * <code>data</code> staring at offset <code>offset[0]</code>.
+    	 *
     	 * @param data the array from which to read
     	 * @param offset A single element array whose first element is the index in
     	 * 		  data from which to begin reading on function entry, and which on
     	 * 		  function exit has been incremented by the number of bytes read.
+    	 *
     	 * @return the value of the <code>short</code> decoded
     	 */
     	public static final short bytesToShort(byte[] data, int[] offset) {
     		/**
     		 * TODO: We use network-order within OceanStore, but temporarily
     		 * supporting intel-order to work with some JNI code until JNI code is
     		 * set to interoperate with network-order.
     		 */
     		short result = 0;
     		for (int i = 0; i < SIZE_SHORT; ++i) {
     			result <<= 8;
     			result |= (short) byteToUnsignedInt(data[offset[0]++]);
+    		}
     		return result;
+    	}
     	/**
     	 * Write the bytes representing <code>s</code> into the byte array
     	 * <code>data</code>, starting at index <code>offset [0]</code>, and
     	 * increment <code>offset [0]</code> by the number of bytes written; if
     	 * <code>data == null</code>, increment <code>offset [0]</code> by the
     	 * number of bytes that would have been written otherwise.
+    	 *
     	 * @param s the <code>short</code> to encode
     	 * @param data The byte array to store into, or <code>null</code>.
     	 * @param offset A single element array whose first element is the index in
     	 * 		  data to begin writing at on function entry, and which on
     	 * 		  function exit has been incremented by the number of bytes
     	 * 		  written.
     	 */
     	public static final void shortToBytes(short s, byte[] data, int[] offset) {
     		/**
     		 * TODO: We use network-order within OceanStore, but temporarily
     		 * supporting intel-order to work with some JNI code until JNI code is
     		 * set to interoperate with network-order.
     		 */
     		if (data != null) {
     			data[offset[0] + 1] = (byte) s;
     			data[offset[0]] = (byte) (s >> 8);
+    		}
     		offset[0] += SIZE_SHORT;
+    	}
     	/**
     	 * Return the <code>long</code> represented by the bytes in
     	 * <code>data</code> staring at offset <code>offset[0]</code>.
+    	 *
     	 * @param data the array from which to read
     	 * @param offset A single element array whose first element is the index in
     	 * 		  data from which to begin reading on  function entry, and which
     	 * 		  on function exit has been incremented by the number of bytes
     	 * 		  read.
+    	 *
     	 * @return the value of the <code>long</code> decoded
     	 */
     	public static final long bytesToLong(byte[] data, int[] offset) {
     		long result = 0;
     		for (int i = 0; i < SIZE_LONG; ++i) {
     			result <<= 8;
     			int res = byteToUnsignedInt(data[offset[0]++]);
     			result = result | res;
+    		}
     		return result;
+    	}
     	/**
     	 * Write the bytes representing <code>l</code> into the byte array
     	 * <code>data</code>, starting at index <code>offset [0]</code>, and
     	 * increment <code>offset [0]</code> by the number of bytes written; if
     	 * <code>data == null</code>, increment <code>offset [0]</code> by the
     	 * number of bytes that would have been written otherwise.
+    	 *
     	 * @param l the <code>long</code> to encode
     	 * @param data The byte array to store into, or <code>null</code>.
     	 * @param offset A single element array whose first element is the index in
     	 * 		  data to begin writing at on function entry, and which on
     	 * 		  function exit has been incremented by the number of bytes
     	 * 		  written.
     	 */
     	public static final void longToBytes(long l, byte[] data, int[] offset) {
     		/**
     		 * TODO: We use network-order within OceanStore, but temporarily
     		 * supporting intel-order to work with some JNI code until JNI code is
     		 * set to interoperate with network-order.
     		 */
     		if (data != null) {
     			for (int j = (offset[0] + SIZE_LONG) - 1; j >= offset[0]; --j) {
     				data[j] = (byte) l;
     				l >>= 8;
+    			}
+    		}
     		offset[0] += SIZE_LONG;
+    	}
     	/**
     	 * Return the <code>double</code> represented by the bytes in
     	 * <code>data</code> staring at offset <code>offset[0]</code>.
+    	 *
     	 * @param data the array from which to read
     	 * @param offset A single element array whose first element is the index in
     	 * 		  data from which to begin reading on  function entry, and which
     	 * 		  on function exit has been incremented by the number of bytes
     	 * 		  read.
+    	 *
     	 * @return the value of the <code>double</code> decoded
     	 */
     	public static final double bytesToDouble(byte[] data, int[] offset) {
     		long bits = bytesToLong(data, offset);
     		return Double.longBitsToDouble(bits);
+    	}
     	/**
     	 * Write the bytes representing <code>d</code> into the byte array
     	 * <code>data</code>, starting at index <code>offset [0]</code>, and
     	 * increment <code>offset [0]</code> by the number of bytes written; if
     	 * <code>data == null</code>, increment <code>offset [0]</code> by the
     	 * number of bytes that would have been written otherwise.
+    	 *
     	 * @param d the <code>double</code> to encode
     	 * @param data The byte array to store into, or <code>null</code>.
     	 * @param offset A single element array whose first element is the index in
     	 * 		  data to begin writing at on function entry, and which on
     	 * 		  function exit has been incremented by the number of bytes
     	 * 		  written.
     	 */
     	public static final void doubleToBytes(double d, byte[] data, int[] offset) {
     		long bits = Double.doubleToLongBits(d);
     		longToBytes(bits, data, offset);
+    	}
     	/**
     	 * Return the <code>String</code> represented by the bytes in
     	 * <code>data</code> staring at offset <code>offset[0]</code>. This method
     	 * relies on the user using the corresponding <code>stringToBytes</code>
     	 * method to encode the <code>String</code>, so that it may properly
     	 * retrieve the <code>String</code> length.
+    	 *
     	 * @param data the array from which to read
     	 * @param offset A single element array whose first element is the index in
     	 * 		  data from which to begin reading on function entry, and which on
     	 * 		  function exit has been incremented by the number of bytes read.
+    	 *
     	 * @return the value of the <code>String</code> decoded
     	 */
     	public static final String bytesToString(byte[] data, int[] offset) {
     		offset[0] = 0;
     		int length = bytesToInt(data, offset);
     		String st = null;
     		if ((length < 0) || (length > data.length)) {
     			st = new String(data);
     		} else {
     			st = new String(data, offset[0], length);
+    		}
     		offset[0] += length;
     		return st;
+    	}
     	/**
     	 * Write the bytes representing <code>s</code> into the byte array
     	 * <code>data</code>, starting at index <code>offset [0]</code>, and
     	 * increment <code>offset [0]</code> by the number of bytes written; if
     	 * <code>data == null</code>, increment <code>offset [0]</code> by the
     	 * number of bytes that would have been written otherwise.
+    	 *
     	 * @param s the <code>String</code> to encode
     	 * @param data The byte array to store into, or <code>null</code>.
     	 * @param offset A single element array whose first element is the index in
     	 * 		  data to begin writing at on function entry, and which on
     	 * 		  function exit has been incremented by the number of bytes
     	 * 		  written.
     	 */
     	public static final void stringToBytes(String s, byte[] data, int[] offset) {
     		byte[] s_bytes = s.getBytes();
     		if (data != null) {
     			intToBytes(s_bytes.length, data, offset);
     			memcpy(data, offset[0], s_bytes, 0, s_bytes.length);
     		} else {
     			offset[0] += SIZE_INT;
+    		}
     		offset[0] += s_bytes.length;
+    	}
     	/**
     	 * Return the <code>boolean</code> represented by the bytes in
     	 * <code>data</code> staring at offset <code>offset[0]</code>.
+    	 *
     	 * @param data the array from which to read
     	 * @param offset A single element array whose first element is the index in
     	 * 		  data from which to begin reading on  function entry, and which
     	 * 		  on function exit has been incremented by the number of bytes
     	 * 		  read.
+    	 *
     	 * @return the value of the <code>boolean</code> decoded
     	 */
     	public static final boolean bytesToBool(byte[] data, int[] offset) {
     		boolean result = true;
     		if (data[offset[0]] == 0) {
     			result = false;
+    		}
     		offset[0] += SIZE_BOOL;
     		return result;
+    	}
     	/**
     	 * Write the bytes representing <code>b</code> into the byte array
     	 * <code>data</code>, starting at index <code>offset [0]</code>, and
     	 * increment <code>offset [0]</code> by the number of bytes written; if
     	 * <code>data == null</code>, increment <code>offset [0]</code> by the
     	 * number of bytes that would have been written otherwise.
+    	 *
     	 * @param b the <code>boolean</code> to encode
     	 * @param data The byte array to store into, or <code>null</code>.
     	 * @param offset A single element array whose first element is the index in
     	 * 		  data to begin writing at on function entry, and which on
     	 * 		  function exit has been incremented by the number of bytes
     	 * 		  written.
     	 */
     	public static final void boolToBytes(boolean b, byte[] data, int[] offset) {
     		if (data != null) {
     			data[offset[0]] = (byte) (b ? 1 : 0);
+    		}
     		offset[0] += SIZE_BOOL;
+    	}
     	/**
     	 * Return the <code>BigInteger</code> represented by the bytes in
     	 * <code>data</code> staring at offset <code>offset[0]</code>.
+    	 *
     	 * @param data the array from which to read
     	 * @param offset A single element array whose first element is the index in
     	 * 		  data from which to begin reading on  function entry, and which
     	 * 		  on function exit has been incremented by the number of bytes
     	 * 		  read.
+    	 *
     	 * @return the <code>BigInteger</code> decoded
     	 */
     	public static final BigInteger bytesToBigInteger(byte[] data, int[] offset) {
     		int length = bytesToInt(data, offset);
     		byte[] bytes = new byte[length];
     		offset[0] += memcpy(bytes, 0, data, offset[0], length);
     		return new BigInteger(bytes);
+    	}
     	/**
     	 * Write the bytes representing <code>n</code> into the byte array
     	 * <code>data</code>, starting at index <code>offset [0]</code>, and
     	 * increment <code>offset [0]</code> by the number of bytes written; if
     	 * <code>data == null</code>, increment <code>offset [0]</code> by the
     	 * number of bytes that would have been written otherwise.
+    	 *
     	 * @param n the <code>BigInteger</code> to encode
     	 * @param data The byte array to store into, or <code>null</code>.
     	 * @param offset A single element array whose first element is the index in
     	 * 		  data to begin writing at on function entry, and which on
     	 * 		  function exit has been incremented by the number of bytes
     	 * 		  written.
     	 */
     	public static final void bigIntegerToBytes(BigInteger n, byte[] data,
     		int[] offset) {
     		byte[] bytes = n.toByteArray();
     		intToBytes(bytes.length, data, offset);
     		offset[0] += memcpy(data, offset[0], bytes, 0, bytes.length);
+    	}
     	/**
     	 * Convert an array of <code>bytes</code>s into an array of
     	 * <code>ints</code>.
+    	 *
     	 * @param dst the array to write
     	 * @param dst_offset the start offset in <code>dst</code>, times 4. This
     	 * 		  measures the offset as if <code>dst</code> were an array of
     	 * 		  <code>byte</code>s (rather than <code>int</code>s).
     	 * @param src the array to read
     	 * @param src_offset the start offset in <code>src</code>
     	 * @param length the number of <code>byte</code>s to copy.
     	 */
     	public static final void bytesToInts(int[] dst, int dst_offset, byte[] src,
     		int src_offset, int length) {
     		if ((src == null) || (dst == null) ||
     				((src_offset + length) > src.length) ||
     				((dst_offset + length) > (dst.length * 4)) ||
     				((dst_offset % 4) != 0) || ((length % 4) != 0)) {
     			croak("bytesToInts parameters are invalid" + " src==" + src +
     				" dst==" + dst +
     				(((src == null) || (dst == null)) ? " "
     												  : (" (src_offset+length)>src.length==" +
     				(src_offset + length) + ">" + src.length +
     				" (dst_offset+length)>(dst.length*4)==" +
     				(dst_offset + length) + ">" + (dst.length * 4) +
     				" (dst_offset%4)==" + (dst_offset % 4) + " (length%4)==" +
     				(length % 4) + " dest.length==" + dst.length + " length==" +
     				length)));
+    		}
     		// Convert parameters to normal format
     		int[] offset = new int[1];
     		offset[0] = src_offset;
     		int int_dst_offset = dst_offset / 4;
     		for (int i = 0; i < (length / 4); ++i) {
     			dst[int_dst_offset++] = bytesToInt(src, offset);
+    		}
+    	}
     	/**
     	 * Convert an array of <code>int</code>s into an array of
     	 * <code>bytes</code>.
+    	 *
     	 * @param dst the array to write
     	 * @param dst_offset the start offset in <code>dst</code>
     	 * @param src the array to read
     	 * @param src_offset the start offset in <code>src</code>, times 4. This
     	 * 		  measures the offset as if <code>src</code> were an array of
     	 * 		  <code>byte</code>s (rather than <code>int</code>s).
     	 * @param length the number of <code>byte</code>s to copy.
     	 */
     	public static final void intsToBytes(byte[] dst, int dst_offset, int[] src,
     		int src_offset, int length) {
     		if ((src == null) || (dst == null) ||
     				((dst_offset + length) > dst.length) ||
     				((src_offset + length) > (src.length * 4)) ||
     				((src_offset % 4) != 0) || ((length % 4) != 0)) {
     			croak("intsToBytes parameters are invalid:" + " src=" + src +
     				" dst=" + dst + " (dst_offset=" + dst_offset + " + length=" +
     				length + ")=" + (dst_offset + length) + " > dst.length=" +
     				((dst == null) ? 0 : dst.length) + " (src_offset=" +
     				src_offset + " + length=" + length + ")=" +
     				(src_offset + length) + " > (src.length=" +
     				((src == null) ? 0 : src.length) + "*4)=" +
     				((src == null) ? 0 : (src.length * 4)) + " (src_offset=" +
     				src_offset + " % 4)=" + (src_offset % 4) + " != 0" +
     				" (length=" + length + " % 4)=" + (length % 4) + " != 0");
+    		}
     		// Convert parameters to normal format
     		int[] offset = new int[1];
     		offset[0] = dst_offset;
     		int int_src_offset = src_offset / 4;
     		for (int i = 0; i < (length / 4); ++i) {
     			intToBytes(src[int_src_offset++], dst, offset);
+    		}
+    	}
     	/**
     	 * Convert a <code>byte</code> into an unsigned integer.
+    	 *
     	 * @param b the <code>byte</code> to cast
+    	 *
     	 * @return a postiive <code>int</code> whose lowest byte contains the bits
     	 * 		   of <code>b</code>.
     	 */
     	public static final int byteToUnsignedInt(byte b) {
     		return ((int) b) & 0xff;
+    	}
     	/**
     	 * Copy contents of one array of <code>bytes</code> into another. If either
     	 * array is <code>null</code>, simply return the <code>length</code>
     	 * parameter directly.
+    	 *
     	 * @param dst the array to write, or <code>null</code>
     	 * @param dst_offset the start offset in <code>dst</code>
     	 * @param src the array to read, or <code>null</code>
     	 * @param src_offset the start offset in <code>src</code>
     	 * @param length the number of <code>byte</code>s to copy.
+    	 *
     	 * @return DOCUMENT ME!
     	 */
     	public static int memcpy(byte[] dst, int dst_offset, byte[] src,
     		int src_offset, int length) {
     		if ((dst != null) && (src != null)) {
     			if (dst.length < (dst_offset + length)) {
     				croak("dst.length = " + dst.length + ", but " +
     					"dst_offset = " + dst_offset + " and length = " + length +
     					".");
+    			}
     			if (src.length < (src_offset + length)) {
     				croak("src.length = " + src.length + ", but " +
     					"src_offset = " + src_offset + " and length = " + length +
     					".");
+    			}
     			for (int i = 0; i < length; ++i, ++dst_offset, ++src_offset)
     				dst[dst_offset] = src[src_offset];
+    		}
     		return length;
+    	}
     	/**
     	 * Compare the contents of one array of <code>bytes</code> to another.
+    	 *
     	 * @param a the first array
     	 * @param a_offset the start offset in <code>a</code>
     	 * @param b the second array
     	 * @param b_offset the start offset in <code>b</code>
     	 * @param length the number of <code>byte</code>s to compare.
+    	 *
     	 * @return DOCUMENT ME!
     	 */
     	public static boolean memcmp(byte[] a, int a_offset, byte[] b,
     		int b_offset, int length) {
     		if ((a == null) && (b == null)) {
     			return true;
+    		}
     		if ((a == null) || (b == null)) {
     			return false;
+    		}
     		for (int i = 0; i < length; ++i, ++a_offset, ++b_offset)
     			if (a[a_offset] != b[b_offset]) {
     				return false;
+    			}
     		return true;
+    	}
     	/**
     	 * Fill the given array with zeros.
+    	 *
     	 * @param array the array to clear
     	 * @param offset the start offset
     	 * @param length the number of <code>byte</code>s to clear.
     	 */
     	public static void memclr(byte[] array, int offset, int length) {
     		for (int i = 0; i < length; ++i, ++offset)
     			array[offset] = 0;
+    	}
     	/**
     	 * Round a number up to a given multiple.
+    	 *
     	 * @param value the number to be rounded
     	 * @param multiple the number to which to be rounded
+    	 *
     	 * @return the smallest <code>int</code> greater than or equal to
     	 * 		   <code>value</code> which divides <code>multiple</code> exactly.
     	 */
     	public static int round_up(int value, int multiple) {
     		return (((value - 1) / multiple) + 1) * multiple;
+    	}
     	/**
     	 * Return a new array equal to original except zero-padded to an integral
     	 * mulitple of blocks.  If the original is already an integral multiple of
     	 * blocks, just return it.
+    	 *
     	 * @param original the array of <code>byte</code>s to be padded
     	 * @param block_size the size of the blocks
+    	 *
     	 * @return an array whose size divides <code>block_size</code> exactly. The
     	 * 		   array is either <code>original</code> itself, or a copy whose
     	 * 		   first <code>original.length</code> bytes are equal to
     	 * 		   <code>original</code>.
     	 */
     	public static byte[] zero_pad(byte[] original, int block_size) {
     		if ((original.length % block_size) == 0) {
     			return original;
+    		}
     		byte[] result = new byte[round_up(original.length, block_size)];
     		memcpy(result, 0, original, 0, original.length);
     		// Unnecessary - jvm sets bytes to 0.
     		// memclr (result, original.length, result.length - original.length);
     		return result;
+    	}
     	/**
     	 * Determines whether two arrays of <code>byte</code>s contain the same
     	 * contents.
+    	 *
     	 * @param b1 The first array
     	 * @param b2 The second array
+    	 *
     	 * @return <code>true</code> if both arrays are <code>null</code>, both
     	 * 		   empty, or both of the same length with equal contents.
     	 */
     	public static boolean equals(byte[] b1, byte[] b2) {
     		if (b1 == b2) {
     			return true;
+    		}
     		if ((b1 == null) || (b2 == null)) { // only one is null
     			return false;
+    		}
     		if (b1.length != b2.length) {
     			return false;
+    		}
     		for (int i = 0; i < b1.length; ++i)
     			if (b1[i] != b2[i]) {
     				return false;
+    			}
     		return true;
+    	}
     	/**
     	 * Produce a <code>String</code> representation for the specified array of
     	 * <code>byte</code>s.  Print each <code>byte</code> as two hexadecimal
     	 * digits.
+    	 *
     	 * @param data The array to print
     	 * @param offset the start offset in <code>data</code>
     	 * @param length the number of <code>byte</code>s to print
+    	 *
     	 * @return DOCUMENT ME!
     	 */
     	public static String print_bytes(byte[] data, int offset, int length) {
     		int size = 2 * length;
     		size += ((size / 8) + (size / 64));
     		char[] buf = new char[size];
     		int low_mask = 0x0f;
     		int high_mask = 0xf0;
     		int buf_pos = 0;
     		byte b;
     		int j = 0;
     		for (int i = offset; i < (offset + length); ++i) {
     			b = data[i];
     			buf[buf_pos++] = digits[(high_mask & b) >> 4];
     			buf[buf_pos++] = digits[(low_mask & b)];
     			if ((j % 4) == 3) {
     				buf[buf_pos++] = ' ';
+    			}
     			if ((j % 32) == 31) {
     				buf[buf_pos++] = '\n';
+    			}
     			++j;
+    		}
     		return new String(buf);
+    	}
     	/**
     	 * DOCUMENT ME!
+    	 *
     	 * @param data DOCUMENT ME!
     	 * @param offset DOCUMENT ME!
     	 * @param length DOCUMENT ME!
+    	 *
     	 * @return DOCUMENT ME!
     	 */
     	public static String print_bytes_exact(byte[] data, int offset, int length) {
     		int size = 2 * length;
     		char[] buf = new char[size];
     		int low_mask = 0x0f;
     		int high_mask = 0xf0;
     		int buf_pos = 0;
     		byte b;
     		int j = 0;
     		for (int i = offset; i < (offset + length); ++i) {
     			b = data[i];
     			buf[buf_pos++] = digits[(high_mask & b) >> 4];
     			buf[buf_pos++] = digits[(low_mask & b)];
     			++j;
+    		}
     		return new String(buf);
+    	}
     	/**
     	 * DOCUMENT ME!
+    	 *
     	 * @param data DOCUMENT ME!
+    	 *
     	 * @return DOCUMENT ME!
     	 */
     	public static String print_bytes(byte[] data) {
     		return print_bytes(data, 0, data.length);
+    	}
     	/**
     	 * DOCUMENT ME!
+    	 *
     	 * @param msg DOCUMENT ME!
     	 */
     	private static void croak(String msg) {
     		// throw new java.AssertionViolatedException(msg);
+    	}
     	/**
     	 * DOCUMENT ME!
+    	 *
     	 * @param b DOCUMENT ME!
+    	 *
     	 * @return DOCUMENT ME!
     	 */
     	public static int getUnsigned(byte b) {
     		return ((b & 0xff)); // >> 8);
+    	}
+    }

     package com.iver.cit.jdwglib.util;
     /**
      *  3dim double vector. A vector is transformed different than a point.
      *  The class is now declared final to allow a more aggresive optimization.
+     *
      *  @see       dxfviewer.math.Point3D;
+     *
      *  @version   1.10,?01/13/99
      */
     public final class Vector3D {
       public double x, y, z;       // coordinates, allowing direct access
       /**
+       *
        */
       public Vector3D() {
+      }
       /**
        *  Copy constructor.
        *  @param  v    vector to copy
        */
       public Vector3D(Vector3D v) {
         x = v.x;
         y = v.y;
         z = v.z;
+      }
       /**
        *  Copy from a point.
        *  @param  p   point to copy
        */
       public Vector3D(Point3D p) {
         x = p.x;
         y = p.y;
         z = p.z;
+      }
       /**
        *  @param   xx    x coord
        *  @param   yy    y coord
        *  @param   zz    z coord
        */
       public Vector3D(double xx, double yy, double zz) {
         x = xx;
         y = yy;
         z = zz;
+      }
       /**
        *  Calculate the length.
        *  @return  length of vector
        */
       public double length() {
         return (double)Math.sqrt(x*x+y*y+z*z);
+      }
       /**
        *  Scale.
        *  @param   f     scaling factor
        */
       public void scale(double f) {
         if (f != 1f) {
           x *= f;
           y *= f;
           z *= f;
+        }
+      }
       /**
        *  Normalize. Scale vector so it has length 1.
        */
       public void normalize() {
         scale(1.0f/length());
+      }
       /**
        *  Add a vector.
        *  @param  v      vector to add
        */
       public void add(Vector3D v) {
         x += v.x;
         y += v.y;
         z += v.z;
+      }
       /**
        *  Get sum of vectors.
        *  @param  v     vector to add
        *  @return this+v
        */
       public Vector3D plus(Vector3D v) {
         Vector3D ret = new Vector3D(this);
         ret.add(v);
         return ret;
+      }
       /**
        *  Get sum of this vector and point.
        *  @param  p     point to add
        *  @return this+p
        */
       public Point3D plus(Point3D p) {
         Point3D ret = new Point3D(p);
         ret.add(this);
         return ret;
+      }
       /**
        *  Substract a vector from this.
        *  @param  v     vector to substract
        */
       public void sub(Vector3D v) {
         x -= v.x;
         y -= v.y;
         z -= v.z;
+      }
       /**
        *  Get difference with point.
        *  @param  p     point to substract
        *  @return this-p = -(p-this)
        */
       public Point3D minus(Point3D p) {
         Point3D ret = new Point3D(p);
         ret.sub(this);
         ret.scale(-1f);
         return ret;
+      }
       /**
        *  Get difference with vector.
        *  @param  v     vector to substract
        *  @return this-v
        */
       public Vector3D minus(Vector3D v) {
         Vector3D ret = new Vector3D(this);
         ret.sub(v);
         return ret;
+      }
       /**
        *  Scalar product.
        *  @param  v     vector to multiply
        *  @return this*v
        */
       public double mult(Vector3D v) {
         return x*v.x+y*v.y+z*v.z;
+      }
       /**
        *  Cross product.
        *  @param  v     vector to multiply
        *  @return this x v
        */
       public Vector3D cross(Vector3D v) {
         return new Vector3D(y*v.z - z*v.y,
     			z*v.x - x*v.z,
     			x*v.y - y*v.x);
+      }
       /**
        *  Output.
        *  @return  string representation
        */
       public String toString() {
         return new String(new StringBuffer().append("<").append(x).append(",").append(y).append(",").append(z).append(">"));
+      }
+    }

     package com.iver.cit.jdwglib.util;
     /**
      *  4x4dim double matrix used for perspective transformations.
      *  The class is now declared final to allow a more aggresive optimization.
+     *
      */
     public final class Matrix4D {
       static private final double DEG2RAD = Math.PI/180.0;  // conversion from degree to radians
       public double xx, xy, xz, xw,     // 1st row
     			   yx, yy, yz, yw,     // 2nd row
     			   zx, zy, zz, zw,     // 3rd row
     			   wx, wy, wz, ww;     // 4th row
       /**
        *  Create identity matrix.
        */
       public Matrix4D() {
     	// set to identity mat
     	xx = yy = zz = ww = 1f;
+      }
       /**
        *  Copy constructor.
        *  @param  m   matrix to copy
        */
       public Matrix4D(Matrix4D m) {
     	xx = m.xx;
     	xy = m.xy;
     	xz = m.xz;
     	xw = m.xw;
     	yx = m.yx;
     	yy = m.yy;
     	yz = m.yz;
     	yw = m.yw;
     	zx = m.zx;
     	zy = m.zy;
     	zz = m.zz;
     	zw = m.zw;
     	wx = m.wx;
     	wy = m.wy;
     	wz = m.wz;
     	ww = m.ww;
+      }
       /**
        *  @param  mxx     1st elem in 1st row
        *  @param  mxy     2nd elem in 1st row
        *  @param  mxz     3rd elem in 1st row
        *  @param  mxw     4th elem in 1st row
        *  @param  myx     1st elem in 2nd row
        *  @param  myy     2nd elem in 2nd row
        *  @param  myz     3rd elem in 2nd row
        *  @param  myw     4th elem in 2nd row
        *  @param  mzx     1st elem in 3rd row
        *  @param  mzy     2nd elem in 3rd row
        *  @param  mzz     3rd elem in 3rd row
        *  @param  mzw     4th elem in 3rd row
        *  @param  mwx     1st elem in 4th row
        *  @param  mwy     2nd elem in 4th row
        *  @param  mwz     3rd elem in 4th row
        *  @param  mww     4th elem in 4th row
        */
       public Matrix4D(double mxx, double mxy, double mxz, double mxw,
     		  double myx, double myy, double myz, double myw,
     		  double mzx, double mzy, double mzz, double mzw,
     		  double mwx, double mwy, double mwz, double mww) {
     	xx = mxx;
     	xy = mxy;
     	xz = mxz;
     	xw = mxw;
     	yx = myx;
     	yy = myy;
     	yz = myz;
     	yw = myw;
     	zx = mzx;
     	zy = mzy;
     	zz = mzz;
     	zw = mzw;
     	wx = mwx;
     	wy = mwy;
     	wz = mwz;
     	ww = mww;
+      }
       /**
        *  Reset to identity
        */
       public void identity() {
     	xx = yy = zz = ww = 1f;
     	xy = xz = xw =
     	  yx = yz = yw =
     	  zx = zy = zw =
     	  wx = wy = wz = 0f;
+      }
       /**
        *  Transponize.
        */
       public void transponize() {
     	// switch rows and columns
     	double t;
     	t = xy; xy = yx; yx = t;
     	t = xz; xz = zx; zx = t;
     	t = xw; xw = wx; wx = t;
     	t = yz; yz = zy; zy = t;
     	t = yw; yw = wy; wy = t;
     	t = zw; zw = wz; wz = t;
+      }
       /**
        *  Matrix multiplication of vector.
        *  @param  v   vector to transform
        *  @return transformed vector
        */
       public Vector3D mult(Vector3D v) {
     	return new Vector3D(xx*v.x + xy*v.y + xz*v.z,
     			yx*v.x + yy*v.y + yz*v.z,
     			zx*v.x + zy*v.y + zz*v.z);
+      }
       /**
        *  Transformation of 1 vector.
        *  @param  v   vector to transform
        */
       public void transform(Vector3D v) {
     	double x = xx*v.x + xy*v.y + xz*v.z,
     		  y = yx*v.x + yy*v.y + yz*v.z,
     		  z = zx*v.x + zy*v.y + zz*v.z;
     	v.x = x;
     	v.y = y;
     	v.z = z;
+      }
       /**
        *  Matrix multiplication of point.
        *  @param  p    point to transform
        *  @return transformed point
        */
       public Point3D mult(Point3D p) {
     	Point3D ret = new Point3D(xx*p.x + xy*p.y + xz*p.z + xw,
     				  yx*p.x + yy*p.y + yz*p.z + yw,
     				  zx*p.x + zy*p.y + zz*p.z + zw);
     	ret.scale(1f/(wx*p.x + wy*p.y + wz*p.z + ww));
     	return ret;
+      }
       /**
        *  Transformation of 1 point.
        *  @param  p   point to transform
        */
       public void transform(Point3D p) {
     	double  x = xx*p.x + xy*p.y + xz*p.z + xw,
     		   y = yx*p.x + yy*p.y + yz*p.z + yw,
     		   z = zx*p.x + zy*p.y + zz*p.z + zw,
     		   w = wx*p.x + wy*p.y + wz*p.z + ww;
     	p.x = x/w;
     	p.y = y/w;
     	p.z = z/w;
+      }
       /**Transformacion de un punto considerando solo el plano horizontal
        */
        public void transformXY(Point3D p){
     		double  x = xx*p.x + xy*p.y+ xw,
     		y = yx*p.x + yy*p.y + yw,
     		w = wx*p.x + wy*p.y + ww;
     		p.x = x/w;
     		p.y = y/w;
+       }
       /**
        *  Matrix multiplication.
        *  @param  m   matrix to multiply with
        *  @return this * m
        */
       public Matrix4D mult(Matrix4D m) {
     	if (m != null) {
     	  return new Matrix4D(xx*m.xx + xy*m.yx + xz*m.zx + xw*m.wx,
     			  xx*m.xy + xy*m.yy + xz*m.zy + xw*m.wy,
     			  xx*m.xz + xy*m.yz + xz*m.zz + xw*m.wz,
     			  xx*m.xw + xy*m.yw + xz*m.zw + xw*m.ww,
     			  yx*m.xx + yy*m.yx + yz*m.zx + yw*m.wx,
     			  yx*m.xy + yy*m.yy + yz*m.zy + yw*m.wy,
     			  yx*m.xz + yy*m.yz + yz*m.zz + yw*m.wz,
     			  yx*m.xw + yy*m.yw + yz*m.zw + yw*m.ww,
     			  zx*m.xx + zy*m.yx + zz*m.zx + zw*m.wx,
     			  zx*m.xy + zy*m.yy + zz*m.zy + zw*m.wy,
     			  zx*m.xz + zy*m.yz + zz*m.zz + zw*m.wz,
     			  zx*m.xw + zy*m.yw + zz*m.zw + zw*m.ww,
     			  wx*m.xx + wy*m.yx + wz*m.zx + ww*m.wx,
     			  wx*m.xy + wy*m.yy + wz*m.zy + ww*m.wy,
     			  wx*m.xz + wy*m.yz + wz*m.zz + ww*m.wz,
     			  wx*m.xw + wy*m.yw + wz*m.zw + ww*m.ww);
+    	}
     	else {
     	  return new Matrix4D(this);
+    	}
+      }
       /**
        *  Matrix multiplication.
        *  @param  m  matrix to multply with
        */
       public void multBy(Matrix4D m) {
     	double x = xx*m.xx + xy*m.yx + xz*m.zx + xw*m.wx,
     		  y = xx*m.xy + xy*m.yy + xz*m.zy + xw*m.wy,
     		  z = xx*m.xz + xy*m.yz + xz*m.zz + xw*m.wz,
     		  w = xx*m.xw + xy*m.yw + xz*m.zw + xw*m.ww;
     	xx = x;
     	xy = y;
     	xz = z;
     	xw = w;
     	x = yx*m.xx + yy*m.yx + yz*m.zx + yw*m.wx;
     	y = yx*m.xy + yy*m.yy + yz*m.zy + yw*m.wy;
     	z = yx*m.xz + yy*m.yz + yz*m.zz + yw*m.wz;
     	w = yx*m.xw + yy*m.yw + yz*m.zw + yw*m.ww;
     	yx = x;
     	yy = y;
     	yz = z;
     	yw = w;
     	x = zx*m.xx + zy*m.yx + zz*m.zx + zw*m.wx;
     	y = zx*m.xy + zy*m.yy + zz*m.zy + zw*m.wy;
     	z = zx*m.xz + zy*m.yz + zz*m.zz + zw*m.wz;
     	w = zx*m.xw + zy*m.yw + zz*m.zw + zw*m.ww;
     	zx = x;
     	zy = y;
     	zz = z;
     	zw = w;
     	x = wx*m.xx + wy*m.yx + wz*m.zx + ww*m.wx;
     	y = wx*m.xy + wy*m.yy + wz*m.zy + ww*m.wy;
     	z = wx*m.xz + wy*m.yz + wz*m.zz + ww*m.wz;
     	w = wx*m.xw + wy*m.yw + wz*m.zw + ww*m.ww;
     	wx = x;
     	wy = y;
     	wz = z;
     	ww = w;
+      }
       /**
        *  Matrix multiplication from left.
        *  @param  m  matrix to multiply with.
        */
       public void multLeftBy(Matrix4D m) {
     	double x = m.xx*xx + m.xy*yx + m.xz*zx + m.xw*wx,
     		  y = m.yx*xx + m.yy*yx + m.yz*zx + m.yw*wx,
     		  z = m.zx*xx + m.zy*yx + m.zz*zx + m.zw*wx,
     		  w = m.wx*xx + m.wy*yx + m.wz*zx + m.ww*wx;
     	xx = x;
     	yx = y;
     	zx = z;
     	wx = w;
     	x = m.xx*xy + m.xy*yy + m.xz*zy + m.xw*wy;
     	y = m.yx*xy + m.yy*yy + m.yz*zy + m.yw*wy;
     	z = m.zx*xy + m.zy*yy + m.zz*zy + m.zw*wy;
     	w = m.wx*xy + m.wy*yy + m.wz*zy + m.ww*wy;
     	xy = x;
     	yy = y;
     	zy = z;
     	wy = w;
     	x = m.xx*xz + m.xy*yz + m.xz*zz + m.xw*wz;
     	y = m.yx*xz + m.yy*yz + m.yz*zz + m.yw*wz;
     	z = m.zx*xz + m.zy*yz + m.zz*zz + m.zw*wz;
     	w = m.wx*xz + m.wy*yz + m.wz*zz + m.ww*wz;
     	xz = x;
     	yz = y;
     	zz = z;
     	wz = w;
     	x = m.xx*xw + m.xy*yw + m.xz*zw + m.xw*ww;
     	y = m.yx*xw + m.yy*yw + m.yz*zw + m.yw*ww;
     	z = m.zx*xw + m.zy*yw + m.zz*zw + m.zw*ww;
     	w = m.wx*xw + m.wy*yw + m.wz*zw + m.ww*ww;
     	xw = x;
     	yw = y;
     	zw = z;
     	ww = w;
+      }
       /**
        *  Translate the origin.
        *  @param  x   translation in x
        *  @param  y   translation in y
        *  @param  z   translation in z
        */
       public void translate(double x, double y, double z) {
     	xw += x*xx+y*xy+z*xz;
     	yw += x*yx+y*yy+z*yz;
     	zw += x*zx+y*zy+z*zz;
     	ww += x*wx+y*wy+z*wz;
+      }
       /**
        *  Translate the origin
        *  @param  v   translation vector
        */
       public void translate(Vector3D v) {
     	translate(v.x, v.y, v.z);
+      }
       /**
        *  Translate.
        *  @param  x   translation in x
        *  @param  y   translation in y
        *  @param  z   translation in z
        */
       public void translateLeft(double x, double y, double z) {
     	if (x != 0f) {
     	  xx += x*wx;  xy += x*wy;  xz += x*wz;  xw += x*ww;
+    	}
     	if (y != 0f) {
     	  yx += y*wx;  yy += y*wy;  yz += y*wz;  yw += y*ww;
+    	}
     	if (z != 0f) {
     	  zx += z*wx;  zy += z*wy;  zz += z*wz;  zw += z*ww;
+    	}
+      }
       /**
        *  Translate the origin
        *  @param  v   tranbslation vector
        */
       public void translateLeft(Vector3D v) {
     	translateLeft(v.x, v.y, v.z);
+      }
       /**
        *  Move the stuff.
        *  @param  x   translation in x
        *  @param  y   translation in y
        *  @param  z   translation in z
        */
       public void moveBy(double x, double y, double z) {
     	if (x != 0f) {
     	  xx += x*xw;  yx += x*yw;  zx += x*zw;  wx += x*ww;
+    	}
     	if (y != 0f) {
     	  xy += y*xw;  yy += y*yw;  zy += y*zw;  wy += y*ww;
+    	}
     	if (z != 0f) {
     	  xz += z*xw;  yz += z*yw;  zz += z*zw;  wz += z*ww;
+    	}
+      }
       /**
        *  Translate the origin
        *  @param  v   translation vector
        */
       public void moveBy(Vector3D v) {

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff