Attachment #201464 for bug #183164

View | Details | Raw Unified | Return to bug 183164 | Differences between

and this patch




            type="test">
      </typeDescription>
     <typeDescription
            class="org.eclipse.equinox.bidi.internal.tests.TestProcessor1"
            description="Test processor 1"
            type="test.Processor1">
      </typeDescription>
      <typeDescription
            class="org.eclipse.equinox.bidi.internal.tests.TestProcessor2"
            description="Test processor 2"
            type="test.Processor2">
      </typeDescription>
      <typeDescription
            class="org.eclipse.equinox.bidi.internal.tests.TestProcessor3"
            description="Test processor 3"
            type="test.Processor3">
      </typeDescription>
      <typeDescription
            class="org.eclipse.equinox.bidi.internal.tests.TestProcessorMyCommaRL"
            description="Test my comma RL"
            type="test.MyCommaRL">
      </typeDescription>
       <typeDescription
            class="org.eclipse.equinox.bidi.internal.tests.TestProcessorMyCommaRR"
            description="Test my comma RR"
            type="test.MyCommaRR">
      </typeDescription>
      <typeDescription
            class="org.eclipse.equinox.bidi.internal.tests.TestProcessorMyCommaLL"
            description="Test my comma LL"
            type="test.MyCommaLL">
      </typeDescription>





package org.eclipse.equinox.bidi.internal.tests;

import org.eclipse.equinox.bidi.STextProcessorFactory;
import org.eclipse.equinox.bidi.advanced.STextExpertFactory;
import org.eclipse.equinox.bidi.advanced.ISTextExpert;
import org.eclipse.equinox.bidi.custom.STextProcessor;
import org.eclipse.equinox.bidi.custom.STextTypeHandler;

/**
 * Tests contribution of BiDi processors.
 */
public class STextExtensibilityTest extends STextTestBase {

	public void testBaseContributions() {
		String[] types = STextProcessorFactory.getAllProcessorIDs();
		assertNotNull(types);
		assertTrue(types.length > 0);

		// check one of the types that we know should be there
		assertTrue(isTypePresent(types, "regex"));

		STextProcessor processor = STextProcessorFactory.getProcessor("regex");
		assertNotNull(processor);
	}

	public void testOtherContributions() {
		String[] types = STextProcessorFactory.getAllProcessorIDs();
		assertNotNull(types);
		assertTrue(types.length > 0);

		// check the type added by the test bundle
		assertTrue(isTypePresent(types, "test"));

		STextProcessor processor = STextProcessorFactory.getProcessor("test");
		assertNotNull(processor);

		processor = STextProcessorFactory.getProcessor("badtest");
		assertNull(processor);

		String data, lean, full, model;
		data = "ABC.DEF:HOST-COM=HELLO";
		lean = toUT16(data);
		processor = STextProcessorFactory.getProcessor("test");

		ISTextExpert expert = STextExpertFactory.getExpert("test");
		full = expert.leanToFullText(lean);





package org.eclipse.equinox.bidi.internal.tests;

import org.eclipse.equinox.bidi.STextProcessorFactory;
import org.eclipse.equinox.bidi.advanced.*;

/**

	public void testExtensions() {
		String data;

		expert = STextExpertFactory.getExpert(STextProcessorFactory.COMMA_DELIMITED, env);
		doTest1("Comma #1", "ab,cd, AB, CD, EFG", "ab,cd, AB@, CD@, EFG");

		expert = STextExpertFactory.getExpert(STextProcessorFactory.EMAIL, env);
		doTest1("Email #1", "abc.DEF:GHI", "abc.DEF@:GHI");
		doTest1("Email #2", "DEF.GHI \"A.B\":JK ", "DEF@.GHI @\"A.B\"@:JK ");
		doTest1("Email #3", "DEF,GHI (A,B);JK ", "DEF@,GHI @(A,B)@;JK ");
		doTest1("Email #4", "DEF.GHI (A.B :JK ", "DEF@.GHI @(A.B :JK ");
		env = envArabic;
		expert = STextExpertFactory.getExpert(STextProcessorFactory.EMAIL, env);
		doTest1("Email #5", "#EF.GHI \"A.B\":JK ", "<&#EF.GHI \"A.B\":JK &^");
		doTest1("Email #6", "#EF,GHI (A,B);JK ", "<&#EF,GHI (A,B);JK &^");
		doTest1("Email #7", "#EF.GHI (A.B :JK ", "<&#EF.GHI (A.B :JK &^");
		data = toUT16("peter.pan") + "@" + toUT16("#EF.GHI");
		doTest2("Email #8", data, "<&peter&.pan@#EF.GHI&^");
		env = envHebrew;
		expert = STextExpertFactory.getExpert(STextProcessorFactory.EMAIL, env);
		data = toUT16("peter.pan") + "@" + toUT16("DEF.GHI");
		doTest2("Email #9", data, "peter.pan@DEF@.GHI");

		expert = STextExpertFactory.getExpert(STextProcessorFactory.FILE, env);
		doTest1("File #1", "c:\\A\\B\\FILE.EXT", "c:\\A@\\B@\\FILE@.EXT");

		expert = STextExpertFactory.getExpert(STextProcessorFactory.JAVA, env);
		doTest1("Java #1", "A = B + C;", "A@ = B@ + C;");
		doTest1("Java #2", "A   = B + C;", "A@   = B@ + C;");
		doTest1("Java #3", "A = \"B+C\"+D;", "A@ = \"B+C\"@+D;");

		doTest1("Java #9", "A = //B+C* D;", "A@ = //B+C* D;");
		doTest1("Java #10", "A = //B+C`|D+E;", "A@ = //B+C`|D@+E;");

		expert = STextExpertFactory.getExpert(STextProcessorFactory.PROPERTY, env);
		doTest1("Property #0", "NAME,VAL1,VAL2", "NAME,VAL1,VAL2");
		doTest1("Property #1", "NAME=VAL1,VAL2", "NAME@=VAL1,VAL2");
		doTest1("Property #2", "NAME=VAL1,VAL2=VAL3", "NAME@=VAL1,VAL2=VAL3");

		expert = STextExpertFactory.getExpert(STextProcessorFactory.REGEXP, env);
		data = toUT16("ABC(?") + "#" + toUT16("DEF)GHI");
		doTest2("Regex #0.0", data, "A@B@C@(?#DEF)@G@H@I");
		data = toUT16("ABC(?") + "#" + toUT16("DEF");

		doTest1("Regex #17.7", "aB*567", "aB*@567");

		env = envArabic;
		expert = STextExpertFactory.getExpert(STextProcessorFactory.REGEXP, env);
		data = toUT16("#BC(?") + "#" + toUT16("DEF)GHI");
		doTest2("Regex #0.0", data, "<&#BC(?#DEF)GHI&^");
		data = toUT16("#BC(?") + "#" + toUT16("DEF");

		doTest2("Regex #16.2", data, "<&#HI\\eJKL&^");
		env = envHebrew;

		expert = STextExpertFactory.getExpert(STextProcessorFactory.SQL, env);
		doTest1("SQL #0", "abc GHI", "abc GHI");
		doTest1("SQL #1", "abc DEF   GHI", "abc DEF@   GHI");
		doTest1("SQL #2", "ABC, DEF,   GHI", "ABC@, DEF@,   GHI");

		doTest1("SQL #12", "ABC\"DEF \"\" G I\" JKL,MN", "ABC@\"DEF \"\" G I\"@ JKL@,MN");
		doTest1("SQL #13", "ABC--DEF GHI`|JKL MN", "ABC@--DEF GHI`|JKL@ MN");

		expert = STextExpertFactory.getExpert(STextProcessorFactory.SYSTEM_USER, env);
		doTest1("System #1", "HOST(JACK)", "HOST@(JACK)");

		expert = STextExpertFactory.getExpert(STextProcessorFactory.UNDERSCORE, env);
		doTest1("Underscore #1", "A_B_C_d_e_F_G", "A@_B@_C_d_e_F@_G");

		expert = STextExpertFactory.getExpert(STextProcessorFactory.URL, env);
		doTest1("URL #1", "WWW.DOMAIN.COM/DIR1/DIR2/dir3/DIR4", "WWW@.DOMAIN@.COM@/DIR1@/DIR2/dir3/DIR4");

		expert = STextExpertFactory.getExpert(STextProcessorFactory.XPATH, env);
		doTest1("Xpath #1", "abc(DEF)GHI", "abc(DEF@)GHI");
		doTest1("Xpath #2", "DEF.GHI \"A.B\":JK ", "DEF@.GHI@ \"A.B\"@:JK ");
		doTest1("Xpath #3", "DEF!GHI 'A!B'=JK ", "DEF@!GHI@ 'A!B'@=JK ");
		doTest1("Xpath #4", "DEF.GHI 'A.B :JK ", "DEF@.GHI@ 'A.B :JK ");

		expert = STextExpertFactory.getExpert(STextProcessorFactory.EMAIL, env);
		doTest3("DelimsEsc #1", "abc.DEF.GHI", "abc.DEF@.GHI");
		doTest3("DelimsEsc #2", "DEF.GHI (A:B);JK ", "DEF@.GHI @(A:B)@;JK ");
		doTest3("DelimsEsc #3", "DEF.GHI (A:B);JK ", "DEF@.GHI @(A:B)@;JK ");





package org.eclipse.equinox.bidi.internal.tests;

import org.eclipse.equinox.bidi.STextProcessorFactory;
import org.eclipse.equinox.bidi.advanced.*;

/**

	}

	public void testFullToLean() {
		type = STextProcessorFactory.COMMA_DELIMITED;
		doTest1("testFullToLean #1 - ", "", "", "", new int[0], new int[0], "", "", new int[0], new int[0]);
		int[] map1 = new int[] {0, 1, 2, 3, 4};
		int[] map2 = new int[] {2, 3, 4, 5, 6};

		doTest1("testFullToLean #37 - ", ">>>@@@@@^^^", "", "", map1, map2, "", "", map1, map2);

		// test fullToLeanText with initial state
		type = STextProcessorFactory.SQL;
		doTest2("testFullToLean #38 - ");
	}
}

Lines 11-17 Link Here

(-)src/org/eclipse/equinox/bidi/internal/tests/STextMathTest.java (-3 / +3 lines)
11		11
12	package org.eclipse.equinox.bidi.internal.tests;	12	package org.eclipse.equinox.bidi.internal.tests;
13		13
14	import org.eclipse.equinox.bidi.STextTypeHandlerFactory;	14	import org.eclipse.equinox.bidi.STextProcessorFactory;
15	import org.eclipse.equinox.bidi.advanced.*;	15	import org.eclipse.equinox.bidi.advanced.*;
16		16
17	/**	17	/**
Lines 22-29 Link Here
22	private STextEnvironment envLTR = new STextEnvironment("ar", false, STextEnvironment.ORIENT_LTR);	22	private STextEnvironment envLTR = new STextEnvironment("ar", false, STextEnvironment.ORIENT_LTR);
23	private STextEnvironment envRTL = new STextEnvironment("ar", false, STextEnvironment.ORIENT_RTL);	23	private STextEnvironment envRTL = new STextEnvironment("ar", false, STextEnvironment.ORIENT_RTL);
24		24
25	private ISTextExpert expertLTR = STextExpertFactory.getExpert(STextTypeHandlerFactory.RTL_ARITHMETIC, envLTR);	25	private ISTextExpert expertLTR = STextExpertFactory.getExpert(STextProcessorFactory.RTL_ARITHMETIC, envLTR);
26	private ISTextExpert expertRTL = STextExpertFactory.getExpert(STextTypeHandlerFactory.RTL_ARITHMETIC, envRTL);	26	private ISTextExpert expertRTL = STextExpertFactory.getExpert(STextProcessorFactory.RTL_ARITHMETIC, envRTL);
27		27
28	private void verifyOneLine(String msg, String data, String resLTR, String resRTL) {	28	private void verifyOneLine(String msg, String data, String resLTR, String resRTL) {
29	String lean = toUT16(data);	29	String lean = toUT16(data);




package org.eclipse.equinox.bidi.internal.tests;

import org.eclipse.equinox.bidi.STextDirection;
import org.eclipse.equinox.bidi.STextProcessorFactory;
import org.eclipse.equinox.bidi.advanced.*;

/**


	private void doTestState() {
		String data, lean, full, model;
		ISTextExpert expert = STextExpertFactory.getPrivateExpert(STextProcessorFactory.JAVA);

		data = "A=B+C;/* D=E+F;";
		lean = toUT16(data);
		full = expert.leanToFullText(lean);

		model = "A@=B@+C@;/* D=E+F;";
		assertEquals("full1", model, toPseudo(full));

		data = "A=B+C; D=E+F;";
		lean = toUT16(data);
		full = expert.leanToFullText(lean);

		model = "A=B+C; D=E+F;";
		assertEquals("full2", model, toPseudo(full));

		data = "SOME MORE COMMENTS";
		lean = toUT16(data);
		full = expert.leanToFullText(lean);
		model = data;
		assertEquals("full3", model, toPseudo(full));

		data = "A=B+C;*/ D=E+F;";
		lean = toUT16(data);
		full = expert.leanToFullText(lean);

		model = "A=B+C;@*/ D@=E@+F;";
		assertEquals("full3", model, toPseudo(full));
	}

	private void doTestOrientation() {

		assertEquals("orient #4", STextEnvironment.ORIENT_UNKNOWN, orient);
	}

