/* |
|
* Copyright (c) 1999, 2013, 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 |
|
* particular file as subject to the "Classpath" exception as provided |
|
* by Oracle in the LICENSE file that accompanied this code. |
|
* |
|
* This code is distributed in the hope that it will be useful, but WITHOUT |
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
* version 2 for more details (a copy is included in the LICENSE file that |
|
* accompanied this code). |
|
* |
|
* You should have received a copy of the GNU General Public License version |
|
* 2 along with this work; if not, write to the Free Software Foundation, |
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
|
* |
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
* or visit www.oracle.com if you need additional information or have any |
|
* questions. |
|
*/ |
|
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; |
|
} |