/*

 * 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(){

        StringBuilder str = new StringBuilder("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;

}