+ * 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. + *
+ * 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. + *
+ * 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(){
+ StringBuilder str = new StringBuilder("Address Type: " + addrType + "\n");
+
+ str.append("AddressContents: ");
+ for (int i = 0; i