Attachment #143859 for bug #282096

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

View | Details | Raw Unified | Return to bug 282096
Collapse All | Expand All




 *     Jesper S Moller - bug 283214 - fix XML result serialization
 *     Jesper S Moller - bug 283404 - fixed locale  
 *     Jesper S Moller - bug 281159 - fix document URIs and also filter XML namespace
 *     Jesper Steen Moeller - bug 282096 - make test harness handle all string encoding                                       translate function surrogate aware
 *******************************************************************************/
package org.eclipse.wst.xml.xpath2.processor.test;


import org.eclipse.wst.xml.xpath2.processor.internal.types.ElementType;
import org.eclipse.wst.xml.xpath2.processor.internal.types.NodeType;
import org.eclipse.wst.xml.xpath2.processor.internal.types.QName;
import org.eclipse.wst.xml.xpath2.processor.testsuite.functions.EscapeHTMLURIFuncTest;
import org.osgi.framework.Bundle;
import org.w3c.dom.Document;
import org.w3c.dom.Node;

	}

	protected String getExpectedResult(String xqFile) {
		return getExpectedResult(xqFile, true);
	}

	protected String getExpectedResultNoEscape(String xqFile) {
		return getExpectedResult(xqFile, false);
	}

	protected String getExpectedResult(String xqFile, boolean unescape) {
		String resultFile = xqFile;
		//
		if (resultFile.length() < 10) { // <9 enough? like XPST0001

			// e.printStackTrace();
			content = "XPST0003";
		}
		if (unescape && content.contains("&")) return resolveCharacterReferences(content);
		return content;
	}


		return unwrapResult(getExpectedResult(resultFile), elemName);
	}

	public String extractXPathExpressionNoEscape(String xqFile, String inputFile) {
		return extractXPathExpression(xqFile, inputFile, false);
	}

	public String extractXPathExpression(String xqFile, String inputFile) {
		return extractXPathExpression(xqFile, inputFile, true);
	}

	public String extractXPathExpression(String xqFile, String inputFile, boolean unescape) {
		// get the xpath2 expr from xq file, first
		char[] cbuf = new char[2048];//
		String content = null;

			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		if (unescape && xpath2Expr.contains("&")) {
			return resolveCharacterReferences(xpath2Expr);
		} else {
			return xpath2Expr;
		}
	}

	protected String extractXPathExpression(String xqFile, String inputFile,

		return expectedResult;
	}

	protected String resolveCharacterReferences(String xpath) {
		String docText = "<doc>" + xpath + "</doc>";
		InputStream is;
		try {
			is = new ByteArrayInputStream(docText.getBytes("UTF-8"));
			DOMLoader domloader = new XercesLoader();
			domloader.set_validating(false);
			Document temp = domloader.load(is);
			return temp.getDocumentElement().getFirstChild().getTextContent();
		} catch (UnsupportedEncodingException e) {
			throw new RuntimeException(e);
		} catch (DOMLoaderException e) {
			throw new RuntimeException(e);
		}
	}


}




/*******************************************************************************
 * Copyright (c) 2009 Standards for Technology for Automotive Retail and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *     David Carver (STAR) - initial API and implementation
 *     Jesper Steen Moeller - bug 282096 - special case for a test which works
 *                                         differently in XPath2 than in XQuery
 *******************************************************************************/
 
package org.eclipse.wst.xml.xpath2.processor.testsuite.functions;

import java.io.IOException;

      
      
public class NormalizeUnicodeFuncTest extends AbstractPsychoPathTest {

