Quadcap Embeddable Database

com/quadcap/util/OctetComparator.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.util.Comparator;

/**
 * This class implements a comparator for octet strings.
 *
 * @author Stan Bailes
 */
public class OctetComparator implements Comparator {
    boolean                             reverse = false;
    boolean                             casemap = false;

    static OctetComparator      cmp     = new OctetComparator();
    static OctetComparator      casecmp = new OctetComparator(true,false);
    /**
     * Construct a new octet comparator.
     */
    public OctetComparator() {}

    public OctetComparator(boolean casemap, boolean reverse) {
        this.casemap = casemap;
        this.reverse = reverse;
    }
    
    /**
     * Ordering: is object 'a' <i>less, equal, or greater</i> than object 'b'?
     *
     * <p>(From the ACAP draft: draft-ietf-acap-spec-06.txt)
     *
     * <p>Ordering comparators can determine the ordinal precedence of any
     * two values.  When used for ordering, a comparator's name can be
     * prefixed with "+" or "-" to indicate that the ordering should be
     * normal order or reversed order respectively.  If no prefix is
     * included, "+" is assumed.
     *
     * <p>A comparator may designate certain values as having
     * an undefined ordinal precedence.  Such values collate with equal
     * value after all other values regardless of whether normal or reverse
     * ordering is used.
     *
     * @param a the first object to compare
     * @param b the second object
     * @return if a < b return -1 else if a > b return 1 else return 0
     */
    public int compare(Object a, Object b) {
        OctetString oa = (OctetString)a;
        OctetString ob = (OctetString)b;

        int before = reverse ? 1 : -1;
        int after = 0 - before;

        byte[] va = getBytes(oa);
        byte[] vb = getBytes(ob);
        int i = 0;
        while (i < va.length && i < vb.length) {
            if (va[i] < vb[i]) return before;
            if (va[i] > vb[i]) return after;
            i++;
        }
        if (i < vb.length) return before;
        if (i < va.length) return after;
        return 0;
    }

    /**
     * Determine if the search value is a prefix of the object being
     * searched.  In the case of a prefix search on a multi-value,
     * the match is successful if the value is a prefix of any one of
     * the muliple values.
     *
     * @param obj the "first" object to compare, normally the candidate
     *          object in a SEARCH operation.
     * @param val the "second" object, normally the constant value
     *          specified in the SEARCH operation.
     * @return true if <b>val</b> is a prefix of <b>obj</b>.
     */
    public boolean prefixMatch(OctetString obj, OctetString val) {
        byte[] va = getBytes(val);
        byte[] vb = getBytes(obj);
        if (va.length > vb.length) return false;
        for (int i = 0; i < va.length; i++) {
            if (va[i] != vb[i]) return false;
        }
        return true;
    }

    /**
     * Determine if the search value is a substring of the object being
     * searched.  In the case of a substring search on a multi-value,
     * the match is successful if the value is a substring of any one of
     * the muliple values.
     *
     * @param obj the "first" object to compare, normally the candidate
     *          object in a SEARCH operation.
     * @param val the "second" object, normally the constant value
     *          specified in the SEARCH operation.
     * @return true if <b>val</b> is a substring of <b>obj</b>.
     */
    public boolean substringMatch(OctetString obj, OctetString val) {
        byte[] va = getBytes(obj);
        byte[] vb = getBytes(val);
        int left = va.length - vb.length;
        for (int i = 0; i <= left; i++) {
            boolean match = true;
            for (int j = 0; match && j < vb.length; j++) {
                match = va[i+j] == vb[j];
            }
            if (match) return true;
        }
        return false;
    }


    /**
     * Determine if the search value matches a glob-style pattern.
     *
     * @param obj the object to compare.
     * @param pattern the pattern
     * @return true if <b>obj</b> matches the pattern specified by
     *          <b>pattern</b>.
     */
    public boolean patternMatch(OctetString obj, OctetString pattern) {
        byte[] va = getBytes(obj);
        byte[] vb = getBytes(pattern);
        return pMatch(va, 0, vb, 0);
    }

    boolean pMatch(byte[] va, int a, byte[] vb, int b) {
        while (b < vb.length) {
            byte p = vb[b++];
            switch (p) {
            case (byte)'*':
                if (a >= va.length || b >= vb.length) return true;
                while (a < va.length) {
                    if (pMatch(va, a++, vb, b)) return true;
                }
                return false;
            case (byte)'?':
                if (a++ >= va.length) return false;
                break;
            case (byte)'\\':
                if (b >= vb.length) return false;
                p = vb[b++];
                // fall through...
            default:
                if (a >= va.length) return false;
                if (va[a++] != p) return false;
            }
        }
        return a >= va.length;
    }
            
    int pMatchOrder(byte[] va, int a, byte[] vb, int b) {
        int ret = 0;
        while (b < vb.length) {
            byte p = vb[b++];
            switch (p) {
            case (byte)'*':
                while (a < va.length) {
                    ret = pMatchOrder(va, a++, vb, b);
                    if (ret == 0) return ret;
                }
                return ret;
            case (byte)'?':
                if (a++ >= va.length) return -1;
                break;
            case (byte)'\\':
                if (b >= vb.length) return 1;
                p = vb[b++];
                // fall through...
            default:
                if (a >= va.length) return -1;
                byte q = va[a++];
                if (q < p) return -1;
                if (q > p) return 1;
            }
        }
        return a >= va.length ? 0 : 1;
    }

    /**
     * The layer above which "i;octet" and "i;ascii-casemap" are the
     * same comparator.
     *
     * @param obj the object whose bytes we want.
     */
    byte[] getBytes(OctetString obj) {
        byte[] b = obj.getBytes();
        if (casemap) {
            byte[] cb = new byte[b.length];
            for (int i = 0; i < b.length; i++) {
                byte c = b[i];
                if (c >= 'a' && c <= 'z')
                    cb[i] = (byte)(c - 32);
                else
                    cb[i] = c;
            }
            b = cb;
        }
        return b;
    }
}