Quadcap Embeddable Server

com/quadcap/util/OctetString.java

Go to the documentation of this file.

package com.quadcap.util;

/* Copyright 1997 - 2003 Quadcap Software.  All rights reserved.
 *
 * This software is distributed under the Quadcap Free Software License.
 * This software may be used or modified for any purpose, personal or
 * commercial.  Open Source redistributions are permitted.  Commercial
 * redistribution of larger works derived from, or works which bundle
 * this software requires a "Commercial Redistribution License"; see
 * http://www.quadcap.com/purchase.
 *
 * Redistributions qualify as "Open Source" under  one of the following terms:
 *   
 *    Redistributions are made at no charge beyond the reasonable cost of
 *    materials and delivery.
 *
 *    Redistributions are accompanied by a copy of the Source Code or by an
 *    irrevocable offer to provide a copy of the Source Code for up to three
 *    years at the cost of materials and delivery.  Such redistributions
 *    must allow further use, modification, and redistribution of the Source
 *    Code under substantially the same terms as this license.
 *
 * Redistributions of source code must retain the copyright notices as they
 * appear in each source code file, these license terms, and the
 * disclaimer/limitation of liability set forth as paragraph 6 below.
 *
 * Redistributions in binary form must reproduce this Copyright Notice,
 * these license terms, and the disclaimer/limitation of liability set
 * forth as paragraph 6 below, in the documentation and/or other materials
 * provided with the distribution.
 *
 * The Software is provided on an "AS IS" basis.  No warranty is
 * provided that the Software is free of defects, or fit for a
 * particular purpose.  
 *
 * Limitation of Liability. Quadcap Software shall not be liable
 * for any damages suffered by the Licensee or any third party resulting
 * from use of the Software.
 */

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.io.IOException;
import java.io.OutputStream;

/**
 * An OctetString is a variable length string of octets.
 *
 * @author Stan Bailes
 */
public class OctetString {
    byte[]                      data;

    /**
     * Construct a new OctetString using the specified byte array.  Note
     * that we simply acquire the byte array -- no copying is done!
     *
     * @param data the byte array making up the string
     */
    public OctetString(byte[] data) {
        this.data = data;
    }

    /**
     * Construct a new OctetString using a substring from the specified byte
     * array.  This constructor <b>does</b> allocate a new byte array and
     * copies data from the original array.
     *
     * @param data the source byte array
     * @param offset the position of the first character in the substring
     * @param len the number of bytes in the new string
     */
    public OctetString(byte[] data, int offset, int len) {
        this.data = new byte[len];
        System.arraycopy(data, offset, this.data, 0, len);
    }

    /**
     * Construct a new OctetString from the specified java.lang.String value.
     *
     * @param str the string value
     */
    public OctetString(String str) {
        this.data = str.getBytes();
    }

    /**
     * Return the string representation of this item.
     *
     * @return the string value
     */
    public String toString() { return new String(data); }

    /**
     * For types which can be directly handled by comparators, return this
     * object as a byte array.  For special types (e.g., NIL or List),
     * return null.
     */
    public byte[] getBytes() { return data; }

    public int hashCode() {
        return new String(data).hashCode();
    }
    
    public boolean equals(Object obj) {
        if (obj instanceof OctetString) {
            return OctetComparator.cmp.compare(this, (OctetString)obj) == 0;
        }
        return false;
    }

    public boolean equalsIgnoreCase(Object obj) {
        if (obj instanceof OctetString) {
            OctetString other = (OctetString)obj;
            return OctetComparator.casecmp.compare(this, other) == 0;
        }
        return false;
    }

    /**
     * Return the size of this string.
     */
    public int size() { return data.length; }

    /**
     * String comparison using the binary equality comparator
     */
    public static boolean equals(OctetString s1, int pos1,
                                 OctetString s2, int pos2, int len) {
        for (int i = 0; i < len; i++) {
            if (pos1 + i >= s1.data.length ||
                pos2 + i >= s2.data.length) return false;
            if (s1.data[pos1 + i] != s2.data[pos2 + i]) return false;
        }
        return true;
    }