	@Override
	public String extractXPathExpression(String xqFile, String inputFile) {
		String body = super.extractXPathExpression(xqFile, inputFile);
		try {
			body = resolveCharacterReferences(body);
		} catch (DOMLoaderException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return body;
	}
	
   //Test normalize-unicode with simple text input.
   public void test_fn_normalize_unicode1args_1() throws Exception {

Lines 7-12 Link Here

(-)src/org/eclipse/wst/xml/xpath2/processor/testsuite/core/LiteralsTest.java (-2 / +4 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* David Carver (STAR) - initial API and implementation	9	* David Carver (STAR) - initial API and implementation
		10	* Jesper Steen Moeller - bug 282096 - special case for a test which works
		11	* differently in XPath2 than in XQuery
10	*******************************************************************************/	12	*******************************************************************************/
11		13
12	package org.eclipse.wst.xml.xpath2.processor.testsuite.core;	14	package org.eclipse.wst.xml.xpath2.processor.testsuite.core;
Lines 2013-2019 Link Here
2013	String inputFile = "/TestSources/emptydoc.xml";	2015	String inputFile = "/TestSources/emptydoc.xml";
2014	String xqFile = "/Queries/XQuery/Expressions/PrimaryExpr/Literals/Literals057.xq";	2016	String xqFile = "/Queries/XQuery/Expressions/PrimaryExpr/Literals/Literals057.xq";
2015	String resultFile = "/ExpectedTestResults/Expressions/PrimaryExpr/Literals/Literals057.txt";	2017	String resultFile = "/ExpectedTestResults/Expressions/PrimaryExpr/Literals/Literals057.txt";
2016	String expectedResult = getExpectedResult(resultFile);	2018	String expectedResult = getExpectedResultNoEscape(resultFile);
2017	URL fileURL = bundle.getEntry(inputFile);	2019	URL fileURL = bundle.getEntry(inputFile);
2018	loadDOMDocument(fileURL);	2020	loadDOMDocument(fileURL);
2019		2021
Lines 2022-2028 Link Here
2022		2024
2023	DynamicContext dc = setupDynamicContext(schema);	2025	DynamicContext dc = setupDynamicContext(schema);
2024		2026
2025	String xpath = extractXPathExpression(xqFile, inputFile);	2027	String xpath = extractXPathExpressionNoEscape(xqFile, inputFile);
2026	String actual = null;	2028	String actual = null;
2027	try {	2029	try {
2028	XPath path = compileXPath(dc, xpath);	2030	XPath path = compileXPath(dc, xpath);




 *
 * Contributors:
 *     Andrea Bittau - initial API and implementation from the PsychoPath XPath 2.0 
 *     Jesper Steen Moeller - bug 282096 - clean up string storage
 *******************************************************************************/

package org.eclipse.wst.xml.xpath2.processor.internal.function;

import org.apache.commons.lang.StringEscapeUtils;
import org.eclipse.wst.xml.xpath2.processor.DynamicError;
import org.eclipse.wst.xml.xpath2.processor.ResultSequence;
import org.eclipse.wst.xml.xpath2.processor.ResultSequenceFactory;
import org.eclipse.wst.xml.xpath2.processor.internal.*;
import org.eclipse.wst.xml.xpath2.processor.internal.types.*;
import org.eclipse.wst.xml.xpath2.processor.internal.utils.SurrogateUtils;

import java.util.*;
import java.util.regex.*;

		String str1 = "";
		if (!arg1.empty()) {
			str1 = ((XSString) arg1.first()).value();
			str1 = SurrogateUtils.decodeXML(str1);
			str1 = StringEscapeUtils.unescapeXml(str1);
		}

		ResultSequence arg2 = (ResultSequence) argiter.next();

			ArrayList<String> ret = tokenize(pattern, flags, str1);

			for(String token : ret) {
				rs.add(new XSString(token));
			}
		} catch (PatternSyntaxException err) {
			throw DynamicError.regex_error(null);




 *     Mukul Gandhi - bug 274805 - improvements to xs:integer data type  
 *     Jesper Steen Moeller - bug 285145 - implement full arity checking
 *     David Carver - bug 282096 - improvements for surrogate handling 
 *     Jesper Steen Moeller - bug 282096 - clean up string storage
 *******************************************************************************/

package org.eclipse.wst.xml.xpath2.processor.internal.function;

import org.apache.commons.lang.StringEscapeUtils;
import org.eclipse.wst.xml.xpath2.processor.DynamicContext;
import org.eclipse.wst.xml.xpath2.processor.DynamicError;
import org.eclipse.wst.xml.xpath2.processor.ResultSequence;
import org.eclipse.wst.xml.xpath2.processor.ResultSequenceFactory;
import org.eclipse.wst.xml.xpath2.processor.internal.*;
import org.eclipse.wst.xml.xpath2.processor.internal.types.*;
import org.eclipse.wst.xml.xpath2.processor.internal.utils.SurrogateUtils;

import java.math.BigInteger;
import java.util.*;

		}

		String str = ((XSString) arg1.first()).value();
		str = SurrogateUtils.decodeXML(str);

		ResultSequence rs = ResultSequenceFactory.create_new();
		rs.add(new XSInteger(BigInteger.valueOf(str.codePointCount(0, str.length()))));

		return rs;
	}




 *
 * Contributors:
 *     Andrea Bittau - initial API and implementation from the PsychoPath XPath 2.0 
 *     Jesper Steen Moeller - bug 282096 - clean up string storage and make
 *                                         translate function surrogate aware
 *******************************************************************************/

package org.eclipse.wst.xml.xpath2.processor.internal.function;

import org.apache.commons.lang.StringEscapeUtils;
import org.eclipse.wst.xml.xpath2.processor.DynamicError;
import org.eclipse.wst.xml.xpath2.processor.ResultSequence;
import org.eclipse.wst.xml.xpath2.processor.ResultSequenceFactory;
import org.eclipse.wst.xml.xpath2.processor.internal.*;
import org.eclipse.wst.xml.xpath2.processor.internal.types.*;
import org.eclipse.wst.xml.xpath2.processor.internal.utils.CodePointIterator;
import org.eclipse.wst.xml.xpath2.processor.internal.utils.StringCodePointIterator;

import java.util.*;


		}

		String str = ((XSString) arg1.first()).value();
		str = SurrogateUtils.decodeXML(str);
		String mapstr = ((XSString) arg2.first()).value();
		mapstr = SurrogateUtils.decodeXML(mapstr);
		String transstr = ((XSString) arg3.first()).value();
		transstr = SurrogateUtils.decodeXML(transstr);

		Map<Integer, Integer> replacements = buildReplacementMap(mapstr, transstr);
		
		StringBuffer sb = new StringBuffer(str.length());
		CodePointIterator strIter = new StringCodePointIterator(str);
		for (int input = strIter.current(); input != CodePointIterator.DONE; input = strIter.next()) {
			Integer inputCodepoint = Integer.valueOf(input);
			if (replacements.containsKey(inputCodepoint)) {
				Integer replaceWith = (Integer)replacements.get(inputCodepoint);
				if (replaceWith != null) {
					sb.appendCodePoint(replaceWith.intValue());
				}					
			} else {
				sb.appendCodePoint(input);
			}

			else
				repmap.put(chartofind, replace);

			result = result.replaceAll(chartofind, replace);
		}
		
		rs.add(new XSString(sb.toString()));
		rs.add(new XSString(result));

		return rs;
	}

	/**
	 * Build a replacement map from the mapstr and the transstr for translation. The function returns a Map<Integer, Integer> mapping each codepoint
	 * mentioned in the mapstr into the corresponding codepoint in transstr, or null if there is no matching mapping in transstr.
	 * 
	 * @param mapstr The "mapping from" string
	 * @param transstr The "mapping into" string
	 * @return A map which maps input codepoint to output codepoint (or null)
	 */
	private static Map<Integer, Integer> buildReplacementMap(String mapstr, String transstr) {
		// Build mapping (map from codepoint -> codepoint)		
		Map<Integer, Integer> replacements = new HashMap<Integer, Integer>(mapstr.length() * 4);

		CodePointIterator mapIter = new StringCodePointIterator(mapstr);
		CodePointIterator transIter = new StringCodePointIterator(transstr);
		// Iterate through both mapIter and transIter and produce the mapping
		int mapFrom = mapIter.current();
		int mapTo = transIter.current();
		while (mapFrom != CodePointIterator.DONE) {
			Integer codepointFrom = Integer.valueOf(mapFrom);
			if (! replacements.containsKey(codepointFrom)) {
				// only overwrite if it doesn't exist already
				Integer replacement = mapTo != CodePointIterator.DONE ? Integer.valueOf(mapTo) : null;
				replacements.put(codepointFrom, replacement);
			}
			mapFrom = mapIter.next();
			mapTo = transIter.next();	
		}
		return replacements;
	}

	/**
	 * Calculate the expected arguments.
	 * 
	 * @return The expected arguments.




 *     Andrea Bittau - initial API and implementation from the PsychoPath XPath 2.0
 *     Mukul Gandhi - improvements to the function implementation
 *     David Carver - bug 282096 - improvements for surrogate handling 
 *     Jesper Steen Moeller - bug 282096 - clean up string storage
 *******************************************************************************/

package org.eclipse.wst.xml.xpath2.processor.internal.function;

import org.apache.commons.lang.StringEscapeUtils;
import org.eclipse.wst.xml.xpath2.processor.DynamicError;
import org.eclipse.wst.xml.xpath2.processor.ResultSequence;
import org.eclipse.wst.xml.xpath2.processor.ResultSequenceFactory;

		// "new String(int[] codePoints, int offset, int count)" is a facility
		// introduced in Java 1.5
		String str = new String(codePointArray, 0, codePointArray.length);
		str = StringEscapeUtils.escapeXml(str);
		rs.add(new XSString(str));
		
		return rs;




 * Contributors:
 *     Andrea Bittau - initial API and implementation from the PsychoPath XPath 2.0
 *     David Carver - bug 282096 - improvements for surrogate handling  
 *     Jesper Steen Moeller - bug 282096 - clean up string storage
 *******************************************************************************/

package org.eclipse.wst.xml.xpath2.processor.internal.function;

import org.apache.commons.lang.StringEscapeUtils;
import org.eclipse.wst.xml.xpath2.processor.DynamicError;
import org.eclipse.wst.xml.xpath2.processor.ResultSequence;
import org.eclipse.wst.xml.xpath2.processor.ResultSequenceFactory;
import org.eclipse.wst.xml.xpath2.processor.internal.*;
import org.eclipse.wst.xml.xpath2.processor.internal.types.*;
import org.eclipse.wst.xml.xpath2.processor.internal.utils.SurrogateUtils;

import java.util.*;


		}

