variantutilities.java

java与windows的com桥,可以用来操作所有的com程序如word或者excel等

				break;
			case Variant.VariantShort: // 2
				result = new Short(sourceData.getShort());
				break;
			case Variant.VariantShort | Variant.VariantByref: // 2
				result = new Short(sourceData.getShortRef());
				break;
			case Variant.VariantInt: // 3
				result = new Integer(sourceData.getInt());
				break;
			case Variant.VariantInt | Variant.VariantByref: // 3
				result = new Integer(sourceData.getIntRef());
				break;
			case Variant.VariantFloat: // 4
				result = new Float(sourceData.getFloat());
				break;
			case Variant.VariantFloat | Variant.VariantByref: // 4
				result = new Float(sourceData.getFloatRef());
				break;
			case Variant.VariantDouble: // 5
				result = new Double(sourceData.getDouble());
				break;
			case Variant.VariantDouble | Variant.VariantByref: // 5
				result = new Double(sourceData.getDoubleRef());
				break;
			case Variant.VariantCurrency: // 6
				result = sourceData.getCurrency();
				break;
			case Variant.VariantCurrency | Variant.VariantByref: // 6
				result = sourceData.getCurrencyRef();
				break;
			case Variant.VariantDate: // 7
				result = sourceData.getJavaDate();
				break;
			case Variant.VariantDate | Variant.VariantByref: // 7
				result = sourceData.getJavaDateRef();
				break;
			case Variant.VariantString: // 8
				result = sourceData.getString();
				break;
			case Variant.VariantString | Variant.VariantByref: // 8
				result = sourceData.getStringRef();
				break;
			case Variant.VariantDispatch: // 9
				result = sourceData.getDispatch();
				break;
			case Variant.VariantDispatch | Variant.VariantByref: // 9
				result = sourceData.getDispatchRef(); // Can dispatches even
				// be byRef?
				break;
			case Variant.VariantError: // 10
				result = new NotImplementedException(
						"toJavaObject() Not implemented for VariantError");
				break;
			case Variant.VariantBoolean: // 11
				result = new Boolean(sourceData.getBoolean());
				break;
			case Variant.VariantBoolean | Variant.VariantByref: // 11
				result = new Boolean(sourceData.getBooleanRef());
				break;
			case Variant.VariantVariant: // 12 they are always by ref
				result = new NotImplementedException(
						"toJavaObject() Not implemented for VariantVariant without ByRef");
				break;
			case Variant.VariantVariant | Variant.VariantByref: // 12
				result = sourceData.getVariant();
				break;
			case Variant.VariantObject: // 13
				result = new NotImplementedException(
						"toJavaObject() Not implemented for VariantObject");
				break;
			case Variant.VariantDecimal: // 14
				result = sourceData.getDecimal();
				break;
			case Variant.VariantDecimal | Variant.VariantByref: // 14
				result = sourceData.getDecimalRef();
				break;
			case Variant.VariantByte: // 17
				result = new Byte(sourceData.getByte());
				break;
			case Variant.VariantByte | Variant.VariantByref: // 17
				result = new Byte(sourceData.getByteRef());
				break;
			case Variant.VariantLongInt: // 20
				result = new Long(sourceData.getLong());
				break;
			case Variant.VariantLongInt | Variant.VariantByref: // 20
				result = new Long(sourceData.getLongRef());
				break;
			case Variant.VariantTypeMask: // 4095
				result = new NotImplementedException(
						"toJavaObject() Not implemented for VariantTypeMask");
				break;
			case Variant.VariantArray: // 8192
				result = new NotImplementedException(
						"toJavaObject() Not implemented for VariantArray");
				break;
			case Variant.VariantByref: // 16384
				result = new NotImplementedException(
						"toJavaObject() Not implemented for VariantByref");
				break;
			default:
				result = new NotImplementedException("Unknown return type: "
						+ type);
				// there was a "return result" here that caused defect 1602118
				// so it was removed
				break;
			}// switch (type)

			if (result instanceof JacobException) {
				throw (JacobException) result;
			}
		}

		return result;
	}// toJava()

	/**
	 * Verifies that we have a scale 0 <= x <= 28 and now more than 96 bits of
	 * data. The roundToMSDecimal method will attempt to adjust a BigDecimal to
	 * pass this set of tests
	 * 
	 * @param in
	 * @throws IllegalArgumentException
	 *             if out of bounds
	 */
	protected static void validateDecimalScaleAndBits(BigDecimal in) {
		BigInteger allWordBigInt = in.unscaledValue();
		if (in.scale() > 28) {
			// should this cast to a string and call putStringRef()?
			throw new IllegalArgumentException(
					"VT_DECIMAL only supports a maximum scale of 28 and the passed"
							+ " in value has a scale of " + in.scale());
		} else if (in.scale() < 0) {
			// should this cast to a string and call putStringRef()?
			throw new IllegalArgumentException(
					"VT_DECIMAL only supports a minimum scale of 0 and the passed"
							+ " in value has a scale of " + in.scale());
		} else if (allWordBigInt.bitLength() > 12 * 8) {
			throw new IllegalArgumentException(
					"VT_DECIMAL supports a maximum of "
							+ 12
							* 8
							+ " bits not counting scale and the number passed in has "
							+ allWordBigInt.bitLength());

		} else {
			// no bounds problem to be handled
		}

	}

	/**
	 * Largest possible number with scale set to 0
	 */
	private static final BigDecimal LARGEST_DECIMAL = new BigDecimal(
			new BigInteger("ffffffffffffffffffffffff", 16));
	/**
	 * Smallest possible number with scale set to 0. MS doesn't support negative
	 * scales like BigDecimal.
	 */
	private static final BigDecimal SMALLEST_DECIMAL = new BigDecimal(
			new BigInteger("ffffffffffffffffffffffff", 16).negate());

	/**
	 * Does any validation that couldn't have been fixed by rounding or scale
	 * modification.
	 * 
	 * @param in
	 *            The BigDecimal to be validated
	 * @throws IllegalArgumentException
	 *             if the number is too large or too small or null
	 */
	protected static void validateDecimalMinMax(BigDecimal in) {
		if (in == null) {
			throw new IllegalArgumentException(
					"null is not a supported Decimal value.");
		} else if (LARGEST_DECIMAL.compareTo(in) < 0) {
			throw new IllegalArgumentException(
					"Value too large for VT_DECIMAL data type:" + in.toString()
							+ " integer: " + in.toBigInteger().toString(16)
							+ " scale: " + in.scale());
		} else if (SMALLEST_DECIMAL.compareTo(in) > 0) {
			throw new IllegalArgumentException(
					"Value too small for VT_DECIMAL data type:" + in.toString()
							+ " integer: " + in.toBigInteger().toString(16)
							+ " scale: " + in.scale());
		}

	}

	/**
	 * Rounds the scale and bit length so that it will pass
	 * validateDecimalScaleBits(). Developers should call this method if they
	 * really want MS Decimal and don't want to lose precision.
	 * <p>
	 * Changing the scale on a number that can fit in an MS Decimal can change
	 * the number's representation enough that it will round to a number too
	 * large to be represented by an MS VT_DECIMAL
	 * 
	 * @param sourceDecimal
	 * @return BigDecimal a new big decimal that was rounded to fit in an MS
	 *         VT_DECIMAL
	 */
	public static BigDecimal roundToMSDecimal(BigDecimal sourceDecimal) {
		BigInteger sourceDecimalIntComponent = sourceDecimal.unscaledValue();
		BigDecimal destinationDecimal = new BigDecimal(
				sourceDecimalIntComponent, sourceDecimal.scale());
		int roundingModel = BigDecimal.ROUND_HALF_UP;
		validateDecimalMinMax(destinationDecimal);
		// First limit the number of digits and then the precision.
		// Try and round to 29 digits because we can sometimes do that
		BigInteger allWordBigInt;
		allWordBigInt = destinationDecimal.unscaledValue();
		if (allWordBigInt.bitLength() > 96) {
			destinationDecimal = destinationDecimal.round(new MathContext(29));
			// see if 29 digits uses more than 96 bits
			if (allWordBigInt.bitLength() > 96) {
				// Dang. It was over 97 bits so shorten it one more digit to
				// stay <= 96 bits
				destinationDecimal = destinationDecimal.round(new MathContext(
						28));
			}
		}
		// the bit manipulations above may change the scale so do it afterwards
		// round the scale to the max MS can support
		if (destinationDecimal.scale() > 28) {
			destinationDecimal = destinationDecimal.setScale(28, roundingModel);
		}
		if (destinationDecimal.scale() < 0) {
			destinationDecimal = destinationDecimal.setScale(0, roundingModel);
		}
		return destinationDecimal;
	}
}