/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * ident	"%Z%%M%	%I%	%E% SMI"
 *
 * Copyright (c) 1999 by Sun Microsystems, Inc.
 * All rights reserved.
 *
 */

//  SCCS Status:      @(#)AttributePattern.java	1.1	02/18/98
//  AttributePattern.java: Models a pattern for attribute matching.
//  Author:           James Kempf
//  Created On:       Tue Feb  3 15:26:30 1998
//  Last Modified By: James Kempf
//  Last Modified On: Thu Aug  6 14:33:57 1998
//  Update Count:     19
//

package com.sun.slp;

import java.util.*;
import java.io.*;

/**
 * The AttributePattern class models an attribute pattern. It handles
 * wildcard matching of lowercased, space-compressed strings. Each
 * element in the parts vector is a PatternPart object. A PatternPart
 * object is a pattern consisting of (maximally) a beginning wildcard and
 * string pattern. A PatternPart may be lacking the
 * any of these, but will always have at least one. 
 *
 * @version %R%.%L% %D%
 * @author James Kempf
 */

class AttributePattern extends AttributeString {

    private static final String WILDCARD = "*";

    private Vector parts = new Vector();

    /**
     * The PatternPart class models a single component of a pattern.
     * It may have a beginning wildcard and string
     * pattern in the middle. Any of the parts may be missing, but it will 
     * always have at least one. 
     *
     * @version %R%.%L% %D%
     * @author James Kempf
     */


    private class PatternPart extends Object {

	boolean wildcard = false;
	String pattern = "";

	PatternPart(boolean wc, String str) {
	    wildcard = wc;
	    pattern = str;

	}
    }

    AttributePattern(String str, Locale locale) {

	super(str, locale);

	// Parse out wildcards into PatternPart objects.

	// If there's no wildcards, simply insert the string in as the pattern.

	if (cstring.indexOf(WILDCARD) == -1) {
	    parts.addElement(new PatternPart(false, cstring));

	} else {

	    // Parse the patterns into parts.

	    StringTokenizer tk = new StringTokenizer(cstring, WILDCARD, true);

	    while (tk.hasMoreTokens()) {
		String middle = "";
		boolean wc = false;

		String tok = tk.nextToken();

		// Beginning wildcard, or, if none, then the middle.

		if (tok.equals(WILDCARD)) {
		    wc = true;

		    // Need to look for middle.

		    if (tk.hasMoreTokens()) {
			middle = tk.nextToken();

		    }

		} else {
		    middle = tok;

		}

		// Note that there may be a terminal pattern part that just
		//  consists of a wildcard.

		parts.addElement(new PatternPart(wc, middle));
	    }
	}
    }

    boolean isWildcarded() {
	return (parts.size() > 1);

    }

    // Match the AttributeString object against this pattern,
    //  returning true if they match.

    public boolean match(AttributeString str) {
	String cstring = str.cstring;
	int offset = 0, len = cstring.length();
	int i = 0, n = parts.size();
	boolean match = true;

	// March through the parts, matching against the string.

	for (; i < n; i++) {
	    PatternPart p = (PatternPart)parts.elementAt(i);

	    // If there's a wildcard, check the remainder of the string for
	    //  the pattern.

	    if (p.wildcard) {

		// Note that if the pattern string is empty (""), then this
		//  will return offset, but on the next iteration, it will
		//  fall out of the loop because an empty pattern string
		//  can only occur at the end (like "foo*").

		if ((offset = cstring.indexOf(p.pattern, offset)) == -1) {

		    // The pattern was not found. Break out of the loop.

		    match = false;
		    break;
		}

		offset += p.pattern.length();

		// We are at the end of the string.

		if (offset >= len) {

		    // If we are not at the end of the pattern, then we may not
		    //  have a match.

		    if (i < (n - 1)) {

			// If there is one more in the pattern, and it is
			// a pure wildcard, then we *do* have a match.

			if (i == (n - 2)) {
			    p = (PatternPart)parts.elementAt(i+1);

			    if (p.wildcard == true &&
			       p.pattern.length() <= 0) {
				break;

			    }
			}

			match = false;

		    }

		    // Break out of the loop, no more string to analyze.

		    break;
		}

	    } else {

		// The pattern string must match the beginning part of the 
		// argument string.

		if (!cstring.regionMatches(offset,
					   p.pattern,
					   0,
					   p.
					   pattern.length())) {
		    match = false;
		    break;

		}

		// Bump up offset by the pattern length, and exit if
		// we're beyond the end of the string.

		offset += p.pattern.length();

		if (offset >= len) {
		    break;

		}
	    }
	}

	return match;
    }
}