		String str = ((XSString) arg1.first()).value();
		str = SurrogateUtils.decodeXML(str);

		rs.add(new XSString(str.toLowerCase()));

		return rs;
	}




 *     Mukul Gandhi - bug 273795 - improvements to function, substring
 *     Jesper Steen Moeller - bug 285145 - implement full arity checking
 *     David Carver - bug 282096 - improvements for surrogate handling 
 *     Jesper Steen Moeller - bug 282096 - reimplemented to be surrogate sensitive
 *******************************************************************************/

package org.eclipse.wst.xml.xpath2.processor.internal.function;

import org.apache.commons.lang.StringEscapeUtils;
import org.eclipse.wst.xml.xpath2.processor.DynamicError;
import org.eclipse.wst.xml.xpath2.processor.ResultSequence;
import org.eclipse.wst.xml.xpath2.processor.ResultSequenceFactory;
import org.eclipse.wst.xml.xpath2.processor.internal.*;
import org.eclipse.wst.xml.xpath2.processor.internal.types.*;
import org.eclipse.wst.xml.xpath2.processor.internal.utils.CodePointIterator;
import org.eclipse.wst.xml.xpath2.processor.internal.utils.StringCodePointIterator;

import java.util.*;


		}

		String str = ((XSString) stringArg.first()).value();
		str = SurrogateUtils.decodeXML(str);
		double dstart = ((XSDouble) startPosArg.first()).double_value();
		
		// is start is NaN, no chars are returned
		if (Double.NaN == dstart || Double.NEGATIVE_INFINITY == dstart) {
			return emptyString(rs);
		}
		long istart = Math.round(dstart);
		int start = (int) Math.round(dstart);

		if (isStartOutOfBounds(str, start)) {
		  return emptyString(rs);
		}
		
		long ilength = Long.MAX_VALUE;

		if (lengthArg != null) {
			double dlength = ((XSDouble) lengthArg.first()).double_value();
			if (Double.NaN == dlength)
				return emptyString(rs);
			// Switch to the rounded kind
			ilength = Math.round(dlength);
			if (ilength <= 0)
				return emptyString(rs);
		}
		
		
		// could guess too short in cases supplementary chars 
		StringBuilder sb = new StringBuilder((int) Math.min(str.length(), ilength));
	}
	
	private static ResultSequence substringLength(ResultSequence rs, ResultSequence lengthArg, double dstart, int start, String str) {
		  int length = adjustLength(lengthArg, dstart, start);
		  int endpos = start + length;
		  if (isEndPosOutOfBounds(endpos) || isStartOutOfBounds(str, endpos)) {
			  return emptyString(rs);
		  }
		 
		  if (start == 0 && endpos == 0) {
			  rs.add(new XSString(StringEscapeUtils.escapeXml(str.substring(start))));
		  } else {
			  rs.add(new XSString(StringEscapeUtils.escapeXml(str.substring(start, endpos))));
		  }
		  return rs;
	}

	private static boolean isEndPosOutOfBounds(int endpos) {
		return endpos < 0;
	}

	private static int adjustLength(ResultSequence arg3, double dstart,
			int start) {
		double dlength = ((XSDouble) arg3.first()).double_value();
		  int length = (int) Math.round(dlength);
		  if (dstart < 0) {
			  length = (int)( dlength - (Math.abs(dstart) + 1));
		  } else if (dstart == 0) {
			  length = length - 1;
		  } else if (isEndPosOutOfBounds(length)) {
			  length = start - Math.abs(length);
		  }
		return length;
	}

		// This looks like an inefficient way to iterate, but due to surrogate handling,
		// string indexes are no good here. Welcome to UTF-16!
		
		CodePointIterator strIter = new StringCodePointIterator(str);
		for (long p = 1; strIter.current() != CodePointIterator.DONE; ++p, strIter.next()) {
			if (istart <= p && p - istart < ilength)
				sb.appendCodePoint(strIter.current());
		}
		rs.add(new XSString(sb.toString()));
	}

		return rs;
		return start > str.length();
	}
	
	private static ResultSequence emptyString(ResultSequence rs) {
		rs.add(new XSString(""));
		return rs;




 * Contributors:
 *     Andrea Bittau - initial API and implementation from the PsychoPath XPath 2.0
 *     David Carver - bug 282096 - improvements for surrogate handling  
 *     Jesper Steen Moeller - bug 282096 - clean up string storage
 *******************************************************************************/

package org.eclipse.wst.xml.xpath2.processor.internal.function;

import org.apache.commons.lang.StringEscapeUtils;
import org.eclipse.wst.xml.xpath2.processor.DynamicError;
import org.eclipse.wst.xml.xpath2.processor.ResultSequence;
import org.eclipse.wst.xml.xpath2.processor.ResultSequenceFactory;
import org.eclipse.wst.xml.xpath2.processor.internal.*;
import org.eclipse.wst.xml.xpath2.processor.internal.types.*;
import org.eclipse.wst.xml.xpath2.processor.internal.utils.SurrogateUtils;

import java.util.*;


		String str2 = "";
		if (!arg1.empty()) {
			str1 = ((XSString) arg1.first()).value();
			str1 = SurrogateUtils.decodeXML(str1);
		}

		ResultSequence arg2 = (ResultSequence) argiter.next();
		if (!arg2.empty()) {
			str2 = ((XSString) arg2.first()).value();
			str2 = SurrogateUtils.decodeXML(str2);
		}

		int str1len = str1.length();

			result = str1.substring(index, str1len);
		}

		rs.add(new XSString(result));

		return rs;
	}




 *     Andrea Bittau - initial API and implementation from the PsychoPath XPath 2.0
 *     David Carver - bug 282096 - improvements for surrogate handling
 *     David Carver - bug 262765 - improvements to Regular Expression   
 *     Jesper Steen Moeller - bug 282096 - clean up string storage
 *******************************************************************************/

