/*
* Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
package javax.naming;
/**
* This class represents the binary form of the address of
* a communications end-point.
*<p>
* A BinaryRefAddr consists of a type that describes the communication mechanism
* and an opaque buffer containing the address description
* specific to that communication mechanism. The format and interpretation of
* the address type and the contents of the opaque buffer are based on
* the agreement of three parties: the client that uses the address,
* the object/server that can be reached using the address,
* and the administrator or program that creates the address.
*<p>
* An example of a binary reference address is an BER X.500 presentation address.
* Another example of a binary reference address is a serialized form of
* a service's object handle.
*<p>
* A binary reference address is immutable in the sense that its fields
* once created, cannot be replaced. However, it is possible to access
* the byte array used to hold the opaque buffer. Programs are strongly
* recommended against changing this byte array. Changes to this
* byte array need to be explicitly synchronized.
*
* @author Rosanna Lee
* @author Scott Seligman
*
* @see RefAddr
* @see StringRefAddr
* @since 1.3
*/
/*
* The serialized form of a BinaryRefAddr object consists of its type
* name String and a byte array containing its "contents".
*/
public class
BinaryRefAddr extends
RefAddr {
/**
* Contains the bytes of the address.
* This field is initialized by the constructor and returned
* using getAddressBytes() and getAddressContents().
* @serial
*/
private byte[]
buf = null;
/**
* Constructs a new instance of BinaryRefAddr using its address type and a byte
* array for contents.
*
* @param addrType A non-null string describing the type of the address.
* @param src The non-null contents of the address as a byte array.
* The contents of src is copied into the new BinaryRefAddr.
*/
public
BinaryRefAddr(
String addrType, byte[]
src) {
this(
addrType,
src, 0,
src.length);
}
/**
* Constructs a new instance of BinaryRefAddr using its address type and
* a region of a byte array for contents.
*
* @param addrType A non-null string describing the type of the address.
* @param src The non-null contents of the address as a byte array.
* The contents of src is copied into the new BinaryRefAddr.
* @param offset The starting index in src to get the bytes.
* {@code 0 <= offset <= src.length}.
* @param count The number of bytes to extract from src.
* {@code 0 <= count <= src.length-offset}.
*/
public
BinaryRefAddr(
String addrType, byte[]
src, int
offset, int
count) {
super(
addrType);
buf = new byte[
count];
System.
arraycopy(
src,
offset,
buf, 0,
count);
}
/**
* Retrieves the contents of this address as an Object.
* The result is a byte array.
* Changes to this array will affect this BinaryRefAddr's contents.
* Programs are recommended against changing this array's contents
* and to lock the buffer if they need to change it.
*
* @return The non-null buffer containing this address's contents.
*/
public
Object getContent() {
return
buf;
}
/**
* Determines whether obj is equal to this address. It is equal if
* it contains the same address type and their contents are byte-wise
* equivalent.
* @param obj The possibly null object to check.
* @return true if the object is equal; false otherwise.
*/
public boolean
equals(
Object obj) {
if ((
obj != null) && (
obj instanceof
BinaryRefAddr)) {
BinaryRefAddr target = (
BinaryRefAddr)
obj;
if (
addrType.
compareTo(
target.
addrType) == 0) {
if (
buf == null &&
target.
buf == null)
return true;
if (
buf == null ||
target.
buf == null ||
buf.length !=
target.
buf.length)
return false;
for (int
i = 0;
i <
buf.length;
i++)
if (
buf[
i] !=
target.
buf[
i])
return false;
return true;
}
}
return false;
}
/**
* Computes the hash code of this address using its address type and contents.
* Two BinaryRefAddrs have the same hash code if they have
* the same address type and the same contents.
* It is also possible for different BinaryRefAddrs to have
* the same hash code.
*
* @return The hash code of this address as an int.
*/
public int
hashCode() {
int
hash =
addrType.
hashCode();
for (int
i = 0;
i <
buf.length;
i++) {
hash +=
buf[
i]; // %%% improve later
}
return
hash;
}
/**
* Generates the string representation of this address.
* The string consists of the address's type and contents with labels.
* The first 32 bytes of contents are displayed (in hexadecimal).
* If there are more than 32 bytes, "..." is used to indicate more.
* This string is meant to used for debugging purposes and not
* meant to be interpreted programmatically.
* @return The non-null string representation of this address.
*/
public
String toString(){
StringBuffer str = new
StringBuffer("Address Type: " +
addrType + "\n");
str.
append("AddressContents: ");
for (int
i = 0;
i<
buf.length &&
i < 32;
i++) {
str.
append(
Integer.
toHexString(
buf[
i]) +" ");
}
if (
buf.length >= 32)
str.
append(" ...\n");
return (
str.
toString());
}
/**
* Use serialVersionUID from JNDI 1.1.1 for interoperability
*/
private static final long
serialVersionUID = -3415254970957330361L;
}