From 505db885a3cc29e925aa9e42f52cc5e4f0b5f194 Mon, 18 Jul 2011 14:20:45 -0400 From: Oleg Besedin Date: Mon, 18 Jul 2011 14:19:42 -0400 Subject: [PATCH] Bug 183164 - [Implementation for] Display of Complex Expressions Containing Bidirectional Text diff --git a/bundles/org.eclipse.equinox.bidi.tests/src/org/eclipse/equinox/bidi/internal/tests/STextExtensionsTest.java b/bundles/org.eclipse.equinox.bidi.tests/src/org/eclipse/equinox/bidi/internal/tests/STextExtensionsTest.java index 753361e..b7486eb 100644 --- a/bundles/org.eclipse.equinox.bidi.tests/src/org/eclipse/equinox/bidi/internal/tests/STextExtensionsTest.java +++ b/bundles/org.eclipse.equinox.bidi.tests/src/org/eclipse/equinox/bidi/internal/tests/STextExtensionsTest.java @@ -11,8 +11,8 @@ package org.eclipse.equinox.bidi.internal.tests; -import java.util.Locale; import org.eclipse.equinox.bidi.STextEngine; +import org.eclipse.equinox.bidi.STextEnvironment; import org.eclipse.equinox.bidi.custom.STextProcessor; /** @@ -21,24 +21,28 @@ public class STextExtensionsTest extends STextTestBase { + STextEnvironment env = STextEnvironment.DEFAULT; + STextEnvironment envArabic = new STextEnvironment("ar", false, STextEnvironment.ORIENT_LTR); + STextEnvironment envHebrew = new STextEnvironment("he", false, STextEnvironment.ORIENT_LTR); + STextProcessor processor; int[] state = new int[1]; private void doTest1(String label, String data, String result) { String full; - full = STextEngine.leanToFullText(processor, null, toUT16(data), state); + full = STextEngine.leanToFullText(processor, env, toUT16(data), state); assertEquals(label + " data = " + data, result, toPseudo(full)); } private void doTest2(String label, String data, String result) { String full; - full = STextEngine.leanToFullText(processor, null, data, state); + full = STextEngine.leanToFullText(processor, env, data, state); assertEquals(label + " data = " + data, result, toPseudo(full)); } private void doTest3(String label, String data, String result) { String full; - full = STextEngine.leanToFullText(processor, null, toUT16(data), state); + full = STextEngine.leanToFullText(processor, env, toUT16(data), state); assertEquals(label + " data = " + data, result, toPseudo(full)); } @@ -47,6 +51,7 @@ String data; processor = STextEngine.PROC_COMMA_DELIMITED; state[0] = STextEngine.STATE_INITIAL; + doTest1("Comma #1", "ab,cd, AB, CD, EFG", "ab,cd, AB@, CD@, EFG"); processor = STextEngine.PROC_EMAIL; @@ -55,13 +60,13 @@ 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 "); - Locale.setDefault(new Locale("ar")); + env = envArabic; 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&^"); - Locale.setDefault(new Locale("he")); + env = envHebrew; data = toUT16("peter.pan") + "@" + toUT16("DEF.GHI"); doTest2("Email #9", data, "peter.pan@DEF@.GHI"); @@ -134,7 +139,7 @@ doTest1("Regex #17.6", "aB*123", "aB*@123"); doTest1("Regex #17.7", "aB*567", "aB*@567"); - Locale.setDefault(new Locale("ar")); + env = envArabic; data = toUT16("#BC(?") + "#" + toUT16("DEF)GHI"); doTest2("Regex #0.0", data, "<&#BC(?#DEF)GHI&^"); data = toUT16("#BC(?") + "#" + toUT16("DEF"); @@ -170,7 +175,7 @@ doTest2("Regex #16.1", data, "<&#BC\\qDEF&^"); data = toUT16("#HI") + "\\E" + toUT16("JKL"); doTest2("Regex #16.2", data, "<&#HI\\eJKL&^"); - Locale.setDefault(new Locale("he")); + env = envHebrew; processor = STextEngine.PROC_SQL; state[0] = STextEngine.STATE_INITIAL; diff --git a/bundles/org.eclipse.equinox.bidi.tests/src/org/eclipse/equinox/bidi/internal/tests/STextMathTest.java b/bundles/org.eclipse.equinox.bidi.tests/src/org/eclipse/equinox/bidi/internal/tests/STextMathTest.java index ab836bf..b334e5a 100644 --- a/bundles/org.eclipse.equinox.bidi.tests/src/org/eclipse/equinox/bidi/internal/tests/STextMathTest.java +++ b/bundles/org.eclipse.equinox.bidi.tests/src/org/eclipse/equinox/bidi/internal/tests/STextMathTest.java @@ -11,7 +11,6 @@ package org.eclipse.equinox.bidi.internal.tests; -import java.util.Locale; import org.eclipse.equinox.bidi.STextEngine; import org.eclipse.equinox.bidi.STextEnvironment; import org.eclipse.equinox.bidi.custom.STextProcessor; @@ -21,8 +20,8 @@ */ public class STextMathTest extends STextTestBase { - static final STextEnvironment envLTR = new STextEnvironment(null, false, STextEnvironment.ORIENT_LTR); - static final STextEnvironment envRTL = new STextEnvironment(null, false, STextEnvironment.ORIENT_RTL); + static final STextEnvironment envLTR = new STextEnvironment("ar", false, STextEnvironment.ORIENT_LTR); + static final STextEnvironment envRTL = new STextEnvironment("ar", false, STextEnvironment.ORIENT_RTL); STextProcessor processor = STextEngine.PROC_RTL_ARITHMETIC; @@ -40,13 +39,13 @@ verifyOneLine("Math #2", "2+ABC-DEF", "2+ABC@-DEF", ">@2+ABC@-DEF@^"); verifyOneLine("Math #3", "A+3*BC/DEF", "A@+3*BC@/DEF", ">@A@+3*BC@/DEF@^"); verifyOneLine("Math #4", "4+ABC/DEF", "4+ABC@/DEF", ">@4+ABC@/DEF@^"); - Locale.setDefault(new Locale("ar")); + verifyOneLine("Math #5", "5#BC", "<&5#BC&^", "5#BC"); verifyOneLine("Math #6", "6#BC-DE", "<&6#BC-DE&^", "6#BC-DE"); verifyOneLine("Math #7", "7#BC+DE", "<&7#BC+DE&^", "7#BC+DE"); verifyOneLine("Math #8", "8#BC*DE", "<&8#BC*DE&^", "8#BC*DE"); verifyOneLine("Math #9", "9#BC/DE", "<&9#BC/DE&^", "9#BC/DE"); verifyOneLine("Math #10", "10ab+cd-ef", "10ab+cd-ef", ">@10ab+cd-ef@^"); - Locale.setDefault(new Locale("he")); + } } diff --git a/bundles/org.eclipse.equinox.bidi.tests/src/org/eclipse/equinox/bidi/internal/tests/STextSomeMoreTest.java b/bundles/org.eclipse.equinox.bidi.tests/src/org/eclipse/equinox/bidi/internal/tests/STextSomeMoreTest.java index cbea79a..88d89b3 100644 --- a/bundles/org.eclipse.equinox.bidi.tests/src/org/eclipse/equinox/bidi/internal/tests/STextSomeMoreTest.java +++ b/bundles/org.eclipse.equinox.bidi.tests/src/org/eclipse/equinox/bidi/internal/tests/STextSomeMoreTest.java @@ -64,8 +64,8 @@ } public void testSomeMore() { - assertFalse(env1.isBidi()); - assertTrue(env2.isBidi()); + assertFalse(env1.isProcessingNeeded()); + assertTrue(env2.isProcessingNeeded()); STextProcessor processor = new Processor1(); String full = STextEngine.leanToFullText(processor, env1, "abcd", null); diff --git a/bundles/org.eclipse.equinox.bidi.tests/src/org/eclipse/equinox/bidi/internal/tests/STextUtilTest.java b/bundles/org.eclipse.equinox.bidi.tests/src/org/eclipse/equinox/bidi/internal/tests/STextUtilTest.java index 2b4fe77..385f8c6 100644 --- a/bundles/org.eclipse.equinox.bidi.tests/src/org/eclipse/equinox/bidi/internal/tests/STextUtilTest.java +++ b/bundles/org.eclipse.equinox.bidi.tests/src/org/eclipse/equinox/bidi/internal/tests/STextUtilTest.java @@ -60,7 +60,7 @@ assertEquals("Util #1 full UR - ", result, toPseudo(full)); Locale.setDefault(new Locale(HEBREW)); full = STextUtil.process(toUT16(data)); - String ful2 = STextUtil.process(toUT16(data), null); + 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); @@ -83,7 +83,7 @@ } private void doTest3(String msg, String data, String result, String resLean) { - String full = STextUtil.processTyped(toUT16(data), STextEngine.PROC_COMMA_DELIMITED); + String full = STextUtil.process(toUT16(data), STextEngine.PROC_COMMA_DELIMITED); assertEquals(msg + "full", result, toPseudo(full)); String lean = STextUtil.deprocess(full, STextEngine.PROC_COMMA_DELIMITED); assertEquals(msg + "lean", resLean, toPseudo(lean)); diff --git a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/STextEngine.java b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/STextEngine.java index 3d05bf8..e2cc528 100644 --- a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/STextEngine.java +++ b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/STextEngine.java @@ -15,100 +15,66 @@ import org.eclipse.equinox.bidi.internal.STextImpl; /** - * This class acts as a mediator between applications and structured text - * processors. - * The purpose of structured text processors is to add directional - * formatting characters to ensure correct display. - * This class shields applications from the - * intricacies of structured text processors. - *

- * For a general introduction to structured text, see - * {@link - * the package documentation}. - * - *

How to Specify a Processor

- * - *

All the methods in this class have a first argument which - * designates a processor. - * - *

It must be specified as an instance of {@link STextProcessor}. - * Pre-defined instances are included in STextEngine for all - * the types of structured text supported by this package. - * - *

For processors supplied by other packages, a processor instance - * can be obtained using the - * {@link org.eclipse.equinox.bidi.custom.STextStringProcessor#getProcessor getProcessor} - * method for the registered processors, or by instantiating a private processor. - * - *

Specifying null for the processor as first argument - * of a method causes this method to behave as a no-op. - * - *

State

- * - *

Most of the methods in this class have a text - * argument which may be just a part of a larger body of text. - * When it is the case that the text is submitted in parts with - * repeated calls, there may be a need to pass information from - * one invocation to the next one. For instance, one invocation - * may detect that a comment or a literal has been started but - * has not been completed. In such cases, a state - * argument must be used. - * - *

The state argument must be an array of integers - * with at least one element. Only the first element is used by - * the methods of this class. - * - *

When submitting the initial part of the text, the first element - * of state must contain the value {@link #STATE_INITIAL} - * or any value <= 0. - * - *

After calling a method with a non-null state argument, - * a value is returned in the first element of state. This - * value should be passed unmodified to the method when calling it again - * with the text which is the continuation of the text submitted in the - * last call. - * - *

When the text submitted to a method is not a continuation and is not - * expected to have a continuation , e.g. it is processed all by itself, - * the state argument should be specified as null. - * - *

Code Samples

- * - *

The following code shows how to transform a certain type of structured text - * (directory and file paths) in order to obtain the full - * text corresponding to the given lean text. - * - * 

- *
- *    String leanText = "D:\\\u05d0\u05d1\\\u05d2\\\u05d3.ext";
- *    String fullText = STextEngine.leanToFullText(STextEngine.PROC_FILE, null, leanText, null);
- *    System.out.println("full text = " + fullText);
- *
- *
- * - *

The following code shows how to transform successive lines of Java - * code in order to obtain the full - * text corresponding to the lean text of each line. - * - * 

- *
- *    int[] state = new int[1];
- *    state[0] = STextEngine.STATE_INITIAL;
- *    String leanText = "int i = 3; // first Java statement";
- *    String fullText = STextEngine.leanToFullText(STextEngine.PROC_JAVA, null, leanText, state);
- *    System.out.println("full text = " + fullText);
- *    leanText = "i += 4; // next Java statement";
- *    fullText = STextEngine.leanToFullText(STextEngine.PROC_JAVA, null, leanText, state);
- *    System.out.println("full text = " + fullText);
- *
- *
- * - *

This class provides a user-oriented API but does not provide - * an actual implementation. The real work is done by the class - * {@link STextImpl}. Users of the API need not be concerned by, and - * should not depend upon, details of the implementation in - * STextImpl. - * + * For a general introduction to structured text, see + * {@link the package documentation}. + *

+ * Several common processors are included in STextEngine. For processors + * supplied by other packages, a processor instance can be obtained using the + * {@link org.eclipse.equinox.bidi.custom.STextStringProcessor#getProcessor} + * method for the registered processors, or by instantiating a private processor. + *

+ * Most of the methods in this class have a text + * argument which may be just a part of a larger body of text. + * When it is the case that the text is submitted in parts with + * repeated calls, there may be a need to pass information from + * one invocation to the next one. For instance, one invocation + * may detect that a comment or a literal has been started but + * has not been completed. In such cases, a state + * argument must be used. + *

+ * The state argument must be an array of integers + * with at least one element. Only the first element is used by + * the methods of this class. + *

+ * When submitting the initial part of the text, the first element + * of state must contain the value {@link #STATE_INITIAL} + * or any value <= 0. + *

+ * After calling a method with a non-null state argument, + * a value is returned in the first element of state. This + * value should be passed unmodified to the method when calling it again + * with the text which is the continuation of the text submitted in the + * last call. + *

+ * When the text submitted to a method is not a continuation and is not + * expected to have a continuation , e.g. it is processed all by itself, + * the state argument should be specified as null. + *

+ * Code Samples + *

+ * The following code shows how to transform a certain type of structured text + * (directory and file paths) in order to obtain the full + * text corresponding to the given lean text. + * 

+ *   String leanText = "D:\\\u05d0\u05d1\\\u05d2\\\u05d3.ext";
+ *   String fullText = STextEngine.leanToFullText(STextEngine.PROC_FILE, null, leanText, null);
+ *   System.out.println("full text = " + fullText);
+ *
+ *

+ * The following code shows how to transform successive lines of Java + * code in order to obtain the full + * text corresponding to the lean text of each line. + * 

+ *   int[] state = new int[1];
+ *   state[0] = STextEngine.STATE_INITIAL;
+ *   String leanText = "int i = 3; // first Java statement";
+ *   String fullText = STextEngine.leanToFullText(STextEngine.PROC_JAVA, null, leanText, state);
+ *   System.out.println("full text = " + fullText);
+ *   leanText = "i += 4; // next Java statement";
+ *   fullText = STextEngine.leanToFullText(STextEngine.PROC_JAVA, null, leanText, state);
+ *   System.out.println("full text = " + fullText);
+ *
+ *

* @author Matitiahu Allouche * */ @@ -237,35 +203,25 @@ // nothing to do } - /** Add directional formatting characters to a structured text - * to ensure correct presentation. + /** + * Add directional formatting characters to a structured text + * to ensure correct presentation. + * + * @param processor the processor applicable to the text. If null, + * the method returns unmodified text. + * + * @param environment a bidi environment. If null, the default environment + * is used. + * + * @param text is the structured text string * - * @param processor designates a processor instance. - * For more details, see above - * How to Specify a Processor. - *

If this argument is null, this method - * returns the text string. + * @param state can be used to specify that the text argument is + * the continuation of text submitted in a previous call and/or to receive information + * to pass to continuation calls. If all calls to this method are independent from one another, + * this argument should be specified as null. * - * @param environment specifies an environment whose characteristics - * may affect the processor's behavior. - *

This argument may be specified as null, - * in which case the processor will assume a standard - * environment as specified in - * {@link STextEnvironment#DEFAULT}. - * - * @param text is the structured text string. - * - * @param state can be used to specify that the text - * argument is the continuation of text submitted in a - * previous call and/or to receive information to pass to - * continuation calls. - * For more details, see State above. - *

If all calls to this method are independent from one another, - * this argument should be specified as null. - * - * @return the structured text with directional formatting - * characters added at proper locations to ensure correct - * presentation. + * @return the structured text with directional formatting characters added to ensure + * correct presentation. */ public static String leanToFullText(STextProcessor processor, STextEnvironment environment, String text, int[] state) { if (processor == null) @@ -274,35 +230,24 @@ } /** - * Given a lean string, compute the positions of each of its - * characters within the corresponding full string. + * Given a lean string, compute the positions of each of its + * characters within the corresponding full string. * - * @param processor designates a processor instance. - * For more details, see above - * How to Specify a Processor. - *

If this argument is null, this method - * returns an identity map. + * @param processor designates a processor instance. If null, this + * method returns an identity map. * - * @param environment specifies an environment whose characteristics - * may affect the processor's behavior. - *

This argument may be specified as null, - * in which case the processor will assume a standard - * environment as specified in - * {@link STextEnvironment#DEFAULT}. + * @param environment specifies an environment whose characteristics may affect + * the processor's behavior. If null, the default environment is used. * - * @param text is the structured text string. + * @param text is the structured text string. * - * @param state can be used to specify that the text - * argument is the continuation of text submitted in a - * previous call and/or to receive information to pass to - * continuation calls. - * For more details, see State above. - *

If all calls to this method are independent from one another, - * this argument should be specified as null. + * @param state can be used to specify that the text argument is + * the continuation of text submitted in a previous call and/or to receive information + * to pass to continuation calls. If all calls to this method are independent from one another, + * this argument should be specified as null. * - * @return an array of integers with one element for each of the characters - * in the text argument, equal to the offset of the - * corresponding character in the full string. + * @return an array which specifies offsets of the text characters + * in the full string */ public static int[] leanToFullMap(STextProcessor processor, STextEnvironment environment, String text, int[] state) { if (processor == null) { @@ -315,43 +260,31 @@ } /** - * Given a lean string, compute the offsets of characters - * before which directional formatting characters must be added - * in order to ensure correct presentation. + * Given a lean string, compute the offsets of characters + * before which directional formatting characters must be added + * in order to ensure correct presentation. + *

+ * Only LRMs (for a string with LTR base direction) and RLMs (for + * a string with RTL base direction) are considered. Leading and + * trailing LRE, RLE and PDF which might be prefixed or suffixed + * depending on the {@link STextEnvironment#getOrientation orientation} of the + * GUI component used for display are not reflected in this method. + *

+ * @param processor designates a processor instance * - *

Only LRMs (for a string with LTR base direction) and RLMs (for - * a string with RTL base direction) are considered. Leading and - * trailing LRE, RLE and PDF which might be prefixed or suffixed - * depending on the {@link STextEnvironment#getOrientation orientation} of the - * GUI component used for display are not reflected in this method. + * @param environment specifies an environment whose characteristics may affect + * the processor's behavior. If null, the default environment is used. * - * @param processor designates a processor instance. - * For more details, see above - * How to Specify a Processor. - *

If this argument is null, this method - * returns an empty array. + * @param text is the structured text string * - * @param environment specifies an environment whose characteristics - * may affect the processor's behavior. - *

This argument may be specified as null, - * in which case the processor will assume a standard - * environment as specified in - * {@link STextEnvironment#DEFAULT}. + * @param state can be used to specify that the text argument is + * the continuation of text submitted in a previous call and/or to receive information + * to pass to continuation calls. If all calls to this method are independent from one another, + * this argument should be specified as null. * - * @param text is the structured text string. - * - * @param state can be used to specify that the text - * argument is the continuation of text submitted in a - * previous call and/or to receive information to pass to - * continuation calls. - * For more details, see State above. - *

If all calls to this method are independent from one another, - * this argument should be specified as null. - * - * @return an array of offsets to the characters in the text - * argument before which directional marks must be - * added to ensure correct presentation. - * The offsets are sorted in ascending order. + * @return an array of offsets to the characters in the text argument + * before which directional marks must be added to ensure correct presentation. + * The offsets are sorted in ascending order. */ public static int[] leanBidiCharOffsets(STextProcessor processor, STextEnvironment environment, String text, int[] state) { if (processor == null) @@ -360,36 +293,23 @@ } /** - * Remove directional formatting characters which were added to a - * structured text string to ensure correct presentation. + * Remove directional formatting characters which were added to a + * structured text string to ensure correct presentation. * - * @param processor designates a processor instance. - * For more details, see above - * How to Specify a Processor. - *

If this argument is null, this method - * returns the text string. + * @param processor designates a processor instance * - * @param environment specifies an environment whose characteristics - * may affect the processor's behavior. - *

This argument may be specified as null, - * in which case the processor will assume a standard - * environment as specified in - * {@link STextEnvironment#DEFAULT}. + * @param environment specifies an environment whose characteristics may affect + * the processor's behavior. If null, the default environment is used. * - * @param text is the structured text string including - * directional formatting characters. + * @param text is the structured text string including directional formatting characters. * - * @param state can be used to specify that the text - * argument is the continuation of text submitted in a - * previous call and/or to receive information to pass to - * continuation calls. - * For more details, see State above. - *

If all calls to this method are independent from one another, - * this argument should be specified as null. + * @param state can be used to specify that the text argument is + * the continuation of text submitted in a previous call and/or to receive information + * to pass to continuation calls. If all calls to this method are independent from one another, + * this argument should be specified as null. * - * @return the structured text string without directional formatting - * characters which might have been added by processing it - * with {@link #leanToFullText leanToFullText}. + * @return the structured text string without directional formatting characters + * which might have been added by processing it with {@link #leanToFullText}. * */ public static String fullToLeanText(STextProcessor processor, STextEnvironment environment, String text, int[] state) { @@ -399,41 +319,26 @@ } /** - * Given a full string, compute the positions of each of its - * characters within the corresponding lean string. + * Given a full string, compute the positions of each of its + * characters within the corresponding lean string. * - * @param processor designates a processor instance. - * For more details, see above - * How to Specify a Processor. - *

If this argument is null, this method - * returns an identity map. + * @param processor designates a processor instance * - * @param environment specifies an environment whose characteristics - * may affect the processor's behavior. - *

This argument may be specified as null, - * in which case the processor will assume a standard - * environment as specified in - * {@link STextEnvironment#DEFAULT}. + * @param environment specifies an environment whose characteristics may affect + * the processor's behavior. If null, the default environment is used. * - * @param text is the structured text string including - * directional formatting characters. + * @param text is the structured text string including directional formatting characters. * - * @param state can be used to specify that the text - * argument is the continuation of text submitted in a - * previous call and/or to receive information to pass to - * continuation calls. - * For more details, see State above. - *

If all calls to this method are independent from one another, - * this argument should be specified as null. + * @param state can be used to specify that the text argument is + * the continuation of text submitted in a previous call and/or to receive information + * to pass to continuation calls. If all calls to this method are independent from one another, + * this argument should be specified as null. * - * @return an array of integers with one element for each of the characters - * in the text argument, equal to the offset of the - * corresponding character in the lean string. - * If there is no corresponding - * character in the lean string (because the - * specified character is a directional formatting character - * added when invoking {@link #leanToFullText leanToFullText}), - * the value returned for this character is -1. + * @return an array of integers with one element for each of the characters + * in the text argument, equal to the offset of the corresponding character + * in the lean string. If there is no corresponding character in the lean string + * (because the specified character is a directional formatting character added when invoking + * {@link #leanToFullText}), the value returned for this character is -1. */ public static int[] fullToLeanMap(STextProcessor processor, STextEnvironment environment, String text, int[] state) { if (processor == null) { @@ -446,44 +351,30 @@ } /** - * Given a full string, return the offsets of characters - * which are directional formatting characters that have been added - * in order to ensure correct presentation. + * Given a full string, return the offsets of characters + * which are directional formatting characters that have been added + * in order to ensure correct presentation. + *

+ * LRMs (for a string with LTR base direction), RLMs (for a string with RTL base direction) + * are considered as well as leading and trailing LRE, RLE and PDF which might be prefixed + * or suffixed depending on the {@link STextEnvironment#getOrientation orientation} + * of the GUI component used for display. + *

+ * @param processor designates a processor instance * - *

LRMs (for a string with LTR base direction), RLMs (for - * a string with RTL base direction) are considered as well as - * leading and trailing LRE, RLE and PDF which might be prefixed or suffixed - * depending on the {@link STextEnvironment#getOrientation orientation} - * of the GUI component used for display. + * @param environment specifies an environment whose characteristics may affect + * the processor's behavior. If null, the default environment is used. * - * @param processor designates a processor instance. - * For more details, see above - * How to Specify a Processor. - *

If this argument is null, this method - * returns an empty array. + * @param text is the structured text string including directional formatting characters * - * @param environment specifies an environment whose characteristics - * may affect the processor's behavior. - *

This argument may be specified as null, - * in which case the processor will assume a standard - * environment as specified in - * {@link STextEnvironment#DEFAULT}. + * @param state can be used to specify that the text argument is + * the continuation of text submitted in a previous call and/or to receive information + * to pass to continuation calls. If all calls to this method are independent from one another, + * this argument should be specified as null. * - * @param text is the structured text string including - * directional formatting characters. - * - * @param state can be used to specify that the text - * argument is the continuation of text submitted in a - * previous call and/or to receive information to pass to - * continuation calls. - * For more details, see State above. - *

If all calls to this method are independent from one another, - * this argument should be specified as null. - * - * @return an array of offsets to the characters in the text - * argument which are directional formatting characters - * added to ensure correct presentation. - * The offsets are sorted in ascending order. + * @return an array of offsets to the characters in the text argument which + * are directional formatting characters added to ensure correct presentation. The offsets + * are sorted in ascending order. */ public static int[] fullBidiCharOffsets(STextProcessor processor, STextEnvironment environment, String text, int[] state) { if (processor == null) @@ -492,31 +383,18 @@ } /** - * Get the base direction of a structured text. - * This base direction may depend on - * whether the text contains Arabic or Hebrew words - * (if it contains both, the first Arabic or Hebrew letter in the - * text determines which is the governing script) and on - * whether the GUI is {@link STextEnvironment#getMirrored mirrored}. + * Get the base direction of a structured text. This base direction may depend on + * 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. - * For more details, see above - * How to Specify a Processor. - *

If this argument is null, this method - * returns {@link #DIR_LTR}. + * @param processor designates a processor instance * - * @param environment specifies an environment whose characteristics - * may affect the processor's behavior. - *

This argument may be specified as null, - * in which case the processor will assume a standard - * environment as specified in - * {@link STextEnvironment#DEFAULT}. + * @param environment specifies an environment whose characteristics may affect + * the processor's behavior. If null, the default environment is used. * - * @param text is the structured text string. + * @param text is the structured text string * - * @return the base direction of the structured text. - * It is one of the values {@link #DIR_LTR} - * or {@link #DIR_RTL}. + * @return the base direction of the structured text, {@link #DIR_LTR} or {@link #DIR_RTL} */ public static int getCurDirection(STextProcessor processor, STextEnvironment environment, String text) { if (processor == null) diff --git a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/STextEnvironment.java b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/STextEnvironment.java index 5a6500c..0755826 100644 --- a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/STextEnvironment.java +++ b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/STextEnvironment.java @@ -10,149 +10,98 @@ ******************************************************************************/ package org.eclipse.equinox.bidi; -import java.util.Locale; import org.eclipse.equinox.bidi.internal.STextActivator; /** - * This class defines certain details of the environment within which - * structured text strings are processed. - *

- * All public fields in this class are final, i.e. cannot be - * changed after creating an instance. - *

- * All methods in {@link STextEngine} have a STextEnvironment - * argument. If this argument is specified as null, the - * {@link #DEFAULT} environment is used. - * - *

Code Samples

- *

Example (set all environment parameters) - * 

- *
- *    STextEnvironment myEnv = new STextEnvironment("he_IL", true, STextEnvironment.ORIENT_RTL);
- *
- *
- *

- * This class also provides a number of convenience methods related to the environment. - *

 

- * + * This class describes environment within which structured text strings are + * processed. It includes, for example: + * * @author Matitiahu Allouche */ public class STextEnvironment { /** - * Constant specifying that the orientation of the GUI component - * where a structured text will be displayed is LTR. - * It can appear as orientation argument for the - * {@link STextEnvironment#STextEnvironment STextEnvironment constructor} - * and as value returned by {@link #getOrientation}. + * Specifies that a GUI component should display text Left-To-Right (value is 0). */ public static final int ORIENT_LTR = 0; /** - * Constant specifying that the orientation of the GUI component - * where a structured text will be displayed is RTL. - * It can appear as orientation argument for the - * {@link STextEnvironment#STextEnvironment STextEnvironment constructor} - * and as value returned by {@link #getOrientation}. + * Specifies that a GUI component should display text Right-To-Left (value is 1). */ public static final int ORIENT_RTL = 1; /** - * Constant specifying that the orientation of the GUI component - * where a structured text will be displayed is contextual with - * a default of LTR (if no strong character appears in the text). - * It can appear as orientation argument for the - * {@link STextEnvironment#STextEnvironment STextEnvironment constructor} - * and as value returned by {@link #getOrientation}. + * Specifies that a GUI component should display text depending on the context + * with default orientation being Left-To-Right (value is 2). */ public static final int ORIENT_CONTEXTUAL_LTR = 2; /** - * Constant specifying that the orientation of the GUI component - * where a structured text will be displayed is contextual with - * a default of RTL (if no strong character appears in the text). - * It can appear as orientation argument for the - * {@link STextEnvironment#STextEnvironment STextEnvironment constructor} - * and as value returned by {@link #getOrientation}. + * Specifies that a GUI component should display text depending on the context + * with default orientation being Right-To-Left (value is 3). */ public static final int ORIENT_CONTEXTUAL_RTL = 3; /** - * Constant specifying that the orientation of the GUI component - * where a structured text will be displayed is not known. - * Directional formatting characters must be added as prefix and - * suffix whenever a full text is generated using - * {@link STextEngine#leanToFullText leanToFullText}. - * It can appear as orientation argument for the - * {@link STextEnvironment#STextEnvironment STextEnvironment constructor} - * and as value returned by {@link #getOrientation}. + * Used when the orientation of a GUI component is not known (value is 4). */ public static final int ORIENT_UNKNOWN = 4; /** - * Constant specifying that whatever the orientation of the - * GUI component where a structured text will be displayed, no - * directional formatting characters must be added as prefix or - * suffix when a full text is generated using - * {@link STextEngine#leanToFullText leanToFullText}. - * It can appear as orientation argument for the - * {@link STextEnvironment#STextEnvironment STextEnvironment constructor} - * and as value returned by {@link #getOrientation}. + * Used to specify that no directional formatting characters + * should be added as prefix or suffix (value is 5). */ public static final int ORIENT_IGNORE = 5; /** - * Pre-defined STextEnvironment instance with values - * for a non-mirrored GUI and a Left-to-Right presentation component.
- * The language is set to null, which defaults to the language - * of the current default locale. + * Pre-defined STextEnvironment instance which uses default locale, + * non-mirrored environment, and a Left-to-Right presentation component. */ public static final STextEnvironment DEFAULT = new STextEnvironment(null, false, ORIENT_LTR); /** - * This string is a 2-letters code representing a language as defined by - * ISO-639. If left as null, it defaults to the language - * of the current default locale. + * This string is a 2-letters code representing a language as defined by + * ISO-639. */ - final String language; + final private String language; /** - * Flag specifying that structured text processed under this environment - * should assume that the GUI is mirrored (globally going from right to left). + * Flag specifying that structured text processed under this environment + * should assume that the GUI is mirrored (globally going from right to left). */ - final boolean mirrored; - - /** Specify the orientation (a.k.a. base direction) of the GUI - * component in which the full structured text will - * be displayed. - */ - final int orientation; + final private boolean mirrored; /** - * Constructor + * Specify the orientation (a.k.a. base direction) of the GUI + * component in which the full structured text will + * be displayed. + */ + final private int orientation; + + /** + * Cached value that determines if the Bidi processing is needed + * in this environment. + */ + private Boolean processingNeeded; + + /** + * Creates an instance of a structured text environment. * - * @param lang represents the language to be used in this environment. - * It should be specified as a 2-letters code as defined by - * ISO-639.
- * If longer than 2 letters, the extra letters are ignored.
- * If set to null, it defaults to the language - * of the default locale. - * @see #getLanguage - * - * @param mirrored specifies if the GUI is mirrored. - * @see #getMirrored - * - * @param orientation specifies the orientation of the component - * which is to display the structured text. It must be - * one of the values - * {@link #ORIENT_LTR ORIENT_LTR}, - * {@link #ORIENT_LTR ORIENT_RTL}, - * {@link #ORIENT_CONTEXTUAL_LTR ORIENT_CONTEXTUAL_LTR}, - * {@link #ORIENT_CONTEXTUAL_RTL ORIENT_CONTEXTUAL_RTL}, - * {@link #ORIENT_UNKNOWN ORIENT_UNKNOWN} or - * {@link #ORIENT_IGNORE ORIENT_IGNORE}.
- * If different, it defaults to {@link #ORIENT_UNKNOWN ORIENT_UNKNOWN}. - * @see #getOrientation + * @param lang the language to of the environment, encoded as specified + * in ISO-639. Might be null, in which case the default + * locale is used. + * @param mirrored specifies if the environment is mirrored. + * @param orientation the orientation of the GUI component: + * {@link #ORIENT_LTR ORIENT_LTR}, + * {@link #ORIENT_LTR ORIENT_RTL}, + * {@link #ORIENT_CONTEXTUAL_LTR ORIENT_CONTEXTUAL_LTR}, + * {@link #ORIENT_CONTEXTUAL_RTL ORIENT_CONTEXTUAL_RTL}, + * {@link #ORIENT_UNKNOWN ORIENT_UNKNOWN}, or + * {@link #ORIENT_IGNORE ORIENT_IGNORE}. */ public STextEnvironment(String lang, boolean mirrored, int orientation) { if (lang != null) { @@ -161,151 +110,72 @@ else language = lang; } else - language = null; + language = STextActivator.getInstance().getDefaultLocale().getLanguage(); this.mirrored = mirrored; this.orientation = orientation >= ORIENT_LTR && orientation <= ORIENT_IGNORE ? orientation : ORIENT_UNKNOWN; } /** - * Return a 2-letters code representing a language as defined by - * ISO-639. If specified as null, it defaults to the - * language of the current default locale. + * Returns a 2-letters code representing a language as defined by + * ISO-639. + * @return language of the environment */ public String getLanguage() { - if (language != null) - return language; - return getDefaultLocale().getLanguage(); + return language; } /** - * Return a flag indicating that structured text processed - * within this environment should assume that the GUI is mirrored + * Returns a flag indicating that structured text processed + * within this environment should assume that the GUI is mirrored * (globally going from right to left). + * @return true if environment is mirrored */ public boolean getMirrored() { return mirrored; } - /** Return the orientation (a.k.a. base direction) of the GUI - * component in which the full structured text - * will be displayed.
- * The orientation must have one of the values - * {@link #ORIENT_LTR ORIENT_LTR}, - * {@link #ORIENT_LTR ORIENT_RTL}, - * {@link #ORIENT_CONTEXTUAL_LTR ORIENT_CONTEXTUAL_LTR}, - * {@link #ORIENT_CONTEXTUAL_RTL ORIENT_CONTEXTUAL_RTL}, - * {@link #ORIENT_UNKNOWN ORIENT_UNKNOWN} or - * {@link #ORIENT_IGNORE ORIENT_IGNORE}. - *

- * When the orientation is ORIENT_LTR and the - * structured text has a RTL base direction, - * {@link STextEngine#leanToFullText leanToFullText} - * adds RLE+RLM at the head of the full text and RLM+PDF at its - * end. - *

- * When the orientation is ORIENT_RTL and the - * structured text has a LTR base direction, - * {@link STextEngine#leanToFullText leanToFullText} - * adds LRE+LRM at the head of the full text and LRM+PDF at its - * end. - *

- * When the orientation is ORIENT_CONTEXTUAL_LTR or - * ORIENT_CONTEXTUAL_RTL and the data content would resolve - * to a RTL orientation while the structured text has a LTR base - * direction, {@link STextEngine#leanToFullText leanToFullText} - * adds LRM at the head of the full text. - *

- * When the orientation is ORIENT_CONTEXTUAL_LTR or - * ORIENT_CONTEXTUAL_RTL and the data content would resolve - * to a LTR orientation while the structured text has a RTL base - * direction, {@link STextEngine#leanToFullText leanToFullText} - * adds RLM at the head of the full text. - *

- * When the orientation is ORIENT_UNKNOWN and the - * structured text has a LTR base direction, - * {@link STextEngine#leanToFullText leanToFullText} - * adds LRE+LRM at the head of the full text and LRM+PDF at its - * end. - *

- * When the orientation is ORIENT_UNKNOWN and the - * structured text has a RTL base direction, - * {@link STextEngine#leanToFullText leanToFullText} - * adds RLE+RLM at the head of the full text and RLM+PDF at its - * end. - *

- * When the orientation is ORIENT_IGNORE, - * {@link STextEngine#leanToFullText leanToFullText} does not add any directional - * formatting characters as either prefix or suffix of the full text. - *

+ /** + * Returns the orientation (a.k.a. base direction) of the GUI + * component in which the full structured text + * will be displayed. + *

+ * The orientation values: + *

+ *

*/ public int getOrientation() { return orientation; } /** - * Check whether the current language uses a - * bidi script (Arabic, Hebrew, Farsi or Urdu). - * - * @return true if the current language uses a bidi script. - * The language may have been set explicitly when creating the - * STextEnvironment instance, or it may have - * defaulted to the language of the current default locale. - * @see #getLanguage + * Checks if bidi processing is needed in this environment. + * @return true if bidi processing is needed in this environment */ - public boolean isBidi() { - if (language != null) - return isBidiLanguage(language); - return isBidiLanguage(getDefaultLocale().getLanguage()); - } - - boolean isBidiLanguage(String lang) { - return "iw".equals(lang) || "he".equals(lang) || "ar".equals(lang) || "fa".equals(lang) || "ur".equals(lang); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ - } - - static String lineSep; - - /** - * Retrieve the string which represents a line separator in this environment. - * - * @return the string which is used as line separator (e.g. CRLF). - */ - public static String getLineSep() { - // use bundle properties - if (lineSep == null) { - // lineSep = System.getProperty("line.separator", "\n"); //$NON-NLS-1$//$NON-NLS-2$ - lineSep = getProperty("line.separator"); //$NON-NLS-1$/ + public boolean isProcessingNeeded() { + if (processingNeeded == null) { + String osName = STextActivator.getInstance().getProperty("os.name"); //$NON-NLS-1$/ + if (osName != null) + osName = osName.toLowerCase(); + boolean supportedOS = osName.startsWith("windows") || osName.startsWith("linux"); //$NON-NLS-1$ //$NON-NLS-2$ + if (supportedOS) { + // Check whether the current language uses a bidi script (Arabic, Hebrew, Farsi or Urdu) + boolean isBidi = "iw".equals(language) || //$NON-NLS-1$ + "he".equals(language) || //$NON-NLS-1$ + "ar".equals(language) || //$NON-NLS-1$ + "fa".equals(language) || //$NON-NLS-1$ + "ur".equals(language); //$NON-NLS-1$ + processingNeeded = new Boolean(isBidi); + } else { + processingNeeded = new Boolean(false); + } } - return lineSep; + return processingNeeded.booleanValue(); } - - static String osName; - static boolean flagOS; - - private static String getProperty(String key) { - // use bundle properties - // osName = System.getProperty("os.name").toLowerCase(); //$NON-NLS-1$ - STextActivator sTextActivator = STextActivator.getInstance(); - return sTextActivator.getProperty(key); - } - - private Locale getDefaultLocale() { - STextActivator sTextActivator = STextActivator.getInstance(); - return sTextActivator.getDefaultLocale(); - } - - /** - * Check if the current OS is supported by the structured text packages. - * - * @return true if the current OS is supported. - */ - public static boolean isSupportedOS() { - if (osName == null) { - // use bundle properties - // osName = System.getProperty("os.name").toLowerCase(); //$NON-NLS-1$ - osName = getProperty("os.name").toLowerCase(); //$NON-NLS-1$/ - flagOS = osName.startsWith("windows") || osName.startsWith("linux"); //$NON-NLS-1$ //$NON-NLS-2$ - } - return flagOS; - } - } diff --git a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/STextStringRecord.java b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/STextStringRecord.java index 76bd6f8..6dfa2a1 100644 --- a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/STextStringRecord.java +++ b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/STextStringRecord.java @@ -14,19 +14,19 @@ import org.eclipse.equinox.bidi.custom.STextProcessor; /** - * This class records strings which contain structured text. Several static - * methods in this class allow to record such strings in a pool, and to find if - * a given string is member of the pool. - *

- * Instances of this class are the records which are members of the pool. - *

- * The pool is managed as a cyclic list. When the pool is full, - * each new element overrides the oldest element in the list. - *

- * 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. + * This class records strings which contain structured text. Several static + * methods in this class allow to record such strings in a pool, and to find if + * a given string is member of the pool. + *

+ * Instances of this class are the records which are members of the pool. + *

+ * The pool is managed as a cyclic list. When the pool is full, + * each new element overrides the oldest element in the list. + *

+ * 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 { /** @@ -67,42 +67,42 @@ private short[] boundaries; /** - * Constructor + * Constructor */ private STextStringRecord() { // inhibit creation of new instances by customers } /** - * 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. + * 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 string the string to record. * - * @param segmentCount number of segments allowed in this string. - * This number must be >= 1. + * @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 - * appearing in {@link STextEngine}, or it may be an instance - * created by a plug-in or by the application. + * @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 + * appearing in {@link STextEngine}, 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 - * segment. It must be >= 0 and less than the length of the string. + * @param start offset in the string of the starting character of the first + * segment. It must be >= 0 and less than the length of the string. * - * @param limit offset of the character following the first segment. It - * must be greater than the start argument and - * not greater than the length of the string. + * @param limit offset of the character following the first segment. It + * must be greater than the start argument and + * not greater than the length of the string. * - * @return an instance of STextRecordString which represents this record. - * This instance may be used to specify additional segment with - * {@link #addSegment addSegment}. + * @return an instance of STextRecordString which represents this record. + * This instance may be used to specify additional segment with + * {@link #addSegment addSegment}. * - * @throws IllegalArgumentException if string is null or - * if segmentCount is less than 1. - * @throws also the same exceptions as {@link #addSegment addSegment}. + * @throws IllegalArgumentException if string is null or + * if segmentCount is less than 1. + * @throws also the same exceptions as {@link #addSegment addSegment}. */ public static STextStringRecord addRecord(String string, int segmentCount, STextProcessor processor, int start, int limit) { if (string == null) @@ -139,28 +139,28 @@ } /** - * Add a second or further segment to a 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 - * appearing in {@link STextEngine}, or it may be an instance - * created by a plug-in or by the application. + * @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 + * appearing in {@link STextEngine}, 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 - * segment. It must be >= 0 and less than the length of the string. + * @param start offset in the string of the starting character of the + * segment. It must be >= 0 and less than the length of the string. * - * @param limit offset of the character following the segment. It must be - * greater than the start argument and not greater - * than the length of the string. + * @param limit offset of the character following the segment. It must be + * greater than the start argument and not greater + * than the length of the string. * - * @throws IllegalArgumentException if processor is null, - * or if start or limit have invalid - * values. - * @throws IllegalStateException if the current segment exceeds the - * number of segments specified by segmentCount - * in the call to {@link #addRecord addRecord} which created - * the STextStringRecord instance. + * @throws IllegalArgumentException if processor is null, + * or if start or limit have invalid + * values. + * @throws IllegalStateException if the current segment exceeds the + * number of segments specified by segmentCount + * in the call to {@link #addRecord addRecord} which created + * the STextStringRecord instance. */ public void addSegment(STextProcessor processor, int start, int limit) { if (processor == null) @@ -178,21 +178,21 @@ } /** - * Check if a string is recorded and retrieve its record. + * Check if a string is recorded and retrieve its record. * - * @param string the string to check. + * @param string the string to check. * - * @return null if the string is not recorded in the pool; - * otherwise, return the STextStringRecord instance which - * records this string.
- * 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 - * be retrieved using {@link #getLimit getLimit}, + * @return null if the string is not recorded in the pool; + * otherwise, return the STextStringRecord instance which + * records this string.
+ * 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 + * be retrieved using {@link #getLimit getLimit}, */ public static STextStringRecord getRecord(String string) { if (last < 0) // no records at all @@ -226,10 +226,8 @@ } /** - * Retrieve the number of segments in a record. - * - * @return the number of segments in the current record. This number - * is always >= 1. + * Retrieve the number of segments in a record. + * @return the number of segments in the current record */ public int getSegmentCount() { return usedSegmentCount; @@ -241,21 +239,21 @@ } /** - * Retrieve the processor of a given segment. + * 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 - * segments specified by segmentCount - * in the call to {@link #addRecord addRecord} which created - * the STextStringRecord instance. + * @param segmentNumber number of the segment about which information + * is required. It must be >= 0 and less than the number of + * segments specified by segmentCount + * 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 segmentNumber. + * @return the processor to handle the structured text in the segment + * specified by segmentNumber. * - * @throws IllegalArgumentException if segmentNumber - * has an invalid value. + * @throws IllegalArgumentException if segmentNumber + * has an invalid value. * - * @see #getSegmentCount getSegmentCount + * @see #getSegmentCount */ public STextProcessor getProcessor(int segmentNumber) { checkSegmentNumber(segmentNumber); @@ -263,21 +261,21 @@ } /** - * Retrieve the starting offset of a given segment. + * Retrieve the starting offset 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 - * segments specified by segmentCount - * in the call to {@link #addRecord addRecord} which created - * the STextStringRecord instance. + * @param segmentNumber number of the segment about which information + * is required. It must be >= 0 and less than the number of + * segments specified by segmentCount + * in the call to {@link #addRecord addRecord} which created + * the STextStringRecord instance. * - * @return the starting offset within the string of the segment - * specified by segmentNumber. + * @return the starting offset within the string of the segment + * specified by segmentNumber. * - * @throws IllegalArgumentException if segmentNumber - * has an invalid value. + * @throws IllegalArgumentException if segmentNumber + * has an invalid value. * - * @see #getSegmentCount getSegmentCount + * @see #getSegmentCount */ public int getStart(int segmentNumber) { checkSegmentNumber(segmentNumber); @@ -285,21 +283,21 @@ } /** - * Retrieve the ending offset of a given segment. + * Retrieve the ending offset 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 - * segments specified by segmentCount - * in the call to {@link #addRecord addRecord} which created - * the STextStringRecord instance. + * @param segmentNumber number of the segment about which information + * is required. It must be >= 0 and less than the number of + * segments specified by segmentCount + * in the call to {@link #addRecord addRecord} which created + * the STextStringRecord instance. * - * @return the offset of the position following the segment - * specified by segmentNumber. + * @return the offset of the position following the segment + * specified by segmentNumber. * - * @throws IllegalArgumentException if segmentNumber - * has an invalid value. + * @throws IllegalArgumentException if segmentNumber + * has an invalid value. * - * @see #getSegmentCount getSegmentCount + * @see #getSegmentCount */ public int getLimit(int segmentNumber) { checkSegmentNumber(segmentNumber); @@ -307,9 +305,8 @@ } /** - * Clear the pool. All elements of the pool are erased and any associated - * memory is freed. - * + * Clear the pool. All elements of the pool are erased and any associated + * memory is freed. */ public static synchronized void clear() { for (int i = 0; i <= MAXINDEX; i++) { diff --git a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/STextUtil.java b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/STextUtil.java index f261833..32c4859 100644 --- a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/STextUtil.java +++ b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/STextUtil.java @@ -23,60 +23,60 @@ */ public final class STextUtil { - static class MyProcessor extends STextProcessor { - String separ; + /** + * The default set of separators used to segment a string: dot, colon, slash, backslash. + */ + public static final String defaultSeparators = ".:/\\"; //$NON-NLS-1$ - MyProcessor(String separators) { - separ = separators; - } + // left to right mark + private static final char LRM = '\u200e'; - public String getSeparators(STextEnvironment environment, String text, byte[] dirProps) { - return separ; - } - } + // 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'; /** - * prevent instantiation + * Prevents instantiation. */ private STextUtil() { // empty } - /** This is a convenience method which can add directional marks in a given - * text before the characters specified in the given array of offsets, - * and can add a prefix and/or a suffix of directional formatting characters. - * This can be used for instance after obtaining offsets by calling - * {@link STextEngine#leanBidiCharOffsets leanBidiCharOffsets} in order to - * produce a full text corresponding to the source text. - * The directional formatting characters that will be added at the given - * offsets will be LRMs for structured text strings with LTR base direction - * and RLMs for strings with RTL base direction. Leading and - * trailing LRE, RLE and PDF which might be needed as prefix or suffix - * depending on the orientation of the GUI component used for display - * may be added depending on argument affix. - * - * @param text is the structured text string - * - * @param offsets is an array of offsets to characters in text - * before which an LRM or RLM will be inserted. - * Members of the array must be non-negative numbers smaller - * than the length of text. - * The array must be sorted in ascending order without duplicates. - * This argument may be null if there are no marks to add. - * - * @param direction specifies the base direction of the structured text. - * It must be one of the values {@link STextEngine#DIR_LTR} or - * {@link STextEngine#DIR_RTL}. - * - * @param affix specifies if a prefix and a suffix should be added to - * the result to make sure that the direction - * specified as third argument is honored even if the string - * is displayed in a GUI component with a different orientation. - * - * @return a string corresponding to the source text 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. + /** + * 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. + *

+ * The directional marks will be LRMs for structured text strings with LTR base + * direction and RLMs for strings with RTL base direction. + *

+ * If necessary, leading and trailing directional markers (LRE, RLE and PDF) can + * be added depending on the value of the affix argument. + *

+ * @see STextEngine#leanBidiCharOffsets(STextProcessor, STextEnvironment, String, int[]) + * + * @param text the structured text string + * @param offsets an array of offsets to characters in text + * before which an LRM or RLM will be inserted. + * The array must be sorted in ascending order without duplicates. + * This argument may be null if there are no marks to add. + * @param direction the base direction of the structured text. + * It must be one of the values {@link STextEngine#DIR_LTR}, or + * {@link STextEngine#DIR_RTL}. + * @param affix specifies if a prefix and a suffix should be added to + * the result + * @return a string corresponding to the source text 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(); @@ -118,83 +118,48 @@ return full; } - /*************************************************************************/ - /* */ - /* The following code is provided for compatibility with TextProcessor */ - /* */ - /*************************************************************************/ - - // The default set of separators to use to segment a string. - private 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'; - - static boolean isProcessingNeeded() { - if (!STextEnvironment.isSupportedOS()) - return false; - return STextEnvironment.DEFAULT.isBidi(); - } - /** * Process the given text and return a string with appropriate - * directional formatting characters if the locale is a bidi locale. - * This is equivalent to calling + * directional formatting characters. This is equivalent to calling * {@link #process(String str, String separators)} with the default - * set of separators (dot, colon, slash, backslash). - * - * @param str the text to be processed. - * - * @return the processed string. + * set of separators. + *

+ * 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. + *

+ * For example, a file path such as d:\myfolder\FOLDER\MYFILE.java + * (where capital letters indicate RTL text) should render as + * d:\myfolder\REDLOF\ELIFYM.java. + *

+ * @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. This is done by adding 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. - *

- * For example, a file path such as d:\myfolder\FOLDER\MYFILE.java - * (where capital letters indicate RTL text) should render as - * d:\myfolder\REDLOF\ELIFYM.java.

- *

- * NOTE: this method inserts directional formatting characters into the - * text. Methods like String.equals(String) and - * String.length() called on the resulting string will not - * return the same values as would be returned for the original string.

- * - * @param str the text to process. - * - * @param separators separators by which the string will be segmented. - * If null, the default separators are used - * (dot, colon, slash, backslash). - * - * @return the processed string. - * If str is null, - * or of length 0, or if the current locale is not a bidi one, - * return the original string. + * 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) || !isProcessingNeeded()) + 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 @@ -222,46 +187,20 @@ separators = defaultSeparators; // make sure that LRE/PDF are added around the string - STextEnvironment env = new STextEnvironment(null, false, STextEnvironment.ORIENT_UNKNOWN); - STextProcessor processor = new MyProcessor(separators); + STextProcessor processor = new STextProcessor(separators); return STextEngine.leanToFullText(processor, env, str, null); } /** - * Process a string that has a particular semantic meaning to render - * it correctly on bidi locales. This is done by adding directional - * formatting characters so that presentation using the Unicode - * Bidirectional Algorithm will provide the expected result.. - * The text is segmented according to the syntax specified in the - * type argument. - * Each segment has the Unicode Bidi Algorithm applied to it, but the - * order of the segments is governed by the type of the structured text. - *

- * For example, a file path such as d:\myfolder\FOLDER\MYFILE.java - * (where capital letters indicate RTL text) should render as - * d:\myfolder\REDLOF\ELIFYM.java.

- *

- * NOTE: this method inserts directional formatting characters into the - * text. Methods like String.equals(String) and - * String.length() called on the resulting string will not - * return the same values as would be returned for the original string.

- * - * @param str the text to process. - * - * @param processor specifies a processor instance appropriate for - * the type of the structured text. It will usually be - * one of the pre-defined processor instances appearing in - * {@link STextEngine}, but can be an instance - * added by a plug-in extension or an instance of a - * processor defined in the application itself. - * - * @return the processed string. - * If str is null, - * or of length 0, or if the current locale is not a bidi one, - * return the original string. + * 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 processTyped(String str, STextProcessor processor) { - if ((str == null) || (str.length() <= 1) || !isProcessingNeeded()) + 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. @@ -271,19 +210,21 @@ // make sure that LRE/PDF are added around the string STextEnvironment env = new STextEnvironment(null, false, STextEnvironment.ORIENT_UNKNOWN); + if (!env.isProcessingNeeded()) + return str; return STextEngine.leanToFullText(processor, env, str, null); } /** - * Remove directional formatting characters in the given string that - * were inserted by one of the {@link #process process} methods. - * - * @param str string with directional characters to remove. - * - * @return string with no directional formatting characters. + * 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) || !isProcessingNeeded()) + 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(); @@ -305,22 +246,19 @@ } /** - * Remove directional formatting characters in the given string that - * were inserted by the {@link #processTyped processTyped} method. - * - * @param str string with directional characters to remove. - * - * @param processor to handle the structured text as specified when - * calling {@link #processTyped processTyped}. - * - * @return string with no directional formatting characters. + * 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) || !isProcessingNeeded()) + 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; return STextEngine.fullToLeanText(processor, env, str, null); } diff --git a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/custom/STextProcessor.java b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/custom/STextProcessor.java index 8401d9c..8889373 100644 --- a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/custom/STextProcessor.java +++ b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/custom/STextProcessor.java @@ -57,76 +57,80 @@ * conditionally (by calling {@link #processSeparator processSeparator}). * * - * @author Matitiahu Allouche + * @see STextEngine + * @author Matitiahu Allouche */ -public abstract class STextProcessor { +public class STextProcessor { + + final private String separators; /** - * Locate occurrences of special strings within a structured text - * and return their indexes one after the other in successive calls. - *

- * This method is called repeatedly from the code implementing - * {@link STextEngine#leanToFullText leanToFullText} if the - * number of special cases returned by {@link #getSpecialsCount getSpecialsCount} - * is greater than zero. - *

- * The code implementing this method may use the following methods: - *

+ * 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. + *

+ * This method is called repeatedly from the code implementing + * {@link STextEngine#leanToFullText} if the number of special cases + * returned by {@link #getSpecialsCount} is greater than zero. + *

+ * A processor handling special cases must override this method. + *

+ * @param environment the current environment, which may affect the behavior of + * the processor. This parameter may be specified as + * null, in which case the + * {@link STextEnvironment#DEFAULT DEFAULT} + * environment should be assumed. * - * @param environment the current environment, which may affect the behavior of - * the processor. This parameter may be specified as - * null, 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 text is the structured text string before - * addition of any directional formatting characters. + * @param dirProps is a parameter received by indexOfSpecial + * uniquely to be used as argument for calls to methods which + * need it. * - * @param dirProps is a parameter received by indexOfSpecial - * uniquely to be used as argument for calls to methods which - * need it. + * @param offsets is a parameter received by indexOfSpecial + * uniquely to be used as argument for calls to methods which + * need it. * - * @param offsets is a parameter received by indexOfSpecial - * 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 indexOfSpecial. * - * @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 indexOfSpecial. + * @param fromIndex the index within text to start + * the search from. * - * @param fromIndex the index within text to start - * the search from. + * @return the position where the start of the special case + * corresponding to caseNumber was located. + * The method must return the first occurrence of whatever + * identifies the start of the special case starting from + * fromIndex. 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). + *
If no occurrence is found, the method must return -1. * - * @return the position where the start of the special case - * corresponding to caseNumber was located. - * The method must return the first occurrence of whatever - * identifies the start of the special case starting from - * fromIndex. 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). - *
If no occurrence is found, the method must return -1. - * - * @throws IllegalStateException - * - *

If not overridden, this method throws an - * IllegalStateException. This is appropriate behavior - * (and does not need to be overridden) for processors whose - * number of special cases is zero, which means that - * indexOfSpecial should never be called for them. - * - *

A processor handling special cases must override this method. + * @throws IllegalStateException If not overridden, this method throws an + * IllegalStateException. This is appropriate behavior + * (and does not need to be overridden) for processors whose + * number of special cases is zero, which means that + * indexOfSpecial should never be called for them. */ public int indexOfSpecial(STextEnvironment environment, String text, byte[] dirProps, int[] offsets, int caseNumber, int fromIndex) { // This method must be overridden by all subclasses with special cases. @@ -134,98 +138,83 @@ } /** - * This method handles special cases specific to this processor. - * It is called by {@link STextEngine#leanToFullText leanToFullText} - * when a special case occurrence is located by - * {@link #indexOfSpecial indexOfSpecial}. - *

- * The code implementing this method may use the following methods: - *

- *

- * If a special processing cannot be completed within a current call to - * processSpecial (for instance, a comment has been started - * in the current line but its end appears in a following line), - * processSpecial should specify a final state by - * putting its value in the first element of the state - * parameter. - * The meaning of this state is internal to the processor. - * On a later call to - * {@link STextEngine#leanToFullText leanToFullText} - * specifying that state value, processSpecial will be - * called with that value for parameter caseNumber and - * -1 for parameter separLocation and should - * perform whatever initializations are required depending on the state. + * This method handles special cases specific to this processor. + * It is called by {@link STextEngine#leanToFullText} when a special case occurrence + * is located by {@link #indexOfSpecial}. + *

+ * If a special processing cannot be completed within a current call to + * processSpecial (for instance, a comment has been started + * in the current line but its end appears in a following line), + * processSpecial should specify a final state by + * putting its value in the first element of the state + * parameter. + * The meaning of this state is internal to the processor. + * On a later call to {@link STextEngine#leanToFullText} specifying that + * state value, processSpecial will be called with that value + * for parameter caseNumber and -1 for parameter + * separLocation and should perform whatever initializations are required + * depending on the state. + *

+ * A processor handling special cases (with a number of + * special cases greater than zero) must override this method. + *

+ * @param environment the current environment, which may affect the behavior of + * the processor. This parameter may be specified as + * null, in which case the + * {@link STextEnvironment#DEFAULT DEFAULT} + * environment should be assumed. * - * @param environment the current environment, which may affect the behavior of - * the processor. This parameter may be specified as - * null, 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 text is the structured text string before - * addition of any directional formatting characters. + * @param dirProps is a parameter received by processSpecial + * uniquely to be used as argument for calls to methods which + * need it. * - * @param dirProps is a parameter received by processSpecial - * uniquely to be used as argument for calls to methods which - * need it. + * @param offsets is a parameter received by processSpecial + * uniquely to be used as argument for calls to methods which + * need it. * - * @param offsets is a parameter received by processSpecial - * 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 + * leanToFullText (for instance, a comment or a + * literal started but not closed in the current + * text), it must put a value in the first element + * of the state 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 state argument + * in the next call to leanToFullText together + * with the continuation text. + * The meaning of this number is internal to the processor. * - * @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 - * leanToFullText (for instance, a comment or a - * literal started but not closed in the current - * text), it must put a value in the first element - * of the state 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 state argument - * in the next call to leanToFullText 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 caseNumber number of the special case to handle. + * @param separLocation the position returned by + * {@link #indexOfSpecial indexOfSpecial}. In calls to + * {@link STextEngine#leanToFullText leanToFullText} and other + * methods of {@link STextEngine} specifying a non-null + * state parameter, processSpecial is + * called when initializing the processing with the value of + * caseNumber equal to the value returned in the + * first element of state and the value of + * separLocation equal to -1. * - * @param separLocation the position returned by - * {@link #indexOfSpecial indexOfSpecial}. In calls to - * {@link STextEngine#leanToFullText leanToFullText} and other - * methods of {@link STextEngine} specifying a non-null - * state parameter, processSpecial is - * called when initializing the processing with the value of - * caseNumber equal to the value returned in the - * first element of state and the value of - * separLocation equal to -1. + * @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. + *
A value greater or equal to the length of text + * means that there is no further occurrence of this case in the + * current structured text. * - * @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. - *
A value greater or equal to the length of text - * means that there is no further occurrence of this case in the - * current structured text. - * - * @throws IllegalStateException - * - *

If not overridden, this method throws an - * IllegalStateException. This is appropriate behavior - * (and does not need to be overridden) for processors whose - * number of special cases is zero, which means that - * processSpecial should never be called for them. - * - *

A processor handling special cases (with a number of - * special cases greater than zero) must override this method. + * @throws IllegalStateException If not overridden, this method throws an + * IllegalStateException. This is appropriate behavior + * (and does not need to be overridden) for processors whose + * number of special cases is zero, which means that + * processSpecial should never be called for them. */ public int processSpecial(STextEnvironment environment, String text, byte[] dirProps, int[] offsets, int[] state, int caseNumber, int separLocation) { // This method must be overridden by all subclasses with any special case. @@ -233,248 +222,238 @@ } /** - * This method can be called from within - * {@link #indexOfSpecial indexOfSpecial} or - * {@link #processSpecial processSpecial} in extensions of - * STextProcessor to retrieve the - * bidirectional class of characters in the lean text. + * This method can be called from within {@link #indexOfSpecial} or + * {@link #processSpecial} in extensions of STextProcessor to retrieve + * the bidirectional class of characters in the lean text. * - * @param text is the structured text string received as - * parameter to indexOfSpecial or - * processSpecial. + * @param text is the structured text string received as + * parameter to indexOfSpecial or + * processSpecial. * - * @param dirProps is a parameter received by indexOfSpecial - * or processSpecial, uniquely to be used as argument - * for calls to getDirProp and other methods used - * by processors. + * @param dirProps is a parameter received by indexOfSpecial + * or processSpecial, uniquely to be used as argument + * for calls to getDirProp and other methods used + * by processors. * - * @param index position of the character in the lean text. - * It must be a non-negative number smaller than the length - * of the lean text. + * @param index position of the character in the lean text. + * It must be a non-negative number smaller than the length + * of the lean text. * - * @return the bidirectional class of the character. It is one of the - * values which can be returned by - * java.lang.Character.getDirectionality. - * However, it is recommended to use getDirProp - * rather than java.lang.Character.getDirectionality - * since getDirProp manages a cache of character - * properties and so can be more efficient than calling the - * java.lang.Character method. + * @return the bidirectional class of the character. It is one of the + * values which can be returned by + * java.lang.Character.getDirectionality. + * However, it is recommended to use getDirProp + * rather than java.lang.Character.getDirectionality + * since getDirProp manages a cache of character + * properties and so can be more efficient than calling the + * java.lang.Character method. */ public static final byte getDirProp(String text, byte[] dirProps, int index) { return STextImpl.getDirProp(text, dirProps, index); } /** - * This method can be called from within - * {@link #indexOfSpecial indexOfSpecial} or - * {@link #processSpecial processSpecial} in extensions of - * STextProcessor to set or - * override the bidirectional class of characters in the lean text. + * This method can be called from within {@link #indexOfSpecial} or + * {@link #processSpecial} in extensions of STextProcessor to set or + * override the bidirectional class of characters in the lean text. * - * @param dirProps is a parameter received by indexOfSpecial - * or processSpecial, uniquely to be used as argument - * for calls to setDirProp and other methods used - * by processors. + * @param dirProps is a parameter received by indexOfSpecial + * or processSpecial, uniquely to be used as argument + * for calls to setDirProp and other methods used + * by processors. * - * @param index position of the character in the lean text. - * It must be a non-negative number smaller than the length - * of the lean text. + * @param index position of the character in the lean text. + * It must be a non-negative number smaller than the length + * of the lean text. * - * @param dirProp bidirectional class of the character. It must be - * one of the values which can be returned by - * java.lang.Character.getDirectionality. + * @param dirProp bidirectional class of the character. It must be + * one of the values which can be returned by + * java.lang.Character.getDirectionality. */ public static final void setDirProp(byte[] dirProps, int index, byte dirProp) { STextImpl.setDirProp(dirProps, index, dirProp); } /** - * This method can be called from within - * {@link #indexOfSpecial indexOfSpecial} or - * {@link #processSpecial processSpecial} in extensions of - * STextProcessor - * to specify that a mark character must be added before the character - * at the specified position of the lean text when generating the - * full 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 full text. + * This method can be called from within {@link #indexOfSpecial} or + * {@link #processSpecial} in extensions of STextProcessor + * to specify that a mark character must be added before the character + * at the specified position of the lean text when generating the + * full 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 full text. * - * @param text is the structured text string received as - * parameter to indexOfSpecial or - * processSpecial. + * @param text is the structured text string received as + * parameter to indexOfSpecial or + * processSpecial. * - * @param dirProps is a parameter received by indexOfSpecial - * or processSpecial, uniquely to be used as argument - * for calls to insertMark and other methods used - * by processors. + * @param dirProps is a parameter received by indexOfSpecial + * or processSpecial, uniquely to be used as argument + * for calls to insertMark and other methods used + * by processors. * - * @param offsets is a parameter received by indexOfSpecial - * or processSpecial, uniquely to be used as argument - * for calls to insertMark and other methods used - * by processors. + * @param offsets is a parameter received by indexOfSpecial + * or processSpecial, uniquely to be used as argument + * for calls to insertMark and other methods used + * by processors. * - * @param offset position of the character in the lean text. - * It must be a non-negative number smaller than the length - * of the lean text. - * For the benefit of efficiency, it is better to insert - * multiple marks in ascending order of the offsets. + * @param offset position of the character in the lean text. + * It must be a non-negative number smaller than the length + * of the lean 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, byte[] dirProps, int[] offsets, int offset) { STextImpl.insertMark(text, dirProps, offsets, offset); } /** - * This method can be called from within - * {@link #indexOfSpecial indexOfSpecial} or - * {@link #processSpecial processSpecial} in extensions of - * STextProcessor 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 lean text preceding and following - * the separator itself. + * This method can be called from within {@link #indexOfSpecial} or + * {@link #processSpecial} in extensions of STextProcessor 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 lean text preceding and following the separator itself. + *

+ * The logic implemented in this method considers the text before + * separLocation 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 full text. + *

+ * @param text is the structured text string received as + * parameter to indexOfSpecial or + * processSpecial. * - *

The logic implemented in this method considers the text before - * separLocation 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 full text. + * @param dirProps is a parameter received by indexOfSpecial + * or processSpecial, uniquely to be used as argument + * for calls to processSeparator and other methods used + * by processors. * - * @param text is the structured text string received as - * parameter to indexOfSpecial or - * processSpecial. + * @param offsets is a parameter received by indexOfSpecial + * or processSpecial, uniquely to be used as argument + * for calls to processSeparator and other methods used + * by processors. * - * @param dirProps is a parameter received by indexOfSpecial - * or processSpecial, uniquely to be used as argument - * for calls to processSeparator and other methods used - * by processors. - * - * @param offsets is a parameter received by indexOfSpecial - * or processSpecial, uniquely to be used as argument - * for calls to processSeparator and other methods used - * by processors. - * - * @param separLocation offset of the separator in the lean text. - * It must be a non-negative number smaller than the length - * of the lean text. + * @param separLocation offset of the separator in the lean text. + * It must be a non-negative number smaller than the length + * of the lean text. */ public static final void processSeparator(String text, byte[] dirProps, int[] offsets, int separLocation) { STextImpl.processSeparator(text, dirProps, offsets, separLocation); } /** - * Indicate the separators to use for the current processor. - * This methode is invoked before starting the processing. + * Indicate the separators to use for the current processor. + * This method is invoked before starting the processing. + *

+ * If no separators are specified, this method returns an empty string. + *

+ * @param environment the current environment, which may affect the behavior of + * the processor. This parameter may be specified as + * null, in which case the + * {@link STextEnvironment#DEFAULT DEFAULT} + * environment should be assumed. * - * @param environment the current environment, which may affect the behavior of - * the processor. This parameter may be specified as - * null, in which case the - * {@link STextEnvironment#DEFAULT DEFAULT} - * environment should be assumed. + * @param text is the structured text string to process. * - * @param text is the structured text string to process. + * @param dirProps is a parameter received uniquely to be used as argument + * for calls to getDirProp and other methods used + * by processors. * - * @param dirProps is a parameter received uniquely to be used as argument - * for calls to getDirProp and other methods used - * by processors. - * - * @return a string grouping one-character separators which separate - * the structured text into tokens. - * - *

If not overridden, this method returns an empty string; + * @return a string grouping one-character separators which separate + * the structured text into tokens. */ public String getSeparators(STextEnvironment environment, String text, byte[] dirProps) { - return ""; //$NON-NLS-1$ + return separators; } /** - * Indicate the base text direction appropriate for an instance - * of structured text. - * This methode is invoked before starting the processing. + * Indicate the base text direction appropriate for an instance of structured text. + * This method is invoked before starting the processing. + *

+ * If not overridden, this method returns DIR_LTR. + *

+ * @param environment the current environment, which may affect the behavior of + * the processor. This parameter may be specified as + * null, in which case the + * {@link STextEnvironment#DEFAULT DEFAULT} + * environment should be assumed. * - * @param environment the current environment, which may affect the behavior of - * the processor. This parameter may be specified as - * null, in which case the - * {@link STextEnvironment#DEFAULT DEFAULT} - * environment should be assumed. + * @param text is the structured text string to process. * - * @param text is the structured text string to process. + * @param dirProps is a parameter received uniquely to be used as argument + * for calls to getDirProp and other methods used + * by processors. * - * @param dirProps is a parameter received uniquely to be used as argument - * for calls to getDirProp 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.
- * The value returned is either - * {@link STextEngine#DIR_LTR DIR_LTR} or {@link STextEngine#DIR_RTL DIR_RTL}. - * - *

If not overridden, this method returns DIR_LTR. + * @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.
+ * The value returned is either + * {@link STextEngine#DIR_LTR DIR_LTR} or {@link STextEngine#DIR_RTL DIR_RTL}. */ public int getDirection(STextEnvironment environment, String text, byte[] dirProps) { return STextEngine.DIR_LTR; } /** - * Indicate the number of special cases handled by the current processor. - * This methode is invoked before starting the processing. - * If the number returned is zero, - * {@link #indexOfSpecial indexOfSpecial} and - * {@link #processSpecial processSpecial} will not be invoked. + * 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. + *

+ * If not overridden, this method returns zero. + *

+ * @param environment the current environment, which may affect the behavior of + * the processor. This parameter may be specified as + * null, in which case the + * {@link STextEnvironment#DEFAULT DEFAULT} + * environment should be assumed. * - * @param environment the current environment, which may affect the behavior of - * the processor. This parameter may be specified as - * null, in which case the - * {@link STextEnvironment#DEFAULT DEFAULT} - * environment should be assumed. + * @param text is the structured text string to process. * - * @param text is the structured text string to process. + * @param dirProps is a parameter received uniquely to be used as argument + * for calls to getDirProp and other methods used + * by processors. * - * @param dirProps is a parameter received uniquely to be used as argument - * for calls to getDirProp and other methods used - * by processors. + * @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. * - * @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 indexOfSpecial} and - * {@link STextProcessor#processSpecial processSpecial}. - * Examples of special cases are comments, literals, or - * anything which is not identified by a one-character separator. - * - *

If not overridden, this method returns zero. */ public int getSpecialsCount(STextEnvironment environment, String text, byte[] dirProps) { return 0; } /** - * Check if there is a need for processing structured text. - * This methode is invoked before starting the processing. If the - * processor returns true, no directional formatting - * characters are added to the lean text and the processing - * is shortened. + * Checks if there is a need for processing structured text. + * This method is invoked before starting the processing. If the + * processor returns true, no directional formatting + * characters are added to the lean text and the processing + * is shortened. + *

+ * If not overridden, this method returns false. + *

+ * @param environment the current environment, which may affect the behavior of + * the processor. This parameter may be specified as + * null, in which case the + * {@link STextEnvironment#DEFAULT DEFAULT} + * environment should be assumed. * - * @param environment the current environment, which may affect the behavior of - * the processor. This parameter may be specified as - * null, in which case the - * {@link STextEnvironment#DEFAULT DEFAULT} - * environment should be assumed. + * @param text is the structured text string to process. * - * @param text is the structured text string to process. + * @param dirProps is a parameter received uniquely to be used as argument + * for calls to getDirProp and other methods used + * by processors. * - * @param dirProps is a parameter received uniquely to be used as argument - * for calls to getDirProp 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. * - * @return a flag indicating if there is no need to process the structured - * text to add directional formatting characters. - * - *

If not overridden, this method returns false. */ public boolean skipProcessing(STextEnvironment environment, String text, byte[] dirProps) { return false; diff --git a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/STextDelims.java b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/STextDelims.java index 5bbe015..f6061fd 100644 --- a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/STextDelims.java +++ b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/STextDelims.java @@ -14,17 +14,24 @@ import org.eclipse.equinox.bidi.custom.STextProcessor; /** - * STextDelims is a 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. - * - *

A delimited part is bounded by a start delimiter and an end delimiter. - * + * 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. + *

+ * A delimited part is bounded by a start delimiter and an end delimiter. + *

* @author Matitiahu Allouche */ public abstract class STextDelims extends STextProcessor { + public STextDelims() { + // placeholder + } + + public STextDelims(String separators) { + super(separators); + } + /** * This method locates occurrences of start delimiters. * diff --git a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/STextDelimsEsc.java b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/STextDelimsEsc.java index 67f944d..564cead 100644 --- a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/STextDelimsEsc.java +++ b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/STextDelimsEsc.java @@ -14,23 +14,33 @@ import org.eclipse.equinox.bidi.custom.STextProcessor; /** - * STextDelims is a 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. - * This is similar to {@link STextDelims} except - * that delimiters can be escaped using the backslash character. + * 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. + *

+ * This is similar to {@link STextDelims} except that delimiters can be escaped + * using the backslash character. *

+ *

* * @author Matitiahu Allouche */ public abstract class STextDelimsEsc extends STextDelims { + public STextDelimsEsc() { + // placeholder + } + + public STextDelimsEsc(String separator) { + super(separator); + } + /** * This method handles the text between start and end delimiters * as a token. diff --git a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/STextImpl.java b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/STextImpl.java index d7ddb75..77d365a 100644 --- a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/STextImpl.java +++ b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/STextImpl.java @@ -239,6 +239,46 @@ } /** + * When the orientation is ORIENT_LTR and the + * structured text has a RTL base direction, + * {@link STextEngine#leanToFullText leanToFullText} + * adds RLE+RLM at the head of the full text and RLM+PDF at its + * end. + *

+ * When the orientation is ORIENT_RTL and the + * structured text has a LTR base direction, + * {@link STextEngine#leanToFullText leanToFullText} + * adds LRE+LRM at the head of the full text and LRM+PDF at its + * end. + *

+ * When the orientation is ORIENT_CONTEXTUAL_LTR or + * ORIENT_CONTEXTUAL_RTL and the data content would resolve + * to a RTL orientation while the structured text has a LTR base + * direction, {@link STextEngine#leanToFullText leanToFullText} + * adds LRM at the head of the full text. + *

+ * When the orientation is ORIENT_CONTEXTUAL_LTR or + * ORIENT_CONTEXTUAL_RTL and the data content would resolve + * to a LTR orientation while the structured text has a RTL base + * direction, {@link STextEngine#leanToFullText leanToFullText} + * adds RLM at the head of the full text. + *

+ * When the orientation is ORIENT_UNKNOWN and the + * structured text has a LTR base direction, + * {@link STextEngine#leanToFullText leanToFullText} + * adds LRE+LRM at the head of the full text and LRM+PDF at its + * end. + *

+ * When the orientation is ORIENT_UNKNOWN and the + * structured text has a RTL base direction, + * {@link STextEngine#leanToFullText leanToFullText} + * adds RLE+RLM at the head of the full text and RLM+PDF at its + * end. + *

+ * When the orientation is ORIENT_IGNORE, + * {@link STextEngine#leanToFullText leanToFullText} does not add any directional + * formatting characters as either prefix or suffix of the full text. + *

* @see STextEngine#leanToFullText STextEngine.leanToFullText */ public static String leanToFullText(STextProcessor processor, STextEnvironment environment, String text, int[] state) { diff --git a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/STextSingle.java b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/STextSingle.java index ec8ec0a..2407a7b 100644 --- a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/STextSingle.java +++ b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/STextSingle.java @@ -14,8 +14,7 @@ import org.eclipse.equinox.bidi.custom.STextProcessor; /** - * STextSingle is a processor for structured text - * composed of two parts separated by a separator. + * 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. @@ -30,7 +29,11 @@ * * @author Matitiahu Allouche */ -public abstract class STextSingle extends STextProcessor { +public class STextSingle extends STextProcessor { + + public STextSingle(String separator) { + super(separator); + } /** * This method locates occurrences of the separator. diff --git a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/consumable/STextComma.java b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/consumable/STextComma.java index dc29ad2..418873f 100644 --- a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/consumable/STextComma.java +++ b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/consumable/STextComma.java @@ -10,7 +10,6 @@ ******************************************************************************/ package org.eclipse.equinox.bidi.internal.consumable; -import org.eclipse.equinox.bidi.STextEnvironment; import org.eclipse.equinox.bidi.custom.STextProcessor; /** @@ -20,12 +19,7 @@ * */ public class STextComma extends STextProcessor { - - /** - * @return one separator (comma). - */ - public String getSeparators(STextEnvironment environment, String text, byte[] dirProps) { - return ","; //$NON-NLS-1$ + public STextComma() { + super(","); //$NON-NLS-1$ } - } diff --git a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/consumable/STextEmail.java b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/consumable/STextEmail.java index 05bfaba..2b7cb61 100644 --- a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/consumable/STextEmail.java +++ b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/consumable/STextEmail.java @@ -23,11 +23,8 @@ static final byte R = Character.DIRECTIONALITY_RIGHT_TO_LEFT; static final byte AL = Character.DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC; - /** - * @return separators "<>.:,;@". - */ - public String getSeparators(STextEnvironment environment, String text, byte[] dirProps) { - return "<>.:,;@"; //$NON-NLS-1$ + public STextEmail() { + super("<>.:,;@"); //$NON-NLS-1$ } /** diff --git a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/consumable/STextFile.java b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/consumable/STextFile.java index cc7b2fd..d7185d3 100644 --- a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/consumable/STextFile.java +++ b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/consumable/STextFile.java @@ -10,18 +10,14 @@ ******************************************************************************/ package org.eclipse.equinox.bidi.internal.consumable; -import org.eclipse.equinox.bidi.STextEnvironment; import org.eclipse.equinox.bidi.custom.STextProcessor; /** * Processor adapted to processing directory and file paths. */ public class STextFile extends STextProcessor { - /** - * @return separators ":/\.". - */ - public String getSeparators(STextEnvironment environment, String text, byte[] dirProps) { - return ":/\\."; //$NON-NLS-1$ - } + public STextFile() { + super(":/\\."); //$NON-NLS-1$ + } } diff --git a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/consumable/STextJava.java b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/consumable/STextJava.java index 4b717c1..5562e41 100644 --- a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/consumable/STextJava.java +++ b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/consumable/STextJava.java @@ -13,6 +13,7 @@ import org.eclipse.equinox.bidi.STextEngine; import org.eclipse.equinox.bidi.STextEnvironment; import org.eclipse.equinox.bidi.custom.STextProcessor; +import org.eclipse.equinox.bidi.internal.STextActivator; /** * STextJava is a processor for structured text @@ -35,13 +36,10 @@ */ public class STextJava extends STextProcessor { private static final byte WS = Character.DIRECTIONALITY_WHITESPACE; - static final String lineSep = STextEnvironment.getLineSep(); + static final String lineSep = STextActivator.getInstance().getProperty("line.separator"); //$NON-NLS-1$ - /** - * @return the separators for Java syntax - */ - public String getSeparators(STextEnvironment environment, String text, byte[] dirProps) { - return "[](){}.+-<>=~!&*/%^|?:,;\t"; //$NON-NLS-1$ + public STextJava() { + super("[](){}.+-<>=~!&*/%^|?:,;\t"); //$NON-NLS-1$ } /** diff --git a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/consumable/STextMath.java b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/consumable/STextMath.java index 8bafbb1..450aef9 100644 --- a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/consumable/STextMath.java +++ b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/consumable/STextMath.java @@ -24,11 +24,8 @@ static final byte AL = Character.DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC; static final byte AN = Character.DIRECTIONALITY_ARABIC_NUMBER; - /** - * @return "+-/*()=" as separators specific to this processor. - */ - public String getSeparators(STextEnvironment environment, String text, byte[] dirProps) { - return "+-/*()="; //$NON-NLS-1$ + public STextMath() { + super("+-/*()="); //$NON-NLS-1$ } /** diff --git a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/consumable/STextProperty.java b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/consumable/STextProperty.java index 1cd1b0e..994a80e 100644 --- a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/consumable/STextProperty.java +++ b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/consumable/STextProperty.java @@ -10,7 +10,6 @@ ******************************************************************************/ package org.eclipse.equinox.bidi.internal.consumable; -import org.eclipse.equinox.bidi.STextEnvironment; import org.eclipse.equinox.bidi.internal.STextSingle; /** @@ -21,11 +20,8 @@ * */ public class STextProperty extends STextSingle { - /** - * @return one separator (equal sign). - */ - public String getSeparators(STextEnvironment environment, String text, byte[] dirProps) { - return "="; //$NON-NLS-1$ - } + public STextProperty() { + super("="); //$NON-NLS-1$ + } } diff --git a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/consumable/STextSql.java b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/consumable/STextSql.java index 9c0965c..971a7d8 100644 --- a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/consumable/STextSql.java +++ b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/consumable/STextSql.java @@ -13,6 +13,7 @@ import org.eclipse.equinox.bidi.STextEngine; import org.eclipse.equinox.bidi.STextEnvironment; import org.eclipse.equinox.bidi.custom.STextProcessor; +import org.eclipse.equinox.bidi.internal.STextActivator; /** * STextSql is a processor for structured text @@ -35,13 +36,10 @@ */ public class STextSql extends STextProcessor { private static final byte WS = Character.DIRECTIONALITY_WHITESPACE; - static final String lineSep = STextEnvironment.getLineSep(); + static final String lineSep = STextActivator.getInstance().getProperty("line.separator"); //$NON-NLS-1$ - /** - * @return separators "\t!#%&()*+,-./:;<=>?|[]{}". - */ - public String getSeparators(STextEnvironment environment, String text, byte[] dirProps) { - return "\t!#%&()*+,-./:;<=>?|[]{}"; //$NON-NLS-1$ + public STextSql() { + super("\t!#%&()*+,-./:;<=>?|[]{}"); //$NON-NLS-1$ } /** diff --git a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/consumable/STextSystem.java b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/consumable/STextSystem.java index d31d4da..32b2307 100644 --- a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/consumable/STextSystem.java +++ b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/consumable/STextSystem.java @@ -10,7 +10,6 @@ ******************************************************************************/ package org.eclipse.equinox.bidi.internal.consumable; -import org.eclipse.equinox.bidi.STextEnvironment; import org.eclipse.equinox.bidi.internal.STextSingle; /** @@ -20,11 +19,9 @@ * */ public class STextSystem extends STextSingle { - /** - * @return "(" for the separators specific to this processor. - */ - public String getSeparators(STextEnvironment environment, String text, byte[] dirProps) { - return "("; //$NON-NLS-1$ + + public STextSystem() { + super("("); //$NON-NLS-1$ } } diff --git a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/consumable/STextURL.java b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/consumable/STextURL.java index 956f9b2..5b2df1a 100644 --- a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/consumable/STextURL.java +++ b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/consumable/STextURL.java @@ -10,18 +10,13 @@ ******************************************************************************/ package org.eclipse.equinox.bidi.internal.consumable; -import org.eclipse.equinox.bidi.STextEnvironment; import org.eclipse.equinox.bidi.custom.STextProcessor; /** * Processor adapted to processing URLs. */ public class STextURL extends STextProcessor { - /** - * @return ":?#/@.[]" as the separators specific to this processor. - */ - public String getSeparators(STextEnvironment environment, String text, byte[] dirProps) { - return ":?#/@.[]"; //$NON-NLS-1$ + public STextURL() { + super(":?#/@.[]"); //$NON-NLS-1$ } - } diff --git a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/consumable/STextUnderscore.java b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/consumable/STextUnderscore.java index cefe9ab..eae11f6 100644 --- a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/consumable/STextUnderscore.java +++ b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/consumable/STextUnderscore.java @@ -10,7 +10,6 @@ ******************************************************************************/ package org.eclipse.equinox.bidi.internal.consumable; -import org.eclipse.equinox.bidi.STextEnvironment; import org.eclipse.equinox.bidi.custom.STextProcessor; /** @@ -21,11 +20,8 @@ * */ public class STextUnderscore extends STextProcessor { - /** - * @return "_" as the separators specific to this processor. - */ - public String getSeparators(STextEnvironment environment, String text, byte[] dirProps) { - return "_"; //$NON-NLS-1$ - } + public STextUnderscore() { + super("_"); //$NON-NLS-1$ + } } diff --git a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/consumable/STextXPath.java b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/consumable/STextXPath.java index e115b89..67ec4c5 100644 --- a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/consumable/STextXPath.java +++ b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/consumable/STextXPath.java @@ -17,11 +17,9 @@ * Processor adapted to processing XPath expressions. */ public class STextXPath extends STextDelims { - /** - * @return " /[]<>=!:@.|()+-*" as the separators specific to this processor. - */ - public String getSeparators(STextEnvironment environment, String text, byte[] dirProps) { - return " /[]<>=!:@.|()+-*"; //$NON-NLS-1$ + + public STextXPath() { + super(" /[]<>=!:@.|()+-*"); //$NON-NLS-1$ } /**