package org.eclipse.wst.xml.xpath2.processor.internal.function;

import org.apache.commons.lang.StringEscapeUtils;
import org.eclipse.wst.xml.xpath2.processor.DynamicError;
import org.eclipse.wst.xml.xpath2.processor.ResultSequence;
import org.eclipse.wst.xml.xpath2.processor.ResultSequenceFactory;
import org.eclipse.wst.xml.xpath2.processor.internal.*;
import org.eclipse.wst.xml.xpath2.processor.internal.types.*;
import org.eclipse.wst.xml.xpath2.processor.internal.utils.SurrogateUtils;

import java.util.*;
import java.util.regex.*;

		String str1 = "";
		if (!arg1.empty()) {
			str1 = ((XSString) arg1.first()).value();
			str1 = SurrogateUtils.decodeXML(str1);
			str1 = StringEscapeUtils.unescapeXml(str1);
		}

		ResultSequence arg2 = (ResultSequence) argiter.next();
		String pattern = ((XSString) arg2.first()).value();
		pattern = SurrogateUtils.decodeXML(pattern);
		String flags = null;

		if (argiter.hasNext()) {




 *     Andrea Bittau - initial API and implementation from the PsychoPath XPath 2.0
 *     Mukul Gandhi - bug 280554 - improvements to the function implementation
 *     David Carver - bug 282096 - improvements for surrogate handling  
 *     Jesper Steen Moeller - bug 282096 - clean up string storage and fix surrogate handling
 *******************************************************************************/

package org.eclipse.wst.xml.xpath2.processor.internal.function;

import org.eclipse.wst.xml.xpath2.processor.ResultSequenceFactory;
import org.eclipse.wst.xml.xpath2.processor.internal.*;
import org.eclipse.wst.xml.xpath2.processor.internal.types.*;
import org.eclipse.wst.xml.xpath2.processor.internal.utils.CodePointIterator;
import org.eclipse.wst.xml.xpath2.processor.internal.utils.StringCodePointIterator;

import java.math.BigInteger;
import java.util.*;

		   return rs;

		XSString xstr = (XSString) arg1.first();
		String str = xstr.value();
		str = SurrogateUtils.decodeXML(str);

		CodePointIterator cpi = new StringCodePointIterator(xstr.value());
		
		for (int codePoint = cpi.current(); codePoint != CodePointIterator.DONE; codePoint = cpi.next()) {
           	rs.add(new XSInteger(BigInteger.valueOf(codePoint)));
		}

		return rs;




 * Contributors:
 *     Andrea Bittau - initial API and implementation from the PsychoPath XPath 2.0
 *     David Carver - bug 282096 - improvements for surrogate handling  
 *     Jesper Steen Moeller - bug 282096 - clean up string storage
 *******************************************************************************/

package org.eclipse.wst.xml.xpath2.processor.internal.function;

import org.apache.commons.lang.StringEscapeUtils;
import org.eclipse.wst.xml.xpath2.processor.DynamicError;
import org.eclipse.wst.xml.xpath2.processor.ResultSequence;
import org.eclipse.wst.xml.xpath2.processor.ResultSequenceFactory;
import org.eclipse.wst.xml.xpath2.processor.internal.*;
import org.eclipse.wst.xml.xpath2.processor.internal.types.*;
import org.eclipse.wst.xml.xpath2.processor.internal.utils.SurrogateUtils;

import java.util.*;


		String str2 = "";
		if (!arg1.empty()) {
			str1 = ((XSString) arg1.first()).value();
			str1 = SurrogateUtils.decodeXML(str1);
		}

		ResultSequence arg2 = (ResultSequence) argiter.next();
		if (!arg2.empty()) {
			str2 = ((XSString) arg2.first()).value();
			str2 = SurrogateUtils.decodeXML(str2);
		}

		int str1len = str1.length();

		}

		
		rs.add(new XSString(str1.substring(0, index)));

		return rs;
	}




/*******************************************************************************
 * Copyright (c) 2009 Standards for Technology in Automotive Retail and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     David Carver (STAR) - bug 282096 - initial API and implementation
 *******************************************************************************/
package org.eclipse.wst.xml.xpath2.processor.internal.utils;

public class SurrogateUtils {

	/**
	 * This class will decode a surrogate entity into it's string representation
	 * @param str
	 * @return The decoded string
	 * @since 1.1
	 */
	public static String decodeXML(String str) {
		String decodeString = str;
		while (decodeString.contains("&#x1")) {
			int startpos = decodeString.indexOf("&#x1");
			String starthex = decodeString.substring(startpos);
			int semipos = starthex.indexOf(';');
			String hexValue = starthex.substring(4, semipos);
			int i = Integer.parseInt(hexValue, 16);
			char c = (char)i;
			decodeString = decodeString.replaceAll("&#x1" + hexValue + ";", "" + c);
		}
		return decodeString;
	}
}




/*******************************************************************************
 * Copyright (c) 2009 Jesper Steen Moeller and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Jesper Steen Moeller - bug 282096 - initial API and implementation
 *******************************************************************************/

package org.eclipse.wst.xml.xpath2.processor.internal.utils;

public interface CodePointIterator extends Cloneable
{
    /**
     * Sentinel value returned from iterator when the end is reached.
     * The value is -1 which will never be a valid codepoint.
     */
    public static final int DONE = -1;

    /**
     * Resets the position to 0 and returns the first code point.
     * @return the first code point in the text, or DONE if the text is empty
     */
    public int first();