    /**
     * String search for character.  Should this use a comparator? XXX
     *
     * @param c the character to search for
     * @return the index of the first occurrence of the character in this
     *          string, or -1 if the character does not occur in the string.
     */
    public int indexOf(char c) {
        byte b = (byte)c;
        for (int i = 0; i < data.length; i++) if (data[i] == b) return i;
        return -1;
    }

    /**
     * String search for character.  Should this use a comparator? XXX
     *
     * @param c the character to search for
     * @return the index of the last occurrence of the character in this
     *          string, or -1 if the character does not occur in the string.
     */
    public int lastIndexOf(char c) {
        byte b = (byte)c;
        for (int i = data.length-1; i >= 0; i--) if (data[i] == b) return i;
        return -1;
    }

    /**
     * Return a new string containing the specified substring of this string.
     *
     * @param start the position of the first character of the substring
     * @param end the position of the character after the substring
     * @return the substring
     */
    public OctetString substring(int start, int end) {
        return new OctetString(data, start, end - start);
    }

    /**
     * Return a new string containing the specified substring of this string,
     * starting with the specified character, and ending with the last
     * character of the string.
     *
     * @param start the position of the first character of the substring
     * @return the substring
     */
    public OctetString substring(int start) {
        return substring(start, size());
    }
        

    /**
     * A truly general purpose function designed for a specified task,
     * this returns a new string containing the portion of this string
     * after the last occurrence of the specified character.
     *
     * <p>For example:<pre>
     * "/addressbook/user/stan/ABC457".afterLast('/') returns "ABC457"
     * </pre>
     *
     * @param c the character
     * @return a new <code>OctetString</code> containing the required suffix
     */
    public OctetString afterLast(char c) {
        int pos = data.length;
        while (pos >= 0 && c != data[--pos]) continue;
        pos++;
        int len = data.length - pos;
        return substring(pos);
    }

    /**
     * Return substring containing the portion of this string before the
     * first occurence of the specified character.
     *
     * @param c the character
     * @return a new <code>OctetString</code> containing the substring.
     */
    public OctetString before(char c) {
        int idx = indexOf(c);
        if (idx < 0) return null;
        return substring(0, idx);
    }

    /**
     * A truly general purpose function designed for a specified task,
     * this returns a new string containing the portion of this string
     * before the last occurrence of the specified character.
     *
     * <p>For example:<pre>
     * "/addressbook/user/stan/ABC457".beforeLast('/') returns
     *          "/addressbook/user/stan"
     * </pre>
     *
     * @param c the character
     * @return a new <code>OctetString</code> containing the required prefix
     */
    public OctetString beforeLast(char c) {
        int len = data.length;
        while (len >= 0 && c != data[--len]) continue;
        return substring(0, len);
    }

    /**
     * Another general purpose routine :-)
     * This one converts a particular substring of this string to an
     * integer.
     *
     * @param start the position of the first character of the substring
     * @param end the position of the character after the substring
     *
     */
    public int getIntSubString(int start, int end) {
        int val = 0;
        for (int i = 0; i < end; i++) {
            val *= 10;
            val += Character.digit((char)(data[i]), 10);
        }
        return val;
    }

    /**
     * String concatenation
     */
    public OctetString append(String s) {
        return append(s.getBytes());
    }
     
    /**
     * String concatenation
     */
    public OctetString append(OctetString s) {
        return append(s.data);
    }
     
    /**
     * String concatenation
     */
    public OctetString append(byte[] b) {
        int len = data.length + b.length;
        byte[] ret = new byte[len];
        System.arraycopy(data, 0, ret, 0, data.length);
        System.arraycopy(b, 0, ret, data.length, b.length);
        return new OctetString(ret);
    }
     
}