You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
258 lines
7.8 KiB
258 lines
7.8 KiB
/*
|
|
* Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
|
|
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*/
|
|
|
|
package javax.sql.rowset.serial;
|
|
|
|
import java.sql.*;
|
|
import java.io.*;
|
|
import java.util.*;
|
|
|
|
/**
|
|
* A serialized mapping of a <code>Ref</code> object, which is the mapping in the
|
|
* Java programming language of an SQL <code>REF</code> value.
|
|
* <p>
|
|
* The <code>SerialRef</code> class provides a constructor for
|
|
* creating a <code>SerialRef</code> instance from a <code>Ref</code>
|
|
* object and provides methods for getting and setting the <code>Ref</code> object.
|
|
*
|
|
* <h3> Thread safety </h3>
|
|
*
|
|
* A SerialRef is not safe for use by multiple concurrent threads. If a
|
|
* SerialRef is to be used by more than one thread then access to the SerialRef
|
|
* should be controlled by appropriate synchronization.
|
|
*
|
|
*/
|
|
public class SerialRef implements Ref, Serializable, Cloneable {
|
|
|
|
/**
|
|
* String containing the base type name.
|
|
* @serial
|
|
*/
|
|
private String baseTypeName;
|
|
|
|
/**
|
|
* This will store the type <code>Ref</code> as an <code>Object</code>.
|
|
*/
|
|
private Object object;
|
|
|
|
/**
|
|
* Private copy of the Ref reference.
|
|
*/
|
|
private Ref reference;
|
|
|
|
/**
|
|
* Constructs a <code>SerialRef</code> object from the given <code>Ref</code>
|
|
* object.
|
|
*
|
|
* @param ref a Ref object; cannot be <code>null</code>
|
|
* @throws SQLException if a database access occurs; if <code>ref</code>
|
|
* is <code>null</code>; or if the <code>Ref</code> object returns a
|
|
* <code>null</code> value base type name.
|
|
* @throws SerialException if an error occurs serializing the <code>Ref</code>
|
|
* object
|
|
*/
|
|
public SerialRef(Ref ref) throws SerialException, SQLException {
|
|
if (ref == null) {
|
|
throw new SQLException("Cannot instantiate a SerialRef object " +
|
|
"with a null Ref object");
|
|
}
|
|
reference = ref;
|
|
object = ref;
|
|
if (ref.getBaseTypeName() == null) {
|
|
throw new SQLException("Cannot instantiate a SerialRef object " +
|
|
"that returns a null base type name");
|
|
} else {
|
|
baseTypeName = ref.getBaseTypeName();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns a string describing the base type name of the <code>Ref</code>.
|
|
*
|
|
* @return a string of the base type name of the Ref
|
|
* @throws SerialException in no Ref object has been set
|
|
*/
|
|
public String getBaseTypeName() throws SerialException {
|
|
return baseTypeName;
|
|
}
|
|
|
|
/**
|
|
* Returns an <code>Object</code> representing the SQL structured type
|
|
* to which this <code>SerialRef</code> object refers. The attributes
|
|
* of the structured type are mapped according to the given type map.
|
|
*
|
|
* @param map a <code>java.util.Map</code> object containing zero or
|
|
* more entries, with each entry consisting of 1) a <code>String</code>
|
|
* giving the fully qualified name of a UDT and 2) the
|
|
* <code>Class</code> object for the <code>SQLData</code> implementation
|
|
* that defines how the UDT is to be mapped
|
|
* @return an object instance resolved from the Ref reference and mapped
|
|
* according to the supplied type map
|
|
* @throws SerialException if an error is encountered in the reference
|
|
* resolution
|
|
*/
|
|
public Object getObject(java.util.Map<String,Class<?>> map)
|
|
throws SerialException
|
|
{
|
|
map = new Hashtable<String, Class<?>>(map);
|
|
if (object != null) {
|
|
return map.get(object);
|
|
} else {
|
|
throw new SerialException("The object is not set");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns an <code>Object</code> representing the SQL structured type
|
|
* to which this <code>SerialRef</code> object refers.
|
|
*
|
|
* @return an object instance resolved from the Ref reference
|
|
* @throws SerialException if an error is encountered in the reference
|
|
* resolution
|
|
*/
|
|
public Object getObject() throws SerialException {
|
|
|
|
if (reference != null) {
|
|
try {
|
|
return reference.getObject();
|
|
} catch (SQLException e) {
|
|
throw new SerialException("SQLException: " + e.getMessage());
|
|
}
|
|
}
|
|
|
|
if (object != null) {
|
|
return object;
|
|
}
|
|
|
|
|
|
throw new SerialException("The object is not set");
|
|
|
|
}
|
|
|
|
/**
|
|
* Sets the SQL structured type that this <code>SerialRef</code> object
|
|
* references to the given <code>Object</code> object.
|
|
*
|
|
* @param obj an <code>Object</code> representing the SQL structured type
|
|
* to be referenced
|
|
* @throws SerialException if an error is encountered generating the
|
|
* the structured type referenced by this <code>SerialRef</code> object
|
|
*/
|
|
public void setObject(Object obj) throws SerialException {
|
|
try {
|
|
reference.setObject(obj);
|
|
} catch (SQLException e) {
|
|
throw new SerialException("SQLException: " + e.getMessage());
|
|
}
|
|
object = obj;
|
|
}
|
|
|
|
/**
|
|
* Compares this SerialRef to the specified object. The result is {@code
|
|
* true} if and only if the argument is not {@code null} and is a {@code
|
|
* SerialRef} object that represents the same object as this
|
|
* object.
|
|
*
|
|
* @param obj The object to compare this {@code SerialRef} against
|
|
*
|
|
* @return {@code true} if the given object represents a {@code SerialRef}
|
|
* equivalent to this SerialRef, {@code false} otherwise
|
|
*
|
|
*/
|
|
public boolean equals(Object obj) {
|
|
if (this == obj) {
|
|
return true;
|
|
}
|
|
if(obj instanceof SerialRef) {
|
|
SerialRef ref = (SerialRef)obj;
|
|
return baseTypeName.equals(ref.baseTypeName) &&
|
|
object.equals(ref.object);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Returns a hash code for this {@code SerialRef}.
|
|
* @return a hash code value for this object.
|
|
*/
|
|
public int hashCode() {
|
|
return (31 + object.hashCode()) * 31 + baseTypeName.hashCode();
|
|
}
|
|
|
|
/**
|
|
* Returns a clone of this {@code SerialRef}.
|
|
* The underlying {@code Ref} object will be set to null.
|
|
*
|
|
* @return a clone of this SerialRef
|
|
*/
|
|
public Object clone() {
|
|
try {
|
|
SerialRef ref = (SerialRef) super.clone();
|
|
ref.reference = null;
|
|
return ref;
|
|
} catch (CloneNotSupportedException ex) {
|
|
// this shouldn't happen, since we are Cloneable
|
|
throw new InternalError();
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* readObject is called to restore the state of the SerialRef from
|
|
* a stream.
|
|
*/
|
|
private void readObject(ObjectInputStream s)
|
|
throws IOException, ClassNotFoundException {
|
|
ObjectInputStream.GetField fields = s.readFields();
|
|
object = fields.get("object", null);
|
|
baseTypeName = (String) fields.get("baseTypeName", null);
|
|
reference = (Ref) fields.get("reference", null);
|
|
}
|
|
|
|
/**
|
|
* writeObject is called to save the state of the SerialRef
|
|
* to a stream.
|
|
*/
|
|
private void writeObject(ObjectOutputStream s)
|
|
throws IOException, ClassNotFoundException {
|
|
|
|
ObjectOutputStream.PutField fields = s.putFields();
|
|
fields.put("baseTypeName", baseTypeName);
|
|
fields.put("object", object);
|
|
// Note: this check to see if it is an instance of Serializable
|
|
// is for backwards compatibiity
|
|
fields.put("reference", reference instanceof Serializable ? reference : null);
|
|
s.writeFields();
|
|
}
|
|
|
|
/**
|
|
* The identifier that assists in the serialization of this <code>SerialRef</code>
|
|
* object.
|
|
*/
|
|
static final long serialVersionUID = -4727123500609662274L;
|
|
|
|
|
|
}
|