    /**
     * Sets the position to the last possible position (or 0 if the text is empty)
     * and returns the code point at that position.
     * @return the last code point in the text, or DONE if the text is empty
     * @see #getEndIndex()
     */
    public int last();

    /**
     * Gets the code point at the current position (as returned by getIndex()).
     * @return the code point at the current position or DONE if the current
     * position is off the end of the text.
     * @see #getIndex()
     */
    public int current();

    /**
     * Increments the iterator's code point index by one and returns the code point
     * at the new index.  If the resulting index is at the end of the string, the
     * index is not incremented, and DONE is returned.
     * @return the code point at the new position or DONE if the new
     * position is after the text range.
     */
    public int next();

    /**
     * Decrements the iterator's index by one and returns the character
     * at the new index. If the current index is 0, the index
     * remains at 0 and a value of DONE is returned.
     *
     * @return the code point at the new position (or DONE if the current
     * position is 0)
     */
    public int previous();

    /**
     * Returns the current index (as a codepoint, not a string index).
     * @return the current index.
     */
    public int getIndex();

    /**
     * Create a copy of this code point iterator
     * @return A copy of this
     */
    public Object clone();

}




/*******************************************************************************
 * Copyright (c) 2009 Jesper Steen Moeller and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Jesper Steen Moeller - bug 282096 - initial API and implementation
 *******************************************************************************/
 
package org.eclipse.wst.xml.xpath2.processor.internal.utils;

public final class StringCodePointIterator implements CodePointIterator
{
    private String text;
    private int end;
    // invariant: 0 <= pos <= end
    private int pos;
	private int cpPos;

    /**
     * Constructs an iterator with an initial index of 0.
     */
    public StringCodePointIterator(String text)
    {
        if (text == null)
            throw new NullPointerException();
        
        this.text = text;
        this.end = text.length();
        if (end > 0 && Character.isHighSurrogate(text.charAt(end-1)))
            throw new IllegalArgumentException("Invalid UTF-16 sequence ending with a high surrogate");
       
        this.pos = 0;
        this.cpPos = 0;
    }

    /**
     * Reset this iterator to point to a new string.  This package-visible
     * method is used by other java.text classes that want to avoid allocating
     * new StringCodePointIterator objects every time their setText method
     * is called.
     *
     * @param  text   The String to be iterated over
     * @since 1.2
     */
    public void setText(String text) {
        if (text == null)
            throw new NullPointerException();
        this.text = text;
        this.end = text.length();
        this.pos = 0;
        this.cpPos = 0;
    }

    /**
     * Implements CodePointIterator.first() for String.
     * @see CodePointIterator#first
     */
    public int first()
    {
        pos = 0;
        cpPos = 0;
        return current();
    }

    /**
     * Implements CodePointIterator.last() for String.
     * @see CodePointIterator#last
     */
    public int last()
    {
        pos = end;
        cpPos = Character.codePointCount(text, 0, pos);
        return previous();
     }

    /**
     * Implements CodePointIterator.current() for String.
     * @see CodePointIterator#current
     */
    public int current()
    {
        if (pos < end) {
            char ch1 =  text.charAt(pos);
            if (Character.isHighSurrogate(ch1)) return Character.toCodePoint(ch1, text.charAt(pos+1));
            return ch1;
        }
        else {
            return DONE;
        }
    }

    /**
     * Implements CodePointIterator.next() for String.
     * @see CodePointIterator#next
     */
    public int next()
    {
        if (pos < end - 1) {
            pos++;
            if (Character.isLowSurrogate(text.charAt(pos))) pos++;
            cpPos++;
            return current();
        }
        else {
        	pos = end;
            return DONE;
        }
    }

    /**
     * Implements CodePointIterator.previous() for String.
     * @see CodePointIterator#previous
     */
    public int previous()
    {
        if (pos > 0) {
            pos--;
            if (Character.isLowSurrogate(text.charAt(pos))) pos--; 
            cpPos--;
            return current();
        }
        else {
            return DONE;
        }
    }

    /**
     * Implements CodePointIterator.getIndex() for String.
     * @see CodePointIterator#getIndex
     */
    public int getIndex()
    {
        return cpPos;
    }

    /**
     * Compares the equality of two StringCodePointIterator objects.
     * @param obj the StringCodePointIterator object to be compared with.
     * @return true if the given obj is the same as this
     * StringCodePointIterator object; false otherwise.
     */
    public boolean equals(Object obj)
    {
        if (this == obj)
            return true;
        if (!(obj instanceof StringCodePointIterator))
            return false;

        StringCodePointIterator that = (StringCodePointIterator) obj;

        if (hashCode() != that.hashCode())
            return false;
        if (!text.equals(that.text))
            return false;
        if (pos != that.pos || end != that.end)
            return false;
        return true;
    }

    /**
     * Computes a hashcode for this iterator.
     * @return A hash code
     */
    public int hashCode()
    {
        return text.hashCode() ^ pos ^ end;
    }

    /**
     * Creates a copy of this iterator.
     * @return A copy of this
     */
    public Object clone()
    {
        try {
            StringCodePointIterator other
            = (StringCodePointIterator) super.clone();
            return other;
        }
        catch (CloneNotSupportedException e) {
            throw new InternalError();
        }
    }

}

Return to bug 282096

Lines 12-17 Link Here

(-)src/org/eclipse/wst/xml/xpath2/processor/test/AbstractPsychoPathTest.java (-10 / +39 lines)
12	* Jesper S Moller - bug 283214 - fix XML result serialization	12	* Jesper S Moller - bug 283214 - fix XML result serialization
13	* Jesper S Moller - bug 283404 - fixed locale	13	* Jesper S Moller - bug 283404 - fixed locale
14	* Jesper S Moller - bug 281159 - fix document URIs and also filter XML namespace	14	* Jesper S Moller - bug 281159 - fix document URIs and also filter XML namespace
		15	* Jesper Steen Moeller - bug 282096 - make test harness handle all string encoding translate function surrogate aware
15	*******************************************************************************/	16	*******************************************************************************/
16	package org.eclipse.wst.xml.xpath2.processor.test;	17	package org.eclipse.wst.xml.xpath2.processor.test;
17		18
Lines 46-51 Link Here
46	import org.eclipse.wst.xml.xpath2.processor.internal.types.ElementType;	47	import org.eclipse.wst.xml.xpath2.processor.internal.types.ElementType;
47	import org.eclipse.wst.xml.xpath2.processor.internal.types.NodeType;	48	import org.eclipse.wst.xml.xpath2.processor.internal.types.NodeType;
48	import org.eclipse.wst.xml.xpath2.processor.internal.types.QName;	49	import org.eclipse.wst.xml.xpath2.processor.internal.types.QName;
		50	import org.eclipse.wst.xml.xpath2.processor.testsuite.functions.EscapeHTMLURIFuncTest;
