1 /* 2 * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 package javax.sql.rowset.serial; 27 28 import java.sql.*; 29 import java.io.*; 30 import java.util.Arrays; 31 32 /** 33 * A serialized mapping in the Java programming language of an SQL 34 * <code>CLOB</code> value. 35 * <P> 36 * The <code>SerialClob</code> class provides a constructor for creating 37 * an instance from a <code>Clob</code> object. Note that the <code>Clob</code> 38 * object should have brought the SQL <code>CLOB</code> value's data over 39 * to the client before a <code>SerialClob</code> object 40 * is constructed from it. The data of an SQL <code>CLOB</code> value can 41 * be materialized on the client as a stream of Unicode characters. 42 * <P> 43 * <code>SerialClob</code> methods make it possible to get a substring 44 * from a <code>SerialClob</code> object or to locate the start of 45 * a pattern of characters. 46 * 47 * <h3> Thread safety </h3> 48 * 49 * <p> A SerialClob is not safe for use by multiple concurrent threads. If a 50 * SerialClob is to be used by more than one thread then access to the SerialClob 51 * should be controlled by appropriate synchronization. 52 * @author Jonathan Bruce 53 */ 54 public class SerialClob implements Clob, Serializable, Cloneable { 55 56 /** 57 * A serialized array of characters containing the data of the SQL 58 * <code>CLOB</code> value that this <code>SerialClob</code> object 59 * represents. 60 * 61 * @serial 62 */ 63 private char buf[]; 64 65 /** 66 * Internal Clob representation if SerialClob is initialized with a 67 * Clob. Null if SerialClob is initialized with a char[]. 68 */ 69 private Clob clob; 70 71 /** 72 * The length in characters of this <code>SerialClob</code> object's 73 * internal array of characters. 74 * 75 * @serial 76 */ 77 private long len; 78 79 /** 80 * The original length in characters of this <code>SerialClob</code> 81 * object's internal array of characters. 82 * 83 * @serial 84 */ 85 private long origLen; 86 87 /** 88 * Constructs a <code>SerialClob</code> object that is a serialized version of 89 * the given <code>char</code> array. 90 * <p> 91 * The new <code>SerialClob</code> object is initialized with the data from the 92 * <code>char</code> array, thus allowing disconnected <code>RowSet</code> 93 * objects to establish a serialized <code>Clob</code> object without touching 94 * the data source. 95 * 96 * @param ch the char array representing the <code>Clob</code> object to be 97 * serialized 98 * @throws SerialException if an error occurs during serialization 99 * @throws SQLException if a SQL error occurs 100 */ SerialClob(char ch[])101 public SerialClob(char ch[]) throws SerialException, SQLException { 102 103 // %%% JMB. Agreed. Add code here to throw a SQLException if no 104 // support is available for locatorsUpdateCopy=false 105 // Serializing locators is not supported. 106 107 len = ch.length; 108 buf = new char[(int)len]; 109 for (int i = 0; i < len ; i++){ 110 buf[i] = ch[i]; 111 } 112 origLen = len; 113 clob = null; 114 } 115 116 /** 117 * Constructs a <code>SerialClob</code> object that is a serialized 118 * version of the given <code>Clob</code> object. 119 * <P> 120 * The new <code>SerialClob</code> object is initialized with the 121 * data from the <code>Clob</code> object; therefore, the 122 * <code>Clob</code> object should have previously brought the 123 * SQL <code>CLOB</code> value's data over to the client from 124 * the database. Otherwise, the new <code>SerialClob</code> object 125 * object will contain no data. 126 * <p> 127 * Note: The <code>Clob</code> object supplied to this constructor must 128 * return non-null for both the <code>Clob.getCharacterStream()</code> 129 * and <code>Clob.getAsciiStream</code> methods. This <code>SerialClob</code> 130 * constructor cannot serialize a <code>Clob</code> object in this instance 131 * and will throw an <code>SQLException</code> object. 132 * 133 * @param clob the <code>Clob</code> object from which this 134 * <code>SerialClob</code> object is to be constructed; cannot be null 135 * @throws SerialException if an error occurs during serialization 136 * @throws SQLException if a SQL error occurs in capturing the CLOB; 137 * if the <code>Clob</code> object is a null; or if either of the 138 * <code>Clob.getCharacterStream()</code> and <code>Clob.getAsciiStream()</code> 139 * methods on the <code>Clob</code> returns a null 140 * @see java.sql.Clob 141 */ SerialClob(Clob clob)142 public SerialClob(Clob clob) throws SerialException, SQLException { 143 144 if (clob == null) { 145 throw new SQLException("Cannot instantiate a SerialClob " + 146 "object with a null Clob object"); 147 } 148 len = clob.length(); 149 this.clob = clob; 150 buf = new char[(int)len]; 151 int read = 0; 152 int offset = 0; 153 154 try (Reader charStream = clob.getCharacterStream()) { 155 if (charStream == null) { 156 throw new SQLException("Invalid Clob object. The call to getCharacterStream " + 157 "returned null which cannot be serialized."); 158 } 159 160 // Note: get an ASCII stream in order to null-check it, 161 // even though we don't do anything with it. 162 try (InputStream asciiStream = clob.getAsciiStream()) { 163 if (asciiStream == null) { 164 throw new SQLException("Invalid Clob object. The call to getAsciiStream " + 165 "returned null which cannot be serialized."); 166 } 167 } 168 169 try (Reader reader = new BufferedReader(charStream)) { 170 do { 171 read = reader.read(buf, offset, (int)(len - offset)); 172 offset += read; 173 } while (read > 0); 174 } 175 } catch (java.io.IOException ex) { 176 throw new SerialException("SerialClob: " + ex.getMessage()); 177 } 178 179 origLen = len; 180 } 181 182 /** 183 * Retrieves the number of characters in this <code>SerialClob</code> 184 * object's array of characters. 185 * 186 * @return a <code>long</code> indicating the length in characters of this 187 * <code>SerialClob</code> object's array of character 188 * @throws SerialException if an error occurs; 189 * if {@code free} had previously been called on this object 190 */ length()191 public long length() throws SerialException { 192 isValid(); 193 return len; 194 } 195 196 /** 197 * Returns this <code>SerialClob</code> object's data as a stream 198 * of Unicode characters. Unlike the related method, <code>getAsciiStream</code>, 199 * a stream is produced regardless of whether the <code>SerialClob</code> object 200 * was created with a <code>Clob</code> object or a <code>char</code> array. 201 * 202 * @return a <code>java.io.Reader</code> object containing this 203 * <code>SerialClob</code> object's data 204 * @throws SerialException if an error occurs; 205 * if {@code free} had previously been called on this object 206 */ getCharacterStream()207 public java.io.Reader getCharacterStream() throws SerialException { 208 isValid(); 209 return (java.io.Reader) new CharArrayReader(buf); 210 } 211 212 /** 213 * Retrieves the <code>CLOB</code> value designated by this <code>SerialClob</code> 214 * object as an ascii stream. This method forwards the <code>getAsciiStream</code> 215 * call to the underlying <code>Clob</code> object in the event that this 216 * <code>SerialClob</code> object is instantiated with a <code>Clob</code> 217 * object. If this <code>SerialClob</code> object is instantiated with 218 * a <code>char</code> array, a <code>SerialException</code> object is thrown. 219 * 220 * @return a <code>java.io.InputStream</code> object containing 221 * this <code>SerialClob</code> object's data 222 * @throws SerialException if this {@code SerialClob} object was not 223 * instantiated with a <code>Clob</code> object; 224 * if {@code free} had previously been called on this object 225 * @throws SQLException if there is an error accessing the 226 * <code>CLOB</code> value represented by the <code>Clob</code> object 227 * that was used to create this <code>SerialClob</code> object 228 */ getAsciiStream()229 public java.io.InputStream getAsciiStream() throws SerialException, SQLException { 230 isValid(); 231 if (this.clob != null) { 232 return this.clob.getAsciiStream(); 233 } else { 234 throw new SerialException("Unsupported operation. SerialClob cannot " + 235 "return a the CLOB value as an ascii stream, unless instantiated " + 236 "with a fully implemented Clob object."); 237 } 238 } 239 240 /** 241 * Returns a copy of the substring contained in this 242 * <code>SerialClob</code> object, starting at the given position 243 * and continuing for the specified number or characters. 244 * 245 * @param pos the position of the first character in the substring 246 * to be copied; the first character of the 247 * <code>SerialClob</code> object is at position 248 * <code>1</code>; must not be less than <code>1</code>, 249 * and the sum of the starting position and the length 250 * of the substring must be less than the length of this 251 * <code>SerialClob</code> object 252 * @param length the number of characters in the substring to be 253 * returned; must not be greater than the length of 254 * this <code>SerialClob</code> object, and the 255 * sum of the starting position and the length 256 * of the substring must be less than the length of this 257 * <code>SerialClob</code> object 258 * @return a <code>String</code> object containing a substring of 259 * this <code>SerialClob</code> object beginning at the 260 * given position and containing the specified number of 261 * consecutive characters 262 * @throws SerialException if either of the arguments is out of bounds; 263 * if {@code free} had previously been called on this object 264 */ getSubString(long pos, int length)265 public String getSubString(long pos, int length) throws SerialException { 266 267 isValid(); 268 if (pos < 1 || pos > this.length()) { 269 throw new SerialException("Invalid position in SerialClob object set"); 270 } 271 272 if ((pos-1) + length > this.length()) { 273 throw new SerialException("Invalid position and substring length"); 274 } 275 276 try { 277 return new String(buf, (int)pos - 1, length); 278 279 } catch (StringIndexOutOfBoundsException e) { 280 throw new SerialException("StringIndexOutOfBoundsException: " + 281 e.getMessage()); 282 } 283 284 } 285 286 /** 287 * Returns the position in this <code>SerialClob</code> object 288 * where the given <code>String</code> object begins, starting 289 * the search at the specified position. This method returns 290 * <code>-1</code> if the pattern is not found. 291 * 292 * @param searchStr the <code>String</code> object for which to 293 * search 294 * @param start the position in this <code>SerialClob</code> object 295 * at which to start the search; the first position is 296 * <code>1</code>; must not be less than <code>1</code> nor 297 * greater than the length of this <code>SerialClob</code> object 298 * @return the position at which the given <code>String</code> object 299 * begins, starting the search at the specified position; 300 * <code>-1</code> if the given <code>String</code> object is 301 * not found or the starting position is out of bounds; position 302 * numbering for the return value starts at <code>1</code> 303 * @throws SerialException if the {@code free} method had been 304 * previously called on this object 305 * @throws SQLException if there is an error accessing the Clob value 306 * from the database. 307 */ position(String searchStr, long start)308 public long position(String searchStr, long start) 309 throws SerialException, SQLException { 310 isValid(); 311 if (start < 1 || start > len) { 312 return -1; 313 } 314 315 char pattern[] = searchStr.toCharArray(); 316 317 int pos = (int)start-1; 318 int i = 0; 319 long patlen = pattern.length; 320 321 while (pos < len) { 322 if (pattern[i] == buf[pos]) { 323 if (i + 1 == patlen) { 324 return (pos + 1) - (patlen - 1); 325 } 326 i++; pos++; // increment pos, and i 327 328 } else if (pattern[i] != buf[pos]) { 329 pos++; // increment pos only 330 } 331 } 332 return -1; // not found 333 } 334 335 /** 336 * Returns the position in this <code>SerialClob</code> object 337 * where the given <code>Clob</code> signature begins, starting 338 * the search at the specified position. This method returns 339 * <code>-1</code> if the pattern is not found. 340 * 341 * @param searchStr the <code>Clob</code> object for which to search 342 * @param start the position in this <code>SerialClob</code> object 343 * at which to begin the search; the first position is 344 * <code>1</code>; must not be less than <code>1</code> nor 345 * greater than the length of this <code>SerialClob</code> object 346 * @return the position at which the given <code>Clob</code> 347 * object begins in this <code>SerialClob</code> object, 348 * at or after the specified starting position 349 * @throws SerialException if an error occurs locating the Clob signature; 350 * if the {@code free} method had been previously called on this object 351 * @throws SQLException if there is an error accessing the Clob value 352 * from the database 353 */ position(Clob searchStr, long start)354 public long position(Clob searchStr, long start) 355 throws SerialException, SQLException { 356 isValid(); 357 return position(searchStr.getSubString(1,(int)searchStr.length()), start); 358 } 359 360 /** 361 * Writes the given Java <code>String</code> to the <code>CLOB</code> 362 * value that this <code>SerialClob</code> object represents, at the position 363 * <code>pos</code>. 364 * 365 * @param pos the position at which to start writing to the <code>CLOB</code> 366 * value that this <code>SerialClob</code> object represents; the first 367 * position is <code>1</code>; must not be less than <code>1</code> nor 368 * greater than the length of this <code>SerialClob</code> object 369 * @param str the string to be written to the <code>CLOB</code> 370 * value that this <code>SerialClob</code> object represents 371 * @return the number of characters written 372 * @throws SerialException if there is an error accessing the 373 * <code>CLOB</code> value; if an invalid position is set; if an 374 * invalid offset value is set; if number of bytes to be written 375 * is greater than the <code>SerialClob</code> length; or the combined 376 * values of the length and offset is greater than the Clob buffer; 377 * if the {@code free} method had been previously called on this object 378 */ setString(long pos, String str)379 public int setString(long pos, String str) throws SerialException { 380 return (setString(pos, str, 0, str.length())); 381 } 382 383 /** 384 * Writes <code>len</code> characters of <code>str</code>, starting 385 * at character <code>offset</code>, to the <code>CLOB</code> value 386 * that this <code>Clob</code> represents. 387 * 388 * @param pos the position at which to start writing to the <code>CLOB</code> 389 * value that this <code>SerialClob</code> object represents; the first 390 * position is <code>1</code>; must not be less than <code>1</code> nor 391 * greater than the length of this <code>SerialClob</code> object 392 * @param str the string to be written to the <code>CLOB</code> 393 * value that this <code>Clob</code> object represents 394 * @param offset the offset into <code>str</code> to start reading 395 * the characters to be written 396 * @param length the number of characters to be written 397 * @return the number of characters written 398 * @throws SerialException if there is an error accessing the 399 * <code>CLOB</code> value; if an invalid position is set; if an 400 * invalid offset value is set; if number of bytes to be written 401 * is greater than the <code>SerialClob</code> length; or the combined 402 * values of the length and offset is greater than the Clob buffer; 403 * if the {@code free} method had been previously called on this object 404 */ setString(long pos, String str, int offset, int length)405 public int setString(long pos, String str, int offset, int length) 406 throws SerialException { 407 isValid(); 408 String temp = str.substring(offset); 409 char cPattern[] = temp.toCharArray(); 410 411 if (offset < 0 || offset > str.length()) { 412 throw new SerialException("Invalid offset in byte array set"); 413 } 414 415 if (pos < 1 || pos > this.length()) { 416 throw new SerialException("Invalid position in Clob object set"); 417 } 418 419 if ((long)(length) > origLen) { 420 throw new SerialException("Buffer is not sufficient to hold the value"); 421 } 422 423 if ((length + offset) > str.length()) { 424 // need check to ensure length + offset !> bytes.length 425 throw new SerialException("Invalid OffSet. Cannot have combined offset " + 426 " and length that is greater that the Blob buffer"); 427 } 428 429 int i = 0; 430 pos--; //values in the array are at position one less 431 while ( i < length || (offset + i +1) < (str.length() - offset ) ) { 432 this.buf[(int)pos + i ] = cPattern[offset + i ]; 433 i++; 434 } 435 return i; 436 } 437 438 /** 439 * Retrieves a stream to be used to write Ascii characters to the 440 * <code>CLOB</code> value that this <code>SerialClob</code> object represents, 441 * starting at position <code>pos</code>. This method forwards the 442 * <code>setAsciiStream()</code> call to the underlying <code>Clob</code> object in 443 * the event that this <code>SerialClob</code> object is instantiated with a 444 * <code>Clob</code> object. If this <code>SerialClob</code> object is instantiated 445 * with a <code>char</code> array, a <code>SerialException</code> object is thrown. 446 * 447 * @param pos the position at which to start writing to the 448 * <code>CLOB</code> object 449 * @return the stream to which ASCII encoded characters can be written 450 * @throws SerialException if SerialClob is not instantiated with a 451 * Clob object; 452 * if the {@code free} method had been previously called on this object 453 * @throws SQLException if there is an error accessing the 454 * <code>CLOB</code> value 455 * @see #getAsciiStream 456 */ setAsciiStream(long pos)457 public java.io.OutputStream setAsciiStream(long pos) 458 throws SerialException, SQLException { 459 isValid(); 460 if (this.clob != null) { 461 return this.clob.setAsciiStream(pos); 462 } else { 463 throw new SerialException("Unsupported operation. SerialClob cannot " + 464 "return a writable ascii stream\n unless instantiated with a Clob object " + 465 "that has a setAsciiStream() implementation"); 466 } 467 } 468 469 /** 470 * Retrieves a stream to be used to write a stream of Unicode characters 471 * to the <code>CLOB</code> value that this <code>SerialClob</code> object 472 * represents, at position <code>pos</code>. This method forwards the 473 * <code>setCharacterStream()</code> call to the underlying <code>Clob</code> 474 * object in the event that this <code>SerialClob</code> object is instantiated with a 475 * <code>Clob</code> object. If this <code>SerialClob</code> object is instantiated with 476 * a <code>char</code> array, a <code>SerialException</code> is thrown. 477 * 478 * @param pos the position at which to start writing to the 479 * <code>CLOB</code> value 480 * 481 * @return a stream to which Unicode encoded characters can be written 482 * @throws SerialException if the SerialClob is not instantiated with 483 * a Clob object; 484 * if the {@code free} method had been previously called on this object 485 * @throws SQLException if there is an error accessing the 486 * <code>CLOB</code> value 487 * @see #getCharacterStream 488 */ setCharacterStream(long pos)489 public java.io.Writer setCharacterStream(long pos) 490 throws SerialException, SQLException { 491 isValid(); 492 if (this.clob != null) { 493 return this.clob.setCharacterStream(pos); 494 } else { 495 throw new SerialException("Unsupported operation. SerialClob cannot " + 496 "return a writable character stream\n unless instantiated with a Clob object " + 497 "that has a setCharacterStream implementation"); 498 } 499 } 500 501 /** 502 * Truncates the <code>CLOB</code> value that this <code>SerialClob</code> 503 * object represents so that it has a length of <code>len</code> 504 * characters. 505 * <p> 506 * Truncating a <code>SerialClob</code> object to length 0 has the effect of 507 * clearing its contents. 508 * 509 * @param length the length, in bytes, to which the <code>CLOB</code> 510 * value should be truncated 511 * @throws SerialException if there is an error accessing the 512 * <code>CLOB</code> value; 513 * if the {@code free} method had been previously called on this object 514 */ truncate(long length)515 public void truncate(long length) throws SerialException { 516 isValid(); 517 if (length > len) { 518 throw new SerialException 519 ("Length more than what can be truncated"); 520 } else { 521 len = length; 522 // re-size the buffer 523 524 if (len == 0) { 525 buf = new char[] {}; 526 } else { 527 buf = (this.getSubString(1, (int)len)).toCharArray(); 528 } 529 } 530 } 531 532 533 /** 534 * Returns a {@code Reader} object that contains a partial 535 * {@code SerialClob} value, starting 536 * with the character specified by pos, which is length characters in length. 537 * 538 * @param pos the offset to the first character of the partial value to 539 * be retrieved. The first character in the {@code SerialClob} is at position 1. 540 * @param length the length in characters of the partial value to be retrieved. 541 * @return {@code Reader} through which the partial {@code SerialClob} 542 * value can be read. 543 * @throws SQLException if pos is less than 1 or if pos is greater than the 544 * number of characters in the {@code SerialClob} or if pos + length 545 * is greater than the number of characters in the {@code SerialClob}; 546 * @throws SerialException if the {@code free} method had been previously 547 * called on this object 548 * @since 1.6 549 */ getCharacterStream(long pos, long length)550 public Reader getCharacterStream(long pos, long length) throws SQLException { 551 isValid(); 552 if (pos < 1 || pos > len) { 553 throw new SerialException("Invalid position in Clob object set"); 554 } 555 556 if ((pos-1) + length > len) { 557 throw new SerialException("Invalid position and substring length"); 558 } 559 if (length <= 0) { 560 throw new SerialException("Invalid length specified"); 561 } 562 return new CharArrayReader(buf, (int)pos, (int)length); 563 } 564 565 /** 566 * This method frees the {@code SeriableClob} object and releases the 567 * resources that it holds. 568 * The object is invalid once the {@code free} method is called. 569 * <p> 570 * If {@code free} is called multiple times, the subsequent 571 * calls to {@code free} are treated as a no-op. 572 * </P> 573 * @throws SQLException if an error occurs releasing 574 * the Clob's resources 575 * @since 1.6 576 */ free()577 public void free() throws SQLException { 578 if (buf != null) { 579 buf = null; 580 if (clob != null) { 581 clob.free(); 582 } 583 clob = null; 584 } 585 } 586 587 /** 588 * Compares this SerialClob to the specified object. The result is {@code 589 * true} if and only if the argument is not {@code null} and is a {@code 590 * SerialClob} object that represents the same sequence of characters as this 591 * object. 592 * 593 * @param obj The object to compare this {@code SerialClob} against 594 * 595 * @return {@code true} if the given object represents a {@code SerialClob} 596 * equivalent to this SerialClob, {@code false} otherwise 597 * 598 */ equals(Object obj)599 public boolean equals(Object obj) { 600 if (this == obj) { 601 return true; 602 } 603 if (obj instanceof SerialClob) { 604 SerialClob sc = (SerialClob)obj; 605 if (this.len == sc.len) { 606 return Arrays.equals(buf, sc.buf); 607 } 608 } 609 return false; 610 } 611 612 /** 613 * Returns a hash code for this {@code SerialClob}. 614 * @return a hash code value for this object. 615 */ hashCode()616 public int hashCode() { 617 return ((31 + Arrays.hashCode(buf)) * 31 + (int)len) * 31 + (int)origLen; 618 } 619 620 /** 621 * Returns a clone of this {@code SerialClob}. The copy will contain a 622 * reference to a clone of the internal character array, not a reference 623 * to the original internal character array of this {@code SerialClob} object. 624 * The underlying {@code Clob} object will be set to null. 625 * 626 * @return a clone of this SerialClob 627 */ clone()628 public Object clone() { 629 try { 630 SerialClob sc = (SerialClob) super.clone(); 631 sc.buf = (buf != null) ? Arrays.copyOf(buf, (int)len) : null; 632 sc.clob = null; 633 return sc; 634 } catch (CloneNotSupportedException ex) { 635 // this shouldn't happen, since we are Cloneable 636 throw new InternalError(); 637 } 638 } 639 640 /** 641 * readObject is called to restore the state of the SerialClob from 642 * a stream. 643 */ readObject(ObjectInputStream s)644 private void readObject(ObjectInputStream s) 645 throws IOException, ClassNotFoundException { 646 647 ObjectInputStream.GetField fields = s.readFields(); 648 char[] tmp = (char[])fields.get("buf", null); 649 if (tmp == null) 650 throw new InvalidObjectException("buf is null and should not be!"); 651 buf = tmp.clone(); 652 len = fields.get("len", 0L); 653 if (buf.length != len) 654 throw new InvalidObjectException("buf is not the expected size"); 655 origLen = fields.get("origLen", 0L); 656 clob = (Clob) fields.get("clob", null); 657 } 658 659 /** 660 * writeObject is called to save the state of the SerialClob 661 * to a stream. 662 */ writeObject(ObjectOutputStream s)663 private void writeObject(ObjectOutputStream s) 664 throws IOException, ClassNotFoundException { 665 666 ObjectOutputStream.PutField fields = s.putFields(); 667 fields.put("buf", buf); 668 fields.put("len", len); 669 fields.put("origLen", origLen); 670 // Note: this check to see if it is an instance of Serializable 671 // is for backwards compatibiity 672 fields.put("clob", clob instanceof Serializable ? clob : null); 673 s.writeFields(); 674 } 675 676 /** 677 * Check to see if this object had previously had its {@code free} method 678 * called 679 * 680 * @throws SerialException 681 */ isValid()682 private void isValid() throws SerialException { 683 if (buf == null) { 684 throw new SerialException("Error: You cannot call a method on a " 685 + "SerialClob instance once free() has been called."); 686 } 687 } 688 689 /** 690 * The identifier that assists in the serialization of this {@code SerialClob} 691 * object. 692 */ 693 static final long serialVersionUID = -1662519690087375313L; 694 } 695