	private void doTestOrient(String processorDefID, String label, String data, String resLTR, String resRTL, String resCon) {
		String full, lean;

		ISTextExpert expertLTR = STextExpertFactory.getExpert(processorDefID, envLTR);
		ISTextExpert expertRTL = STextExpertFactory.getExpert(processorDefID, envRTL);
		ISTextExpert expertCRL = STextExpertFactory.getExpert(processorDefID, envCRL);

		lean = toUT16(data);
		full = expertLTR.leanToFullText(lean);


	private void doTestLeanOffsets() {
		String lean, data, label;
		ISTextExpert expert = STextExpertFactory.getExpert(STextProcessorFactory.JAVA);

		int[] offsets;
		int[] model;

	private void doTestFullOffsets(String label, String data, int[] resLTR, int[] resRTL, int[] resCon) {
		String full, lean, msg;
		int[] offsets;
		ISTextExpert expertLTR = STextExpertFactory.getExpert(STextProcessorFactory.COMMA_DELIMITED, envLTR);
		ISTextExpert expertRTL = STextExpertFactory.getExpert(STextProcessorFactory.COMMA_DELIMITED, envRTL);
		ISTextExpert expertCLR = STextExpertFactory.getExpert(STextProcessorFactory.COMMA_DELIMITED, envCLR);

		lean = toUT16(data);
		full = expertLTR.leanToFullText(lean);


		doTestOrientation();

		doTestOrient(STextProcessorFactory.COMMA_DELIMITED, "Methods #1 ", "", "", "", "");
		doTestOrient(STextProcessorFactory.COMMA_DELIMITED, "Methods #2 ", "abc", "abc", ">@abc@^", "abc");
		doTestOrient(STextProcessorFactory.COMMA_DELIMITED, "Methods #3 ", "ABC", "ABC", ">@ABC@^", "@ABC");
		doTestOrient(STextProcessorFactory.COMMA_DELIMITED, "Methods #4 ", "bcd,ef", "bcd,ef", ">@bcd,ef@^", "bcd,ef");
		doTestOrient(STextProcessorFactory.COMMA_DELIMITED, "Methods #5 ", "BCD,EF", "BCD@,EF", ">@BCD@,EF@^", "@BCD@,EF");
		doTestOrient(STextProcessorFactory.COMMA_DELIMITED, "Methods #6 ", "cde,FG", "cde,FG", ">@cde,FG@^", "cde,FG");
		doTestOrient(STextProcessorFactory.COMMA_DELIMITED, "Methods #7 ", "CDE,fg", "CDE,fg", ">@CDE,fg@^", "@CDE,fg");
		doTestOrient(STextProcessorFactory.COMMA_DELIMITED, "Methods #8 ", "12..def,GH", "12..def,GH", ">@12..def,GH@^", "12..def,GH");
		doTestOrient(STextProcessorFactory.COMMA_DELIMITED, "Methods #9 ", "34..DEF,gh", "34..DEF,gh", ">@34..DEF,gh@^", "@34..DEF,gh");

		doTestSkipProcessing();



		doTestDirection();

		ISTextExpert expert = STextExpertFactory.getExpert(STextProcessorFactory.COMMA_DELIMITED);
		String data = "A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z";
		String lean = toUT16(data);
		String full = expert.leanToFullText(lean);




/*******************************************************************************
 * Copyright (c) 2010, 2011 IBM Corporation 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:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.equinox.bidi.internal.tests;


/**
 * Tests null processor
 */
public class STextNullProcessorTest extends STextTestBase {

	static final int[] EMPTY_INT_ARRAY = new int[0];

	public void testNullProcessor() {
		/* not needed
		String full = STextEngine.leanToFullText(null, null, "abc", null);
		assertEquals("leanToFullText", "abc", full);
		int[] state = new int[1];
		state[0] = 3;
		full = STextEngine.leanToFullText(null, null, "abc", state);
		assertEquals("leanToFullText with state", "abc", full);
		int[] offsets = STextEngine.leanBidiCharOffsets(null, null, "abc", null);
		assertEquals("leanBidiCharOffsets", 0, offsets.length);
		offsets = STextEngine.fullBidiCharOffsets(null, null, "abc", null);
		assertEquals("fullBidiCharOffsets", 0, offsets.length);
		String lean = STextEngine.fullToLeanText(null, null, "abc", null);
		assertEquals("fullToLeanText", "abc", lean);
		lean = STextEngine.fullToLeanText(null, null, "abc", state);
		assertEquals("fullToLeanText with state", "abc", lean);
		int[] map = STextEngine.leanToFullMap(null, null, "abc", null);
		int[] model = {0, 1, 2};
		assertEquals("leanToFullMap", array_display(model), array_display(map));
		map = STextEngine.fullToLeanMap(null, null, "abc", null);
		assertEquals("fullToLeanMap", array_display(model), array_display(map));
		int direction = STextEngine.getCurDirection(null, null, "abc");
		assertEquals("getCurDirection", STextEngine.DIR_LTR, direction);
		*/
	}
}




/*******************************************************************************
 * Copyright (c) 2010, 2011 IBM Corporation 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:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.equinox.bidi.internal.tests;

import java.util.Locale;
import org.eclipse.equinox.bidi.STextTypeHandlerFactory;
import org.eclipse.equinox.bidi.STextProcessor;
import org.eclipse.equinox.bidi.custom.STextTypeHandler;

/**
 * Tests methods in BidiComplexUtil
 */

public class STextProcessorTest extends STextTestBase {

	private static final String HEBREW = "iw";

	private static final String HEBREW2 = "he";

	private static final String ARABIC = "ar";

	private static final String FARSI = "fa";

	private static final String URDU = "ur";

	private Locale locale;

	protected void setUp() throws Exception {
		super.setUp();
		locale = Locale.getDefault();
	}

	protected void tearDown() {
		Locale.setDefault(locale);
	}

	private void doTest1(String data, String result) {
		Locale.setDefault(Locale.ENGLISH);
		String full = STextProcessor.process(toUT16(data));
		assertEquals("Util #1 full EN - ", data, toPseudo(full));
		Locale.setDefault(new Locale(HEBREW2));
		full = STextProcessor.process(toUT16(data));
		assertEquals("Util #1 full HE - ", result, toPseudo(full));
		Locale.setDefault(new Locale(ARABIC));
		full = STextProcessor.process(toUT16(data));
		assertEquals("Util #1 full AR - ", result, toPseudo(full));
		Locale.setDefault(new Locale(FARSI));
		full = STextProcessor.process(toUT16(data));
		assertEquals("Util #1 full FA - ", result, toPseudo(full));
		Locale.setDefault(new Locale(URDU));
		full = STextProcessor.process(toUT16(data));
		assertEquals("Util #1 full UR - ", result, toPseudo(full));
		Locale.setDefault(new Locale(HEBREW));
		full = STextProcessor.process(toUT16(data));
		String ful2 = STextProcessor.process(toUT16(data), (String) null);
		assertEquals("Util #1 full - ", result, toPseudo(full));
		assertEquals("Util #1 ful2 - ", result, toPseudo(ful2));
		String lean = STextProcessor.deprocess(full);
		assertEquals("Util #1 lean - ", data, toPseudo(lean));
	}

	private void doTest2(String msg, String data, String result) {
		doTest2(msg, data, result, data);
	}

	private void doTest2(String msg, String data, String result, String resLean) {
		String full = STextProcessor.process(toUT16(data), "*");
		assertEquals(msg + "full", result, toPseudo(full));
		String lean = STextProcessor.deprocess(full);
		assertEquals(msg + "lean", resLean, toPseudo(lean));
	}

	private void doTest3(String msg, String data, String result) {
		doTest3(msg, data, result, data);
	}

	private void doTest3(String msg, String data, String result, String resLean) {
		STextTypeHandler handler = STextTypeHandlerFactory.getHandler(STextTypeHandlerFactory.COMMA_DELIMITED);
		String full = STextProcessor.process(toUT16(data), handler);
		assertEquals(msg + "full", result, toPseudo(full));
		String lean = STextProcessor.deprocess(full, handler);
		assertEquals(msg + "lean", resLean, toPseudo(lean));
	}

	private void doTest4(String msg, String data, int[] offsets, int direction, boolean affix, String result) {
		String txt = msg + "text=" + data + "\n    offsets=" + array_display(offsets) + "\n    direction=" + direction + "\n    affix=" + affix;
		String lean = toUT16(data);
		String full = STextProcessor.insertMarks(lean, offsets, direction, affix);
		assertEquals(txt, result, toPseudo(full));
	}

	public void testBidiComplexUtil() {

		// Test process() and deprocess() with default delimiters
		doTest1("ABC/DEF/G", ">@ABC@/DEF@/G@^");
		// Test process() and deprocess() with specified delimiters
		doTest2("Util #2.1 - ", "", "");
		doTest2("Util #2.2 - ", ">@ABC@^", ">@ABC@^", "ABC");
		doTest2("Util #2.3 - ", "abc", "abc");
		doTest2("Util #2.4 - ", "!abc", ">@!abc@^");
		doTest2("Util #2.5 - ", "abc!", ">@abc!@^");
		doTest2("Util #2.6 - ", "ABC*DEF*G", ">@ABC@*DEF@*G@^");
		// Test process() and deprocess() with specified expression type
		doTest3("Util #3.1 - ", "ABC,DEF,G", ">@ABC@,DEF@,G@^");
		doTest3("Util #3.2 - ", "", "");
		doTest3("Util #3.3 - ", ">@DEF@^", ">@DEF@^", "DEF");
		// Test insertMarks()
		doTest4("Util #4.1 - ", "ABCDEFG", new int[] {3, 6}, 0, false, "ABC@DEF@G");
		doTest4("Util #4.2 - ", "ABCDEFG", new int[] {3, 6}, 0, true, ">@ABC@DEF@G@^");
		doTest4("Util #4.3 - ", "ABCDEFG", new int[] {3, 6}, 1, false, "ABC&DEF&G");
		doTest4("Util #4.4 - ", "ABCDEFG", new int[] {3, 6}, 1, true, "<&ABC&DEF&G&^");
		doTest4("Util #4.5 - ", "", new int[] {3, 6}, 0, false, "");
		doTest4("Util #4.6 - ", "", new int[] {3, 6}, 0, true, "");
		doTest4("Util #4.7 - ", "ABCDEFG", null, 1, false, "ABCDEFG");
		doTest4("Util #4.8 - ", "ABCDEFG", null, 1, true, "<&ABCDEFG&^");
	}
}




		assertFalse(env1.isProcessingNeeded());
		assertTrue(env2.isProcessingNeeded());

		ISTextExpert expert1 = STextExpertFactory.getExpert("test.Processor1", env1);
		String full = expert1.leanToFullText("abcd");
		assertEquals("@a@b@c@d", toPseudo(full));

		ISTextExpert expert2 = STextExpertFactory.getExpert("test.Processor2", env1);
		boolean catchFlag = false;
		try {
			full = expert2.leanToFullText("abcd");

		assertTrue("Catch missing indexOfSpecial", catchFlag);

		catchFlag = false;
		ISTextExpert expert3 = STextExpertFactory.getExpert("test.Processor3", env1);
		try {
			full = expert3.leanToFullText("abcd");
		} catch (IllegalStateException e) {





package org.eclipse.equinox.bidi.internal.tests;

import org.eclipse.equinox.bidi.STextProcessorFactory;
import org.eclipse.equinox.bidi.STextStringRecord;
import org.eclipse.equinox.bidi.STextTypeHandlerFactory;

/**
 *	Tests the StringRecord class	

		// check handling of invalid arguments
		catchFlag = false;
		try {
			sr = STextStringRecord.addRecord(null, 1, STextProcessorFactory.EMAIL, 0, 1);
		} catch (IllegalArgumentException e) {
			catchFlag = true;
		}

		} catch (IllegalArgumentException e) {
			catchFlag = true;
		}
		assertTrue("Catch null processor argument", catchFlag);
		catchFlag = false;
		try {
			sr = STextStringRecord.addRecord("abc", 0, STextProcessorFactory.EMAIL, 0, 1);
		} catch (IllegalArgumentException e) {
			catchFlag = true;
		}
		assertTrue("Catch invalid segment count argument", catchFlag);
		catchFlag = false;
		try {
			sr = STextStringRecord.addRecord("abc", 1, STextProcessorFactory.EMAIL, -1, 1);
		} catch (IllegalArgumentException e) {
			catchFlag = true;
		}
		assertTrue("Catch invalid start argument", catchFlag);
		catchFlag = false;
		try {
			sr = STextStringRecord.addRecord("abc", 1, STextProcessorFactory.EMAIL, 4, 1);
		} catch (IllegalArgumentException e) {
			catchFlag = true;
		}
		assertTrue("Catch invalid start argument", catchFlag);
		catchFlag = false;
		try {
			sr = STextStringRecord.addRecord("abc", 1, STextProcessorFactory.EMAIL, 0, 0);
		} catch (IllegalArgumentException e) {
			catchFlag = true;
		}
		assertTrue("Catch invalid limit argument", catchFlag);
		catchFlag = false;
		try {
			sr = STextStringRecord.addRecord("abc", 1, STextProcessorFactory.EMAIL, 0, 5);
		} catch (IllegalArgumentException e) {
			catchFlag = true;
		}

		assertEquals(null, sr);
		for (int i = 0; i < lim; i++) {
			String str = Integer.toString(i);
			sr = STextStringRecord.addRecord(str, 1, STextProcessorFactory.EMAIL, 0, 1);
		}
		sr = STextStringRecord.getRecord(null);
		assertEquals(null, sr);


		for (int i = lim; i <= poolSize; i++) {
			String str = Integer.toString(i);
			sr = STextStringRecord.addRecord(str, 1, STextProcessorFactory.EMAIL, 0, 1);
		}
		for (int i = 1; i <= poolSize; i++) {
			String str = Integer.toString(i);

		}
		sr = STextStringRecord.getRecord("0");
		assertEquals(null, sr);
		sr = STextStringRecord.addRecord("thisisalongstring", 3, STextProcessorFactory.EMAIL, 0, 2);
		sr.addSegment(STextProcessorFactory.JAVA, 4, 5);
		sr.addSegment(STextProcessorFactory.FILE, 6, 7);
		catchFlag = false;
		try {
			sr.addSegment(STextProcessorFactory.EMAIL, 10, 13);
		} catch (IllegalStateException e) {
			catchFlag = true;
		}
		assertTrue("Catch too many segments", catchFlag);
		assertEquals(3, sr.getSegmentCount());
		assertEquals(STextProcessorFactory.EMAIL, sr.getProcessor(0));
		assertEquals(STextProcessorFactory.JAVA, sr.getProcessor(1));
		assertEquals(STextProcessorFactory.FILE, sr.getProcessor(2));
		assertEquals(0, sr.getStart(0));
		assertEquals(4, sr.getStart(1));
		assertEquals(6, sr.getStart(2));

Lines 10-18 Link Here

(-)src/org/eclipse/equinox/bidi/internal/tests/STextTest.java (-2 / +2 lines)
10	******************************************************************************/	10	******************************************************************************/
11	package org.eclipse.equinox.bidi.internal.tests;	11	package org.eclipse.equinox.bidi.internal.tests;
12		12
13	import org.eclipse.equinox.bidi.custom.STextTypeHandler;	13	import org.eclipse.equinox.bidi.custom.STextProcessor;
14		14
15	public class STextTest extends STextTypeHandler {	15	public class STextTest extends STextProcessor {
16		16
17	public STextTest() {	17	public STextTest() {
18	super("-=.:");	18	super("-=.:");

Lines 14-20 Link Here

(-)src/org/eclipse/equinox/bidi/internal/tests/STextTestBase.java (-1 / +1 lines)
14	import junit.framework.TestCase;	14	import junit.framework.TestCase;
15		15
16	/**	16	/**
17	* Base functionality for the handler tests.	17	* Base functionality for the processor tests.
18	*/	18	*/
19	public class STextTestBase extends TestCase {	19	public class STextTestBase extends TestCase {
20		20




/*******************************************************************************
 * Copyright (c) 2010, 2011 IBM Corporation 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:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.equinox.bidi.internal.tests;

import java.util.Locale;
import org.eclipse.equinox.bidi.STextProcessorFactory;
import org.eclipse.equinox.bidi.STextUtil;
import org.eclipse.equinox.bidi.custom.STextProcessor;

/**
 * Tests methods in BidiComplexUtil
 */

public class STextUtilTest extends STextTestBase {

	private static final String HEBREW = "iw";

	private static final String HEBREW2 = "he";

	private static final String ARABIC = "ar";

	private static final String FARSI = "fa";

	private static final String URDU = "ur";

	private Locale locale;

	protected void setUp() throws Exception {
		super.setUp();
		locale = Locale.getDefault();
	}

	protected void tearDown() {
		Locale.setDefault(locale);
	}

	private void doTest1(String data, String result) {
		Locale.setDefault(Locale.ENGLISH);
		String full = STextUtil.process(toUT16(data));
		assertEquals("Util #1 full EN - ", data, toPseudo(full));
		Locale.setDefault(new Locale(HEBREW2));
		full = STextUtil.process(toUT16(data));
		assertEquals("Util #1 full HE - ", result, toPseudo(full));
		Locale.setDefault(new Locale(ARABIC));
		full = STextUtil.process(toUT16(data));
		assertEquals("Util #1 full AR - ", result, toPseudo(full));
		Locale.setDefault(new Locale(FARSI));
		full = STextUtil.process(toUT16(data));
		assertEquals("Util #1 full FA - ", result, toPseudo(full));
		Locale.setDefault(new Locale(URDU));
		full = STextUtil.process(toUT16(data));
		assertEquals("Util #1 full UR - ", result, toPseudo(full));
		Locale.setDefault(new Locale(HEBREW));
		full = STextUtil.process(toUT16(data));
		String ful2 = STextUtil.process(toUT16(data), (String) null);
		assertEquals("Util #1 full - ", result, toPseudo(full));
		assertEquals("Util #1 ful2 - ", result, toPseudo(ful2));
		String lean = STextUtil.deprocess(full);
		assertEquals("Util #1 lean - ", data, toPseudo(lean));
	}

	private void doTest2(String msg, String data, String result) {
		doTest2(msg, data, result, data);
	}

	private void doTest2(String msg, String data, String result, String resLean) {
		String full = STextUtil.process(toUT16(data), "*");
		assertEquals(msg + "full", result, toPseudo(full));
		String lean = STextUtil.deprocess(full);
		assertEquals(msg + "lean", resLean, toPseudo(lean));
	}

	private void doTest3(String msg, String data, String result) {
		doTest3(msg, data, result, data);
	}

	private void doTest3(String msg, String data, String result, String resLean) {
		STextProcessor descriptor = STextProcessorFactory.getProcessor(STextProcessorFactory.COMMA_DELIMITED);
		String full = STextUtil.process(toUT16(data), descriptor);
		assertEquals(msg + "full", result, toPseudo(full));
		String lean = STextUtil.deprocess(full, descriptor);
		assertEquals(msg + "lean", resLean, toPseudo(lean));
	}

	private void doTest4(String msg, String data, int[] offsets, int direction, boolean affix, String result) {
		String txt = msg + "text=" + data + "\n    offsets=" + array_display(offsets) + "\n    direction=" + direction + "\n    affix=" + affix;
		String lean = toUT16(data);
		String full = STextUtil.insertMarks(lean, offsets, direction, affix);
		assertEquals(txt, result, toPseudo(full));
	}

	public void testBidiComplexUtil() {

		// Test process() and deprocess() with default delimiters
		doTest1("ABC/DEF/G", ">@ABC@/DEF@/G@^");
		// Test process() and deprocess() with specified delimiters
		doTest2("Util #2.1 - ", "", "");
		doTest2("Util #2.2 - ", ">@ABC@^", ">@ABC@^", "ABC");
		doTest2("Util #2.3 - ", "abc", "abc");
		doTest2("Util #2.4 - ", "!abc", ">@!abc@^");
		doTest2("Util #2.5 - ", "abc!", ">@abc!@^");
		doTest2("Util #2.6 - ", "ABC*DEF*G", ">@ABC@*DEF@*G@^");
		// Test process() and deprocess() with specified expression type
		doTest3("Util #3.1 - ", "ABC,DEF,G", ">@ABC@,DEF@,G@^");
		doTest3("Util #3.2 - ", "", "");
		doTest3("Util #3.3 - ", ">@DEF@^", ">@DEF@^", "DEF");
		// Test insertMarks()
		doTest4("Util #4.1 - ", "ABCDEFG", new int[] {3, 6}, 0, false, "ABC@DEF@G");
		doTest4("Util #4.2 - ", "ABCDEFG", new int[] {3, 6}, 0, true, ">@ABC@DEF@G@^");
		doTest4("Util #4.3 - ", "ABCDEFG", new int[] {3, 6}, 1, false, "ABC&DEF&G");
		doTest4("Util #4.4 - ", "ABCDEFG", new int[] {3, 6}, 1, true, "<&ABC&DEF&G&^");
		doTest4("Util #4.5 - ", "", new int[] {3, 6}, 0, false, "");
		doTest4("Util #4.6 - ", "", new int[] {3, 6}, 0, true, "");
		doTest4("Util #4.7 - ", "ABCDEFG", null, 1, false, "ABCDEFG");
		doTest4("Util #4.8 - ", "ABCDEFG", null, 1, true, "<&ABCDEFG&^");
	}
}




/*******************************************************************************
 * Copyright (c) 2010, 2011 IBM Corporation 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:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/
package org.eclipse.equinox.bidi.internal.tests;

import org.eclipse.equinox.bidi.advanced.STextEnvironment;
import org.eclipse.equinox.bidi.custom.*;

public class TestHandler1 extends STextTypeHandler {

	public int getSpecialsCount(STextEnvironment env) {
		return 1;
	}

	public int indexOfSpecial(STextEnvironment env, String text, STextCharTypes charTypes, STextOffsets offsets, int caseNumber, int fromIndex) {
		return fromIndex;
	}

	public int processSpecial(STextEnvironment env, String text, STextCharTypes charTypes, STextOffsets offsets, int[] state, int caseNumber, int separLocation) {
		int len = text.length();
		for (int i = len - 1; i >= 0; i--) {
			STextTypeHandler.insertMark(text, charTypes, offsets, i);
			STextTypeHandler.insertMark(text, charTypes, offsets, i);
		}
		return len;
	}
}




/*******************************************************************************
 * Copyright (c) 2010, 2011 IBM Corporation 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:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/
package org.eclipse.equinox.bidi.internal.tests;

import org.eclipse.equinox.bidi.advanced.STextEnvironment;
import org.eclipse.equinox.bidi.custom.STextTypeHandler;

public class TestHandler2 extends STextTypeHandler {

	public int getSpecialsCount(STextEnvironment env) {
		return 1;
	}

}




/*******************************************************************************
 * Copyright (c) 2010, 2011 IBM Corporation 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:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/
package org.eclipse.equinox.bidi.internal.tests;

import org.eclipse.equinox.bidi.advanced.STextEnvironment;
import org.eclipse.equinox.bidi.custom.*;

public class TestHandler3 extends STextTypeHandler {

	public int getSpecialsCount(STextEnvironment env) {
		return 1;
	}

	public int indexOfSpecial(STextEnvironment env, String text, STextCharTypes charTypes, STextOffsets offsets, int caseNumber, int fromIndex) {
		return fromIndex;
	}
}




/*******************************************************************************
 * Copyright (c) 2010, 2011 IBM Corporation 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:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/
package org.eclipse.equinox.bidi.internal.tests;

import org.eclipse.equinox.bidi.STextDirection;
import org.eclipse.equinox.bidi.advanced.STextEnvironment;
import org.eclipse.equinox.bidi.custom.STextCharTypes;
import org.eclipse.equinox.bidi.custom.STextTypeHandler;

public class TestHandlerMyComma extends STextTypeHandler {

	private final static byte AL = Character.DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC;
	protected final static int LTR = STextDirection.DIR_LTR;
	protected final static int RTL = STextDirection.DIR_RTL;

	final int dirArabic;
	final int dirHebrew;

	public TestHandlerMyComma(int dirArabic, int dirHebrew) {
		this.dirArabic = dirArabic;
		this.dirHebrew = dirHebrew;
	}

	public String getSeparators(STextEnvironment environment) {
		return ","; //$NON-NLS-1$
	}

	public boolean skipProcessing(STextEnvironment environment, String text, STextCharTypes charTypes) {
		byte charType = charTypes.getBidiTypeAt(0);
		if (charType == AL)
			return true;
		return false;
	}

	public int getDirection(STextEnvironment environment, String text) {
		return getDirection(environment, text, new STextCharTypes(this, environment, text));
	}

	public int getDirection(STextEnvironment environment, String text, STextCharTypes charTypes) {
		for (int i = 0; i < text.length(); i++) {
			byte charType = charTypes.getBidiTypeAt(i);
			if (charType == AL)
				return dirArabic;
		}
		return dirHebrew;
	}
}




/*******************************************************************************
 * Copyright (c) 2010, 2011 IBM Corporation 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:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/
package org.eclipse.equinox.bidi.internal.tests;

public class TestHandlerMyCommaLL extends TestHandlerMyComma {

	public TestHandlerMyCommaLL() {
		super(LTR, LTR);
	}
}




/*******************************************************************************
 * Copyright (c) 2010, 2011 IBM Corporation 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:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/
package org.eclipse.equinox.bidi.internal.tests;

public class TestHandlerMyCommaRL extends TestHandlerMyComma {

	public TestHandlerMyCommaRL() {
		super(RTL, LTR);
	}
}




/*******************************************************************************
 * Copyright (c) 2010, 2011 IBM Corporation 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:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/
package org.eclipse.equinox.bidi.internal.tests;

public class TestHandlerMyCommaRR extends TestHandlerMyComma {

	public TestHandlerMyCommaRR() {
		super(RTL, RTL);
	}
}




/*******************************************************************************
 * Copyright (c) 2010, 2011 IBM Corporation 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:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/
package org.eclipse.equinox.bidi.internal.tests;

import org.eclipse.equinox.bidi.advanced.STextEnvironment;
import org.eclipse.equinox.bidi.custom.*;

public class TestProcessor1 extends STextProcessor {

	public int getSpecialsCount(STextEnvironment env) {
		return 1;
	}

	public int indexOfSpecial(STextEnvironment env, String text, STextCharTypes charTypes, STextOffsets offsets, int caseNumber, int fromIndex) {
		return fromIndex;
	}

	public int processSpecial(STextEnvironment env, String text, STextCharTypes charTypes, STextOffsets offsets, int[] state, int caseNumber, int separLocation) {
		int len = text.length();
		for (int i = len - 1; i >= 0; i--) {
			STextProcessor.insertMark(text, charTypes, offsets, i);
			STextProcessor.insertMark(text, charTypes, offsets, i);
		}
		return len;
	}
}




/*******************************************************************************
 * Copyright (c) 2010, 2011 IBM Corporation 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:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/
package org.eclipse.equinox.bidi.internal.tests;

import org.eclipse.equinox.bidi.advanced.STextEnvironment;
import org.eclipse.equinox.bidi.custom.STextProcessor;

public class TestProcessor2 extends STextProcessor {

	public int getSpecialsCount(STextEnvironment env) {
		return 1;
	}

}




/*******************************************************************************
 * Copyright (c) 2010, 2011 IBM Corporation 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:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/
package org.eclipse.equinox.bidi.internal.tests;

import org.eclipse.equinox.bidi.advanced.STextEnvironment;
import org.eclipse.equinox.bidi.custom.*;

public class TestProcessor3 extends STextProcessor {

	public int getSpecialsCount(STextEnvironment env) {
		return 1;
	}

	public int indexOfSpecial(STextEnvironment env, String text, STextCharTypes charTypes, STextOffsets offsets, int caseNumber, int fromIndex) {
		return fromIndex;
	}
}




/*******************************************************************************
 * Copyright (c) 2010, 2011 IBM Corporation 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:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/
package org.eclipse.equinox.bidi.internal.tests;

import org.eclipse.equinox.bidi.STextDirection;
import org.eclipse.equinox.bidi.advanced.STextEnvironment;
import org.eclipse.equinox.bidi.custom.STextCharTypes;
import org.eclipse.equinox.bidi.custom.STextProcessor;

public class TestProcessorMyComma extends STextProcessor {

	private final static byte AL = Character.DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC;
	protected final static int LTR = STextDirection.DIR_LTR;
	protected final static int RTL = STextDirection.DIR_RTL;

	final int dirArabic;
	final int dirHebrew;

	public TestProcessorMyComma(int dirArabic, int dirHebrew) {
		this.dirArabic = dirArabic;
		this.dirHebrew = dirHebrew;
	}

	public String getSeparators(STextEnvironment environment) {
		return ","; //$NON-NLS-1$
	}

	public boolean skipProcessing(STextEnvironment environment, String text, STextCharTypes charTypes) {
		byte charType = charTypes.getBidiTypeAt(0);
		if (charType == AL)
			return true;
		return false;
	}

	public int getDirection(STextEnvironment environment, String text) {
		return getDirection(environment, text, new STextCharTypes(this, environment, text));
	}

	public int getDirection(STextEnvironment environment, String text, STextCharTypes charTypes) {
		for (int i = 0; i < text.length(); i++) {
			byte charType = charTypes.getBidiTypeAt(i);
			if (charType == AL)
				return dirArabic;
		}
		return dirHebrew;
	}
}




/*******************************************************************************
 * Copyright (c) 2010, 2011 IBM Corporation 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:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/
package org.eclipse.equinox.bidi.internal.tests;

public class TestProcessorMyCommaLL extends TestProcessorMyComma {

	public TestProcessorMyCommaLL() {
		super(LTR, LTR);
	}
}




/*******************************************************************************
 * Copyright (c) 2010, 2011 IBM Corporation 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:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/
package org.eclipse.equinox.bidi.internal.tests;

public class TestProcessorMyCommaRL extends TestProcessorMyComma {

	public TestProcessorMyCommaRL() {
		super(RTL, LTR);
	}
}




/*******************************************************************************
 * Copyright (c) 2010, 2011 IBM Corporation 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:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/
package org.eclipse.equinox.bidi.internal.tests;

public class TestProcessorMyCommaRR extends TestProcessorMyComma {

	public TestProcessorMyCommaRR() {
		super(RTL, RTL);
	}
}




	public STextTestSuite() {
		addTestSuite(STextExtensibilityTest.class);
		addTestSuite(STextMethodsTest.class);
		addTestSuite(STextNullProcessorTest.class);
		addTestSuite(STextFullToLeanTest.class);
		addTestSuite(STextExtensionsTest.class);
		addTestSuite(STextMathTest.class);
		addTestSuite(STextSomeMoreTest.class);
		addTestSuite(STextUtilTest.class);
		addTestSuite(STextStringRecordTest.class);
	}
}

Lines 12-18 Link Here

(-)src/org/eclipse/equinox/bidi/STextDirection.java (-1 / +1 lines)
12		12
13	import org.eclipse.equinox.bidi.advanced.STextEnvironment;	13	import org.eclipse.equinox.bidi.advanced.STextEnvironment;
14		14
15	// TBD combine with STextProcessor; remove duplicates of those two constants	15	// TBD combine with STextUtil; remove duplicates of those two constants
16	public interface STextDirection {	16	public interface STextDirection {
17		17
18	/**	18	/**




/*******************************************************************************
 * Copyright (c) 2010, 2011 IBM Corporation 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:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/
package org.eclipse.equinox.bidi;

import org.eclipse.equinox.bidi.advanced.*;
import org.eclipse.equinox.bidi.custom.STextTypeHandler;

/**
 *  This class provides a number of convenience functions facilitating the
 *  processing of structured text.
 *
 *  @noextend This class is not intended to be subclassed by clients.
 *  @noinstantiate This class is not intended to be instantiated by clients.
 *
 *  @author Matitiahu Allouche
 */
public final class STextProcessor {

	/**
	 * The default set of separators used to segment a string: dot, colon, slash, backslash.
	 */
	public static final String defaultSeparators = ".:/\\"; //$NON-NLS-1$

	// left to right mark
	private static final char LRM = '\u200e';

	// left to right mark
	private static final char RLM = '\u200f';

	// left to right embedding
	private static final char LRE = '\u202a';

	// right to left embedding
	private static final char RLE = '\u202b';

	// pop directional format
	private static final char PDF = '\u202c';

	/**
	 * Prevents instantiation.
	 */
	private STextProcessor() {
		// empty
	}

	/** 
	 * This method adds directional marks to the given text before the characters 
	 * specified in the given array of offsets. It can be used to add a prefix and/or 
	 * a suffix of directional formatting characters.
	 * <p>
	 * The directional marks will be LRMs for structured text strings with LTR base 
	 * direction and RLMs for strings with RTL base direction.
	 * </p><p> 
	 * If necessary, leading and trailing directional markers (LRE, RLE and PDF) can 
	 * be added depending on the value of the <code>affix</code> argument.
	 * </p>
	 * @see ISTextExpert#leanBidiCharOffsets(String)
	 * 
	 * @param  text the structured text string
	 * @param  offsets an array of offsets to characters in <code>text</code>
	 *         before which an LRM or RLM will be inserted.
	 *         The array must be sorted in ascending order without duplicates.
	 *         This argument may be <code>null</code> if there are no marks to add.
	 * @param  direction the base direction of the structured text.
	 *         It must be one of the values {@link STextDirection#DIR_LTR}, or
	 *         {@link STextDirection#DIR_RTL}.
	 * @param  affix specifies if a prefix and a suffix should be added to
	 *         the result
	 * @return a string corresponding to the source <code>text</code> with
	 *         directional marks (LRMs or RLMs) added at the specified offsets,
	 *         and directional formatting characters (LRE, RLE, PDF) added
	 *         as prefix and suffix if so required.
	 */
	public static String insertMarks(String text, int[] offsets, int direction, boolean affix) {
		int textLen = text.length();
		if (textLen == 0)
			return ""; //$NON-NLS-1$

		String curPrefix, curSuffix, full;
		char curMark, c;
		char[] fullChars;
		if (direction == STextDirection.DIR_LTR) {
			curMark = LRM;
			curPrefix = "\u202a\u200e"; /* LRE+LRM *///$NON-NLS-1$
			curSuffix = "\u200e\u202c"; /* LRM+PDF *///$NON-NLS-1$
		} else {
			curMark = RLM;
			curPrefix = "\u202b\u200f"; /* RLE+RLM *///$NON-NLS-1$
			curSuffix = "\u200f\u202c"; /* RLM+PDF *///$NON-NLS-1$
		}
		// add marks at offsets
		if ((offsets != null) && (offsets.length > 0)) {
			int offLen = offsets.length;
			fullChars = new char[textLen + offLen];
			int added = 0;
			for (int i = 0, j = 0; i < textLen; i++) {
				c = text.charAt(i);
				if ((j < offLen) && (i == offsets[j])) {
					fullChars[i + added] = curMark;
					added++;
					j++;
				}
				fullChars[i + added] = c;
			}
			full = new String(fullChars);
		} else {
			full = text;
		}
		if (affix)
			return curPrefix + full + curSuffix;
		return full;
	}

	/**
	 *  Process the given text and return a string with appropriate
	 *  directional formatting characters. This is equivalent to calling
	 *  {@link #process(String str, String separators)} with the default
	 *  set of separators.
	 *  <p>
	 *  The processing adds directional formatting characters so that presentation 
	 *  using the Unicode Bidirectional Algorithm will provide the expected result.
	 *  The text is segmented according to the provided separators.
	 *  Each segment has the Unicode Bidi Algorithm applied to it,
	 *  but as a whole, the string is oriented left to right.
	 *  </p><p>
	 *  For example, a file path such as <tt>d:\myfolder\FOLDER\MYFILE.java</tt>
	 *  (where capital letters indicate RTL text) should render as
	 *  <tt>d:\myfolder\REDLOF\ELIFYM.java</tt>.
	 *  </p>
	 *  @param  str the text to be processed
	 *  @return the processed string
	 */
	public static String process(String str) {
		return process(str, defaultSeparators);
	}

	/**
	 * Process a string that has a particular semantic meaning to render
	 * it correctly on bidi locales. 
	 * @see #process(String)
	 * @param  str the text to process
	 * @param  separators separators by which the string will be segmented
	 * @return the processed string
	 */
	public static String process(String str, String separators) {
		if ((str == null) || (str.length() <= 1))
			return str;

		// do not process a string that has already been processed.
		if (str.charAt(0) == LRE && str.charAt(str.length() - 1) == PDF)
			return str;

		STextEnvironment env = new STextEnvironment(null, false, STextEnvironment.ORIENT_UNKNOWN);
		if (!env.isProcessingNeeded())
			return str;
		// do not process a string if all the following conditions are true:
		//  a) it has no RTL characters
		//  b) it starts with a LTR character
		//  c) it ends with a LTR character or a digit
		boolean isStringBidi = false;
		int strLength = str.length();
		char c;
		for (int i = 0; i < strLength; i++) {
			c = str.charAt(i);
			if (((c >= 0x05d0) && (c <= 0x07b1)) || ((c >= 0xfb1d) && (c <= 0xfefc))) {
				isStringBidi = true;
				break;
			}
		}
		while (!isStringBidi) {
			if (!Character.isLetter(str.charAt(0)))
				break;
			c = str.charAt(strLength - 1);
			if (!Character.isDigit(c) && !Character.isLetter(c))
				break;
			return str;
		}

		if (separators == null)
			separators = defaultSeparators;

		// make sure that LRE/PDF are added around the string
		STextTypeHandler handler = new STextTypeHandler(separators);
		ISTextExpert expert = STextExpertFactory.getExpert(handler, env);
		return expert.leanToFullText(str);
	}

	/**
	 * Processes a string that has a particular semantic meaning to render
	 * it correctly on bidi locales. 
	 * @see #process(String)
	 * @param  str the text to process
	 * @param  handler a handler instance appropriate for the type of the structured text
	 * @return the processed string
	 */
	public static String process(String str, STextTypeHandler handler) {
		if ((str == null) || (str.length() <= 1))
			return str;

		// do not process a string that has already been processed.
		char c = str.charAt(0);
		if (((c == LRE) || (c == RLE)) && str.charAt(str.length() - 1) == PDF)
			return str;

		// make sure that LRE/PDF are added around the string
		STextEnvironment env = new STextEnvironment(null, false, STextEnvironment.ORIENT_UNKNOWN);
		if (!env.isProcessingNeeded())
			return str;
		ISTextExpert expert = STextExpertFactory.getExpert(handler, env);
		return expert.leanToFullText(str);
	}

	/**
	 * Removes directional formatting characters in the given string.
	 * @param  str string with directional characters to remove
	 * @return string without directional formatting characters
	 */
	public static String deprocess(String str) {
		if ((str == null) || (str.length() <= 1))
			return str;
		STextEnvironment env = new STextEnvironment(null, false, STextEnvironment.ORIENT_UNKNOWN);
		if (!env.isProcessingNeeded())
			return str;

		StringBuffer buf = new StringBuffer();
		int strLen = str.length();
		for (int i = 0; i < strLen; i++) {
			char c = str.charAt(i);
			switch (c) {
				case LRM :
					continue;
				case LRE :
					continue;
				case PDF :
					continue;
				default :
					buf.append(c);
			}
		}
		return buf.toString();
	}

	/**
	 * Removes directional formatting characters in the given string.
	 * @param  str string with directional characters to remove
	 * @param  handler appropriate for the structured text
	 * @return string without directional formatting characters
	 */
	public static String deprocess(String str, STextTypeHandler handler) {
		if ((str == null) || (str.length() <= 1))
			return str;

		// make sure that LRE/PDF are added around the string
		STextEnvironment env = new STextEnvironment(null, false, STextEnvironment.ORIENT_UNKNOWN);
		if (!env.isProcessingNeeded())
			return str;
		ISTextExpert expert = STextExpertFactory.getExpert(handler, env);
		return expert.fullToLeanText(str);
	}

}




/*******************************************************************************
 * Copyright (c) 2010, 2011 IBM Corporation 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:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/
package org.eclipse.equinox.bidi;

import org.eclipse.equinox.bidi.custom.STextProcessor;
import org.eclipse.equinox.bidi.internal.STextTypesCollector;

/**
 * This class provides access to registered structured text processors.
 * 
 * @noinstantiate This class is not intended to be instantiated by clients.
 */
final public class STextProcessorFactory {

	/**
	 * Structured text processor for property file statements. It expects the following format:
	 * <pre>
	 *  name=value
	 * </pre>
	 */
	public static final String PROPERTY = "property"; //$NON-NLS-1$

	/**
	 * Structured text processor for compound names. It expects text to be made of one or more 
	 * parts separated by underscores:
	 * <pre>
	 *  part1_part2_part3
	 * </pre>
	 */
	public static final String UNDERSCORE = "underscore"; //$NON-NLS-1$

	/**
	 * Structured text processor for comma-delimited lists, such as:
	 * <pre>
	 *  part1,part2,part3
	 * </pre>
	 */
	public static final String COMMA_DELIMITED = "comma"; //$NON-NLS-1$

	/**
	 * Structured text processor for strings with the following format:
	 * <pre>
	 *  system(user)
	 * </pre>
	 */
	public static final String SYSTEM_USER = "system"; //$NON-NLS-1$

	/**
	 * Structured text processor for directory and file paths.
	 */
	public static final String FILE = "file"; //$NON-NLS-1$

	/**
	 * Structured text processor for e-mail addresses.
	 */
	public static final String EMAIL = "email"; //$NON-NLS-1$

	/**
	 * Structured text processor for URLs.
	 */
	public static final String URL = "url"; //$NON-NLS-1$

	/**
	 * Structured text processor for regular expressions, possibly spanning multiple lines.
	 */
	public static final String REGEXP = "regex"; //$NON-NLS-1$

	/**
	 * Structured text processor for XPath expressions.
	 */
	public static final String XPATH = "xpath"; //$NON-NLS-1$

	/**
	 * Structured text processor for Java code, possibly spanning multiple lines.
	 */
	public static final String JAVA = "java"; //$NON-NLS-1$

	/**
	 * Structured text processor for SQL statements, possibly spanning multiple lines.
	 */
	public static final String SQL = "sql"; //$NON-NLS-1$

	/**
	 *  Structured text processor for arithmetic expressions, possibly with a RTL base direction.
	 */
	public static final String RTL_ARITHMETIC = "math"; //$NON-NLS-1$

	/**
	 * Prevents instantiation
	 */
	private STextProcessorFactory() {
		// placeholder
	}

	/**
	 * Retrieve all IDs of registered structured text processors.
	 * @return an array of text processor IDs.
	 */
	static public String[] getAllProcessorIDs() {
		return STextTypesCollector.getInstance().getTypes();
	}

	/**
	 *  Obtain a structured text processor of a given type.
	 *  @param id string identifying processor
	 *  @return a processor of the required type, or <code>null</code> if the type is unknown
	 */
	static public STextProcessor getProcessor(String id) {
		return STextTypesCollector.getInstance().getProcessor(id);
	}

}




 * A string may be itself entirely a structured text, or it may contain
 * segments each of which is a structured text of a given type. Each such
 * segment is identified by its starting and ending offsets within the
 * string, and by the processor which is appropriate to handle it.
 */
public class STextStringRecord {
	/**

	// reference to the recorded string
	private String string;

	// reference to the processors of the STT segments in the recorded string
	private String[] processors;

	// reference to the boundaries of the STT segments in the recorded string
	// (entries 0, 2, 4, ... are start offsets; entries 1, 3, 5, ... are


	/**
	 * Record a string in the pool. The caller must specify the number
	 * of segments in the record (at least 1), and the processor, starting
	 * and ending offsets for the first segment.
	 *
	 * @param  string the string to record.

	 * @param  segmentCount number of segments allowed in this string.
	 *         This number must be >= 1.
	 *
	 * @param  processor the processor appropriate to handle the type
	 *         of structured text present in the first segment.
	 *         It may be one of the pre-defined processor instances, or it may be an instance
	 *         created by a plug-in or by the application.
	 *
	 * @param  start offset in the string of the starting character of the first

	 *         if <code>segmentCount</code> is less than 1.
	 * @throws also the same exceptions as {@link #addSegment addSegment}.
	 */
	public static STextStringRecord addRecord(String string, int segmentCount, String processorID, int start, int limit) {
		if (string == null)
			throw new IllegalArgumentException("The string argument must not be null!"); //$NON-NLS-1$
		if (segmentCount < 1)

		}
		hashArray[last] = string.hashCode();
		for (int i = 0; i < record.usedSegmentCount; i++)
			record.processors[i] = null;
		if (segmentCount > record.totalSegmentCount) {
			record.processors = new String[segmentCount];
			record.boundaries = new short[segmentCount * 2];
			record.totalSegmentCount = segmentCount;
		}
		record.usedSegmentCount = 0;
		record.string = string;
		record.addSegment(processorID, start, limit);
		return record;
	}

	/**
	 * Add a second or further segment to a record.
	 *
	 * @param  processor the processor appropriate to handle the type
	 *         of structured text present in this segment.
	 *         It may be one of the pre-defined processor instances, or it may be an instance
	 *         created by a plug-in or by the application.
	 *
	 * @param  start offset in the string of the starting character of the

	 *         greater than the <code>start</code> argument and not greater
	 *         than the length of the string.
	 *
	 * @throws IllegalArgumentException if <code>processor</code> is null,
	 *         or if <code>start</code> or <code>limit</code> have invalid
	 *         values.
	 * @throws IllegalStateException if the current segment exceeds the

	 *         in the call to {@link #addRecord addRecord} which created
	 *         the STextStringRecord instance.
	 */
	public void addSegment(String processorID, int start, int limit) {
		if (processorID == null)
			throw new IllegalArgumentException("The processor argument must not be null!"); //$NON-NLS-1$
		if (start < 0 || start >= string.length())
			throw new IllegalArgumentException("The start position must be at least 0 and less than the length of the string!"); //$NON-NLS-1$
		if (limit <= start || limit > string.length())
			throw new IllegalArgumentException("The limit position must be greater than the start position but no greater than the length of the string!"); //$NON-NLS-1$
		if (usedSegmentCount >= totalSegmentCount)
			throw new IllegalStateException("All segments of the record are already used!"); //$NON-NLS-1$
		processors[usedSegmentCount] = processorID;
		boundaries[usedSegmentCount * 2] = (short) start;
		boundaries[usedSegmentCount * 2 + 1] = (short) limit;
		usedSegmentCount++;

	 *         records this string.<br>
	 *         Once a record has been found, the number of its segments can
	 *         be retrieved using {@link #getSegmentCount getSegmentCount},
	 *         its processor can
	 *         be retrieved using {@link #getProcessor getProcessor},
	 *         its starting offset can
	 *         be retrieved using {@link #getStart getStart},
	 *         its ending offset can

	}

	/**
	 * Retrieve the processor of a given segment.
	 *
	 * @param  segmentNumber number of the segment about which information
	 *         is required. It must be >= 0 and less than the number of

	 *         in the call to {@link #addRecord addRecord} which created
	 *         the STextStringRecord instance.
	 *
	 * @return the processor to handle the structured text in the segment
	 *         specified by <code>segmentNumber</code>.
	 *
	 * @throws IllegalArgumentException if <code>segmentNumber</code>

	 *
	 * @see    #getSegmentCount
	 */
	public String getProcessor(int segmentNumber) {
		checkSegmentNumber(segmentNumber);
		return processors[segmentNumber];
	}

	/**

			if (record == null)
				continue;
			record.boundaries = null;
			record.processors = null;
			record.totalSegmentCount = 0;
			record.usedSegmentCount = 0;
			recordRefs[i].clear();




/*******************************************************************************
 * Copyright (c) 2010, 2011 IBM Corporation 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:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/
package org.eclipse.equinox.bidi;

import org.eclipse.equinox.bidi.custom.STextTypeHandler;
import org.eclipse.equinox.bidi.internal.STextTypesCollector;

/**
 * This class provides access to registered structured text handlers.
 * 
 * @noinstantiate This class is not intended to be instantiated by clients.
 */
final public class STextTypeHandlerFactory {

	/**
	 * Structured text handler for property file statements. It expects the following format:
	 * <pre>
	 *  name=value
	 * </pre>
	 */
	public static final String PROPERTY = "property"; //$NON-NLS-1$

	/**
	 * Structured text handler for compound names. It expects text to be made of one or more 
	 * parts separated by underscores:
	 * <pre>
	 *  part1_part2_part3
	 * </pre>
	 */
	public static final String UNDERSCORE = "underscore"; //$NON-NLS-1$

	/**
	 * Structured text handler for comma-delimited lists, such as:
	 * <pre>
	 *  part1,part2,part3
	 * </pre>
	 */
	public static final String COMMA_DELIMITED = "comma"; //$NON-NLS-1$

	/**
	 * Structured text handler for strings with the following format:
	 * <pre>
	 *  system(user)
	 * </pre>
	 */
	public static final String SYSTEM_USER = "system"; //$NON-NLS-1$

	/**
	 * Structured text handler for directory and file paths.
	 */
	public static final String FILE = "file"; //$NON-NLS-1$

	/**
	 * Structured text handler for e-mail addresses.
	 */
	public static final String EMAIL = "email"; //$NON-NLS-1$

	/**
	 * Structured text handler for URLs.
	 */
	public static final String URL = "url"; //$NON-NLS-1$

	/**
	 * Structured text handler for regular expressions, possibly spanning multiple lines.
	 */
	public static final String REGEXP = "regex"; //$NON-NLS-1$

	/**
	 * Structured text handler for XPath expressions.
	 */
	public static final String XPATH = "xpath"; //$NON-NLS-1$

	/**
	 * Structured text handler for Java code, possibly spanning multiple lines.
	 */
	public static final String JAVA = "java"; //$NON-NLS-1$

	/**
	 * Structured text handler for SQL statements, possibly spanning multiple lines.
	 */
	public static final String SQL = "sql"; //$NON-NLS-1$

	/**
	 *  Structured text handler for arithmetic expressions, possibly with a RTL base direction.
	 */
	public static final String RTL_ARITHMETIC = "math"; //$NON-NLS-1$

	/**
	 * Prevents instantiation
	 */
	private STextTypeHandlerFactory() {
		// placeholder
	}

	/**
	 * Retrieve all IDs of registered structured text handlers.
	 * @return an array of text handler IDs.
	 */
	static public String[] getAllHandlerIDs() {
		return STextTypesCollector.getInstance().getTypes();
	}

	/**
	 *  Obtain a structured text handler of a given type.
	 *  @param id string identifying handler
	 *  @return a handler of the required type, or <code>null</code> if the type is unknown
	 */
	static public STextTypeHandler getHandler(String id) {
		return STextTypesCollector.getInstance().getHandler(id);
	}

}




/*******************************************************************************
 * Copyright (c) 2010, 2011 IBM Corporation 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:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/
package org.eclipse.equinox.bidi;

import org.eclipse.equinox.bidi.advanced.*;
import org.eclipse.equinox.bidi.custom.STextProcessor;

/**
 *  This class provides a number of convenience functions facilitating the
 *  processing of structured text.
 *
 *  @noextend This class is not intended to be subclassed by clients.
 *  @noinstantiate This class is not intended to be instantiated by clients.
 *
 *  @author Matitiahu Allouche
 */
public final class STextUtil {

	/**
	 * The default set of separators used to segment a string: dot, colon, slash, backslash.
	 */
	public static final String defaultSeparators = ".:/\\"; //$NON-NLS-1$

	// left to right mark
	private static final char LRM = '\u200e';

	// left to right mark
	private static final char RLM = '\u200f';

	// left to right embedding
	private static final char LRE = '\u202a';

	// right to left embedding
	private static final char RLE = '\u202b';

	// pop directional format
	private static final char PDF = '\u202c';

	/**
	 * Prevents instantiation.
	 */
	private STextUtil() {
		// empty
	}

	/** 
	 * This method adds directional marks to the given text before the characters 
	 * specified in the given array of offsets. It can be used to add a prefix and/or 
	 * a suffix of directional formatting characters.
	 * <p>
	 * The directional marks will be LRMs for structured text strings with LTR base 
	 * direction and RLMs for strings with RTL base direction.
	 * </p><p> 
	 * If necessary, leading and trailing directional markers (LRE, RLE and PDF) can 
	 * be added depending on the value of the <code>affix</code> argument.
	 * </p>
	 * @see ISTextExpert#leanBidiCharOffsets(String)
	 * 
	 * @param  text the structured text string
	 * @param  offsets an array of offsets to characters in <code>text</code>
	 *         before which an LRM or RLM will be inserted.
	 *         The array must be sorted in ascending order without duplicates.
	 *         This argument may be <code>null</code> if there are no marks to add.
	 * @param  direction the base direction of the structured text.
	 *         It must be one of the values {@link STextDirection#DIR_LTR}, or
	 *         {@link STextDirection#DIR_RTL}.
	 * @param  affix specifies if a prefix and a suffix should be added to
	 *         the result
	 * @return a string corresponding to the source <code>text</code> with
	 *         directional marks (LRMs or RLMs) added at the specified offsets,
	 *         and directional formatting characters (LRE, RLE, PDF) added
	 *         as prefix and suffix if so required.
	 */
	public static String insertMarks(String text, int[] offsets, int direction, boolean affix) {
		int textLen = text.length();
		if (textLen == 0)
			return ""; //$NON-NLS-1$

		String curPrefix, curSuffix, full;
		char curMark, c;
		char[] fullChars;
		if (direction == STextDirection.DIR_LTR) {
			curMark = LRM;
			curPrefix = "\u202a\u200e"; /* LRE+LRM *///$NON-NLS-1$
			curSuffix = "\u200e\u202c"; /* LRM+PDF *///$NON-NLS-1$
		} else {
			curMark = RLM;
			curPrefix = "\u202b\u200f"; /* RLE+RLM *///$NON-NLS-1$
			curSuffix = "\u200f\u202c"; /* RLM+PDF *///$NON-NLS-1$
		}
		// add marks at offsets
		if ((offsets != null) && (offsets.length > 0)) {
			int offLen = offsets.length;
			fullChars = new char[textLen + offLen];
			int added = 0;
			for (int i = 0, j = 0; i < textLen; i++) {
				c = text.charAt(i);
				if ((j < offLen) && (i == offsets[j])) {
					fullChars[i + added] = curMark;
					added++;
					j++;
				}
				fullChars[i + added] = c;
			}
			full = new String(fullChars);
		} else {
			full = text;
		}
		if (affix)
			return curPrefix + full + curSuffix;
		return full;
	}

	/**
	 *  Process the given text and return a string with appropriate
	 *  directional formatting characters. This is equivalent to calling
	 *  {@link #process(String str, String separators)} with the default
	 *  set of separators.
	 *  <p>
	 *  The processing adds directional formatting characters so that presentation 
	 *  using the Unicode Bidirectional Algorithm will provide the expected result.
	 *  The text is segmented according to the provided separators.
	 *  Each segment has the Unicode Bidi Algorithm applied to it,
	 *  but as a whole, the string is oriented left to right.
	 *  </p><p>
	 *  For example, a file path such as <tt>d:\myfolder\FOLDER\MYFILE.java</tt>
	 *  (where capital letters indicate RTL text) should render as
	 *  <tt>d:\myfolder\REDLOF\ELIFYM.java</tt>.
	 *  </p>
	 *  @param  str the text to be processed
	 *  @return the processed string
	 */
	public static String process(String str) {
		return process(str, defaultSeparators);
	}

	/**
	 * Process a string that has a particular semantic meaning to render
	 * it correctly on bidi locales. 
	 * @see #process(String)
	 * @param  str the text to process
	 * @param  separators separators by which the string will be segmented
	 * @return the processed string
	 */
	public static String process(String str, String separators) {
		if ((str == null) || (str.length() <= 1))
			return str;

		// do not process a string that has already been processed.
		if (str.charAt(0) == LRE && str.charAt(str.length() - 1) == PDF)
			return str;

		STextEnvironment env = new STextEnvironment(null, false, STextEnvironment.ORIENT_UNKNOWN);
		if (!env.isProcessingNeeded())
			return str;
		// do not process a string if all the following conditions are true:
		//  a) it has no RTL characters
		//  b) it starts with a LTR character
		//  c) it ends with a LTR character or a digit
		boolean isStringBidi = false;
		int strLength = str.length();
		char c;
		for (int i = 0; i < strLength; i++) {
			c = str.charAt(i);
			if (((c >= 0x05d0) && (c <= 0x07b1)) || ((c >= 0xfb1d) && (c <= 0xfefc))) {
				isStringBidi = true;
				break;
			}
		}
		while (!isStringBidi) {
			if (!Character.isLetter(str.charAt(0)))
				break;
			c = str.charAt(strLength - 1);
			if (!Character.isDigit(c) && !Character.isLetter(c))
				break;
			return str;
		}

		if (separators == null)
			separators = defaultSeparators;

		// make sure that LRE/PDF are added around the string
		STextProcessor processor = new STextProcessor(separators);
		ISTextExpert processorNew = STextExpertFactory.getExpert(processor, env);
		return processorNew.leanToFullText(str);
	}

	/**
	 * Processes a string that has a particular semantic meaning to render
	 * it correctly on bidi locales. 
	 * @see #process(String)
	 * @param  str the text to process
	 * @param  processor a processor instance appropriate for the type of the structured text
	 * @return the processed string
	 */
	public static String process(String str, STextProcessor processor) {
		if ((str == null) || (str.length() <= 1))
			return str;

		// do not process a string that has already been processed.
		char c = str.charAt(0);
		if (((c == LRE) || (c == RLE)) && str.charAt(str.length() - 1) == PDF)
			return str;

		// make sure that LRE/PDF are added around the string
		STextEnvironment env = new STextEnvironment(null, false, STextEnvironment.ORIENT_UNKNOWN);
		if (!env.isProcessingNeeded())
			return str;
		ISTextExpert processorNew = STextExpertFactory.getExpert(processor, env);
		return processorNew.leanToFullText(str);
	}

	/**
	 * Removes directional formatting characters in the given string.
	 * @param  str string with directional characters to remove
	 * @return string without directional formatting characters
	 */
	public static String deprocess(String str) {
		if ((str == null) || (str.length() <= 1))
			return str;
		STextEnvironment env = new STextEnvironment(null, false, STextEnvironment.ORIENT_UNKNOWN);
		if (!env.isProcessingNeeded())
			return str;

		StringBuffer buf = new StringBuffer();
		int strLen = str.length();
		for (int i = 0; i < strLen; i++) {
			char c = str.charAt(i);
			switch (c) {
				case LRM :
					continue;
				case LRE :
					continue;
				case PDF :
					continue;
				default :
					buf.append(c);
			}
		}
		return buf.toString();
	}

	/**
	 * Removes directional formatting characters in the given string.
	 * @param  str string with directional characters to remove
	 * @param  processor appropriate for the structured text
	 * @return string without directional formatting characters
	 */
	public static String deprocess(String str, STextProcessor processor) {
		if ((str == null) || (str.length() <= 1))
			return str;

		// make sure that LRE/PDF are added around the string
		STextEnvironment env = new STextEnvironment(null, false, STextEnvironment.ORIENT_UNKNOWN);
		if (!env.isProcessingNeeded())
			return str;
		ISTextExpert processorNew = STextExpertFactory.getExpert(processor, env);
		return processorNew.fullToLeanText(str);
	}

}




 * For a general introduction to structured text, see
 * {@link <a href="package-summary.html"> the package documentation</a>}.
 * <p>
 * Several common processors are included in <b>STextEngine</b>. For processors 
 * supplied by other packages, a processor instance can be obtained using the
 * {@link org.eclipse.equinox.bidi.STextProcessorFactory#getProcessor}
 * method for the registered processors, or by instantiating a private processor.
 * </p><p>
 * Most of the methods in this class have a <code>text</code>
 * argument which may be just a part of a larger body of text.

	 * Add directional formatting characters to a structured text
	 * to ensure correct presentation.
	 * 
	 * @param  processor the processor applicable to the text. If <code>null</code>, 
	 * the method returns unmodified text.
	 * 
	 * @param  environment a bidi environment. If <code>null</code>, the default environment 

	 * Given a <i>lean</i> string, compute the positions of each of its
	 * characters within the corresponding <i>full</i> string.
	 *
	 * @param  processor designates a processor instance. If <code>null</code>, this 
	 * method returns an identity map.
	 *
	 * @param  environment specifies an environment whose characteristics may affect 
	 * the processor's behavior. If <code>null</code>, the default environment is used.
	 *
	 * @param text is the structured text string.
	 *

	 * depending on the {@link STextEnvironment#getOrientation orientation} of the
	 * GUI component used for display are not reflected in this method.
	 * </p>
	 * @param processor designates a processor instance
	 *
	 * @param  environment specifies an environment whose characteristics may affect 
	 * the processor's behavior. If <code>null</code>, the default environment is used.
	 *
	 * @param text is the structured text string
	 *

	 * Remove directional formatting characters which were added to a
	 * structured text string to ensure correct presentation.
	 *
	 * @param  processor designates a processor instance
	 *
	 * @param  environment specifies an environment whose characteristics may affect 
	 * the processor's behavior. If <code>null</code>, the default environment is used.
	 *
	 * @param text is the structured text string including directional formatting characters.
	 *

	 * Given a <i>full</i> string, compute the positions of each of its
	 * characters within the corresponding <i>lean</i> string.
	 *
	 * @param  processor designates a processor instance
	 *
	 * @param  environment specifies an environment whose characteristics may affect 
	 * the processor's behavior. If <code>null</code>, the default environment is used.
	 *
	 * @param  text is the structured text string including directional formatting characters.
	 *

	 * or suffixed depending on the {@link STextEnvironment#getOrientation orientation} 
	 * of the GUI component used for display.
	 * </p>
	 * @param  processor designates a processor instance
	 *
	 * @param  environment specifies an environment whose characteristics may affect 
	 * the processor's behavior. If <code>null</code>, the default environment is used.
	 *
	 * @param  text is the structured text string including directional formatting characters
	 *

	 * whether the text contains Arabic or Hebrew words. If the text contains both, 
	 * the first Arabic or Hebrew letter in the text determines which is the governing script.
	 *
	 * @param  processor designates a processor instance
	 *
	 * @param  environment specifies an environment whose characteristics may affect 
	 * the processor's behavior. If <code>null</code>, the default environment is used.
	 *
	 * @param  text is the structured text string
	 *

Lines 17-23 Link Here

(-)src/org/eclipse/equinox/bidi/advanced/ISTextExpertStateful.java (-1 / +1 lines)
17	public int getState();	17	public int getState();
18		18
19	/**	19	/**
20	* Resets non-shared expert state to initial.	20	* Resets non-shared processor state to initial.
21	*/	21	*/
22	public void resetState();	22	public void resetState();
23		23





import java.util.HashMap;
import java.util.Map;
import org.eclipse.equinox.bidi.STextProcessorFactory;
import org.eclipse.equinox.bidi.custom.STextProcessor;
import org.eclipse.equinox.bidi.internal.STextExpertImpl;
import org.eclipse.equinox.bidi.internal.STextExpertMultipassImpl;

final public class STextExpertFactory {



	static public ISTextExpert getExpert() {
		if (defaultExpert == null) {
			STextProcessor descriptor = new STextProcessor(defaultSeparators);
			defaultExpert = new STextExpertImpl(descriptor, STextEnvironment.DEFAULT);
		}
		return defaultExpert;
	}

	static public ISTextExpert getExpert(String type) {
		ISTextExpert processor;
		synchronized (sharedDefaultExperts) {
			processor = (ISTextExpert) sharedDefaultExperts.get(type);
			if (processor == null) {
				STextProcessor descriptor = STextProcessorFactory.getProcessor(type);
				if (descriptor == null)
					return null;
				processor = new STextExpertImpl(descriptor, STextEnvironment.DEFAULT);
				sharedDefaultExperts.put(type, processor);
			}
		}
		return processor;
	}

	static public ISTextExpert getExpert(String type, STextEnvironment environment) {
		ISTextExpert processor;
		synchronized (sharedExperts) {
			Map processors = (Map) sharedExperts.get(type);
			if (processors == null) {
				processors = new HashMap(); // environment -> processor
				sharedExperts.put(type, processors);
			}
			processor = (ISTextExpert) processors.get(environment);
			if (processor == null) {
				STextProcessor descriptor = STextProcessorFactory.getProcessor(type);
				if (descriptor == null)
					return null;
				processor = new STextExpertImpl(descriptor, environment);
				processors.put(type, processor);
			}
		}
		return processor;
	}

	static public ISTextExpert getExpert(STextProcessor descriptor, STextEnvironment environment) {
		return new STextExpertImpl(descriptor, environment);
	}

	static public ISTextExpertStateful getPrivateExpert(String type) {

	}

	static public ISTextExpertStateful getPrivateExpert(String type, STextEnvironment environment) {
		STextProcessor descriptor = STextProcessorFactory.getProcessor(type);
		if (descriptor == null)
			return null;
		return new STextExpertMultipassImpl(descriptor, environment);
	}

}





	private static final int CHARTYPES_ADD = 2;

	final protected STextProcessor processor;
	final protected STextEnvironment environment;
	final protected String text;

	// 1 byte for each char in text
	private byte[] types;

	// structured text direction. -1 means not yet computed; -2 means within processor.getDirection
	private int direction = -1;

	/**
	 *  Constructor
	 *  
	 *  @param  processor is the processor handling this occurrence of
	 *          structured text.
	 *          
	 *  @param  environment the current environment, which may affect the behavior of
	 *          the processor. This parameter may be specified as
	 *          <code>null</code>, in which case the
	 *          {@link STextEnvironment#DEFAULT DEFAULT}
	 *          environment should be assumed.
	 *  
	 *  @param text is the text whose characters are analyzed.
	 */
	public STextCharTypes(STextProcessor processor, STextEnvironment environment, String text) {
		this.processor = processor;
		this.environment = environment;
		this.text = text;
		types = new byte[text.length()];


	public int getDirection() {
		if (direction < 0)
			direction = processor.getDirection(environment, text, this);
		return direction;
	}


		byte charType = Character.getDirectionality(text.charAt(index));
		if (charType == B) {
			if (direction < 0) {
				if (direction < -1) // called by processor.getDirection
					return charType; // avoid infinite recursion
				direction = -2; // signal we go within processor.getDirection
				direction = processor.getDirection(environment, text, this);
			}
			charType = (direction == STextEnvironment.ORIENT_RTL) ? R : L;
		}

	 *  be displayed.
	 *  
	 *  @param  envir is the current environment, which may affect the behavior of
	 *          the processor. This parameter may be specified as
	 *          <code>null</code>, in which case the
	 *          {@link STextEnvironment#DEFAULT DEFAULT}
	 *          environment should be assumed.

Lines 67-73 Link Here

(-)src/org/eclipse/equinox/bidi/custom/STextOffsets.java (-1 / +1 lines)
67	/**	67	/**
68	* Insert an offset value in the offset array so that the array	68	* Insert an offset value in the offset array so that the array
69	* stays in ascending order.	69	* stays in ascending order.
70	* @param procData is a group of data accessible to handlers.	70	* @param procData is a group of data accessible to processors.
71	* @param offset is the value to insert.	71	* @param offset is the value to insert.
72	*/	72	*/
73	public void insertOffset(STextCharTypes charTypes, int offset) {	73	public void insertOffset(STextCharTypes charTypes, int offset) {




/*******************************************************************************
 * Copyright (c) 2010, 2011 IBM Corporation 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:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/
package org.eclipse.equinox.bidi.custom;

import org.eclipse.equinox.bidi.STextDirection;
import org.eclipse.equinox.bidi.advanced.STextEnvironment;
import org.eclipse.equinox.bidi.advanced.ISTextExpert;
import org.eclipse.equinox.bidi.internal.STextImpl;

/**
 *  Generic processor to be used as superclass (base class)
 *  for specific structured text processors.
 *  <p>
 *  Here are some guidelines about how to write structured text
 *  processors.
 *  <ul>
 *    <li>Processor instances may be accessed simultaneously by
 *        several threads. They should have no instance variables.</li>
 *    <li>The common logic uses processor methods to query the
 *        characteristics of the specific processor:
 *        <ul>
 *          <li>the separators which separate the structured text into
 *              tokens. See {@link #getSeparators getSeparators}.</li>
 *          <li>the direction which governs the display of tokens
 *              one after the other. See {@link #getDirection getDirection}.</li>
 *          <li>the number of special cases which need to be handled by
 *              code specific to that processor.
 *              See {@link #getSpecialsCount getSpecialsCount}.</li>
 *        </ul></li>
 *    <li>Before starting deeper analysis of the submitted text, the common
 *        logic gives to the processor a chance to shorten the processus by
 *        invoking its {@link #skipProcessing skipProcessing} method.</li>
 *    <li>The common logic then analyzes the text to segment it into tokens
 *        according to the appearance of separators (as retrieved using
 *        {@link #getSeparators getSeparators}).</li>
 *    <li>If the processor indicated a positive number of special cases as
 *        return value from its {@link #getSpecialsCount getSpecialsCount}
 *        method, the common logic will repeatedly invoke the processor's
 *        {@link #indexOfSpecial indexOfSpecial} method to let it signal the
 *        presence of special strings which may further delimit the source text.</li>
 *    <li>When such a special case is signalled by the processor, the common
 *        logic will call the processor's {@link #processSpecial processSpecial}
 *        method to give it the opportunity to handle it as needed. Typical
 *        actions that the processor may perform are to add directional marks
 *        inconditionally (by calling {@link #insertMark insertMark} or
 *        conditionally (by calling {@link #processSeparator processSeparator}).</li>
 *  </ul>
 *
 * @author Matitiahu Allouche
 */
public class STextProcessor {

	final private String separators;

	/**
	 * Creates a new instance of the STextProcessor class.
	 */
	public STextProcessor() {
		separators = ""; //$NON-NLS-1$
	}

	/**
	 * Creates a new instance of the STextProcessor class.
	 * @param separators string consisting of characters that split the text into fragments
	 */
	public STextProcessor(String separators) {
		this.separators = separators;
	}

	/**
	 * Locate occurrences of special strings within a structured text
	 * and return their indexes one after the other in successive calls.
	 * <p>
	 * This method is called repeatedly if the number of special cases 
	 * returned by {@link #getSpecialsCount} is greater than zero.
	 * </p><p>
	 * A processor handling special cases must override this method.
	 * </p>
	 * @param  environment the current environment, which may affect the behavior of
	 *         the processor. This parameter may be specified as
	 *         <code>null</code>, in which case the
	 *         {@link STextEnvironment#DEFAULT DEFAULT}
	 *         environment should be assumed.
	 *
	 * @param  text is the structured text string before
	 *         addition of any directional formatting characters.
	 *
	 * @param  charTypes is a parameter received by <code>indexOfSpecial</code>
	 *         uniquely to be used as argument for calls to methods which
	 *         need it.
	 *
	 * @param  offsets is a parameter received by <code>indexOfSpecial</code>
	 *         uniquely to be used as argument for calls to methods which
	 *         need it.
	 *
	 * @param  caseNumber number of the special case to locate.
	 *         This number varies from 1 to the number of special cases
	 *         returned by {@link #getSpecialsCount getSpecialsCount}
	 *         for this processor.
	 *         The meaning of this number is internal to the class
	 *         implementing <code>indexOfSpecial</code>.
	 *
	 * @param  fromIndex the index within <code>text</code> to start
	 *         the search from.
	 *
	 * @return the position where the start of the special case
	 *         corresponding to <code>caseNumber</code> was located.
	 *         The method must return the first occurrence of whatever
	 *         identifies the start of the special case starting from
	 *         <code>fromIndex</code>. The method does not have to check if
	 *         this occurrence appears within the scope of another special
	 *         case (e.g. a comment starting delimiter within the scope of
	 *         a literal or vice-versa).
	 *         <br>If no occurrence is found, the method must return -1.
	 *
	 * @throws IllegalStateException If not overridden, this method throws an
	 * <code>IllegalStateException</code>. This is appropriate behavior
	 * (and does not need to be overridden) for processors whose
	 * number of special cases is zero, which means that
	 * <code>indexOfSpecial</code> should never be called for them.
	 */
	public int indexOfSpecial(STextEnvironment environment, String text, STextCharTypes charTypes, STextOffsets offsets, int caseNumber, int fromIndex) {
		// This method must be overridden by all subclasses with special cases.
		throw new IllegalStateException("A processor with specialsCount > 0 must have an indexOfSpecial() method."); //$NON-NLS-1$
	}

	/**
	 * This method handles special cases specific to this processor.
	 * It is called when a special case occurrence 
	 * is located by {@link #indexOfSpecial}.
	 * <p>
	 * If a special processing cannot be completed within a current call to
	 * <code>processSpecial</code> (for instance, a comment has been started
	 * in the current line but its end appears in a following line),
	 * <code>processSpecial</code> should specify a final state by
	 * putting its value in the first element of the <code>state</code>
	 * parameter.
	 * The meaning of this state is internal to the processor.
	 * On a later call, <code>processSpecial</code> will be called with that value 
	 * for parameter <code>caseNumber</code> and <code>-1</code> for parameter 
	 * <code>separLocation</code> and should perform whatever initializations are required
	 * depending on the state.
	 * </p><p>
	 * A processor handling special cases (with a number of
	 * special cases greater than zero) must override this method.
	 * </p>
	 * @param  environment the current environment, which may affect the behavior of
	 *         the processor. This parameter may be specified as
	 *         <code>null</code>, in which case the
	 *         {@link STextEnvironment#DEFAULT DEFAULT}
	 *         environment should be assumed.
	 *
	 * @param  text is the structured text string before
	 *         addition of any directional formatting characters.
	 *
	 * @param  charTypes is a parameter received by <code>processSpecial</code>
	 *         uniquely to be used as argument for calls to methods which
	 *         need it.
	 *
	 * @param  offsets is a parameter received by <code>processSpecial</code>
	 *         uniquely to be used as argument for calls to methods which
	 *         need it.
	 *
	 * @param  state is an integer array with at least one element.
	 *         If the processor needs to signal the occurrence of a
	 *         special case which must be passed to the next call to
	 *         <code>leanToFullText</code> (for instance, a comment or a
	 *         literal started but not closed in the current
	 *         <code>text</code>), it must put a value in the first element
	 *         of the <code>state</code> parameter.
	 *         This number must be >= 1 and less or equal to the number of special
	 *         cases returned by {@link #getSpecialsCount getSpecialsCount}
	 *         by this processor.
	 *         This number is passed back to the caller
	 *         and should be specified as <code>state</code> argument
	 *         in the next call to <code>leanToFullText</code> together
	 *         with the continuation text.
	 *         The meaning of this number is internal to the processor.
	 *
	 * @param  caseNumber number of the special case to handle.
	 *
	 * @param  separLocation the position returned by
	 *         {@link #indexOfSpecial indexOfSpecial}. In calls to
	 *         {@link ISTextExpert#leanToFullText leanToFullText} and other
	 *         methods of {@link ISTextExpert} specifying a  non-null
	 *         <code>state</code> parameter, <code>processSpecial</code> is
	 *         called when initializing the processing with the value of
	 *         <code>caseNumber</code> equal to the value returned in the
	 *         first element of <code>state</code> and the value of
	 *         <code>separLocation</code> equal to <code>-1</code>.
	 *
	 * @return the position after the scope of the special case ends.
	 *         For instance, the position after the end of a comment,
	 *         the position after the end of a literal.
	 *         <br>A value greater or equal to the length of <code>text</code>
	 *         means that there is no further occurrence of this case in the
	 *         current structured text.
	 *
	 * @throws IllegalStateException If not overridden, this method throws an
	 * <code>IllegalStateException</code>. This is appropriate behavior
	 * (and does not need to be overridden) for processors whose
	 * number of special cases is zero, which means that
	 * <code>processSpecial</code> should never be called for them.
	 */
	public int processSpecial(STextEnvironment environment, String text, STextCharTypes charTypes, STextOffsets offsets, int[] state, int caseNumber, int separLocation) {
		// This method must be overridden by all subclasses with any special case.
		throw new IllegalStateException("A processor with specialsCount > 0 must have a processSpecial() method."); //$NON-NLS-1$
	}

	/**
	 * This method can be called from within {@link #indexOfSpecial} or
	 * {@link #processSpecial} in extensions of <code>STextProcessor</code>
	 * to specify that a mark character must be added before the character
	 * at the specified position of the <i>lean</i> text when generating the
	 * <i>full</i> text. The mark character will be LRM for structured text
	 * with a LTR base direction, and RLM for structured text with RTL
	 * base direction. The mark character is not added physically by this
	 * method, but its position is noted and will be used when generating
	 * the <i>full</i> text.
	 *
	 * @param  text is the structured text string received as
	 *         parameter to <code>indexOfSpecial</code> or
	 *         <code>processSpecial</code>.
	 *
	 * @param  charTypes is a parameter received by <code>indexOfSpecial</code>
	 *         or <code>processSpecial</code>, uniquely to be used as argument
	 *         for calls to <code>insertMark</code> and other methods used
	 *         by processors.
	 *
	 * @param  offsets is a parameter received by <code>indexOfSpecial</code>
	 *         or <code>processSpecial</code>, uniquely to be used as argument
	 *         for calls to <code>insertMark</code> and other methods used
	 *         by processors.
	 *
	 * @param  offset position of the character in the <i>lean</i> text.
	 *         It must be a non-negative number smaller than the length
	 *         of the <i>lean</i> text.
	 *         For the benefit of efficiency, it is better to insert
	 *         multiple marks in ascending order of the offsets.
	 */
	public static final void insertMark(String text, STextCharTypes charTypes, STextOffsets offsets, int offset) {
		offsets.insertOffset(charTypes, offset);
	}

	/**
	 * This method can be called from within {@link #indexOfSpecial} or
	 * {@link #processSpecial} in extensions of <code>STextProcessor</code> to add 
	 * a directional mark before a separator if needed for correct display, 
	 * depending on the base direction of the text and on the class of the
	 * characters in the <i>lean</i> text preceding and following the separator itself.
	 * <p>
	 * The logic implemented in this method considers the text before
	 * <code>separLocation</code> and the text following it. If, and only if,
	 * a directional mark is needed to insure that the two parts of text
	 * will be laid out according to the base direction, a mark will be
	 * added when generating the <i>full</i> text.
	 * </p>
	 * @param  text is the structured text string received as
	 *         parameter to <code>indexOfSpecial</code> or
	 *         <code>processSpecial</code>.
	 *
	 * @param  charTypes is a parameter received by <code>indexOfSpecial</code>
	 *         or <code>processSpecial</code>, uniquely to be used as argument
	 *         for calls to <code>processSeparator</code> and other methods used
	 *         by processors.
	 *
	 * @param  offsets is a parameter received by <code>indexOfSpecial</code>
	 *         or <code>processSpecial</code>, uniquely to be used as argument
	 *         for calls to <code>processSeparator</code> and other methods used
	 *         by processors.
	 *
	 * @param  separLocation offset of the separator in the <i>lean</i> text.
	 *         It must be a non-negative number smaller than the length
	 *         of the <i>lean</i> text.
	 */
	public static final void processSeparator(String text, STextCharTypes charTypes, STextOffsets offsets, int separLocation) {
		STextImpl.processSeparator(text, charTypes, offsets, separLocation);
	}

	/**
	 * Indicate the separators to use for the current processor.
	 * This method is invoked before starting the processing.
	 * <p>
	 * If no separators are specified, this method returns an empty string.
	 * </p>
	 * @param  environment the current environment, which may affect the behavior of
	 *         the processor. This parameter may be specified as
	 *         <code>null</code>, in which case the
	 *         {@link STextEnvironment#DEFAULT DEFAULT}
	 *         environment should be assumed.
	 *
	 * @return a string grouping one-character separators which separate
	 *         the structured text into tokens.
	 */
	public String getSeparators(STextEnvironment environment) {
		return separators;
	}

	/**
	 * Indicate the base text direction appropriate for an instance of structured text.
	 * This method is invoked before starting the processing.
	 * <p>
	 * If not overridden, this method returns <code>DIR_LTR</code>.
	 * </p>
	 * @param  environment the current environment, which may affect the behavior of
	 *         the processor. This parameter may be specified as
	 *         <code>null</code>, in which case the
	 *         {@link STextEnvironment#DEFAULT DEFAULT}
	 *         environment should be assumed.
	 *
	 * @param  text is the structured text string to process.
	 *
	 * @return the base direction of the structured text. This direction
	 *         may not be the same depending on the environment and on
	 *         whether the structured text contains Arabic or Hebrew
	 *         letters.<br>
	 *         The value returned is either
	 *         {@link STextDirection#DIR_LTR DIR_LTR} or {@link STextDirection#DIR_RTL DIR_RTL}.
	 */
	public int getDirection(STextEnvironment environment, String text) {
		return STextDirection.DIR_LTR;
	}

	/**
	 * Indicate the base text direction appropriate for an instance of structured text.
	 * This method is invoked before starting the processing.
	 * <p>
	 * If not overridden, this method returns <code>DIR_LTR</code>.
	 * </p>
	 * @param  environment the current environment, which may affect the behavior of
	 *         the processor. This parameter may be specified as
	 *         <code>null</code>, in which case the
	 *         {@link STextEnvironment#DEFAULT DEFAULT}
	 *         environment should be assumed.
	 *
	 * @param  text is the structured text string to process.
	 *
	 * @param  charTypes is a parameter received uniquely to be used as argument
	 *         for calls to <code>getCharType</code> and other methods used
	 *         by processors.
	 *
	 * @return the base direction of the structured text. This direction
	 *         may not be the same depending on the environment and on
	 *         whether the structured text contains Arabic or Hebrew
	 *         letters.<br>
	 *         The value returned is either
	 *         {@link STextDirection#DIR_LTR DIR_LTR} or {@link STextDirection#DIR_RTL DIR_RTL}.
	 */
	public int getDirection(STextEnvironment environment, String text, STextCharTypes charTypes) {
		return STextDirection.DIR_LTR;
	}

	/**
	 * Indicate the number of special cases handled by the current processor.
	 * This method is invoked before starting the processing.
	 * If the number returned is zero, {@link #indexOfSpecial} and
	 * {@link #processSpecial} will not be invoked.
	 * <p>
	 * If not overridden, this method returns <code>zero</code>.
	 * </p>
	 * @param  environment the current environment, which may affect the behavior of
	 *         the processor. This parameter may be specified as
	 *         <code>null</code>, in which case the
	 *         {@link STextEnvironment#DEFAULT DEFAULT}
	 *         environment should be assumed.
	 *
	 * @return the number of special cases for the associated processor.
	 *         Special cases exist for some types of structured text
	 *         processors. They are implemented by overriding methods
	 *         {@link STextProcessor#indexOfSpecial} and {@link STextProcessor#processSpecial}.
	 *         Examples of special cases are comments, literals, or
	 *         anything which is not identified by a one-character separator.
	 *
	 */
	public int getSpecialsCount(STextEnvironment environment) {
		return 0;
	}

	/**
	 * Checks if there is a need for processing structured text.
	 * This method is invoked before starting the processing. If the
	 * processor returns <code>true</code>, no directional formatting
	 * characters are added to the <i>lean</i> text and the processing
	 * is shortened.
	 * <p>
	 * If not overridden, this method returns <code>false</code>.
	 * </p>
	 * @param  environment the current environment, which may affect the behavior of
	 *         the processor. This parameter may be specified as
	 *         <code>null</code>, in which case the
	 *         {@link STextEnvironment#DEFAULT DEFAULT}
	 *         environment should be assumed.
	 *
	 * @param  text is the structured text string to process.
	 *
	 * @param  charTypes is a parameter received uniquely to be used as argument
	 *         for calls to <code>getCharType</code> and other methods used
	 *         by processors.
	 *
	 * @return a flag indicating if there is no need to process the structured
	 *         text to add directional formatting characters.
	 *
	 */
	public boolean skipProcessing(STextEnvironment environment, String text, STextCharTypes charTypes) {
		return false;
	}

}




/*******************************************************************************
 * Copyright (c) 2010, 2011 IBM Corporation 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:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/
package org.eclipse.equinox.bidi.custom;

import org.eclipse.equinox.bidi.STextDirection;
import org.eclipse.equinox.bidi.advanced.ISTextExpert;
import org.eclipse.equinox.bidi.advanced.STextEnvironment;
import org.eclipse.equinox.bidi.internal.STextImpl;

/**
 *  Generic handler to be used as superclass (base class)
 *  for specific structured text handlers.
 *  <p>
 *  Here are some guidelines about how to write structured text
 *  handlers.
 *  <ul>
 *    <li>Handler instances may be accessed simultaneously by
 *        several threads. They should have no instance variables.</li>
 *    <li>The common logic uses handler methods to query the
 *        characteristics of the specific handler:
 *        <ul>
 *          <li>the separators which separate the structured text into
 *              tokens. See {@link #getSeparators getSeparators}.</li>
 *          <li>the direction which governs the display of tokens
 *              one after the other. See {@link #getDirection getDirection}.</li>
 *          <li>the number of special cases which need to be handled by
 *              code specific to that handler.
 *              See {@link #getSpecialsCount getSpecialsCount}.</li>
 *        </ul></li>
 *    <li>Before starting deeper analysis of the submitted text, the common
 *        logic gives to the handler a chance to shorten the processus by
 *        invoking its {@link #skipProcessing skipProcessing} method.</li>
 *    <li>The common logic then analyzes the text to segment it into tokens
 *        according to the appearance of separators (as retrieved using
 *        {@link #getSeparators getSeparators}).</li>
 *    <li>If the handler indicated a positive number of special cases as
 *        return value from its {@link #getSpecialsCount getSpecialsCount}
 *        method, the common logic will repeatedly invoke the handler's
 *        {@link #indexOfSpecial indexOfSpecial} method to let it signal the
 *        presence of special strings which may further delimit the source text.</li>
 *    <li>When such a special case is signalled by the handler, the common
 *        logic will call the handler's {@link #processSpecial processSpecial}
 *        method to give it the opportunity to handle it as needed. Typical
 *        actions that the handler may perform are to add directional marks
 *        inconditionally (by calling {@link #insertMark insertMark} or
 *        conditionally (by calling {@link #processSeparator processSeparator}).</li>
 *  </ul>
 *
 * @author Matitiahu Allouche
 */
public class STextTypeHandler {

	final private String separators;

	/**
	 * Creates a new instance of the STextTypeHandler class.
	 */
	public STextTypeHandler() {
		separators = ""; //$NON-NLS-1$
	}

	/**
	 * Creates a new instance of the STextTypeHandler class.
	 * @param separators string consisting of characters that split the text into fragments
	 */
	public STextTypeHandler(String separators) {
		this.separators = separators;
	}

	/**
	 * Locate occurrences of special strings within a structured text
	 * and return their indexes one after the other in successive calls.
	 * <p>
	 * This method is called repeatedly if the number of special cases 
	 * returned by {@link #getSpecialsCount} is greater than zero.
	 * </p><p>
	 * A handler handling special cases must override this method.
	 * </p>
	 * @param  environment the current environment, which may affect the behavior of
	 *         the handler. This parameter may be specified as
	 *         <code>null</code>, in which case the
	 *         {@link STextEnvironment#DEFAULT DEFAULT}
	 *         environment should be assumed.
	 *
	 * @param  text is the structured text string before
	 *         addition of any directional formatting characters.
	 *
	 * @param  charTypes is a parameter received by <code>indexOfSpecial</code>
	 *         uniquely to be used as argument for calls to methods which
	 *         need it.
	 *
	 * @param  offsets is a parameter received by <code>indexOfSpecial</code>
	 *         uniquely to be used as argument for calls to methods which
	 *         need it.
	 *
	 * @param  caseNumber number of the special case to locate.
	 *         This number varies from 1 to the number of special cases
	 *         returned by {@link #getSpecialsCount getSpecialsCount}
	 *         for this handler.
	 *         The meaning of this number is internal to the class
	 *         implementing <code>indexOfSpecial</code>.
	 *
	 * @param  fromIndex the index within <code>text</code> to start
	 *         the search from.
	 *
	 * @return the position where the start of the special case
	 *         corresponding to <code>caseNumber</code> was located.
	 *         The method must return the first occurrence of whatever
	 *         identifies the start of the special case starting from
	 *         <code>fromIndex</code>. The method does not have to check if
	 *         this occurrence appears within the scope of another special
	 *         case (e.g. a comment starting delimiter within the scope of
	 *         a literal or vice-versa).
	 *         <br>If no occurrence is found, the method must return -1.
	 *
	 * @throws IllegalStateException If not overridden, this method throws an
	 * <code>IllegalStateException</code>. This is appropriate behavior
	 * (and does not need to be overridden) for handlers whose
	 * number of special cases is zero, which means that
	 * <code>indexOfSpecial</code> should never be called for them.
	 */
	public int indexOfSpecial(STextEnvironment environment, String text, STextCharTypes charTypes, STextOffsets offsets, int caseNumber, int fromIndex) {
		// This method must be overridden by all subclasses with special cases.
		throw new IllegalStateException("A handler with specialsCount > 0 must have an indexOfSpecial() method."); //$NON-NLS-1$
	}

	/**
	 * This method handles special cases specific to this handler.
	 * It is called when a special case occurrence 
	 * is located by {@link #indexOfSpecial}.
	 * <p>
	 * If a special processing cannot be completed within a current call to
	 * <code>processSpecial</code> (for instance, a comment has been started
	 * in the current line but its end appears in a following line),
	 * <code>processSpecial</code> should specify a final state by
	 * putting its value in the first element of the <code>state</code>
	 * parameter.
	 * The meaning of this state is internal to the handler.
	 * On a later call, <code>processSpecial</code> will be called with that value 
	 * for parameter <code>caseNumber</code> and <code>-1</code> for parameter 
	 * <code>separLocation</code> and should perform whatever initializations are required
	 * depending on the state.
	 * </p><p>
	 * A handler handling special cases (with a number of
	 * special cases greater than zero) must override this method.
	 * </p>
	 * @param  environment the current environment, which may affect the behavior of
	 *         the handler. This parameter may be specified as
	 *         <code>null</code>, in which case the
	 *         {@link STextEnvironment#DEFAULT DEFAULT}
	 *         environment should be assumed.
	 *
	 * @param  text is the structured text string before
	 *         addition of any directional formatting characters.
	 *
	 * @param  charTypes is a parameter received by <code>processSpecial</code>
	 *         uniquely to be used as argument for calls to methods which
	 *         need it.
	 *
	 * @param  offsets is a parameter received by <code>processSpecial</code>
	 *         uniquely to be used as argument for calls to methods which
	 *         need it.
	 *
	 * @param  state is an integer array with at least one element.
	 *         If the handler needs to signal the occurrence of a
	 *         special case which must be passed to the next call to
	 *         <code>leanToFullText</code> (for instance, a comment or a
	 *         literal started but not closed in the current
	 *         <code>text</code>), it must put a value in the first element
	 *         of the <code>state</code> parameter.
	 *         This number must be >= 1 and less or equal to the number of special
	 *         cases returned by {@link #getSpecialsCount getSpecialsCount}
	 *         by this handler.
	 *         This number is passed back to the caller
	 *         and should be specified as <code>state</code> argument
	 *         in the next call to <code>leanToFullText</code> together
	 *         with the continuation text.
	 *         The meaning of this number is internal to the handler.
	 *
	 * @param  caseNumber number of the special case to handle.
	 *
	 * @param  separLocation the position returned by
	 *         {@link #indexOfSpecial indexOfSpecial}. In calls to
	 *         {@link ISTextExpert#leanToFullText leanToFullText} and other
	 *         methods of {@link ISTextExpert} specifying a  non-null
	 *         <code>state</code> parameter, <code>processSpecial</code> is
	 *         called when initializing the processing with the value of
	 *         <code>caseNumber</code> equal to the value returned in the
	 *         first element of <code>state</code> and the value of
	 *         <code>separLocation</code> equal to <code>-1</code>.
	 *
	 * @return the position after the scope of the special case ends.
	 *         For instance, the position after the end of a comment,
	 *         the position after the end of a literal.
	 *         <br>A value greater or equal to the length of <code>text</code>
	 *         means that there is no further occurrence of this case in the
	 *         current structured text.
	 *
	 * @throws IllegalStateException If not overridden, this method throws an
	 * <code>IllegalStateException</code>. This is appropriate behavior
	 * (and does not need to be overridden) for handlers whose
	 * number of special cases is zero, which means that
	 * <code>processSpecial</code> should never be called for them.
	 */
	public int processSpecial(STextEnvironment environment, String text, STextCharTypes charTypes, STextOffsets offsets, int[] state, int caseNumber, int separLocation) {
		// This method must be overridden by all subclasses with any special case.
		throw new IllegalStateException("A handler with specialsCount > 0 must have a processSpecial() method."); //$NON-NLS-1$
	}

	/**
	 * This method can be called from within {@link #indexOfSpecial} or
	 * {@link #processSpecial} in extensions of <code>STextTypeHandler</code>
	 * to specify that a mark character must be added before the character
	 * at the specified position of the <i>lean</i> text when generating the
	 * <i>full</i> text. The mark character will be LRM for structured text
	 * with a LTR base direction, and RLM for structured text with RTL
	 * base direction. The mark character is not added physically by this
	 * method, but its position is noted and will be used when generating
	 * the <i>full</i> text.
	 *
	 * @param  text is the structured text string received as
	 *         parameter to <code>indexOfSpecial</code> or
	 *         <code>processSpecial</code>.
	 *
	 * @param  charTypes is a parameter received by <code>indexOfSpecial</code>
	 *         or <code>processSpecial</code>, uniquely to be used as argument
	 *         for calls to <code>insertMark</code> and other methods used
	 *         by handlers.
	 *
	 * @param  offsets is a parameter received by <code>indexOfSpecial</code>
	 *         or <code>processSpecial</code>, uniquely to be used as argument
	 *         for calls to <code>insertMark</code> and other methods used
	 *         by handlers.
	 *
	 * @param  offset position of the character in the <i>lean</i> text.
	 *         It must be a non-negative number smaller than the length
	 *         of the <i>lean</i> text.
	 *         For the benefit of efficiency, it is better to insert
	 *         multiple marks in ascending order of the offsets.
	 */
	public static final void insertMark(String text, STextCharTypes charTypes, STextOffsets offsets, int offset) {
		offsets.insertOffset(charTypes, offset);
	}

	/**
	 * This method can be called from within {@link #indexOfSpecial} or
	 * {@link #processSpecial} in extensions of <code>STextTypeHandler</code> to add 
	 * a directional mark before a separator if needed for correct display, 
	 * depending on the base direction of the text and on the class of the
	 * characters in the <i>lean</i> text preceding and following the separator itself.
	 * <p>
	 * The logic implemented in this method considers the text before
	 * <code>separLocation</code> and the text following it. If, and only if,
	 * a directional mark is needed to insure that the two parts of text
	 * will be laid out according to the base direction, a mark will be
	 * added when generating the <i>full</i> text.
	 * </p>
	 * @param  text is the structured text string received as
	 *         parameter to <code>indexOfSpecial</code> or
	 *         <code>processSpecial</code>.
	 *
	 * @param  charTypes is a parameter received by <code>indexOfSpecial</code>
	 *         or <code>processSpecial</code>, uniquely to be used as argument
	 *         for calls to <code>processSeparator</code> and other methods used
	 *         by handlers.
	 *
	 * @param  offsets is a parameter received by <code>indexOfSpecial</code>
	 *         or <code>processSpecial</code>, uniquely to be used as argument
	 *         for calls to <code>processSeparator</code> and other methods used
	 *         by handlers.
	 *
	 * @param  separLocation offset of the separator in the <i>lean</i> text.
	 *         It must be a non-negative number smaller than the length
	 *         of the <i>lean</i> text.
	 */
	public static final void processSeparator(String text, STextCharTypes charTypes, STextOffsets offsets, int separLocation) {
		STextImpl.processSeparator(text, charTypes, offsets, separLocation);
	}

	/**
	 * Indicate the separators to use for the current handler.
	 * This method is invoked before starting the processing.
	 * <p>
	 * If no separators are specified, this method returns an empty string.
	 * </p>
	 * @param  environment the current environment, which may affect the behavior of
	 *         the handler. This parameter may be specified as
	 *         <code>null</code>, in which case the
	 *         {@link STextEnvironment#DEFAULT DEFAULT}
	 *         environment should be assumed.
	 *
	 * @return a string grouping one-character separators which separate
	 *         the structured text into tokens.
	 */
	public String getSeparators(STextEnvironment environment) {
		return separators;
	}

	/**
	 * Indicate the base text direction appropriate for an instance of structured text.
	 * This method is invoked before starting the processing.
	 * <p>
	 * If not overridden, this method returns <code>DIR_LTR</code>.
	 * </p>
	 * @param  environment the current environment, which may affect the behavior of
	 *         the handler. This parameter may be specified as
	 *         <code>null</code>, in which case the
	 *         {@link STextEnvironment#DEFAULT DEFAULT}
	 *         environment should be assumed.
	 *
	 * @param  text is the structured text string to process.
	 *
	 * @return the base direction of the structured text. This direction
	 *         may not be the same depending on the environment and on
	 *         whether the structured text contains Arabic or Hebrew
	 *         letters.<br>
	 *         The value returned is either
	 *         {@link STextDirection#DIR_LTR DIR_LTR} or {@link STextDirection#DIR_RTL DIR_RTL}.
	 */
	public int getDirection(STextEnvironment environment, String text) {
		return STextDirection.DIR_LTR;
	}

	/**
	 * Indicate the base text direction appropriate for an instance of structured text.
	 * This method is invoked before starting the processing.
	 * <p>
	 * If not overridden, this method returns <code>DIR_LTR</code>.
	 * </p>
	 * @param  environment the current environment, which may affect the behavior of
	 *         the handler. This parameter may be specified as
	 *         <code>null</code>, in which case the
	 *         {@link STextEnvironment#DEFAULT DEFAULT}
	 *         environment should be assumed.
	 *
	 * @param  text is the structured text string to process.
	 *
	 * @param  charTypes is a parameter received uniquely to be used as argument
	 *         for calls to <code>getCharType</code> and other methods used
	 *         by handlers.
	 *
	 * @return the base direction of the structured text. This direction
	 *         may not be the same depending on the environment and on
	 *         whether the structured text contains Arabic or Hebrew
	 *         letters.<br>
	 *         The value returned is either
	 *         {@link STextDirection#DIR_LTR DIR_LTR} or {@link STextDirection#DIR_RTL DIR_RTL}.
	 */
	public int getDirection(STextEnvironment environment, String text, STextCharTypes charTypes) {
		return STextDirection.DIR_LTR;
	}

	/**
	 * Indicate the number of special cases handled by the current handler.
	 * This method is invoked before starting the processing.
	 * If the number returned is zero, {@link #indexOfSpecial} and
	 * {@link #processSpecial} will not be invoked.
	 * <p>
	 * If not overridden, this method returns <code>zero</code>.
	 * </p>
	 * @param  environment the current environment, which may affect the behavior of
	 *         the handler. This parameter may be specified as
	 *         <code>null</code>, in which case the
	 *         {@link STextEnvironment#DEFAULT DEFAULT}
	 *         environment should be assumed.
	 *
	 * @return the number of special cases for the associated handler.
	 *         Special cases exist for some types of structured text
	 *         handlers. They are implemented by overriding methods
	 *         {@link STextTypeHandler#indexOfSpecial} and {@link STextTypeHandler#processSpecial}.
	 *         Examples of special cases are comments, literals, or
	 *         anything which is not identified by a one-character separator.
	 *
	 */
	public int getSpecialsCount(STextEnvironment environment) {
		return 0;
	}

	/**
	 * Checks if there is a need for processing structured text.
	 * This method is invoked before starting the processing. If the
	 * handler returns <code>true</code>, no directional formatting
	 * characters are added to the <i>lean</i> text and the processing
	 * is shortened.
	 * <p>
	 * If not overridden, this method returns <code>false</code>.
	 * </p>
	 * @param  environment the current environment, which may affect the behavior of
	 *         the handler. This parameter may be specified as
	 *         <code>null</code>, in which case the
	 *         {@link STextEnvironment#DEFAULT DEFAULT}
	 *         environment should be assumed.
	 *
	 * @param  text is the structured text string to process.
	 *
	 * @param  charTypes is a parameter received uniquely to be used as argument
	 *         for calls to <code>getCharType</code> and other methods used
	 *         by handlers.
	 *
	 * @return a flag indicating if there is no need to process the structured
	 *         text to add directional formatting characters.
	 *
	 */
	public boolean skipProcessing(STextEnvironment environment, String text, STextCharTypes charTypes) {
		return false;
	}

}




package org.eclipse.equinox.bidi.internal;

import org.eclipse.equinox.bidi.advanced.STextEnvironment;

import org.eclipse.equinox.bidi.custom.*;

/**
 *  A base processor for structured text composed of text segments separated 
 *  by separators where the text segments may include delimited parts within 
 *  which separators are treated like regular characters.
 *  <p>

 *  </p>
 *  @author Matitiahu Allouche
 */
public abstract class STextDelims extends STextProcessor {

	public STextDelims() {
		// placeholder

	 *          of <code>text</code> if no end delimiter is found.
	 */
	public int processSpecial(STextEnvironment environment, String text, STextCharTypes charTypes, STextOffsets offsets, int[] state, int caseNumber, int separLocation) {
		STextProcessor.processSeparator(text, charTypes, offsets, separLocation);
		int loc = separLocation + 1;
		char delim = getDelimiters().charAt((caseNumber * 2) - 1);
		loc = text.indexOf(delim, loc);




package org.eclipse.equinox.bidi.internal;

import org.eclipse.equinox.bidi.advanced.STextEnvironment;

import org.eclipse.equinox.bidi.custom.*;

/**
 *  A base processor for structured text composed of text segments separated 
 *  by separators where the text segments may include delimited parts within 
 *  which separators are treated like regular characters and the delimiters 
 *  may be escaped.

	 *  ignoring possibly escaped end delimiters.
	 */
	public int processSpecial(STextEnvironment environment, String text, STextCharTypes charTypes, STextOffsets offsets, int[] state, int caseNumber, int separLocation) {
		STextProcessor.processSeparator(text, charTypes, offsets, separLocation);
		int location = separLocation + 1;
		char delim = getDelimiters().charAt((caseNumber * 2) - 1);
		while (true) {




/*******************************************************************************
 * Copyright (c) 2010, 2011 IBM Corporation 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:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/
package org.eclipse.equinox.bidi.internal;

import org.eclipse.equinox.bidi.advanced.STextEnvironment;
import org.eclipse.equinox.bidi.advanced.ISTextExpert;
import org.eclipse.equinox.bidi.custom.STextProcessor;

public class STextExpertImpl implements ISTextExpert {

	protected STextProcessor structuredTextDescriptor;
	protected STextEnvironment environment;

	// XXX potentially problematic - implementation might write into it?
	private final static int[] initialState = new int[] {0};

	public STextExpertImpl(STextProcessor structuredTextDescriptor, STextEnvironment environment) {
		this.structuredTextDescriptor = structuredTextDescriptor;
		this.environment = environment;
	}

	public String leanToFullText(String text) {
		return STextImpl.leanToFullText(structuredTextDescriptor, environment, text, initialState);
	}

	public int[] leanToFullMap(String text) {
		return STextImpl.leanToFullMap(structuredTextDescriptor, environment, text, initialState);
	}

	public int[] leanBidiCharOffsets(String text) {
		return STextImpl.leanBidiCharOffsets(structuredTextDescriptor, environment, text, initialState);
	}

	public String fullToLeanText(String text) {
		return STextImpl.fullToLeanText(structuredTextDescriptor, environment, text, initialState);
	}

	public int[] fullToLeanMap(String text) {
		return STextImpl.fullToLeanMap(structuredTextDescriptor, environment, text, initialState);
	}

	public int[] fullBidiCharOffsets(String text) {
		return STextImpl.fullBidiCharOffsets(structuredTextDescriptor, environment, text, initialState);
	}

	public int getCurDirection(String text) {
		return structuredTextDescriptor.getDirection(environment, text);
	}

}




/*******************************************************************************
 * Copyright (c) 2010, 2011 IBM Corporation 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:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/
package org.eclipse.equinox.bidi.internal;

import org.eclipse.equinox.bidi.advanced.STextEnvironment;
import org.eclipse.equinox.bidi.advanced.ISTextExpertStateful;
import org.eclipse.equinox.bidi.custom.STextProcessor;

public class STextExpertMultipassImpl extends STextExpertImpl implements ISTextExpertStateful {

	/**
	 *  Constant to use in the first element of the <code>state</code>
	 *  argument when calling most methods of this class
	 *  to indicate that there is no context of previous lines which
	 *  should be initialized before performing the operation.
	 */
	public static final int STATE_INITIAL = 0;

	private int[] state = new int[] {STATE_INITIAL};

	public STextExpertMultipassImpl(STextProcessor structuredTextDescriptor, STextEnvironment environment) {
		super(structuredTextDescriptor, environment);
		resetState();
	}

	public String leanToFullText(String text) {
		return STextImpl.leanToFullText(structuredTextDescriptor, environment, text, state);
	}

	public int[] leanToFullMap(String text) {
		return STextImpl.leanToFullMap(structuredTextDescriptor, environment, text, state);
	}

	public int[] leanBidiCharOffsets(String text) {
		return STextImpl.leanBidiCharOffsets(structuredTextDescriptor, environment, text, state);
	}

	public String fullToLeanText(String text) {
		return STextImpl.fullToLeanText(structuredTextDescriptor, environment, text, state);
	}

	public int[] fullToLeanMap(String text) {
		return STextImpl.fullToLeanMap(structuredTextDescriptor, environment, text, state);
	}

	public int[] fullBidiCharOffsets(String text) {
		return STextImpl.fullBidiCharOffsets(structuredTextDescriptor, environment, text, state);
	}

	public int getCurDirection(String text) {
		return structuredTextDescriptor.getDirection(environment, text);
	}

	public void resetState() {
		state[0] = STATE_INITIAL;
	}

	public void setState(int newState) {
		state[0] = newState;
	}

	public int getState() {
		return state[0];
	}

}




package org.eclipse.equinox.bidi.internal;

import org.eclipse.equinox.bidi.STextDirection;
import org.eclipse.equinox.bidi.advanced.STextEnvironment;
import org.eclipse.equinox.bidi.advanced.ISTextExpert;
import org.eclipse.equinox.bidi.custom.*;

public class STextImpl {

	static final String EMPTY_STRING = ""; //$NON-NLS-1$


	static final int FIXES_LENGTH = PREFIX_LENGTH + SUFFIX_LENGTH;
	static final int[] EMPTY_INT_ARRAY = new int[0];
	static final STextEnvironment IGNORE_ENVIRONMENT = new STextEnvironment(null, false, STextEnvironment.ORIENT_IGNORE);
	static final int STATE_INITIAL = 0;

	/**
	 *  Prevent creation of a STextImpl instance
	 */
	private STextImpl() {
		// nothing to do
		this.structuredTextHandler = structuredTextHandler;
		this.environment = environment;
		this.state = state;
	}

	static long computeNextLocation(STextProcessor processor, STextEnvironment environment, String text, STextCharTypes charTypes, STextOffsets offsets, int[] locations, int curPos) {
		String separators = processor.getSeparators(environment);
	}

	public int[] leanToFullMap(String text) {
		return STextImpl.leanToFullMap(structuredTextHandler, environment, text, state);
	}

	public int[] leanBidiCharOffsets(String text) {
		return STextImpl.leanBidiCharOffsets(structuredTextHandler, environment, text, state);
	}

	public String fullToLeanText(String text) {
		return STextImpl.fullToLeanText(structuredTextHandler, environment, text, state);
	}

	public int[] fullToLeanMap(String text) {
		return STextImpl.fullToLeanMap(structuredTextHandler, environment, text, state);
	}

	public int[] fullBidiCharOffsets(String text) {
		return STextImpl.fullBidiCharOffsets(structuredTextHandler, environment, text, state);
	}

	public int getCurDirection(String text) {
		return structuredTextHandler.getDirection(environment, text);
	}

	public void resetState() {
		state[0] = STATE_INITIAL;
	}

	public void setState(int newState) {
		state[0] = newState;
	}

	public static void setState(int[] state, int newState) {
		if (state != null)
			state[0] = newState;
	}

	public int getState() {
		return state[0];
	}

	static long computeNextLocation(STextTypeHandler handler, STextEnvironment environment, String text, STextCharTypes charTypes, STextOffsets offsets, int[] locations, int curPos) {
		String separators = handler.getSeparators(environment);
		int separCount = separators.length();
		int specialsCount = processor.getSpecialsCount(environment);
		int len = text.length();
		int nextLocation = len;
		int idxLocation = 0;

			int location = locations[separCount + i];
			if (location < curPos) {
				offsets.ensureRoom();
				location = processor.indexOfSpecial(environment, text, charTypes, offsets, i + 1, curPos);
				if (location < 0)
					location = len;
				locations[separCount + i] = location;

	 *  <p>
	 *  @see ISTextExpert#leanToFullText STextEngine.leanToFullText
	 */
	public static String leanToFullText(STextProcessor processor, STextEnvironment environment, String text, int[] state) {
		int len = text.length();
		if (len == 0)
			return text;
		STextCharTypes charTypes = new STextCharTypes(processor, environment, text);
		STextOffsets offsets = leanToFullCommon(processor, environment, text, state, charTypes);
		int prefixLength = offsets.getPrefixLength();
		int count = offsets.getCount();
		if (count == 0 && prefixLength == 0)

		return new String(fullChars);
	}

	public static int[] leanToFullMap(STextProcessor processor, STextEnvironment environment, String text, int[] state) {
		int len = text.length();
		if (len == 0)
			return EMPTY_INT_ARRAY;
		STextCharTypes charTypes = new STextCharTypes(processor, environment, text);
		STextOffsets offsets = leanToFullCommon(processor, environment, text, state, charTypes);
		int prefixLength = offsets.getPrefixLength();
		int[] map = new int[len];
		int count = offsets.getCount(); // number of used entries

		return map;
	}

	public static int[] leanBidiCharOffsets(STextProcessor processor, STextEnvironment environment, String text, int[] state) {
		int len = text.length();
		if (len == 0)
			return EMPTY_INT_ARRAY;
		STextCharTypes charTypes = new STextCharTypes(processor, environment, text);
		STextOffsets offsets = leanToFullCommon(processor, environment, text, state, charTypes);
		return offsets.getArray();
	}

	/**
	 *  Constant to use in the first element of the <code>state</code>
	 *  argument when calling most methods of this class
	 *  to indicate that there is no context of previous lines which
	 *  should be initialized before performing the operation.
	 */
	public static final int STATE_INITIAL = 0; // TBD move

	static STextOffsets leanToFullCommon(STextProcessor processor, STextEnvironment environment, String text, int[] state, STextCharTypes charTypes) {
		if (environment == null)
			environment = STextEnvironment.DEFAULT;
		if (state == null) {
			state = new int[1];
			state[0] = STATE_INITIAL;
		}
		int len = text.length();
		int direction = processor.getDirection(environment, text, charTypes);
		STextOffsets offsets = new STextOffsets();
		if (!processor.skipProcessing(environment, text, charTypes)) {
			// initialize locations
			int separCount = processor.getSeparators(environment).length();
			int[] locations = new int[separCount + processor.getSpecialsCount(environment)];
			for (int i = 0, k = locations.length; i < k; i++) {
				locations[i] = -1;
			}
			// current position
			int curPos = 0;
			if (state[0] > STATE_INITIAL) {
				offsets.ensureRoom();
				int initState = state[0];
				state[0] = STATE_INITIAL;
				curPos = processor.processSpecial(environment, text, charTypes, offsets, state, initState, -1);
			}
			while (true) {
				// location of next token to handle
				int nextLocation;
				// index of next token to handle (if < separCount, this is a separator; otherwise a special case
				int idxLocation;
				long res = computeNextLocation(processor, environment, text, charTypes, offsets, locations, curPos);
				nextLocation = (int) (res & 0x00000000FFFFFFFF); /* low word */
				if (nextLocation >= len)
					break;

					curPos = nextLocation + 1;
				} else {
					idxLocation -= (separCount - 1); // because caseNumber starts from 1
					curPos = processor.processSpecial(environment, text, charTypes, offsets, state, idxLocation, nextLocation);
				}
				if (curPos >= len)
					break;
			} // end while
		} // end if (!processor.skipProcessing())
		int prefixLength;
		int orientation = environment.getOrientation();
		if (orientation == STextEnvironment.ORIENT_IGNORE)

		return offsets;
	}

	public static String fullToLeanText(STextProcessor processor, STextEnvironment environment, String text, int[] state) {
		if (text.length() == 0)
			return text;
		if (environment == null)
			environment = STextEnvironment.DEFAULT;
		int dir = processor.getDirection(environment, text);
		char curMark = MARKS[dir];
		char curEmbed = EMBEDS[dir];
		int i; // used as loop index

				chars[i - cnt] = c;
		}
		String lean = new String(chars, 0, lenText - cnt);
		String full = leanToFullText(processor, IGNORE_ENVIRONMENT, lean, state);
		if (full.equals(text))
			return lean;


		return lean;
	}

	public static int[] fullToLeanMap(STextProcessor processor, STextEnvironment environment, String full, int[] state) {
		int lenFull = full.length();
		if (lenFull == 0)
			return EMPTY_INT_ARRAY;
		String lean = fullToLeanText(processor, environment, full, state);
		int lenLean = lean.length();
		int dir = processor.getDirection(environment, lean);
		char curMark = MARKS[dir];
		char curEmbed = EMBEDS[dir];
		int[] map = new int[lenFull];

		return map;
	}

	public static int[] fullBidiCharOffsets(STextProcessor processor, STextEnvironment environment, String full, int[] state) {
		int lenFull = full.length();
		if (lenFull == 0)
			return EMPTY_INT_ARRAY;
		String lean = fullToLeanText(processor, environment, full, state);
		STextOffsets offsets = new STextOffsets();
		int lenLean = lean.length();
		int idxLean, idxFull;




package org.eclipse.equinox.bidi.internal;

import org.eclipse.equinox.bidi.advanced.STextEnvironment;

import org.eclipse.equinox.bidi.custom.*;

/**
 *  A base processor for structured text composed of two parts separated by a separator.
 *  The first occurrence of the separator delimits the end of the first part
 *  and the start of the second part. Further occurrences of the separator,
 *  if any, are treated like regular characters of the second text part.
 *  The processor makes sure that the text be presented in the form
 *  (assuming that the equal sign is the separator):
 *  <pre>
 *  part1=part2
 *  </pre>
 *  The string returned by {@link STextProcessor#getSeparators getSeparators}
 *  for this processor should contain exactly one character.
 *  Additional characters will be ignored.
 *
 *  @author Matitiahu Allouche
 */
public class STextSingle extends STextProcessor {

	public STextSingle(String separator) {
		super(separator);

	 *  @return the length of <code>text</code>.
	 */
	public int processSpecial(STextEnvironment environment, String text, STextCharTypes charTypes, STextOffsets offsets, int[] state, int caseNumber, int separLocation) {
		STextProcessor.processSeparator(text, charTypes, offsets, separLocation);
		return text.length();
	}

	/**
	 *  This method returns 1 as number of special cases handled by this processor.
	 *
	 *  @return 1.
	 */




import java.util.HashMap;
import java.util.Map;
import org.eclipse.core.runtime.*;
import org.eclipse.equinox.bidi.custom.STextProcessor;

public class STextTypesCollector implements IRegistryEventListener {



	private static final String CE_NAME = "typeDescription"; //$NON-NLS-1$
	private static final String ATTR_TYPE = "type"; //$NON-NLS-1$
	private static final String ATTR_PROCESSOR = "class"; //$NON-NLS-1$

	private Map types;
	private Map factories;

		return result;
	}

	public STextProcessor getProcessor(String type) {
		if (types == null)
			read();
		Object processor = types.get(type);
		if (processor instanceof STextProcessor)
			return (STextProcessor) processor;
		return null;
	}


				if (CE_NAME != confElements[j].getName())
					STextActivator.logError("BiDi types: unexpected element name " + confElements[j].getName(), new IllegalArgumentException()); //$NON-NLS-1$
				String type = confElements[j].getAttribute(ATTR_TYPE);
				Object processor;
				try {
					processor = confElements[j].createExecutableExtension(ATTR_PROCESSOR);
				} catch (CoreException e) {
					STextActivator.logError("BiDi types: unable to create processor for " + type, e); //$NON-NLS-1$
					continue;
				}
				types.put(type, processor);
				factories.put(type, confElements[j]);
			}
		}




 ******************************************************************************/
package org.eclipse.equinox.bidi.internal.consumable;

import org.eclipse.equinox.bidi.custom.STextProcessor;

/**
 *  Processor adapted to processing comma-delimited lists, such as:
 *  <pre>
 *    part1,part2,part3
 *  </pre>
 */
public class STextComma extends STextProcessor {
	public STextComma() {
		super(","); //$NON-NLS-1$
	}

Lines 16-22 Link Here

(-)src/org/eclipse/equinox/bidi/internal/consumable/STextEmail.java (-2 / +2 lines)
16	import org.eclipse.equinox.bidi.internal.STextDelimsEsc;	16	import org.eclipse.equinox.bidi.internal.STextDelimsEsc;
17		17
18	/**	18	/**
19	* Handler adapted to processing e-mail addresses.	19	* Processor adapted to processing e-mail addresses.
20	*/	20	*/
21	public class STextEmail extends STextDelimsEsc {	21	public class STextEmail extends STextDelimsEsc {
22	static final byte L = Character.DIRECTIONALITY_LEFT_TO_RIGHT;	22	static final byte L = Character.DIRECTIONALITY_LEFT_TO_RIGHT;
Lines 59-65 Link Here
59	}	59	}
60		60
61	/**	61	/**
62	* @return 2 as number of special cases handled by this handler.	62	* @return 2 as number of special cases handled by this processor.
63	*/	63	*/
64	public int getSpecialsCount(STextEnvironment environment) {	64	public int getSpecialsCount(STextEnvironment environment) {
65	return 2;	65	return 2;




 ******************************************************************************/
package org.eclipse.equinox.bidi.internal.consumable;

import org.eclipse.equinox.bidi.custom.STextProcessor;

/**
 *  Processor adapted to processing directory and file paths.
 */
public class STextFile extends STextProcessor {

	public STextFile() {
		super(":/\\."); //$NON-NLS-1$




 ******************************************************************************/
package org.eclipse.equinox.bidi.internal.consumable;

import org.eclipse.equinox.bidi.advanced.STextEnvironment;
import org.eclipse.equinox.bidi.advanced.ISTextExpert;
import org.eclipse.equinox.bidi.advanced.STextEnvironment;
import org.eclipse.equinox.bidi.custom.*;
import org.eclipse.equinox.bidi.internal.STextActivator;
import org.eclipse.equinox.bidi.internal.STextImpl;

/**
 *  <code>STextJava</code> is a processor for structured text
 *  composed of Java statements. Such a structured text may span
 *  multiple lines.
 *  <p>

 *
 *  @author Matitiahu Allouche
 */
public class STextJava extends STextProcessor {
	private static final byte WS = Character.DIRECTIONALITY_WHITESPACE;
	static final String lineSep = STextActivator.getInstance().getProperty("line.separator"); //$NON-NLS-1$


	}

	/**
	 *  @return 4 as the number of special cases handled by this processor.
	 */
	public int getSpecialsCount(STextEnvironment environment) {
		return 4;

	public int processSpecial(STextEnvironment environment, String text, STextCharTypes charTypes, STextOffsets offsets, int[] state, int caseNumber, int separLocation) {
		int location, counter, i;

		STextProcessor.processSeparator(text, charTypes, offsets, separLocation);
		switch (caseNumber) {
			case 1 : /* space */
				separLocation++;

					location = separLocation + 2; // skip the opening slash-aster
				location = text.indexOf("*/", location); //$NON-NLS-1$
				if (location < 0) {
					state[0] = caseNumber;
					return text.length();
				}
				// we need to call processSeparator since text may follow the
				//  end of comment immediately without even a space
				STextProcessor.processSeparator(text, charTypes, offsets, location);
				return location + 2;
			case 4 : /* slash-slash comment */
				location = text.indexOf(lineSep, separLocation + 2);




import org.eclipse.equinox.bidi.STextDirection;
import org.eclipse.equinox.bidi.advanced.STextEnvironment;
import org.eclipse.equinox.bidi.custom.STextCharTypes;
import org.eclipse.equinox.bidi.custom.STextProcessor;

/**
 *  Processor adapted to processing arithmetic expressions with
 *  a possible right-to-left base direction.
 */
public class STextMath extends STextProcessor {
	static final byte L = Character.DIRECTIONALITY_LEFT_TO_RIGHT;
	static final byte R = Character.DIRECTIONALITY_RIGHT_TO_LEFT;
	static final byte AL = Character.DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC;

Lines 13-19 Link Here

(-)src/org/eclipse/equinox/bidi/internal/consumable/STextProperty.java (-1 / +1 lines)
13	import org.eclipse.equinox.bidi.internal.STextSingle;	13	import org.eclipse.equinox.bidi.internal.STextSingle;
14		14
15	/**	15	/**
16	* Handler adapted to processing property file statements.	16	* Processor adapted to processing property file statements.
17	* It expects the following string format:	17	* It expects the following string format:
18	* <pre>	18	* <pre>
19	* name=value	19	* name=value




package org.eclipse.equinox.bidi.internal.consumable;

import org.eclipse.equinox.bidi.STextDirection;
import org.eclipse.equinox.bidi.advanced.STextEnvironment;
import org.eclipse.equinox.bidi.advanced.ISTextExpert;
import org.eclipse.equinox.bidi.advanced.STextEnvironment;
import org.eclipse.equinox.bidi.custom.*;
import org.eclipse.equinox.bidi.internal.STextImpl;

/**
 *  <code>STextRegex</code> is a processor for regular expressions.
 *  Such expressions may span multiple lines.
 *  <p>
 *  In applications like an editor where parts of the text might be modified

 *
 *  @author Matitiahu Allouche
 */
public class STextRegex extends STextProcessor {
	static final String[] startStrings = {"", /*  0 *//* dummy *///$NON-NLS-1$
			"(?#", /*  1 *//* comment (?#...) *///$NON-NLS-1$
			"(?<", /*  2 *//* named group (?<name> *///$NON-NLS-1$

	static final byte EN = Character.DIRECTIONALITY_EUROPEAN_NUMBER;

	/**
	 *  This method retrieves the number of special cases handled by this processor.
	 *  
	 *  @return the number of special cases for this processor.
	 */
	public int getSpecialsCount(STextEnvironment environment) {
		return maxSpecial;

					// initial state from previous line
					location = 0;
				} else {
					STextProcessor.processSeparator(text, charTypes, offsets, separLocation);
					// skip the opening "(?#"
					location = separLocation + 3;
				}
				location = text.indexOf(')', location);
				if (location < 0) {
					state[0] = caseNumber;
					return text.length();
				}
				return location + 1;

			case 5 : /* conditional named back reference (?(<name>) */
			case 6 : /* conditional named back reference (?('name') */
			case 7 : /* named parentheses reference (?&name) */
				STextProcessor.processSeparator(text, charTypes, offsets, separLocation);
				// no need for calling processSeparator() for the following cases
				//   since the starting string contains a L char
			case 8 : /* named group (?P<name> */

					// initial state from previous line
					location = 0;
				} else {
					STextProcessor.processSeparator(text, charTypes, offsets, separLocation);
					// skip the opening "\Q"
					location = separLocation + 2;
				}
				location = text.indexOf("\\E", location); //$NON-NLS-1$
				if (location < 0) {
					state[0] = caseNumber;
					return text.length();
				}
				// set the charType for the "E" to L (Left to Right character)
				charTypes.setBidiTypeAt(location + 1, L);
				return location + 2;
			case 18 : /* R, AL, AN, EN */
				STextProcessor.processSeparator(text, charTypes, offsets, separLocation);
				return separLocation + 1;

		}




 ******************************************************************************/
package org.eclipse.equinox.bidi.internal.consumable;

import org.eclipse.equinox.bidi.advanced.STextEnvironment;
import org.eclipse.equinox.bidi.advanced.ISTextExpert;
import org.eclipse.equinox.bidi.advanced.STextEnvironment;
import org.eclipse.equinox.bidi.custom.*;
import org.eclipse.equinox.bidi.internal.STextActivator;
import org.eclipse.equinox.bidi.internal.STextImpl;

/**
 *  <code>STextSql</code> is a processor for structured text
 *  composed of SQL statements. Such a structured text may span
 *  multiple lines.
 *  <p>

 *
 *  @author Matitiahu Allouche
 */
public class STextSql extends STextProcessor {
	private static final byte WS = Character.DIRECTIONALITY_WHITESPACE;
	static final String lineSep = STextActivator.getInstance().getProperty("line.separator"); //$NON-NLS-1$


	}

	/**
	 *  @return 5 as the number of special cases handled by this processor.
	 */
	public int getSpecialsCount(STextEnvironment environment) {
		return 5;

	public int processSpecial(STextEnvironment environment, String text, STextCharTypes charTypes, STextOffsets offsets, int[] state, int caseNumber, int separLocation) {
		int location;

		STextProcessor.processSeparator(text, charTypes, offsets, separLocation);
		switch (caseNumber) {
			case 1 : /* space */
				separLocation++;

				while (true) {
					location = text.indexOf('\'', location);
					if (location < 0) {
						state[0] = caseNumber;
						return text.length();
					}
					if ((location + 1) < text.length() && text.charAt(location + 1) == '\'') {

					location = separLocation + 2; // skip the opening slash-aster
				location = text.indexOf("*/", location); //$NON-NLS-1$
				if (location < 0) {
					state[0] = caseNumber;
					return text.length();
				}
				// we need to call processSeparator since text may follow the
				//  end of comment immediately without even a space
				STextProcessor.processSeparator(text, charTypes, offsets, location);
				return location + 2;
			case 5 : /* hyphen-hyphen comment */
				location = text.indexOf(lineSep, separLocation + 2);

Lines 13-19 Link Here

(-)src/org/eclipse/equinox/bidi/internal/consumable/STextSystem.java (-1 / +1 lines)
13	import org.eclipse.equinox.bidi.internal.STextSingle;	13	import org.eclipse.equinox.bidi.internal.STextSingle;
14		14
15	/**	15	/**
16	* Handler adapted to processing structured text with the following format:	16	* Processor adapted to processing structured text with the following format:
17	* <pre>	17	* <pre>
18	* system(user)	18	* system(user)
19	* </pre>	19	* </pre>




 ******************************************************************************/
package org.eclipse.equinox.bidi.internal.consumable;

import org.eclipse.equinox.bidi.custom.STextProcessor;

/**
 *  Processor adapted to processing URLs.
 */
public class STextURL extends STextProcessor {
	public STextURL() {
		super(":?#/@.[]"); //$NON-NLS-1$
	}




 ******************************************************************************/
package org.eclipse.equinox.bidi.internal.consumable;

import org.eclipse.equinox.bidi.custom.STextProcessor;

/**
 *  Processor adapted to processing compound names.
 *  This type covers names made of one or more parts, separated by underscores:
 *  <pre>
 *    part1_part2_part3
 *  </pre>
 */
public class STextUnderscore extends STextProcessor {

	public STextUnderscore() {
		super("_"); //$NON-NLS-1$




package org.eclipse.equinox.bidi.internal.consumable;

import org.eclipse.equinox.bidi.advanced.STextEnvironment;

import org.eclipse.equinox.bidi.internal.STextDelims;

/**
 *  Processor adapted to processing XPath expressions.
 */
public class STextXPath extends STextDelims {


	}

	/**
	 *  @return 2 as the number of special cases handled by this processor.
	 */
	public int getSpecialsCount(STextEnvironment environment) {
		return 2;

Return to bug 183164

Lines 12-18 Link Here

(-)src/org/eclipse/equinox/bidi/internal/tests/STextMethodsTest.java (-30 / +25 lines)
12	package org.eclipse.equinox.bidi.internal.tests;	12	package org.eclipse.equinox.bidi.internal.tests;
13		13
14	import org.eclipse.equinox.bidi.STextDirection;	14	import org.eclipse.equinox.bidi.STextDirection;
15	import org.eclipse.equinox.bidi.STextTypeHandlerFactory;	15	import org.eclipse.equinox.bidi.STextProcessorFactory;
16	import org.eclipse.equinox.bidi.advanced.*;	16	import org.eclipse.equinox.bidi.advanced.*;
17		17
18	/**	18	/**
Lines 47-77 Link Here
47		47
48	private void doTestState() {	48	private void doTestState() {
49	String data, lean, full, model;	49	String data, lean, full, model;
50	ISTextExpert expert = STextExpertFactory.getPrivateExpert(STextTypeHandlerFactory.JAVA);	50	ISTextExpert expert = STextExpertFactory.getPrivateExpert(STextProcessorFactory.JAVA);
51		51
52	data = "A=B+C;/* D=E+F;";	52	data = "A=B+C;/* D=E+F;";
53	lean = toUT16(data);	53	lean = toUT16(data);
54	full = expert.leanToFullText(lean);	54	full = expert.leanToFullText(lean);
		55
55	model = "A@=B@+C@;/* D=E+F;";	56	model = "A@=B@+C@;/* D=E+F;";
56	assertEquals("full1", model, toPseudo(full));	57	assertEquals("full1", model, toPseudo(full));
57
58	data = "A=B+C; D=E+F;";	58	data = "A=B+C; D=E+F;";
59	lean = toUT16(data);	59	lean = toUT16(data);
60	full = expert.leanToFullText(lean);	60	full = expert.leanToFullText(lean);
61	model = data;	61
		62	model = "A=B+C; D=E+F;";
62	assertEquals("full2", model, toPseudo(full));	63	assertEquals("full2", model, toPseudo(full));
63
64	data = "SOME MORE COMMENTS";
65	lean = toUT16(data);
66	full = expert.leanToFullText(lean);
67	model = data;
68	assertEquals("full3", model, toPseudo(full));
69
70	data = "A=B+C;*/ D=E+F;";	64	data = "A=B+C;*/ D=E+F;";
71	lean = toUT16(data);	65	lean = toUT16(data);
72	full = expert.leanToFullText(lean);	66	full = expert.leanToFullText(lean);
		67
73	model = "A=B+C;@*/ D@=E@+F;";	68	model = "A=B+C;@*/ D@=E@+F;";
74	assertEquals("full4", model, toPseudo(full));	69	assertEquals("full3", model, toPseudo(full));
75	}	70	}
76		71
77	private void doTestOrientation() {	72	private void doTestOrientation() {
Lines 88-99 Link Here
88	assertEquals("orient #4", STextEnvironment.ORIENT_UNKNOWN, orient);	83	assertEquals("orient #4", STextEnvironment.ORIENT_UNKNOWN, orient);
89	}	84	}
90		85
91	private void doTestOrient(String handlerDefID, String label, String data, String resLTR, String resRTL, String resCon) {	86	private void doTestOrient(String processorDefID, String label, String data, String resLTR, String resRTL, String resCon) {
92	String full, lean;	87	String full, lean;
93		88
94	ISTextExpert expertLTR = STextExpertFactory.getExpert(handlerDefID, envLTR);	89	ISTextExpert expertLTR = STextExpertFactory.getExpert(processorDefID, envLTR);
95	ISTextExpert expertRTL = STextExpertFactory.getExpert(handlerDefID, envRTL);	90	ISTextExpert expertRTL = STextExpertFactory.getExpert(processorDefID, envRTL);
96	ISTextExpert expertCRL = STextExpertFactory.getExpert(handlerDefID, envCRL);	91	ISTextExpert expertCRL = STextExpertFactory.getExpert(processorDefID, envCRL);
97		92
98	lean = toUT16(data);	93	lean = toUT16(data);
99	full = expertLTR.leanToFullText(lean);	94	full = expertLTR.leanToFullText(lean);
Lines 111-117 Link Here
111		106
112	private void doTestLeanOffsets() {	107	private void doTestLeanOffsets() {
113	String lean, data, label;	108	String lean, data, label;
114	ISTextExpert expert = STextExpertFactory.getPrivateExpert(STextTypeHandlerFactory.JAVA);	109	ISTextExpert expert = STextExpertFactory.getExpert(STextProcessorFactory.JAVA);
115		110
116	int[] offsets;	111	int[] offsets;
117	int[] model;	112	int[] model;
Lines 133-141 Link Here
133	private void doTestFullOffsets(String label, String data, int[] resLTR, int[] resRTL, int[] resCon) {	128	private void doTestFullOffsets(String label, String data, int[] resLTR, int[] resRTL, int[] resCon) {
134	String full, lean, msg;	129	String full, lean, msg;
135	int[] offsets;	130	int[] offsets;
136	ISTextExpert expertLTR = STextExpertFactory.getExpert(STextTypeHandlerFactory.COMMA_DELIMITED, envLTR);	131	ISTextExpert expertLTR = STextExpertFactory.getExpert(STextProcessorFactory.COMMA_DELIMITED, envLTR);
137	ISTextExpert expertRTL = STextExpertFactory.getExpert(STextTypeHandlerFactory.COMMA_DELIMITED, envRTL);	132	ISTextExpert expertRTL = STextExpertFactory.getExpert(STextProcessorFactory.COMMA_DELIMITED, envRTL);
138	ISTextExpert expertCLR = STextExpertFactory.getExpert(STextTypeHandlerFactory.COMMA_DELIMITED, envCLR);	133	ISTextExpert expertCLR = STextExpertFactory.getExpert(STextProcessorFactory.COMMA_DELIMITED, envCLR);
139		134
140	lean = toUT16(data);	135	lean = toUT16(data);
141	full = expertLTR.leanToFullText(lean);	136	full = expertLTR.leanToFullText(lean);
Lines 243-257 Link Here
243		238
244	doTestOrientation();	239	doTestOrientation();
245		240
246	doTestOrient(STextTypeHandlerFactory.COMMA_DELIMITED, "Methods #1 ", "", "", "", "");	241	doTestOrient(STextProcessorFactory.COMMA_DELIMITED, "Methods #1 ", "", "", "", "");
247	doTestOrient(STextTypeHandlerFactory.COMMA_DELIMITED, "Methods #2 ", "abc", "abc", ">@abc@^", "abc");	242	doTestOrient(STextProcessorFactory.COMMA_DELIMITED, "Methods #2 ", "abc", "abc", ">@abc@^", "abc");
248	doTestOrient(STextTypeHandlerFactory.COMMA_DELIMITED, "Methods #3 ", "ABC", "ABC", ">@ABC@^", "@ABC");	243	doTestOrient(STextProcessorFactory.COMMA_DELIMITED, "Methods #3 ", "ABC", "ABC", ">@ABC@^", "@ABC");
249	doTestOrient(STextTypeHandlerFactory.COMMA_DELIMITED, "Methods #4 ", "bcd,ef", "bcd,ef", ">@bcd,ef@^", "bcd,ef");	244	doTestOrient(STextProcessorFactory.COMMA_DELIMITED, "Methods #4 ", "bcd,ef", "bcd,ef", ">@bcd,ef@^", "bcd,ef");
250	doTestOrient(STextTypeHandlerFactory.COMMA_DELIMITED, "Methods #5 ", "BCD,EF", "BCD@,EF", ">@BCD@,EF@^", "@BCD@,EF");	245	doTestOrient(STextProcessorFactory.COMMA_DELIMITED, "Methods #5 ", "BCD,EF", "BCD@,EF", ">@BCD@,EF@^", "@BCD@,EF");
251	doTestOrient(STextTypeHandlerFactory.COMMA_DELIMITED, "Methods #6 ", "cde,FG", "cde,FG", ">@cde,FG@^", "cde,FG");	246	doTestOrient(STextProcessorFactory.COMMA_DELIMITED, "Methods #6 ", "cde,FG", "cde,FG", ">@cde,FG@^", "cde,FG");
252	doTestOrient(STextTypeHandlerFactory.COMMA_DELIMITED, "Methods #7 ", "CDE,fg", "CDE,fg", ">@CDE,fg@^", "@CDE,fg");	247	doTestOrient(STextProcessorFactory.COMMA_DELIMITED, "Methods #7 ", "CDE,fg", "CDE,fg", ">@CDE,fg@^", "@CDE,fg");
253	doTestOrient(STextTypeHandlerFactory.COMMA_DELIMITED, "Methods #8 ", "12..def,GH", "12..def,GH", ">@12..def,GH@^", "12..def,GH");	248	doTestOrient(STextProcessorFactory.COMMA_DELIMITED, "Methods #8 ", "12..def,GH", "12..def,GH", ">@12..def,GH@^", "12..def,GH");
254	doTestOrient(STextTypeHandlerFactory.COMMA_DELIMITED, "Methods #9 ", "34..DEF,gh", "34..DEF,gh", ">@34..DEF,gh@^", "@34..DEF,gh");	249	doTestOrient(STextProcessorFactory.COMMA_DELIMITED, "Methods #9 ", "34..DEF,gh", "34..DEF,gh", ">@34..DEF,gh@^", "@34..DEF,gh");
255		250
256	doTestSkipProcessing();	251	doTestSkipProcessing();
257		252
Lines 263-269 Link Here
263		258
264	doTestDirection();	259	doTestDirection();
265		260
266	ISTextExpert expert = STextExpertFactory.getExpert(STextTypeHandlerFactory.COMMA_DELIMITED);	261	ISTextExpert expert = STextExpertFactory.getExpert(STextProcessorFactory.COMMA_DELIMITED);
267	String data = "A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z";	262	String data = "A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z";
268	String lean = toUT16(data);	263	String lean = toUT16(data);
269	String full = expert.leanToFullText(lean);	264	String full = expert.leanToFullText(lean);

Lines 25-31 Link Here

(-)src/org/eclipse/equinox/bidi/STextStringRecord.java (-24 / +24 lines)
25	* A string may be itself entirely a structured text, or it may contain	25	* A string may be itself entirely a structured text, or it may contain
26	* segments each of which is a structured text of a given type. Each such	26	* segments each of which is a structured text of a given type. Each such
27	* segment is identified by its starting and ending offsets within the	27	* segment is identified by its starting and ending offsets within the
28	* string, and by the handler which is appropriate to handle it.	28	* string, and by the processor which is appropriate to handle it.
29	*/	29	*/
30	public class STextStringRecord {	30	public class STextStringRecord {
31	/**	31	/**
Lines 57-64 Link Here
57	// reference to the recorded string	57	// reference to the recorded string
58	private String string;	58	private String string;
59		59
60	// reference to the handlers of the STT segments in the recorded string	60	// reference to the processors of the STT segments in the recorded string
61	private String[] handlers;	61	private String[] processors;
62		62
63	// reference to the boundaries of the STT segments in the recorded string	63	// reference to the boundaries of the STT segments in the recorded string
64	// (entries 0, 2, 4, ... are start offsets; entries 1, 3, 5, ... are	64	// (entries 0, 2, 4, ... are start offsets; entries 1, 3, 5, ... are
Lines 74-80 Link Here
74		74
75	/**	75	/**
76	* Record a string in the pool. The caller must specify the number	76	* Record a string in the pool. The caller must specify the number
77	* of segments in the record (at least 1), and the handler, starting	77	* of segments in the record (at least 1), and the processor, starting
78	* and ending offsets for the first segment.	78	* and ending offsets for the first segment.
79	*	79	*
80	* @param string the string to record.	80	* @param string the string to record.
Lines 82-90 Link Here
82	* @param segmentCount number of segments allowed in this string.	82	* @param segmentCount number of segments allowed in this string.
83	* This number must be >= 1.	83	* This number must be >= 1.
84	*	84	*
85	* @param handler the handler appropriate to handle the type	85	* @param processor the processor appropriate to handle the type
86	* of structured text present in the first segment.	86	* of structured text present in the first segment.
87	* It may be one of the pre-defined handler instances, or it may be an instance	87	* It may be one of the pre-defined processor instances, or it may be an instance
88	* created by a plug-in or by the application.	88	* created by a plug-in or by the application.
89	*	89	*
90	* @param start offset in the string of the starting character of the first	90	* @param start offset in the string of the starting character of the first
Lines 102-108 Link Here
102	* if <code>segmentCount</code> is less than 1.	102	* if <code>segmentCount</code> is less than 1.
103	* @throws also the same exceptions as {@link #addSegment addSegment}.	103	* @throws also the same exceptions as {@link #addSegment addSegment}.
104	*/	104	*/
105	public static STextStringRecord addRecord(String string, int segmentCount, String handlerID, int start, int limit) {	105	public static STextStringRecord addRecord(String string, int segmentCount, String processorID, int start, int limit) {
106	if (string == null)	106	if (string == null)
107	throw new IllegalArgumentException("The string argument must not be null!"); //$NON-NLS-1$	107	throw new IllegalArgumentException("The string argument must not be null!"); //$NON-NLS-1$
108	if (segmentCount < 1)	108	if (segmentCount < 1)
Lines 124-147 Link Here
124	}	124	}
125	hashArray[last] = string.hashCode();	125	hashArray[last] = string.hashCode();
126	for (int i = 0; i < record.usedSegmentCount; i++)	126	for (int i = 0; i < record.usedSegmentCount; i++)
127	record.handlers[i] = null;	127	record.processors[i] = null;
128	if (segmentCount > record.totalSegmentCount) {	128	if (segmentCount > record.totalSegmentCount) {
129	record.handlers = new String[segmentCount];	129	record.processors = new String[segmentCount];
130	record.boundaries = new short[segmentCount * 2];	130	record.boundaries = new short[segmentCount * 2];
131	record.totalSegmentCount = segmentCount;	131	record.totalSegmentCount = segmentCount;
132	}	132	}
133	record.usedSegmentCount = 0;	133	record.usedSegmentCount = 0;
134	record.string = string;	134	record.string = string;
135	record.addSegment(handlerID, start, limit);	135	record.addSegment(processorID, start, limit);
136	return record;	136	return record;
137	}	137	}
138		138
139	/**	139	/**
140	* Add a second or further segment to a record.	140	* Add a second or further segment to a record.
141	*	141	*
142	* @param handler the handler appropriate to handle the type	142	* @param processor the processor appropriate to handle the type
143	* of structured text present in this segment.	143	* of structured text present in this segment.
144	* It may be one of the pre-defined handler instances, or it may be an instance	144	* It may be one of the pre-defined processor instances, or it may be an instance
145	* created by a plug-in or by the application.	145	* created by a plug-in or by the application.
146	*	146	*
147	* @param start offset in the string of the starting character of the	147	* @param start offset in the string of the starting character of the
Lines 151-157 Link Here
151	* greater than the <code>start</code> argument and not greater	151	* greater than the <code>start</code> argument and not greater
152	* than the length of the string.	152	* than the length of the string.
153	*	153	*
154	* @throws IllegalArgumentException if <code>handler</code> is null,	154	* @throws IllegalArgumentException if <code>processor</code> is null,
155	* or if <code>start</code> or <code>limit</code> have invalid	155	* or if <code>start</code> or <code>limit</code> have invalid
156	* values.	156	* values.
157	* @throws IllegalStateException if the current segment exceeds the	157	* @throws IllegalStateException if the current segment exceeds the
Lines 159-174 Link Here
159	* in the call to {@link #addRecord addRecord} which created	159	* in the call to {@link #addRecord addRecord} which created
160	* the STextStringRecord instance.	160	* the STextStringRecord instance.
161	*/	161	*/
162	public void addSegment(String handlerID, int start, int limit) {	162	public void addSegment(String processorID, int start, int limit) {
163	if (handlerID == null)	163	if (processorID == null)
164	throw new IllegalArgumentException("The handler argument must not be null!"); //$NON-NLS-1$	164	throw new IllegalArgumentException("The processor argument must not be null!"); //$NON-NLS-1$
165	if (start < 0 \|\| start >= string.length())	165	if (start < 0 \|\| start >= string.length())
166	throw new IllegalArgumentException("The start position must be at least 0 and less than the length of the string!"); //$NON-NLS-1$	166	throw new IllegalArgumentException("The start position must be at least 0 and less than the length of the string!"); //$NON-NLS-1$
167	if (limit <= start \|\| limit > string.length())	167	if (limit <= start \|\| limit > string.length())
168	throw new IllegalArgumentException("The limit position must be greater than the start position but no greater than the length of the string!"); //$NON-NLS-1$	168	throw new IllegalArgumentException("The limit position must be greater than the start position but no greater than the length of the string!"); //$NON-NLS-1$
169	if (usedSegmentCount >= totalSegmentCount)	169	if (usedSegmentCount >= totalSegmentCount)
170	throw new IllegalStateException("All segments of the record are already used!"); //$NON-NLS-1$	170	throw new IllegalStateException("All segments of the record are already used!"); //$NON-NLS-1$
171	handlers[usedSegmentCount] = handlerID;	171	processors[usedSegmentCount] = processorID;
172	boundaries[usedSegmentCount * 2] = (short) start;	172	boundaries[usedSegmentCount * 2] = (short) start;
173	boundaries[usedSegmentCount * 2 + 1] = (short) limit;	173	boundaries[usedSegmentCount * 2 + 1] = (short) limit;
174	usedSegmentCount++;	174	usedSegmentCount++;
Lines 184-191 Link Here
184	* records this string.<br>	184	* records this string.<br>
185	* Once a record has been found, the number of its segments can	185	* Once a record has been found, the number of its segments can
186	* be retrieved using {@link #getSegmentCount getSegmentCount},	186	* be retrieved using {@link #getSegmentCount getSegmentCount},
187	* its handler can	187	* its processor can
188	* be retrieved using {@link #getHandler getHandler},	188	* be retrieved using {@link #getProcessor getProcessor},
189	* its starting offset can	189	* its starting offset can
190	* be retrieved using {@link #getStart getStart},	190	* be retrieved using {@link #getStart getStart},
191	* its ending offset can	191	* its ending offset can
Lines 236-242 Link Here
236	}	236	}
237		237
238	/**	238	/**
239	* Retrieve the handler of a given segment.	239	* Retrieve the processor of a given segment.
240	*	240	*
241	* @param segmentNumber number of the segment about which information	241	* @param segmentNumber number of the segment about which information
242	* is required. It must be >= 0 and less than the number of	242	* is required. It must be >= 0 and less than the number of
Lines 244-250 Link Here
244	* in the call to {@link #addRecord addRecord} which created	244	* in the call to {@link #addRecord addRecord} which created
245	* the STextStringRecord instance.	245	* the STextStringRecord instance.
246	*	246	*
247	* @return the handler to handle the structured text in the segment	247	* @return the processor to handle the structured text in the segment
248	* specified by <code>segmentNumber</code>.	248	* specified by <code>segmentNumber</code>.
249	*	249	*
250	* @throws IllegalArgumentException if <code>segmentNumber</code>	250	* @throws IllegalArgumentException if <code>segmentNumber</code>
Lines 252-260 Link Here
252	*	252	*
253	* @see #getSegmentCount	253	* @see #getSegmentCount
254	*/	254	*/
255	public String getHandler(int segmentNumber) {	255	public String getProcessor(int segmentNumber) {
256	checkSegmentNumber(segmentNumber);	256	checkSegmentNumber(segmentNumber);
257	return handlers[segmentNumber];	257	return processors[segmentNumber];
258	}	258	}
259		259
260	/**	260	/**
Lines 315-321 Link Here
315	if (record == null)	315	if (record == null)
316	continue;	316	continue;
317	record.boundaries = null;	317	record.boundaries = null;
318	record.handlers = null;	318	record.processors = null;
319	record.totalSegmentCount = 0;	319	record.totalSegmentCount = 0;
320	record.usedSegmentCount = 0;	320	record.usedSegmentCount = 0;
321	recordRefs[i].clear();	321	recordRefs[i].clear();

Lines 10-41 Link Here

(-)plugin.xml (-12 / +12 lines)
10	type="test">	10	type="test">
11	</typeDescription>	11	</typeDescription>
12	<typeDescription	12	<typeDescription
13	class="org.eclipse.equinox.bidi.internal.tests.TestHandler1"	13	class="org.eclipse.equinox.bidi.internal.tests.TestProcessor1"
14	description="Test Handler 1"	14	description="Test processor 1"
15	type="test.Handler1">	15	type="test.Processor1">
16	</typeDescription>	16	</typeDescription>
17	<typeDescription	17	<typeDescription
18	class="org.eclipse.equinox.bidi.internal.tests.TestHandler2"	18	class="org.eclipse.equinox.bidi.internal.tests.TestProcessor2"
19	description="Test Handler 2"	19	description="Test processor 2"
20	type="test.Handler2">	20	type="test.Processor2">
21	</typeDescription>	21	</typeDescription>
22	<typeDescription	22	<typeDescription
23	class="org.eclipse.equinox.bidi.internal.tests.TestHandler3"	23	class="org.eclipse.equinox.bidi.internal.tests.TestProcessor3"
24	description="Test Handler 3"	24	description="Test processor 3"
25	type="test.Handler3">	25	type="test.Processor3">
26	</typeDescription>	26	</typeDescription>
27	<typeDescription	27	<typeDescription
28	class="org.eclipse.equinox.bidi.internal.tests.TestHandlerMyCommaRL"	28	class="org.eclipse.equinox.bidi.internal.tests.TestProcessorMyCommaRL"
29	description="Test my comma RL"	29	description="Test my comma RL"
30	type="test.MyCommaRL">	30	type="test.MyCommaRL">
31	</typeDescription>	31	</typeDescription>
32	<typeDescription	32	<typeDescription
33	class="org.eclipse.equinox.bidi.internal.tests.TestHandlerMyCommaRR"	33	class="org.eclipse.equinox.bidi.internal.tests.TestProcessorMyCommaRR"
34	description="Test my comma RR"	34	description="Test my comma RR"
35	type="test.MyCommaRR">	35	type="test.MyCommaRR">
36	</typeDescription>	36	</typeDescription>
37	<typeDescription	37	<typeDescription
38	class="org.eclipse.equinox.bidi.internal.tests.TestHandlerMyCommaLL"	38	class="org.eclipse.equinox.bidi.internal.tests.TestProcessorMyCommaLL"
39	description="Test my comma LL"	39	description="Test my comma LL"
40	type="test.MyCommaLL">	40	type="test.MyCommaLL">
41	</typeDescription>	41	</typeDescription>

Added Link Here

(-)src/org/eclipse/equinox/bidi/internal/tests/STextNullProcessorTest.java (+47 lines)
1	/*******************************************************************************
2	* Copyright (c) 2010, 2011 IBM Corporation 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	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.equinox.bidi.internal.tests;
13
14
15	/**
16	* Tests null processor
17	*/
18	public class STextNullProcessorTest extends STextTestBase {
19
20	static final int[] EMPTY_INT_ARRAY = new int[0];
21
22	public void testNullProcessor() {
23	/* not needed
24	String full = STextEngine.leanToFullText(null, null, "abc", null);
25	assertEquals("leanToFullText", "abc", full);
26	int[] state = new int[1];
27	state[0] = 3;
28	full = STextEngine.leanToFullText(null, null, "abc", state);
29	assertEquals("leanToFullText with state", "abc", full);
30	int[] offsets = STextEngine.leanBidiCharOffsets(null, null, "abc", null);
31	assertEquals("leanBidiCharOffsets", 0, offsets.length);
32	offsets = STextEngine.fullBidiCharOffsets(null, null, "abc", null);
33	assertEquals("fullBidiCharOffsets", 0, offsets.length);
34	String lean = STextEngine.fullToLeanText(null, null, "abc", null);
35	assertEquals("fullToLeanText", "abc", lean);
36	lean = STextEngine.fullToLeanText(null, null, "abc", state);
37	assertEquals("fullToLeanText with state", "abc", lean);
38	int[] map = STextEngine.leanToFullMap(null, null, "abc", null);
39	int[] model = {0, 1, 2};
40	assertEquals("leanToFullMap", array_display(model), array_display(map));
41	map = STextEngine.fullToLeanMap(null, null, "abc", null);
42	assertEquals("fullToLeanMap", array_display(model), array_display(map));
43	int direction = STextEngine.getCurDirection(null, null, "abc");
44	assertEquals("getCurDirection", STextEngine.DIR_LTR, direction);
45	*/
46	}
47	}

Lines 25-35 Link Here

(-)src/org/eclipse/equinox/bidi/internal/tests/STextSomeMoreTest.java (-3 / +3 lines)
25	assertFalse(env1.isProcessingNeeded());	25	assertFalse(env1.isProcessingNeeded());
26	assertTrue(env2.isProcessingNeeded());	26	assertTrue(env2.isProcessingNeeded());
27		27
28	ISTextExpert expert1 = STextExpertFactory.getExpert("test.Handler1", env1);	28	ISTextExpert expert1 = STextExpertFactory.getExpert("test.Processor1", env1);
29	String full = expert1.leanToFullText("abcd");	29	String full = expert1.leanToFullText("abcd");
30	assertEquals("@a@b@c@d", toPseudo(full));	30	assertEquals("@a@b@c@d", toPseudo(full));
31		31
32	ISTextExpert expert2 = STextExpertFactory.getExpert("test.Handler2", env1);	32	ISTextExpert expert2 = STextExpertFactory.getExpert("test.Processor2", env1);
33	boolean catchFlag = false;	33	boolean catchFlag = false;
34	try {	34	try {
35	full = expert2.leanToFullText("abcd");	35	full = expert2.leanToFullText("abcd");
Lines 39-45 Link Here
39	assertTrue("Catch missing indexOfSpecial", catchFlag);	39	assertTrue("Catch missing indexOfSpecial", catchFlag);
40		40
41	catchFlag = false;	41	catchFlag = false;
42	ISTextExpert expert3 = STextExpertFactory.getExpert("test.Handler3", env1);	42	ISTextExpert expert3 = STextExpertFactory.getExpert("test.Processor3", env1);
43	try {	43	try {
44	full = expert3.leanToFullText("abcd");	44	full = expert3.leanToFullText("abcd");
45	} catch (IllegalStateException e) {	45	} catch (IllegalStateException e) {

Lines 23-33 Link Here

(-)src/org/eclipse/equinox/bidi/tests/STextTestSuite.java (-1 / +2 lines)
23	public STextTestSuite() {	23	public STextTestSuite() {
24	addTestSuite(STextExtensibilityTest.class);	24	addTestSuite(STextExtensibilityTest.class);
25	addTestSuite(STextMethodsTest.class);	25	addTestSuite(STextMethodsTest.class);
		26	addTestSuite(STextNullProcessorTest.class);
26	addTestSuite(STextFullToLeanTest.class);	27	addTestSuite(STextFullToLeanTest.class);
27	addTestSuite(STextExtensionsTest.class);	28	addTestSuite(STextExtensionsTest.class);
28	addTestSuite(STextMathTest.class);	29	addTestSuite(STextMathTest.class);
29	addTestSuite(STextSomeMoreTest.class);	30	addTestSuite(STextSomeMoreTest.class);
30	addTestSuite(STextProcessorTest.class);	31	addTestSuite(STextUtilTest.class);
31	addTestSuite(STextStringRecordTest.class);	32	addTestSuite(STextStringRecordTest.class);
32	}	33	}
33	}	34	}

Lines 1-269 Link Here

(-)src/org/eclipse/equinox/bidi/STextProcessor.java (-269 lines)
1	/*******************************************************************************
2	* Copyright (c) 2010, 2011 IBM Corporation 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	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11	package org.eclipse.equinox.bidi;
12
13	import org.eclipse.equinox.bidi.advanced.*;
14	import org.eclipse.equinox.bidi.custom.STextTypeHandler;
15
16	/**
17	* This class provides a number of convenience functions facilitating the
18	* processing of structured text.
19	*
20	* @noextend This class is not intended to be subclassed by clients.
21	* @noinstantiate This class is not intended to be instantiated by clients.
22	*
23	* @author Matitiahu Allouche
24	*/
25	public final class STextProcessor {
26
27	/**
28	* The default set of separators used to segment a string: dot, colon, slash, backslash.
29	*/
30	public static final String defaultSeparators = ".:/\\"; //$NON-NLS-1$
31
32	// left to right mark
33	private static final char LRM = '\u200e';
34
35	// left to right mark
36	private static final char RLM = '\u200f';
37
38	// left to right embedding
39	private static final char LRE = '\u202a';
40
41	// right to left embedding
42	private static final char RLE = '\u202b';
43
44	// pop directional format
45	private static final char PDF = '\u202c';
46
47	/**
48	* Prevents instantiation.
49	*/
50	private STextProcessor() {
51	// empty
52	}
53
54	/**
55	* This method adds directional marks to the given text before the characters
56	* specified in the given array of offsets. It can be used to add a prefix and/or
57	* a suffix of directional formatting characters.
58	* <p>
59	* The directional marks will be LRMs for structured text strings with LTR base
60	* direction and RLMs for strings with RTL base direction.
61	* </p><p>
62	* If necessary, leading and trailing directional markers (LRE, RLE and PDF) can
63	* be added depending on the value of the <code>affix</code> argument.
64	* </p>
65	* @see ISTextExpert#leanBidiCharOffsets(String)
66	*
67	* @param text the structured text string
68	* @param offsets an array of offsets to characters in <code>text</code>
69	* before which an LRM or RLM will be inserted.
70	* The array must be sorted in ascending order without duplicates.
71	* This argument may be <code>null</code> if there are no marks to add.
72	* @param direction the base direction of the structured text.
73	* It must be one of the values {@link STextDirection#DIR_LTR}, or
74	* {@link STextDirection#DIR_RTL}.
75	* @param affix specifies if a prefix and a suffix should be added to
76	* the result
77	* @return a string corresponding to the source <code>text</code> with
78	* directional marks (LRMs or RLMs) added at the specified offsets,
79	* and directional formatting characters (LRE, RLE, PDF) added
80	* as prefix and suffix if so required.
81	*/
82	public static String insertMarks(String text, int[] offsets, int direction, boolean affix) {
83	int textLen = text.length();
84	if (textLen == 0)
85	return ""; //$NON-NLS-1$
86
87	String curPrefix, curSuffix, full;
88	char curMark, c;
89	char[] fullChars;
90	if (direction == STextDirection.DIR_LTR) {
91	curMark = LRM;
92	curPrefix = "\u202a\u200e"; /* LRE+LRM *///$NON-NLS-1$
93	curSuffix = "\u200e\u202c"; /* LRM+PDF *///$NON-NLS-1$
94	} else {
95	curMark = RLM;
96	curPrefix = "\u202b\u200f"; /* RLE+RLM *///$NON-NLS-1$
97	curSuffix = "\u200f\u202c"; /* RLM+PDF *///$NON-NLS-1$
98	}
99	// add marks at offsets
100	if ((offsets != null) && (offsets.length > 0)) {
101	int offLen = offsets.length;
102	fullChars = new char[textLen + offLen];
103	int added = 0;
104	for (int i = 0, j = 0; i < textLen; i++) {
105	c = text.charAt(i);
106	if ((j < offLen) && (i == offsets[j])) {
107	fullChars[i + added] = curMark;
108	added++;
109	j++;
110	}
111	fullChars[i + added] = c;
112	}
113	full = new String(fullChars);
114	} else {
115	full = text;
116	}
117	if (affix)
118	return curPrefix + full + curSuffix;
119	return full;
120	}
121
122	/**
123	* Process the given text and return a string with appropriate
124	* directional formatting characters. This is equivalent to calling
125	* {@link #process(String str, String separators)} with the default
126	* set of separators.
127	* <p>
128	* The processing adds directional formatting characters so that presentation
129	* using the Unicode Bidirectional Algorithm will provide the expected result.
130	* The text is segmented according to the provided separators.
131	* Each segment has the Unicode Bidi Algorithm applied to it,
132	* but as a whole, the string is oriented left to right.
133	* </p><p>
134	* For example, a file path such as <tt>d:\myfolder\FOLDER\MYFILE.java</tt>
135	* (where capital letters indicate RTL text) should render as
136	* <tt>d:\myfolder\REDLOF\ELIFYM.java</tt>.
137	* </p>
138	* @param str the text to be processed
139	* @return the processed string
140	*/
141	public static String process(String str) {
142	return process(str, defaultSeparators);
143	}
144
145	/**
146	* Process a string that has a particular semantic meaning to render
147	* it correctly on bidi locales.
148	* @see #process(String)
149	* @param str the text to process
150	* @param separators separators by which the string will be segmented
151	* @return the processed string
152	*/
153	public static String process(String str, String separators) {
154	if ((str == null) \|\| (str.length() <= 1))
155	return str;
156
157	// do not process a string that has already been processed.
158	if (str.charAt(0) == LRE && str.charAt(str.length() - 1) == PDF)
159	return str;
160
161	STextEnvironment env = new STextEnvironment(null, false, STextEnvironment.ORIENT_UNKNOWN);
162	if (!env.isProcessingNeeded())
163	return str;
164	// do not process a string if all the following conditions are true:
165	// a) it has no RTL characters
166	// b) it starts with a LTR character
167	// c) it ends with a LTR character or a digit
168	boolean isStringBidi = false;
169	int strLength = str.length();
170	char c;
171	for (int i = 0; i < strLength; i++) {
172	c = str.charAt(i);
173	if (((c >= 0x05d0) && (c <= 0x07b1)) \|\| ((c >= 0xfb1d) && (c <= 0xfefc))) {
174	isStringBidi = true;
175	break;
176	}
177	}
178	while (!isStringBidi) {
179	if (!Character.isLetter(str.charAt(0)))
180	break;
181	c = str.charAt(strLength - 1);
182	if (!Character.isDigit(c) && !Character.isLetter(c))
183	break;
184	return str;
185	}
186
187	if (separators == null)
188	separators = defaultSeparators;
189
190	// make sure that LRE/PDF are added around the string
191	STextTypeHandler handler = new STextTypeHandler(separators);
192	ISTextExpert expert = STextExpertFactory.getExpert(handler, env);
193	return expert.leanToFullText(str);
194	}
195
196	/**
197	* Processes a string that has a particular semantic meaning to render
198	* it correctly on bidi locales.
199	* @see #process(String)
200	* @param str the text to process
201	* @param handler a handler instance appropriate for the type of the structured text
202	* @return the processed string
203	*/
204	public static String process(String str, STextTypeHandler handler) {
205	if ((str == null) \|\| (str.length() <= 1))
206	return str;
207
208	// do not process a string that has already been processed.
209	char c = str.charAt(0);
210	if (((c == LRE) \|\| (c == RLE)) && str.charAt(str.length() - 1) == PDF)
211	return str;
212
213	// make sure that LRE/PDF are added around the string
214	STextEnvironment env = new STextEnvironment(null, false, STextEnvironment.ORIENT_UNKNOWN);
215	if (!env.isProcessingNeeded())
216	return str;
217	ISTextExpert expert = STextExpertFactory.getExpert(handler, env);
218	return expert.leanToFullText(str);
219	}
220
221	/**
222	* Removes directional formatting characters in the given string.
223	* @param str string with directional characters to remove
224	* @return string without directional formatting characters
225	*/
226	public static String deprocess(String str) {
227	if ((str == null) \|\| (str.length() <= 1))
228	return str;
229	STextEnvironment env = new STextEnvironment(null, false, STextEnvironment.ORIENT_UNKNOWN);
230	if (!env.isProcessingNeeded())
231	return str;
232
233	StringBuffer buf = new StringBuffer();
234	int strLen = str.length();
235	for (int i = 0; i < strLen; i++) {
236	char c = str.charAt(i);
237	switch (c) {
238	case LRM :
239	continue;
240	case LRE :
241	continue;
242	case PDF :
243	continue;
244	default :
245	buf.append(c);
246	}
247	}
248	return buf.toString();
249	}
250
251	/**
252	* Removes directional formatting characters in the given string.
253	* @param str string with directional characters to remove
254	* @param handler appropriate for the structured text
255	* @return string without directional formatting characters
256	*/
257	public static String deprocess(String str, STextTypeHandler handler) {
258	if ((str == null) \|\| (str.length() <= 1))
259	return str;
260
261	// make sure that LRE/PDF are added around the string
262	STextEnvironment env = new STextEnvironment(null, false, STextEnvironment.ORIENT_UNKNOWN);
263	if (!env.isProcessingNeeded())
264	return str;
265	ISTextExpert expert = STextExpertFactory.getExpert(handler, env);
266	return expert.fullToLeanText(str);
267	}
268
269	}

Lines 1-120 Link Here

(-)src/org/eclipse/equinox/bidi/STextTypeHandlerFactory.java (-120 lines)
1	/*******************************************************************************
2	* Copyright (c) 2010, 2011 IBM Corporation 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	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11	package org.eclipse.equinox.bidi;
12
13	import org.eclipse.equinox.bidi.custom.STextTypeHandler;
14	import org.eclipse.equinox.bidi.internal.STextTypesCollector;
15
16	/**
17	* This class provides access to registered structured text handlers.
18	*
19	* @noinstantiate This class is not intended to be instantiated by clients.
20	*/
21	final public class STextTypeHandlerFactory {
22
23	/**
24	* Structured text handler for property file statements. It expects the following format:
25	* <pre>
26	* name=value
27	* </pre>
28	*/
29	public static final String PROPERTY = "property"; //$NON-NLS-1$
30
31	/**
32	* Structured text handler for compound names. It expects text to be made of one or more
33	* parts separated by underscores:
34	* <pre>
35	* part1_part2_part3
36	* </pre>
37	*/
38	public static final String UNDERSCORE = "underscore"; //$NON-NLS-1$
39
40	/**
41	* Structured text handler for comma-delimited lists, such as:
42	* <pre>
43	* part1,part2,part3
44	* </pre>
45	*/
46	public static final String COMMA_DELIMITED = "comma"; //$NON-NLS-1$
47
48	/**
49	* Structured text handler for strings with the following format:
50	* <pre>
51	* system(user)
52	* </pre>
53	*/
54	public static final String SYSTEM_USER = "system"; //$NON-NLS-1$
55
56	/**
57	* Structured text handler for directory and file paths.
58	*/
59	public static final String FILE = "file"; //$NON-NLS-1$
60
61	/**
62	* Structured text handler for e-mail addresses.
63	*/
64	public static final String EMAIL = "email"; //$NON-NLS-1$
65
66	/**
67	* Structured text handler for URLs.
68	*/
69	public static final String URL = "url"; //$NON-NLS-1$
70
71	/**
72	* Structured text handler for regular expressions, possibly spanning multiple lines.
73	*/
74	public static final String REGEXP = "regex"; //$NON-NLS-1$
75
76	/**
77	* Structured text handler for XPath expressions.
78	*/
79	public static final String XPATH = "xpath"; //$NON-NLS-1$
80
81	/**
82	* Structured text handler for Java code, possibly spanning multiple lines.
83	*/
84	public static final String JAVA = "java"; //$NON-NLS-1$
85
86	/**
87	* Structured text handler for SQL statements, possibly spanning multiple lines.
88	*/
89	public static final String SQL = "sql"; //$NON-NLS-1$
90
91	/**
92	* Structured text handler for arithmetic expressions, possibly with a RTL base direction.
93	*/
94	public static final String RTL_ARITHMETIC = "math"; //$NON-NLS-1$
95
96	/**
97	* Prevents instantiation
98	*/
99	private STextTypeHandlerFactory() {
100	// placeholder
101	}
102
103	/**
104	* Retrieve all IDs of registered structured text handlers.
105	* @return an array of text handler IDs.
106	*/
107	static public String[] getAllHandlerIDs() {
108	return STextTypesCollector.getInstance().getTypes();
109	}
110
111	/**
112	* Obtain a structured text handler of a given type.
113	* @param id string identifying handler
114	* @return a handler of the required type, or <code>null</code> if the type is unknown
115	*/
116	static public STextTypeHandler getHandler(String id) {
117	return STextTypesCollector.getInstance().getHandler(id);
118	}
119
120	}

Added Link Here

(-)src/org/eclipse/equinox/bidi/STextUtil.java (+269 lines)
1	/*******************************************************************************
2	* Copyright (c) 2010, 2011 IBM Corporation 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	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11	package org.eclipse.equinox.bidi;
12
13	import org.eclipse.equinox.bidi.advanced.*;
14	import org.eclipse.equinox.bidi.custom.STextProcessor;
15
16	/**
17	* This class provides a number of convenience functions facilitating the
18	* processing of structured text.
19	*
20	* @noextend This class is not intended to be subclassed by clients.
21	* @noinstantiate This class is not intended to be instantiated by clients.
22	*
23	* @author Matitiahu Allouche
24	*/
25	public final class STextUtil {
26
27	/**
28	* The default set of separators used to segment a string: dot, colon, slash, backslash.
29	*/
30	public static final String defaultSeparators = ".:/\\"; //$NON-NLS-1$
31
32	// left to right mark
33	private static final char LRM = '\u200e';
34
35	// left to right mark
36	private static final char RLM = '\u200f';
37
38	// left to right embedding
39	private static final char LRE = '\u202a';
40
41	// right to left embedding
42	private static final char RLE = '\u202b';
43
44	// pop directional format
45	private static final char PDF = '\u202c';
46
47	/**
48	* Prevents instantiation.
49	*/
50	private STextUtil() {
51	// empty
52	}
53
54	/**
55	* This method adds directional marks to the given text before the characters
56	* specified in the given array of offsets. It can be used to add a prefix and/or
57	* a suffix of directional formatting characters.
58	* <p>
59	* The directional marks will be LRMs for structured text strings with LTR base
60	* direction and RLMs for strings with RTL base direction.
61	* </p><p>
62	* If necessary, leading and trailing directional markers (LRE, RLE and PDF) can
63	* be added depending on the value of the <code>affix</code> argument.
64	* </p>
65	* @see ISTextExpert#leanBidiCharOffsets(String)
66	*
67	* @param text the structured text string
68	* @param offsets an array of offsets to characters in <code>text</code>
69	* before which an LRM or RLM will be inserted.
70	* The array must be sorted in ascending order without duplicates.
71	* This argument may be <code>null</code> if there are no marks to add.
72	* @param direction the base direction of the structured text.
73	* It must be one of the values {@link STextDirection#DIR_LTR}, or
74	* {@link STextDirection#DIR_RTL}.
75	* @param affix specifies if a prefix and a suffix should be added to
76	* the result
77	* @return a string corresponding to the source <code>text</code> with
78	* directional marks (LRMs or RLMs) added at the specified offsets,
79	* and directional formatting characters (LRE, RLE, PDF) added
80	* as prefix and suffix if so required.
81	*/
82	public static String insertMarks(String text, int[] offsets, int direction, boolean affix) {
83	int textLen = text.length();
84	if (textLen == 0)
85	return ""; //$NON-NLS-1$
86
87	String curPrefix, curSuffix, full;
88	char curMark, c;
89	char[] fullChars;
90	if (direction == STextDirection.DIR_LTR) {
91	curMark = LRM;
92	curPrefix = "\u202a\u200e"; /* LRE+LRM *///$NON-NLS-1$
93	curSuffix = "\u200e\u202c"; /* LRM+PDF *///$NON-NLS-1$
94	} else {
95	curMark = RLM;
96	curPrefix = "\u202b\u200f"; /* RLE+RLM *///$NON-NLS-1$
97	curSuffix = "\u200f\u202c"; /* RLM+PDF *///$NON-NLS-1$
98	}
99	// add marks at offsets
100	if ((offsets != null) && (offsets.length > 0)) {
101	int offLen = offsets.length;
102	fullChars = new char[textLen + offLen];
103	int added = 0;
104	for (int i = 0, j = 0; i < textLen; i++) {
105	c = text.charAt(i);
106	if ((j < offLen) && (i == offsets[j])) {
107	fullChars[i + added] = curMark;
108	added++;
109	j++;
110	}
111	fullChars[i + added] = c;
112	}
113	full = new String(fullChars);
114	} else {
115	full = text;
116	}
117	if (affix)
118	return curPrefix + full + curSuffix;
119	return full;
120	}
121
122	/**
123	* Process the given text and return a string with appropriate
124	* directional formatting characters. This is equivalent to calling
125	* {@link #process(String str, String separators)} with the default
126	* set of separators.
127	* <p>
128	* The processing adds directional formatting characters so that presentation
129	* using the Unicode Bidirectional Algorithm will provide the expected result.
130	* The text is segmented according to the provided separators.
131	* Each segment has the Unicode Bidi Algorithm applied to it,
132	* but as a whole, the string is oriented left to right.
133	* </p><p>
134	* For example, a file path such as <tt>d:\myfolder\FOLDER\MYFILE.java</tt>
135	* (where capital letters indicate RTL text) should render as
136	* <tt>d:\myfolder\REDLOF\ELIFYM.java</tt>.
137	* </p>
138	* @param str the text to be processed
139	* @return the processed string
140	*/
141	public static String process(String str) {
142	return process(str, defaultSeparators);
143	}
144
145	/**
146	* Process a string that has a particular semantic meaning to render
147	* it correctly on bidi locales.
148	* @see #process(String)
149	* @param str the text to process
150	* @param separators separators by which the string will be segmented
151	* @return the processed string
152	*/
153	public static String process(String str, String separators) {
154	if ((str == null) \|\| (str.length() <= 1))
155	return str;
156
157	// do not process a string that has already been processed.
158	if (str.charAt(0) == LRE && str.charAt(str.length() - 1) == PDF)
159	return str;
160
161	STextEnvironment env = new STextEnvironment(null, false, STextEnvironment.ORIENT_UNKNOWN);
162	if (!env.isProcessingNeeded())
163	return str;
164	// do not process a string if all the following conditions are true:
165	// a) it has no RTL characters
166	// b) it starts with a LTR character
167	// c) it ends with a LTR character or a digit
168	boolean isStringBidi = false;
169	int strLength = str.length();
170	char c;
171	for (int i = 0; i < strLength; i++) {
172	c = str.charAt(i);
173	if (((c >= 0x05d0) && (c <= 0x07b1)) \|\| ((c >= 0xfb1d) && (c <= 0xfefc))) {
174	isStringBidi = true;
175	break;
176	}
177	}
178	while (!isStringBidi) {
179	if (!Character.isLetter(str.charAt(0)))
180	break;
181	c = str.charAt(strLength - 1);
182	if (!Character.isDigit(c) && !Character.isLetter(c))
183	break;
184	return str;
185	}
186
187	if (separators == null)
188	separators = defaultSeparators;
189
190	// make sure that LRE/PDF are added around the string
191	STextProcessor processor = new STextProcessor(separators);
192	ISTextExpert processorNew = STextExpertFactory.getExpert(processor, env);
193	return processorNew.leanToFullText(str);
194	}
195
196	/**
197	* Processes a string that has a particular semantic meaning to render
198	* it correctly on bidi locales.
199	* @see #process(String)
200	* @param str the text to process
201	* @param processor a processor instance appropriate for the type of the structured text
202	* @return the processed string
203	*/
204	public static String process(String str, STextProcessor processor) {
205	if ((str == null) \|\| (str.length() <= 1))
206	return str;
207
208	// do not process a string that has already been processed.
209	char c = str.charAt(0);
210	if (((c == LRE) \|\| (c == RLE)) && str.charAt(str.length() - 1) == PDF)
211	return str;
212
213	// make sure that LRE/PDF are added around the string
214	STextEnvironment env = new STextEnvironment(null, false, STextEnvironment.ORIENT_UNKNOWN);
215	if (!env.isProcessingNeeded())
216	return str;
217	ISTextExpert processorNew = STextExpertFactory.getExpert(processor, env);
218	return processorNew.leanToFullText(str);
219	}
220
221	/**
222	* Removes directional formatting characters in the given string.
223	* @param str string with directional characters to remove
224	* @return string without directional formatting characters
225	*/
226	public static String deprocess(String str) {
227	if ((str == null) \|\| (str.length() <= 1))
228	return str;
229	STextEnvironment env = new STextEnvironment(null, false, STextEnvironment.ORIENT_UNKNOWN);
230	if (!env.isProcessingNeeded())
231	return str;
232
233	StringBuffer buf = new StringBuffer();
234	int strLen = str.length();
235	for (int i = 0; i < strLen; i++) {
236	char c = str.charAt(i);
237	switch (c) {
238	case LRM :
239	continue;
240	case LRE :
241	continue;
242	case PDF :
243	continue;
244	default :
245	buf.append(c);
246	}
247	}
248	return buf.toString();
249	}
250
251	/**
252	* Removes directional formatting characters in the given string.
253	* @param str string with directional characters to remove
254	* @param processor appropriate for the structured text
255	* @return string without directional formatting characters
256	*/
257	public static String deprocess(String str, STextProcessor processor) {
258	if ((str == null) \|\| (str.length() <= 1))
259	return str;
260
261	// make sure that LRE/PDF are added around the string
262	STextEnvironment env = new STextEnvironment(null, false, STextEnvironment.ORIENT_UNKNOWN);
263	if (!env.isProcessingNeeded())
264	return str;
265	ISTextExpert processorNew = STextExpertFactory.getExpert(processor, env);
266	return processorNew.fullToLeanText(str);
267	}
268
269	}

Lines 14-23 Link Here

(-)src/org/eclipse/equinox/bidi/advanced/ISTextExpert.java (-17 / +17 lines)
14	* For a general introduction to structured text, see	14	* For a general introduction to structured text, see
15	* {@link <a href="package-summary.html"> the package documentation</a>}.	15	* {@link <a href="package-summary.html"> the package documentation</a>}.
16	* <p>	16	* <p>
17	* Several common handlers are included in <b>STextEngine</b>. For handlers	17	* Several common processors are included in <b>STextEngine</b>. For processors
18	* supplied by other packages, a handler instance can be obtained using the	18	* supplied by other packages, a processor instance can be obtained using the
19	* {@link org.eclipse.equinox.bidi.STextTypeHandlerFactory#getHandler}	19	* {@link org.eclipse.equinox.bidi.STextProcessorFactory#getProcessor}
20	* method for the registered handlers, or by instantiating a private handler.	20	* method for the registered processors, or by instantiating a private processor.
21	* </p><p>	21	* </p><p>
22	* Most of the methods in this class have a <code>text</code>	22	* Most of the methods in this class have a <code>text</code>
23	* argument which may be just a part of a larger body of text.	23	* argument which may be just a part of a larger body of text.
Lines 100-106 Link Here
100	* Add directional formatting characters to a structured text	100	* Add directional formatting characters to a structured text
101	* to ensure correct presentation.	101	* to ensure correct presentation.
102	*	102	*
103	* @param handler the handler applicable to the text. If <code>null</code>,	103	* @param processor the processor applicable to the text. If <code>null</code>,
104	* the method returns unmodified text.	104	* the method returns unmodified text.
105	*	105	*
106	* @param environment a bidi environment. If <code>null</code>, the default environment	106	* @param environment a bidi environment. If <code>null</code>, the default environment
Lines 122-132 Link Here
122	* Given a <i>lean</i> string, compute the positions of each of its	122	* Given a <i>lean</i> string, compute the positions of each of its
123	* characters within the corresponding <i>full</i> string.	123	* characters within the corresponding <i>full</i> string.
124	*	124	*
125	* @param handler designates a handler instance. If <code>null</code>, this	125	* @param processor designates a processor instance. If <code>null</code>, this
126	* method returns an identity map.	126	* method returns an identity map.
127	*	127	*
128	* @param environment specifies an environment whose characteristics may affect	128	* @param environment specifies an environment whose characteristics may affect
129	* the handler's behavior. If <code>null</code>, the default environment is used.	129	* the processor's behavior. If <code>null</code>, the default environment is used.
130	*	130	*
131	* @param text is the structured text string.	131	* @param text is the structured text string.
132	*	132	*
Lines 151-160 Link Here
151	* depending on the {@link STextEnvironment#getOrientation orientation} of the	151	* depending on the {@link STextEnvironment#getOrientation orientation} of the
152	* GUI component used for display are not reflected in this method.	152	* GUI component used for display are not reflected in this method.
153	* </p>	153	* </p>
154	* @param handler designates a handler instance	154	* @param processor designates a processor instance
155	*	155	*
156	* @param environment specifies an environment whose characteristics may affect	156	* @param environment specifies an environment whose characteristics may affect
157	* the handler's behavior. If <code>null</code>, the default environment is used.	157	* the processor's behavior. If <code>null</code>, the default environment is used.
158	*	158	*
159	* @param text is the structured text string	159	* @param text is the structured text string
160	*	160	*
Lines 173-182 Link Here
173	* Remove directional formatting characters which were added to a	173	* Remove directional formatting characters which were added to a
174	* structured text string to ensure correct presentation.	174	* structured text string to ensure correct presentation.
175	*	175	*
176	* @param handler designates a handler instance	176	* @param processor designates a processor instance
177	*	177	*
178	* @param environment specifies an environment whose characteristics may affect	178	* @param environment specifies an environment whose characteristics may affect
179	* the handler's behavior. If <code>null</code>, the default environment is used.	179	* the processor's behavior. If <code>null</code>, the default environment is used.
180	*	180	*
181	* @param text is the structured text string including directional formatting characters.	181	* @param text is the structured text string including directional formatting characters.
182	*	182	*
Lines 195-204 Link Here
195	* Given a <i>full</i> string, compute the positions of each of its	195	* Given a <i>full</i> string, compute the positions of each of its
196	* characters within the corresponding <i>lean</i> string.	196	* characters within the corresponding <i>lean</i> string.
197	*	197	*
198	* @param handler designates a handler instance	198	* @param processor designates a processor instance
199	*	199	*
200	* @param environment specifies an environment whose characteristics may affect	200	* @param environment specifies an environment whose characteristics may affect
201	* the handler's behavior. If <code>null</code>, the default environment is used.	201	* the processor's behavior. If <code>null</code>, the default environment is used.
202	*	202	*
203	* @param text is the structured text string including directional formatting characters.	203	* @param text is the structured text string including directional formatting characters.
204	*	204	*
Lines 225-234 Link Here
225	* or suffixed depending on the {@link STextEnvironment#getOrientation orientation}	225	* or suffixed depending on the {@link STextEnvironment#getOrientation orientation}
226	* of the GUI component used for display.	226	* of the GUI component used for display.
227	* </p>	227	* </p>
228	* @param handler designates a handler instance	228	* @param processor designates a processor instance
229	*	229	*
230	* @param environment specifies an environment whose characteristics may affect	230	* @param environment specifies an environment whose characteristics may affect
231	* the handler's behavior. If <code>null</code>, the default environment is used.	231	* the processor's behavior. If <code>null</code>, the default environment is used.
232	*	232	*
233	* @param text is the structured text string including directional formatting characters	233	* @param text is the structured text string including directional formatting characters
234	*	234	*
Lines 248-257 Link Here
248	* whether the text contains Arabic or Hebrew words. If the text contains both,	248	* whether the text contains Arabic or Hebrew words. If the text contains both,
249	* the first Arabic or Hebrew letter in the text determines which is the governing script.	249	* the first Arabic or Hebrew letter in the text determines which is the governing script.
250	*	250	*
251	* @param handler designates a handler instance	251	* @param processor designates a processor instance
252	*	252	*
253	* @param environment specifies an environment whose characteristics may affect	253	* @param environment specifies an environment whose characteristics may affect
254	* the handler's behavior. If <code>null</code>, the default environment is used.	254	* the processor's behavior. If <code>null</code>, the default environment is used.
255	*	255	*
256	* @param text is the structured text string	256	* @param text is the structured text string
257	*	257	*

Lines 12-20 Link Here

(-)src/org/eclipse/equinox/bidi/advanced/STextExpertFactory.java (-30 / +31 lines)
12		12
13	import java.util.HashMap;	13	import java.util.HashMap;
14	import java.util.Map;	14	import java.util.Map;
15	import org.eclipse.equinox.bidi.STextTypeHandlerFactory;	15	import org.eclipse.equinox.bidi.STextProcessorFactory;
16	import org.eclipse.equinox.bidi.custom.STextTypeHandler;	16	import org.eclipse.equinox.bidi.custom.STextProcessor;
17	import org.eclipse.equinox.bidi.internal.STextImpl;	17	import org.eclipse.equinox.bidi.internal.STextExpertImpl;
		18	import org.eclipse.equinox.bidi.internal.STextExpertMultipassImpl;
18		19
19	final public class STextExpertFactory {	20	final public class STextExpertFactory {
20		21
Lines 35-83 Link Here
35		36
36	static public ISTextExpert getExpert() {	37	static public ISTextExpert getExpert() {
37	if (defaultExpert == null) {	38	if (defaultExpert == null) {
38	STextTypeHandler handler = new STextTypeHandler(defaultSeparators);	39	STextProcessor descriptor = new STextProcessor(defaultSeparators);
39	defaultExpert = new STextImpl(handler, STextEnvironment.DEFAULT, null);	40	defaultExpert = new STextExpertImpl(descriptor, STextEnvironment.DEFAULT);
40	}	41	}
41	return defaultExpert;	42	return defaultExpert;
42	}	43	}
43		44
44	static public ISTextExpert getExpert(String type) {	45	static public ISTextExpert getExpert(String type) {
45	ISTextExpert expert;	46	ISTextExpert processor;
46	synchronized (sharedDefaultExperts) {	47	synchronized (sharedDefaultExperts) {
47	expert = (ISTextExpert) sharedDefaultExperts.get(type);	48	processor = (ISTextExpert) sharedDefaultExperts.get(type);
48	if (expert == null) {	49	if (processor == null) {
49	STextTypeHandler handler = STextTypeHandlerFactory.getHandler(type);	50	STextProcessor descriptor = STextProcessorFactory.getProcessor(type);
50	if (handler == null)	51	if (descriptor == null)
51	return null;	52	return null;
52	expert = new STextImpl(handler, STextEnvironment.DEFAULT, null);	53	processor = new STextExpertImpl(descriptor, STextEnvironment.DEFAULT);
53	sharedDefaultExperts.put(type, expert);	54	sharedDefaultExperts.put(type, processor);
54	}	55	}
55	}	56	}
56	return expert;	57	return processor;
57	}	58	}
58		59
59	static public ISTextExpert getExpert(String type, STextEnvironment environment) {	60	static public ISTextExpert getExpert(String type, STextEnvironment environment) {
60	ISTextExpert expert;	61	ISTextExpert processor;
61	synchronized (sharedExperts) {	62	synchronized (sharedExperts) {
62	Map experts = (Map) sharedExperts.get(type);	63	Map processors = (Map) sharedExperts.get(type);
63	if (experts == null) {	64	if (processors == null) {
64	experts = new HashMap(); // environment -> expert	65	processors = new HashMap(); // environment -> processor
65	sharedExperts.put(type, experts);	66	sharedExperts.put(type, processors);
66	}	67	}
67	expert = (ISTextExpert) experts.get(environment);	68	processor = (ISTextExpert) processors.get(environment);
68	if (expert == null) {	69	if (processor == null) {
69	STextTypeHandler handler = STextTypeHandlerFactory.getHandler(type);	70	STextProcessor descriptor = STextProcessorFactory.getProcessor(type);
70	if (handler == null)	71	if (descriptor == null)
71	return null;	72	return null;
72	expert = new STextImpl(handler, environment, null);	73	processor = new STextExpertImpl(descriptor, environment);
73	experts.put(type, expert);	74	processors.put(type, processor);
74	}	75	}
75	}	76	}
76	return expert;	77	return processor;
77	}	78	}
78		79
79	static public ISTextExpert getExpert(STextTypeHandler handler, STextEnvironment environment) {	80	static public ISTextExpert getExpert(STextProcessor descriptor, STextEnvironment environment) {
80	return new STextImpl(handler, environment, new int[1]);	81	return new STextExpertImpl(descriptor, environment);
81	}	82	}
82		83
83	static public ISTextExpertStateful getPrivateExpert(String type) {	84	static public ISTextExpertStateful getPrivateExpert(String type) {
Lines 85-94 Link Here
85	}	86	}
86		87
87	static public ISTextExpertStateful getPrivateExpert(String type, STextEnvironment environment) {	88	static public ISTextExpertStateful getPrivateExpert(String type, STextEnvironment environment) {
88	STextTypeHandler handler = STextTypeHandlerFactory.getHandler(type);	89	STextProcessor descriptor = STextProcessorFactory.getProcessor(type);
89	if (handler == null)	90	if (descriptor == null)
90	return null;	91	return null;
91	return new STextImpl(handler, environment, new int[1]);	92	return new STextExpertMultipassImpl(descriptor, environment);
92	}	93	}
93		94
94	}	95	}

Lines 35-66 Link Here

(-)src/org/eclipse/equinox/bidi/custom/STextCharTypes.java (-11 / +11 lines)
35		35
36	private static final int CHARTYPES_ADD = 2;	36	private static final int CHARTYPES_ADD = 2;
37		37
38	final protected STextTypeHandler handler;	38	final protected STextProcessor processor;
39	final protected STextEnvironment environment;	39	final protected STextEnvironment environment;
40	final protected String text;	40	final protected String text;
41		41
42	// 1 byte for each char in text	42	// 1 byte for each char in text
43	private byte[] types;	43	private byte[] types;
44		44
45	// structured text direction. -1 means not yet computed; -2 means within handler.getDirection	45	// structured text direction. -1 means not yet computed; -2 means within processor.getDirection
46	private int direction = -1;	46	private int direction = -1;
47		47
48	/**	48	/**
49	* Constructor	49	* Constructor
50	*	50	*
51	* @param handler is the handler handling this occurrence of	51	* @param processor is the processor handling this occurrence of
52	* structured text.	52	* structured text.
53	*	53	*
54	* @param environment the current environment, which may affect the behavior of	54	* @param environment the current environment, which may affect the behavior of
55	* the handler. This parameter may be specified as	55	* the processor. This parameter may be specified as
56	* <code>null</code>, in which case the	56	* <code>null</code>, in which case the
57	* {@link STextEnvironment#DEFAULT DEFAULT}	57	* {@link STextEnvironment#DEFAULT DEFAULT}
58	* environment should be assumed.	58	* environment should be assumed.
59	*	59	*
60	* @param text is the text whose characters are analyzed.	60	* @param text is the text whose characters are analyzed.
61	*/	61	*/
62	public STextCharTypes(STextTypeHandler handler, STextEnvironment environment, String text) {	62	public STextCharTypes(STextProcessor processor, STextEnvironment environment, String text) {
63	this.handler = handler;	63	this.processor = processor;
64	this.environment = environment;	64	this.environment = environment;
65	this.text = text;	65	this.text = text;
66	types = new byte[text.length()];	66	types = new byte[text.length()];
Lines 68-74 Link Here
68		68
69	public int getDirection() {	69	public int getDirection() {
70	if (direction < 0)	70	if (direction < 0)
71	direction = handler.getDirection(environment, text, this);	71	direction = processor.getDirection(environment, text, this);
72	return direction;	72	return direction;
73	}	73	}
74		74
Lines 96-105 Link Here
96	byte charType = Character.getDirectionality(text.charAt(index));	96	byte charType = Character.getDirectionality(text.charAt(index));
97	if (charType == B) {	97	if (charType == B) {
98	if (direction < 0) {	98	if (direction < 0) {
99	if (direction < -1) // called by handler.getDirection	99	if (direction < -1) // called by processor.getDirection
100	return charType; // avoid infinite recursion	100	return charType; // avoid infinite recursion
101	direction = -2; // signal we go within handler.getDirection	101	direction = -2; // signal we go within processor.getDirection
102	direction = handler.getDirection(environment, text, this);	102	direction = processor.getDirection(environment, text, this);
103	}	103	}
104	charType = (direction == STextEnvironment.ORIENT_RTL) ? R : L;	104	charType = (direction == STextEnvironment.ORIENT_RTL) ? R : L;
105	}	105	}
Lines 125-131 Link Here
125	* be displayed.	125	* be displayed.
126	*	126	*
127	* @param envir is the current environment, which may affect the behavior of	127	* @param envir is the current environment, which may affect the behavior of
128	* the handler. This parameter may be specified as	128	* the processor. This parameter may be specified as
129	* <code>null</code>, in which case the	129	* <code>null</code>, in which case the
130	* {@link STextEnvironment#DEFAULT DEFAULT}	130	* {@link STextEnvironment#DEFAULT DEFAULT}
131	* environment should be assumed.	131	* environment should be assumed.