49	import org.osgi.framework.Bundle;	51	import org.osgi.framework.Bundle;
50	import org.w3c.dom.Document;	52	import org.w3c.dom.Document;
51	import org.w3c.dom.Node;	53	import org.w3c.dom.Node;
Lines 185-190 Link Here
185	}	187	}
186		188
187	protected String getExpectedResult(String xqFile) {	189	protected String getExpectedResult(String xqFile) {
		190	return getExpectedResult(xqFile, true);
		191	}
		192
		193	protected String getExpectedResultNoEscape(String xqFile) {
		194	return getExpectedResult(xqFile, false);
		195	}
		196
		197	protected String getExpectedResult(String xqFile, boolean unescape) {
188	String resultFile = xqFile;	198	String resultFile = xqFile;
189	//	199	//
190	if (resultFile.length() < 10) { // <9 enough? like XPST0001	200	if (resultFile.length() < 10) { // <9 enough? like XPST0001
Lines 226-231 Link Here
226	// e.printStackTrace();	236	// e.printStackTrace();
227	content = "XPST0003";	237	content = "XPST0003";
228	}	238	}
		239	if (unescape && content.contains("&")) return resolveCharacterReferences(content);
229	return content;	240	return content;
230	}	241	}
231		242
Lines 237-243 Link Here
237	return unwrapResult(getExpectedResult(resultFile), elemName);	248	return unwrapResult(getExpectedResult(resultFile), elemName);
238	}	249	}
239		250
		251	public String extractXPathExpressionNoEscape(String xqFile, String inputFile) {
		252	return extractXPathExpression(xqFile, inputFile, false);
		253	}
		254
240	public String extractXPathExpression(String xqFile, String inputFile) {	255	public String extractXPathExpression(String xqFile, String inputFile) {
		256	return extractXPathExpression(xqFile, inputFile, true);
		257	}
		258
		259	public String extractXPathExpression(String xqFile, String inputFile, boolean unescape) {
241	// get the xpath2 expr from xq file, first	260	// get the xpath2 expr from xq file, first
242	char[] cbuf = new char[2048];//	261	char[] cbuf = new char[2048];//
243	String content = null;	262	String content = null;
Lines 277-283 Link Here
277	// TODO Auto-generated catch block	296	// TODO Auto-generated catch block
278	e.printStackTrace();	297	e.printStackTrace();
279	}	298	}
280	return xpath2Expr;	299	if (unescape && xpath2Expr.contains("&")) {
		300	return resolveCharacterReferences(xpath2Expr);
		301	} else {
		302	return xpath2Expr;
		303	}
281	}	304	}
282		305
283	protected String extractXPathExpression(String xqFile, String inputFile,	306	protected String extractXPathExpression(String xqFile, String inputFile,
Lines 398-412 Link Here
398	return expectedResult;	421	return expectedResult;
399	}	422	}
400		423
401	protected String resolveCharacterReferences(String xpath)	424	protected String resolveCharacterReferences(String xpath) {
402	throws IOException, DOMLoaderException {	425	String docText = "<doc>" + xpath + "</doc>";
403	String docText = "<doc>" + xpath + "</doc>";	426	InputStream is;
404	InputStream is = new ByteArrayInputStream(docText.getBytes("UTF-8"));	427	try {
405	DOMLoader domloader = new XercesLoader();	428	is = new ByteArrayInputStream(docText.getBytes("UTF-8"));
406	domloader.set_validating(false);	429	DOMLoader domloader = new XercesLoader();
407	Document temp = domloader.load(is);	430	domloader.set_validating(false);
408	return temp.getDocumentElement().getFirstChild().getTextContent();	431	Document temp = domloader.load(is);
409	}	432	return temp.getDocumentElement().getFirstChild().getTextContent();
		433	} catch (UnsupportedEncodingException e) {
		434	throw new RuntimeException(e);
		435	} catch (DOMLoaderException e) {
		436	throw new RuntimeException(e);
		437	}
		438	}
410		439
411		440
412	}	441	}

Lines 1-4 Link Here

(-)src/org/eclipse/wst/xml/xpath2/processor/testsuite/functions/NormalizeUnicodeFuncTest.java (-14 / +13 lines)
1		1	/*******************************************************************************
		2	* Copyright (c) 2009 Standards for Technology for Automotive Retail and others.
		3	* All rights reserved. This program and the accompanying materials
		4	* are made available under the terms of the Eclipse Public License v1.0
		5	* which accompanies this distribution, and is available at
		6	* http://www.eclipse.org/legal/epl-v10.html
		7	*
		8	* Contributors:
		9	* David Carver (STAR) - initial API and implementation
		10	* Jesper Steen Moeller - bug 282096 - special case for a test which works
		11	* differently in XPath2 than in XQuery
		12	*******************************************************************************/
		13
