jdk-sandbox: comparison jdk/src/java.sql.rowset/share/classes/javax/sql/rowset/serial/SerialBlob.java

equal deleted inserted replaced

-:3dba338b5d00
+:701f6f90dc0b
 /*
-* Copyright (c) 2003, 2014, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2003, 2015, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 /**
 * A serialized array of uninterpreted bytes representing the
 * value of this <code>SerialBlob</code> object.
 * @serial
 */
-private byte buf[];
+private byte[] buf;
 /**
 * The internal representation of the <code>Blob</code> object on which this
 * <code>SerialBlob</code> object is based.
 */
 * @param b the <code>byte</code> array containing the data for the
 *        <code>Blob</code> object to be serialized
 * @throws SerialException if an error occurs during serialization
 * @throws SQLException if a SQL errors occurs
 */
-public SerialBlob(byte[] b) throws SerialException, SQLException {
+public SerialBlob(byte[] b)
+throws SerialException, SQLException {
 len = b.length;
 buf = new byte[(int)len];
 for(int i = 0; i < len; i++) {
 buf[i] = b[i];
 }
 origLen = len;
 }
 * @throws SerialException if an error occurs during serialization
 * @throws SQLException if the <code>Blob</code> passed to this
 *     to this constructor is a <code>null</code>.
 * @see java.sql.Blob
 */
-public SerialBlob (Blob blob) throws SerialException, SQLException {
+public SerialBlob (Blob blob)
+throws SerialException, SQLException {
 if (blob == null) {
-throw new SQLException("Cannot instantiate a SerialBlob " +
+throw new SQLException(
-"object with a null Blob object");
+"Cannot instantiate a SerialBlob object with a null Blob object");
 }
 len = blob.length();
 buf = blob.getBytes(1, (int)len );
 this.blob = blob;
-//if ( len < 10240000)
-// len = 10240000;
 origLen = len;
 }
 /**
 * Copies the specified number of bytes, starting at the given
 * if {@code free} had previously been called on this object
 * @throws SQLException if there is an error accessing the <code>BLOB</code>
 *         value from the database
 */
 public long position(byte[] pattern, long start)
 throws SerialException, SQLException {
 isValid();
 if (start < 1 || start > len) {
 return -1;
 }
 * if {@code free} had previously been called on this object
 * @throws SQLException if there is an error accessing the <code>BLOB</code>
 *         value from the database
 */
 public long position(Blob pattern, long start)
 throws SerialException, SQLException {
 isValid();
 return position(pattern.getBytes(1, (int)(pattern.length())), start);
 }
 /**
 * @throws SQLException if there is an error accessing the <code>BLOB</code>
 *         value from the database
 * @see #getBytes
 */
 public int setBytes(long pos, byte[] bytes)
 throws SerialException, SQLException {
-return (setBytes(pos, bytes, 0, bytes.length));
+return setBytes(pos, bytes, 0, bytes.length);
 }
 /**
 * Writes all or part of the given <code>byte</code> array to the
 * <code>BLOB</code> value that this <code>Blob</code> object represents
 * @throws SQLException if there is an error accessing the <code>BLOB</code>
 *         value from the database.
 * @see #getBytes
 */
 public int setBytes(long pos, byte[] bytes, int offset, int length)
 throws SerialException, SQLException {
 isValid();
 if (offset < 0 || offset > bytes.length) {
 throw new SerialException("Invalid offset in byte array set");
 }
 throw new SerialException("Buffer is not sufficient to hold the value");
 }
 if ((length + offset) > bytes.length) {
 throw new SerialException("Invalid OffSet. Cannot have combined offset " +
 "and length that is greater that the Blob buffer");
 }
 int i = 0;
 pos--; // correct to array indexing
 while ( i < length || (offset + i +1) < (bytes.length-offset) ) {
 *     <code>Blob</code> object that supports <code>setBinaryStream()</code>;
 * if {@code free} had previously been called on this object
 * @see #getBinaryStream
 */
 public java.io.OutputStream setBinaryStream(long pos)
 throws SerialException, SQLException {
 isValid();
 if (this.blob != null) {
 return this.blob.setBinaryStream(pos);
 } else {
 throw new SerialException("Unsupported operation. SerialBlob cannot " +
 * @throws SerialException if there is an error accessing the Blob value;
 *     or the length to truncate is greater that the SerialBlob length;
 * if {@code free} had previously been called on this object
 */
 public void truncate(long length) throws SerialException {
 isValid();
 if (length > len) {
-throw new SerialException
+throw new SerialException(
-("Length more than what can be truncated");
+"Length more than what can be truncated");
 } else if((int)length == 0) {
 buf = new byte[0];
 len = length;
 } else {
 len = length;
 buf = this.getBytes(1, (int)len);
 }
 }
 /**
 isValid();
 if (pos < 1 || pos > this.length()) {
 throw new SerialException("Invalid position in BLOB object set");
 }
 if (length < 1 || length > len - pos + 1) {
-throw new SerialException("length is < 1 or pos + length >"
+throw new SerialException(
-+ "total number of bytes");
+"length is < 1 or pos + length > total number of bytes");
 }
 return new ByteArrayInputStream(buf, (int) pos - 1, (int) length);
 }
 * @return  a clone of this SerialBlob
 */
 public Object clone() {
 try {
 SerialBlob sb = (SerialBlob) super.clone();
-sb.buf =  (buf != null) ? Arrays.copyOf(buf, (int)len) : null;
+sb.buf = (buf != null) ? Arrays.copyOf(buf, (int)len) : null;
 sb.blob = null;
 return sb;
 } catch (CloneNotSupportedException ex) {
 // this shouldn't happen, since we are Cloneable
 throw new InternalError();
 }
 }
 /**
 * readObject is called to restore the state of the SerialBlob from
 * a stream.
 */
 private void readObject(ObjectInputStream s)
 throws IOException, ClassNotFoundException {
 ObjectInputStream.GetField fields = s.readFields();
 byte[] tmp = (byte[])fields.get("buf", null);
 if (tmp == null)
 throw new InvalidObjectException("buf is null and should not be!");
 buf = tmp.clone();
 len = fields.get("len", 0L);
 if (buf.length != len)
 throw new InvalidObjectException("buf is not the expected size");
 origLen = fields.get("origLen", 0L);
 blob = (Blob) fields.get("blob", null);
 }
 /**
 * writeObject is called to save the state of the SerialBlob
 * to a stream.
 *
 * @throws SerialException
 */
 private void isValid() throws SerialException {
 if (buf == null) {
-throw new SerialException("Error: You cannot call a method on a "
+throw new SerialException("Error: You cannot call a method on a " +
-+ "SerialBlob instance once free() has been called.");
+"SerialBlob instance once free() has been called.");
 }
 }
 /**
 * The identifier that assists in the serialization of this

changeset 30641	701f6f90dc0b
parent 25991	e48157b42439