2	package org.eclipse.wst.xml.xpath2.processor.testsuite.functions;	14	package org.eclipse.wst.xml.xpath2.processor.testsuite.functions;
3		15
4	import java.io.IOException;	16	import java.io.IOException;
Lines 12-30 Link Here
12		24
13		25
14	public class NormalizeUnicodeFuncTest extends AbstractPsychoPathTest {	26	public class NormalizeUnicodeFuncTest extends AbstractPsychoPathTest {
15
16	@Override
17	public String extractXPathExpression(String xqFile, String inputFile) {
18	String body = super.extractXPathExpression(xqFile, inputFile);
19	try {
20	body = resolveCharacterReferences(body);
21	} catch (DOMLoaderException e) {
22	e.printStackTrace();
23	} catch (IOException e) {
24	e.printStackTrace();
25	}
26	return body;
27	}
28		27
29	//Test normalize-unicode with simple text input.	28	//Test normalize-unicode with simple text input.
30	public void test_fn_normalize_unicode1args_1() throws Exception {	29	public void test_fn_normalize_unicode1args_1() throws Exception {

Lines 11-28 Link Here

(-)src/org/eclipse/wst/xml/xpath2/processor/internal/function/FnStringLength.java (-4 / +2 lines)
11	* Mukul Gandhi - bug 274805 - improvements to xs:integer data type	11	* Mukul Gandhi - bug 274805 - improvements to xs:integer data type
12	* Jesper Steen Moeller - bug 285145 - implement full arity checking	12	* Jesper Steen Moeller - bug 285145 - implement full arity checking
13	* David Carver - bug 282096 - improvements for surrogate handling	13	* David Carver - bug 282096 - improvements for surrogate handling
		14	* Jesper Steen Moeller - bug 282096 - clean up string storage
14	*******************************************************************************/	15	*******************************************************************************/
15		16
16	package org.eclipse.wst.xml.xpath2.processor.internal.function;	17	package org.eclipse.wst.xml.xpath2.processor.internal.function;
17		18
18	import org.apache.commons.lang.StringEscapeUtils;
19	import org.eclipse.wst.xml.xpath2.processor.DynamicContext;	19	import org.eclipse.wst.xml.xpath2.processor.DynamicContext;
20	import org.eclipse.wst.xml.xpath2.processor.DynamicError;	20	import org.eclipse.wst.xml.xpath2.processor.DynamicError;
21	import org.eclipse.wst.xml.xpath2.processor.ResultSequence;	21	import org.eclipse.wst.xml.xpath2.processor.ResultSequence;
22	import org.eclipse.wst.xml.xpath2.processor.ResultSequenceFactory;	22	import org.eclipse.wst.xml.xpath2.processor.ResultSequenceFactory;
23	import org.eclipse.wst.xml.xpath2.processor.internal.*;	23	import org.eclipse.wst.xml.xpath2.processor.internal.*;
24	import org.eclipse.wst.xml.xpath2.processor.internal.types.*;	24	import org.eclipse.wst.xml.xpath2.processor.internal.types.*;
25	import org.eclipse.wst.xml.xpath2.processor.internal.utils.SurrogateUtils;
26		25
27	import java.math.BigInteger;	26	import java.math.BigInteger;
28	import java.util.*;	27	import java.util.*;
Lines 98-107 Link Here
98	}	97	}
99		98
100	String str = ((XSString) arg1.first()).value();	99	String str = ((XSString) arg1.first()).value();
101	str = SurrogateUtils.decodeXML(str);
102		100
103	ResultSequence rs = ResultSequenceFactory.create_new();	101	ResultSequence rs = ResultSequenceFactory.create_new();
104	rs.add(new XSInteger(BigInteger.valueOf(str.length())));	102	rs.add(new XSInteger(BigInteger.valueOf(str.codePointCount(0, str.length()))));
105		103
106	return rs;	104	return rs;
107	}	105	}

Lines 9-19 Link Here

(-)src/org/eclipse/wst/xml/xpath2/processor/internal/function/FnCodepointsToString.java (-2 / +1 lines)
9	* Andrea Bittau - initial API and implementation from the PsychoPath XPath 2.0	9	* Andrea Bittau - initial API and implementation from the PsychoPath XPath 2.0
10	* Mukul Gandhi - improvements to the function implementation	10	* Mukul Gandhi - improvements to the function implementation
11	* David Carver - bug 282096 - improvements for surrogate handling	11	* David Carver - bug 282096 - improvements for surrogate handling
		12	* Jesper Steen Moeller - bug 282096 - clean up string storage
12	*******************************************************************************/	13	*******************************************************************************/
13		14
14	package org.eclipse.wst.xml.xpath2.processor.internal.function;	15	package org.eclipse.wst.xml.xpath2.processor.internal.function;
15		16
16	import org.apache.commons.lang.StringEscapeUtils;
17	import org.eclipse.wst.xml.xpath2.processor.DynamicError;	17	import org.eclipse.wst.xml.xpath2.processor.DynamicError;
18	import org.eclipse.wst.xml.xpath2.processor.ResultSequence;	18	import org.eclipse.wst.xml.xpath2.processor.ResultSequence;
19	import org.eclipse.wst.xml.xpath2.processor.ResultSequenceFactory;	19	import org.eclipse.wst.xml.xpath2.processor.ResultSequenceFactory;
Lines 83-89 Link Here
83	// "new String(int[] codePoints, int offset, int count)" is a facility	83	// "new String(int[] codePoints, int offset, int count)" is a facility
84	// introduced in Java 1.5	84	// introduced in Java 1.5
85	String str = new String(codePointArray, 0, codePointArray.length);	85	String str = new String(codePointArray, 0, codePointArray.length);
86	str = StringEscapeUtils.escapeXml(str);
87	rs.add(new XSString(str));	86	rs.add(new XSString(str));
88		87
89	return rs;	88	return rs;

Lines 10-26 Link Here

(-)src/org/eclipse/wst/xml/xpath2/processor/internal/function/FnSubstring.java (-60 / +27 lines)
10	* Mukul Gandhi - bug 273795 - improvements to function, substring	10	* Mukul Gandhi - bug 273795 - improvements to function, substring
11	* Jesper Steen Moeller - bug 285145 - implement full arity checking	11	* Jesper Steen Moeller - bug 285145 - implement full arity checking
12	* David Carver - bug 282096 - improvements for surrogate handling	12	* David Carver - bug 282096 - improvements for surrogate handling
		13	* Jesper Steen Moeller - bug 282096 - reimplemented to be surrogate sensitive
13	*******************************************************************************/	14	*******************************************************************************/
14		15
15	package org.eclipse.wst.xml.xpath2.processor.internal.function;	16	package org.eclipse.wst.xml.xpath2.processor.internal.function;
16		17
17	import org.apache.commons.lang.StringEscapeUtils;
18	import org.eclipse.wst.xml.xpath2.processor.DynamicError;	18	import org.eclipse.wst.xml.xpath2.processor.DynamicError;
19	import org.eclipse.wst.xml.xpath2.processor.ResultSequence;	19	import org.eclipse.wst.xml.xpath2.processor.ResultSequence;
20	import org.eclipse.wst.xml.xpath2.processor.ResultSequenceFactory;	20	import org.eclipse.wst.xml.xpath2.processor.ResultSequenceFactory;
21	import org.eclipse.wst.xml.xpath2.processor.internal.*;	21	import org.eclipse.wst.xml.xpath2.processor.internal.*;
22	import org.eclipse.wst.xml.xpath2.processor.internal.types.*;	22	import org.eclipse.wst.xml.xpath2.processor.internal.types.*;
23	import org.eclipse.wst.xml.xpath2.processor.internal.utils.SurrogateUtils;	23	import org.eclipse.wst.xml.xpath2.processor.internal.utils.CodePointIterator;
		24	import org.eclipse.wst.xml.xpath2.processor.internal.utils.StringCodePointIterator;
24		25
25	import java.util.*;	26	import java.util.*;
26		27
Lines 100-175 Link Here
100	}	101	}
101		102
102	String str = ((XSString) stringArg.first()).value();	103	String str = ((XSString) stringArg.first()).value();
103	str = SurrogateUtils.decodeXML(str);
104	double dstart = ((XSDouble) startPosArg.first()).double_value();	104	double dstart = ((XSDouble) startPosArg.first()).double_value();
105		105
106	if (Double.NaN == dstart) {	106	// is start is NaN, no chars are returned
		107	if (Double.NaN == dstart \|\| Double.NEGATIVE_INFINITY == dstart) {
107	return emptyString(rs);	108	return emptyString(rs);
108	}	109	}
109		110	long istart = Math.round(dstart);
110	int start = (int) Math.round(dstart);
111
112	if (isStartOutOfBounds(str, start)) {
113	return emptyString(rs);
114	}
115		111
116	start = adjustStartPosition(start);	112	long ilength = Long.MAX_VALUE;
117
118	if (lengthArg != null) {	113	if (lengthArg != null) {
119	return substringLength(rs, lengthArg, dstart, start, str);	114	double dlength = ((XSDouble) lengthArg.first()).double_value();
		115	if (Double.NaN == dlength)
		116	return emptyString(rs);
		117	// Switch to the rounded kind
		118	ilength = Math.round(dlength);
		119	if (ilength <= 0)
		120	return emptyString(rs);
120	}	121	}
121		122
122	rs.add(new XSString(StringEscapeUtils.escapeXml(str.substring(start))));	123
123		124	// could guess too short in cases supplementary chars
124	return rs;	125	StringBuilder sb = new StringBuilder((int) Math.min(str.length(), ilength));
125	}
126
127	private static ResultSequence substringLength(ResultSequence rs, ResultSequence lengthArg, double dstart, int start, String str) {
128	int length = adjustLength(lengthArg, dstart, start);
129	int endpos = start + length;
130	if (isEndPosOutOfBounds(endpos) \|\| isStartOutOfBounds(str, endpos)) {
131	return emptyString(rs);
132	}
133
134	if (start == 0 && endpos == 0) {
135	rs.add(new XSString(StringEscapeUtils.escapeXml(str.substring(start))));
136	} else {
137	rs.add(new XSString(StringEscapeUtils.escapeXml(str.substring(start, endpos))));
138	}
139	return rs;
140	}
141
142	private static boolean isEndPosOutOfBounds(int endpos) {
143	return endpos < 0;
144	}
145
146	private static int adjustLength(ResultSequence arg3, double dstart,
147	int start) {
148	double dlength = ((XSDouble) arg3.first()).double_value();
149	int length = (int) Math.round(dlength);
150	if (dstart < 0) {
151	length = (int)( dlength - (Math.abs(dstart) + 1));
152	} else if (dstart == 0) {
153	length = length - 1;
154	} else if (isEndPosOutOfBounds(length)) {
155	length = start - Math.abs(length);
156	}
157	return length;
158	}
159		126
160	private static int adjustStartPosition(int start) {	127	// This looks like an inefficient way to iterate, but due to surrogate handling,
161	if (start <= 0) {	128	// string indexes are no good here. Welcome to UTF-16!
162	start = 0;	129
163	} else {	130	CodePointIterator strIter = new StringCodePointIterator(str);
164	start = start - 1;	131	for (long p = 1; strIter.current() != CodePointIterator.DONE; ++p, strIter.next()) {
		132	if (istart <= p && p - istart < ilength)
		133	sb.appendCodePoint(strIter.current());
165	}	134	}
166	return start;	135	rs.add(new XSString(sb.toString()));
167	}
168		136
169	private static boolean isStartOutOfBounds(String str, int start) {	137	return rs;
170	return start > str.length();
171	}	138	}
172		139
173	private static ResultSequence emptyString(ResultSequence rs) {	140	private static ResultSequence emptyString(ResultSequence rs) {
174	rs.add(new XSString(""));	141	rs.add(new XSString(""));
175	return rs;	142	return rs;

Added Link Here

(-)src/org/eclipse/wst/xml/xpath2/processor/internal/utils/CodePointIterator.java (+75 lines)
1	/*******************************************************************************
2	* Copyright (c) 2009 Jesper Steen Moeller and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Jesper Steen Moeller - bug 282096 - initial API and implementation
10	*******************************************************************************/
11
12	package org.eclipse.wst.xml.xpath2.processor.internal.utils;
13
14	public interface CodePointIterator extends Cloneable
15	{
16	/**
17	* Sentinel value returned from iterator when the end is reached.
18	* The value is -1 which will never be a valid codepoint.
19	*/
20	public static final int DONE = -1;
21
22	/**
23	* Resets the position to 0 and returns the first code point.
24	* @return the first code point in the text, or DONE if the text is empty
25	*/
26	public int first();
27
28	/**
29	* Sets the position to the last possible position (or 0 if the text is empty)
30	* and returns the code point at that position.
31	* @return the last code point in the text, or DONE if the text is empty
32	* @see #getEndIndex()
33	*/
34	public int last();
35
36	/**
37	* Gets the code point at the current position (as returned by getIndex()).
38	* @return the code point at the current position or DONE if the current
39	* position is off the end of the text.
40	* @see #getIndex()
41	*/
42	public int current();
43
44	/**
45	* Increments the iterator's code point index by one and returns the code point
46	* at the new index. If the resulting index is at the end of the string, the
47	* index is not incremented, and DONE is returned.
48	* @return the code point at the new position or DONE if the new
49	* position is after the text range.
50	*/
51	public int next();
52
53	/**
54	* Decrements the iterator's index by one and returns the character
55	* at the new index. If the current index is 0, the index
56	* remains at 0 and a value of DONE is returned.
57	*
58	* @return the code point at the new position (or DONE if the current
59	* position is 0)
60	*/
61	public int previous();
62
63	/**
64	* Returns the current index (as a codepoint, not a string index).
65	* @return the current index.
66	*/
67	public int getIndex();
68
69	/**
70	* Create a copy of this code point iterator
71	* @return A copy of this
72	*/
73	public Object clone();
74
75	}