<?xml version='1.0' encoding='UTF-8'?>

<!-- Schema file written by PDE -->

<schema targetNamespace="org.eclipse.equinox.bidi" xmlns="http://www.w3.org/2001/XMLSchema">

<annotation>

      <appInfo>

         <meta.schema plugin="org.eclipse.equinox.bidi" id="org.eclipse.equinox.bidi.bidiTypes" name="String types that need special bi-directinal handling"/>

      </appInfo>

      <documentation>

         Use this extension point to describe processing for strings that need special Bi-directional handling, such as file paths, SQL expressions, or Java code.

      </documentation>

   </annotation>

   <element name="extension">

      <annotation>

         <appInfo>

            <meta.element />

         </appInfo>

      </annotation>

      <complexType>

         <sequence>

            <element ref="typeDescription" minOccurs="1" maxOccurs="unbounded"/>

         </sequence>

         <attribute name="point" type="string" use="required">

            <annotation>

               <documentation>

               </documentation>

            </annotation>

         </attribute>

         <attribute name="id" type="string" use="required">

            <annotation>

               <documentation>

                  Unique identifier of this extension

               </documentation>

            </annotation>

         </attribute>

         <attribute name="name" type="string">

            <annotation>

               <documentation>

               </documentation>

               <appInfo>

                  <meta.attribute translatable="true"/>

               </appInfo>

            </annotation>

         </attribute>

      </complexType>

   </element>

   <element name="typeDescription">

      <complexType>

         <attribute name="type" type="string" use="required">

            <annotation>

               <documentation>

                  Type of the expression that this processor will work on.

               </documentation>

            </annotation>

         </attribute>

         <attribute name="class" type="string">

            <annotation>

               <documentation>

                  The processor that provides specialized bi-directional handling for this type of strings.

               </documentation>

               <appInfo>

                  <meta.attribute kind="java" basedOn=":org.eclipse.equinox.bidi.custom.IBidiComplexProcessor"/>

               </appInfo>

            </annotation>

         </attribute>

         <attribute name="description" type="string">

            <annotation>

               <documentation>

                  The description of the string type.

               </documentation>

               <appInfo>

                  <meta.attribute translatable="true"/>

               </appInfo>

            </annotation>

         </attribute>

      </complexType>

   </element>

   <annotation>

      <appInfo>

         <meta.section type="since"/>

      </appInfo>

      <documentation>

         1.0

      </documentation>

   </annotation>

   <annotation>

      <appInfo>

         <meta.section type="examples"/>

      </appInfo>

      <documentation>

         A processor for the complex expressions that support "minus" delimiters can be described as:

<pre>

public class ComplExpSepMinus extends ComplExpBasic

{

    public ComplExpSepMinus()

    {

        super("-");

    }

}

</pre>

      </documentation>

   </annotation>

   <annotation>

      <appInfo>

         <meta.section type="apiinfo"/>

      </appInfo>

      <documentation>

         TBD

      </documentation>

   </annotation>

   <annotation>

      <appInfo>

         <meta.section type="implementation"/>

      </appInfo>

      <documentation>

         All the classes mentioned as Examples

      </documentation>

   </annotation>

   <annotation>

      <appInfo>

         <meta.section type="copyright"/>

      </appInfo>

      <documentation>

         Copyright (c) 2010 IBM Corporation and others.<br>

All rights reserved. This program and the accompanying materials are made 

available under the terms of the Eclipse Public License v1.0 which 

accompanies 

this distribution, and is available at 

<a 

href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>

      </documentation>

   </annotation>

</schema>

/*******************************************************************************

 * Copyright (c) 2010, 2011 IBM Corporation and others.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     IBM Corporation - initial API and implementation

 ******************************************************************************/

package org.eclipse.equinox.bidi;

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

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

/**

 *  This class acts as a mediator between applications and complex

 *  expression processors.

 *  The purpose of complex expression processors is to add directional

 *  formatting characters to ensure correct display.

 *  This class shields applications from the

 *  intricacies of complex expression processors.

 *  <p>

 *  For a general introduction to complex expressions, see

 *  {@link <a href="package-summary.html">

 *  the package documentation</a>}.

 *

 *  <h2><a name="processor">How to Specify a Processor</a></h2>

 *

 *  <p>All the methods in this class have a first argument which

 *  designates a type of processor.

 *

 *  <p>It can be specified as a string (usually one of the

 *  literals to be found in {@link IBidiComplexExpressionTypes}

 *  or as an instance of {@link custom.IBidiComplexProcessor}.

 *

 *  <p>Such an instance can be obtained using the

 *  {@link custom.BidiComplexStringProcessor#getProcessor getProcessor}

 *  method for the registered processors, or by instantiating a private processor.

 *

 *  <p>When the same processor is used in multiple calls, it may be

 *  beneficial to obtain a reference to the processor and to use it

 *  in following calls, rather than to specify the processor by its

 *  type expressed as a string, which necessitates a registry search

 *  for each call.

 *

 *  <p>A processor reference is also the only way to examine the

 *  features of a processor by calling its

 *  {@link custom.IBidiComplexProcessor#getFeatures getFeatures} method.

 *

 *  <p>Specifying <code>null</code> for the processor as first argument

 *  of a method causes this method to behave as a no-op.

 *

 *  <h2><a name="state">State</a></h2>

 *

 *  <p>Most of the methods in this class have a <code>text</code>

 *  argument which may be just a part of a larger body of text.

 *  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 <code>state</code>

 *  argument must be used.

 *

 *  <p>The <code>state</code> argument must be an array of integers

 *  with at least one element. Only the first element is used by

 *  the methods of this class.

 *

 *  <p>When submitting the initial part of the text, the first element

 *  of <code>state</code> must contain the value {@link #STATE_INITIAL}

 *  or any value <= 0.

 *

 *  <p>After calling a method with a non-null <code>state</code> argument,

 *  a value is returned in the first element of <code>state</code>. 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.

 *

 *  <p>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 <code>state</code> argument should be specified as <code>null</code>.

 *

 *  <h2>Code Samples</h2>

 *

 *  <p>The following code shows how to transform a certain type of complex

 *  expression (directory and file paths) in order to obtain the <i>full</i>

 *  text corresponding to the <i>lean</i> text of such an expression.

 *

 *  <pre>

 *

 *    String leanText = "D:\\\u05d0\u05d1\\\u05d2\\\u05d3.ext";

 *    String fullText = BidiComplexEngine.leanToFullText(IBidiComplexExpressionTypes.FILE, null, null, leanText, null);

 *    System.out.println("full text = " + fullText);

 *

 *  </pre>

 *

 *  <p>The following code shows how to transform successive lines of Java

 *  code in order to obtain the <i>full</i>

 *  text corresponding to the <i>lean</i> text of each line.

 *

 *  <pre>

 *

 *    int[] state = new int[1];

 *    state[0] = BidiComplexEngine.STATE_INITIAL;

 *    String leanText = "int i = 3; // first Java statement";

 *    String fullText = BidiComplexEngine.leanToFullText(IBidiComplexExpressionTypes.JAVA, null, null, leanText, state);

 *    System.out.println("full text = " + fullText);

 *    leanText = "i += 4; // next Java statement";

 *    fullText = BidiComplexEngine.leanToFullText(IBidiComplexExpressionTypes.JAVA, null, null, leanText, state);

 *    System.out.println("full text = " + fullText);

 *

 *  </pre>

 *

 *  <p>This class provides a user-oriented API but does not provide

 *  an actual implementation. The real work is done by the class

 *  {@link BidiComplexImpl}. Users of the API need not be concerned by, and

 *  should not depend upon, details of the implementation in

 *  <code>BidiComplexImpl</code>.

 *

 *  @author Matitiahu Allouche

 *

 */

public class BidiComplexEngine {

	/**

	 *  Constant to use in the first element of the <code>state</code>

	 *  argument when calling most methods of this class

	 *  to indicate that there is no context of previous lines which

	 *  should be initialized before performing the operation.

	 */

	public static final int STATE_INITIAL = 0;

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

	/**

	 *  Prevent creation of a BidiComplexEngine instance

	 */

	private BidiComplexEngine() {

		// nothing to do

	}

	/** Add directional formatting characters to a complex expression

	 *  to ensure correct presentation.

	 *

	 *  @param  processor designates one of the registered processors.

	 *          It can be a string containing a keyword according to

	 *          the processor type, or a processor reference.

	 *          For more details, see above <a href="#processor">

	 *          How to Specify a Processor</a>.

	 *          <p>If this argument is <code>null</code>, this method

	 *          returns the <code>text</code> string.

	 *

	 *  @param  features specifies features that affect the processor's

	 *          behavior.

	 *          <p>This argument may be specified as <code>null</code>,

	 *          in which case the processor will use its standard features

	 *          (as returned by the processor

	 *          {@link custom.IBidiComplexProcessor#getFeatures getFeatures}

	 *          method).

	 *

	 *  @param  environment specifies an environment whose characteristics

	 *          may affect the processor's behavior.

	 *          <p>This argument may be specified as <code>null</code>,

	 *          in which case the processor will assume a standard

	 *          environment as specified in

	 *          {@link BidiComplexEnvironment#DEFAULT}.

	 *

	 *  @param text is the text of the complex expression.

	 *

	 *  @param  state can be used to specify that the <code>text</code>

	 *          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 <a href="#state">State</a> above.

	 *          <p>If all calls to this method are independent from one another,

	 *          this argument should be specified as <code>null</code>.

	 *

	 *  @return the complex expression with directional formatting

	 *          characters added at proper locations to ensure correct

	 *          presentation.

	 */

	public static String leanToFullText(Object processor, BidiComplexFeatures features, BidiComplexEnvironment environment, String text, int[] state) {

		if (processor == null)

			return text;

		return BidiComplexImpl.leanToFullText(processor, features, environment, text, state);

	}

	/**

	 *  Given a <i>lean</i> string, compute the positions of each of its

	 *  characters within the corresponding <i>full</i> string.

	 *

	 *  @param  processor designates one of the registered processors.

	 *          It can be a string containing a keyword according to

	 *          the processor type, or a processor reference.

	 *          For more details, see above <a href="#processor">

	 *          How to Specify a Processor</a>.

	 *          <p>If this argument is <code>null</code>, this method

	 *          returns an identity map.

	 *

	 *  @param  features specifies features that affect the processor's

	 *          behavior.

	 *          <p>This argument may be specified as <code>null</code>,

	 *          in which case the processor will use its standard features

	 *          (as returned by the processor

	 *          {@link custom.IBidiComplexProcessor#getFeatures getFeatures}

	 *          method).

	 *

	 *  @param  environment specifies an environment whose characteristics

	 *          may affect the processor's behavior.

	 *          <p>This argument may be specified as <code>null</code>,

	 *          in which case the processor will assume a standard

	 *          environment as specified in

	 *          {@link BidiComplexEnvironment#DEFAULT}.

	 *

	 *  @param text is the text of the complex expression.

	 *

	 *  @param  state can be used to specify that the <code>text</code>

	 *          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 <a href="#state">State</a> above.

	 *          <p>If all calls to this method are independent from one another,

	 *          this argument should be specified as <code>null</code>.

	 *

	 *  @return an array of integers with one element for each of the characters

	 *          in the <code>text</code> argument, equal to the offset of the

	 *          corresponding character in the <i>full</i> string.

	 */

	public static int[] leanToFullMap(Object processor, BidiComplexFeatures features, BidiComplexEnvironment environment, String text, int[] state) {

		if (processor == null) {

			int[] map = new int[text.length()];

			for (int i = 0; i < map.length; i++)

				map[i] = i;

			return map;

		}

		return BidiComplexImpl.leanToFullMap(processor, features, environment, text, state);

	}

	/**

	 *  Given a <i>lean</i> string, compute the offsets of characters

	 *  before which directional formatting characters must be added

	 *  in order to ensure correct presentation.

	 *

	 *  <p>Only LRMs (for an expression with LTR base direction) and RLMs (for

	 *  an expression with RTL base direction) are considered. Leading and

	 *  trailing LRE, RLE and PDF which might be prefixed or suffixed

	 *  depending on the {@link BidiComplexEnvironment#getOrientation orientation} of the

	 *  GUI component used for display are not reflected in this method.

	 *

	 *  @param  processor designates one of the registered processors.

	 *          It can be a string containing a keyword according to

	 *          the processor type, or a processor reference.

	 *          For more details, see above <a href="#processor">

	 *          How to Specify a Processor</a>.

	 *          <p>If this argument is <code>null</code>, this method

	 *          returns an empty array.

	 *

	 *  @param  features specifies features that affect the processor's

	 *          behavior.

	 *          <p>This argument may be specified as <code>null</code>,

	 *          in which case the processor will use its standard features

	 *          (as returned by the processor

	 *          {@link custom.IBidiComplexProcessor#getFeatures getFeatures}

	 *          method).

	 *

	 *  @param  environment specifies an environment whose characteristics

	 *          may affect the processor's behavior.

	 *          <p>This argument may be specified as <code>null</code>,

	 *          in which case the processor will assume a standard

	 *          environment as specified in

	 *          {@link BidiComplexEnvironment#DEFAULT}.

	 *

	 *  @param text is the text of the complex expression.

	 *

	 *  @param  state can be used to specify that the <code>text</code>

	 *          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 <a href="#state">State</a> above.

	 *          <p>If all calls to this method are independent from one another,

	 *          this argument should be specified as <code>null</code>.

	 *

	 *  @return an array of offsets to the characters in the <code>text</code>

	 *          argument before which directional marks must be

	 *          added to ensure correct presentation.

	 *          The offsets are sorted in ascending order.

	 */

	public static int[] leanBidiCharOffsets(Object processor, BidiComplexFeatures features, BidiComplexEnvironment environment, String text, int[] state) {

		if (processor == null)

			return EMPTY_INT_ARRAY;

		return BidiComplexImpl.leanBidiCharOffsets(processor, features, environment, text, state);

	}

	/**

	 *  Remove directional formatting characters which were added to a

	 *  complex expression to ensure correct presentation.

	 *

	 *  @param  processor designates one of the registered processors.

	 *          It can be a string containing a keyword according to

	 *          the processor type, or a processor reference.

	 *          For more details, see above <a href="#processor">

	 *          How to Specify a Processor</a>.

	 *          <p>If this argument is <code>null</code>, this method

	 *          returns the <code>text</code> string.

	 *

	 *  @param  features specifies features that affect the processor's

	 *          behavior.

	 *          <p>This argument may be specified as <code>null</code>,

	 *          in which case the processor will use its standard features

	 *          (as returned by the processor

	 *          {@link custom.IBidiComplexProcessor#getFeatures getFeatures}

	 *          method).

	 *

	 *  @param  environment specifies an environment whose characteristics

	 *          may affect the processor's behavior.

	 *          <p>This argument may be specified as <code>null</code>,

	 *          in which case the processor will assume a standard

	 *          environment as specified in

	 *          {@link BidiComplexEnvironment#DEFAULT}.

	 *

	 *  @param text is the text of the complex expression including

	 *         directional formatting characters.

	 *

	 *  @param  state can be used to specify that the <code>text</code>

	 *          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 <a href="#state">State</a> above.

	 *          <p>If all calls to this method are independent from one another,

	 *          this argument should be specified as <code>null</code>.

	 *

	 *  @return the complex expression without directional formatting

	 *          characters which might have been added by processing it

	 *          with {@link #leanToFullText leanToFullText}.

	 *

	 */

	public static String fullToLeanText(Object processor, BidiComplexFeatures features, BidiComplexEnvironment environment, String text, int[] state) {

		if (processor == null)

			return text;

		return BidiComplexImpl.fullToLeanText(processor, features, environment, text, state);

	}

	/**

	 *  Given a <i>full</i> string, compute the positions of each of its

	 *  characters within the corresponding <i>lean</i> string.

	 *

	 *  @param  processor designates one of the registered processors.

	 *          It can be a string containing a keyword according to

	 *          the processor type, or a processor reference.

	 *          For more details, see above <a href="#processor">

	 *          How to Specify a Processor</a>.

	 *          <p>If this argument is <code>null</code>, this method

	 *          returns an identity map.

	 *

	 *  @param  features specifies features that affect the processor's

	 *          behavior.

	 *          <p>This argument may be specified as <code>null</code>,

	 *          in which case the processor will use its standard features

	 *          (as returned by the processor

	 *          {@link custom.IBidiComplexProcessor#getFeatures getFeatures}

	 *          method).

	 *

	 *  @param  environment specifies an environment whose characteristics

	 *          may affect the processor's behavior.

	 *          <p>This argument may be specified as <code>null</code>,

	 *          in which case the processor will assume a standard

	 *          environment as specified in

	 *          {@link BidiComplexEnvironment#DEFAULT}.

	 *

	 *  @param  text is the text of the complex expression including

	 *          directional formatting characters.

	 *

	 *  @param  state can be used to specify that the <code>text</code>

	 *          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 <a href="#state">State</a> above.

	 *          <p>If all calls to this method are independent from one another,

	 *          this argument should be specified as <code>null</code>.

	 *

	 *  @return an array of integers with one element for each of the characters

	 *          in the <code>text</code> argument, equal to the offset of the

	 *          corresponding character in the <i>lean</i> string.

	 *          If there is no corresponding

	 *          character in the <i>lean</i> string (because the

	 *          specified character is a directional formatting character

	 *          added when invoking {@link #leanToFullText leanToFullText}),

	 *          the value returned for this character is -1.

	 */

	public static int[] fullToLeanMap(Object processor, BidiComplexFeatures features, BidiComplexEnvironment environment, String text, int[] state) {

		if (processor == null) {

			int[] map = new int[text.length()];

			for (int i = 0; i < map.length; i++)

				map[i] = i;

			return map;

		}

		return BidiComplexImpl.fullToLeanMap(processor, features, environment, text, state);

	}

	/**

	 *  Given a <i>full</i> string, return the offsets of characters

	 *  which are directional formatting characters that have been added

	 *  in order to ensure correct presentation.

	 *

	 *  <p>LRMs (for an expression with LTR base direction), RLMs (for

	 *  an expression 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 BidiComplexEnvironment#getOrientation orientation}

	 *  of the GUI component used for display.

	 *

	 *  @param  processor designates one of the registered processors.

	 *          It can be a string containing a keyword according to

	 *          the processor type, or a processor reference.

	 *          For more details, see above <a href="#processor">

	 *          How to Specify a Processor</a>.

	 *          <p>If this argument is <code>null</code>, this method

	 *          returns an empty array.

	 *

	 *  @param  features specifies features that affect the processor's

	 *          behavior.

	 *          <p>This argument may be specified as <code>null</code>,

	 *          in which case the processor will use its standard features

	 *          (as returned by the processor

	 *          {@link custom.IBidiComplexProcessor#getFeatures getFeatures}

	 *          method).

	 *

	 *  @param  environment specifies an environment whose characteristics

	 *          may affect the processor's behavior.

	 *          <p>This argument may be specified as <code>null</code>,

	 *          in which case the processor will assume a standard

	 *          environment as specified in

	 *          {@link BidiComplexEnvironment#DEFAULT}.

	 *

	 *  @param  text is the text of the complex expression including

	 *          directional formatting characters.

	 *

	 *  @param  state can be used to specify that the <code>text</code>

	 *          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 <a href="#state">State</a> above.

	 *          <p>If all calls to this method are independent from one another,

	 *          this argument should be specified as <code>null</code>.

	 *

	 *  @return an array of offsets to the characters in the <code>text</code>

	 *          argument which are directional formatting characters

	 *          added to ensure correct presentation.

	 *          The offsets are sorted in ascending order.

	 */

	public static int[] fullBidiCharOffsets(Object processor, BidiComplexFeatures features, BidiComplexEnvironment environment, String text, int[] state) {

		if (processor == null)

			return EMPTY_INT_ARRAY;

		return BidiComplexImpl.fullBidiCharOffsets(processor, features, environment, text, state);

	}

	/**

	 *  Get the base direction of a complex expression.

	 *  This base direction may depend on

	 *  whether the expression contains Arabic or Hebrew words

	 *  (if it contains both, the first Arabic or Hebrew letter in the

	 *  expression determines which is the governing script) and on

	 *  whether the GUI is {@link BidiComplexEnvironment#getMirrored mirrored}.

	 *

	 *  @param  processor designates one of the registered processors.

	 *          It can be a string containing a keyword according to

	 *          the processor type, or a processor reference.

	 *          For more details, see above <a href="#processor">

	 *          How to Specify a Processor</a>.

	 *          <p>If this argument is <code>null</code>, this method

	 *          returns {@link BidiComplexFeatures#DIR_LTR}.

	 *

	 *  @param  features specifies features that affect the processor's

	 *          behavior.

	 *          <p>This argument may be specified as <code>null</code>,

	 *          in which case the processor will use its standard features

	 *          (as returned by the processor

	 *          {@link custom.IBidiComplexProcessor#getFeatures getFeatures}

	 *          method).

	 *

	 *  @param  environment specifies an environment whose characteristics

	 *          may affect the processor's behavior.

	 *          <p>This argument may be specified as <code>null</code>,

	 *          in which case the processor will assume a standard

	 *          environment as specified in

	 *          {@link BidiComplexEnvironment#DEFAULT}.

	 *

	 *  @param  text is the text of the complex expression.

	 *

	 *  @return the base direction of the complex expression.

	 *          It is one of the values {@link BidiComplexFeatures#DIR_LTR}

	 *          or {@link BidiComplexFeatures#DIR_RTL}.

	 */

	public static int getCurDirection(Object processor, BidiComplexFeatures features, BidiComplexEnvironment environment, String text) {

		return BidiComplexImpl.getCurDirection(processor, features, environment, text, null);

	}

}

/*******************************************************************************

 * Copyright (c) 2010, 2011 IBM Corporation and others.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     IBM Corporation - initial API and implementation

 ******************************************************************************/

package org.eclipse.equinox.bidi;

import java.util.Locale;

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

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

/**

 *  This class defines certain details of the environment within which

 *  complex expressions are processed.

 *  <p>

 *  All public fields in this class are <code>final</code>, i.e. cannot be

 *  changed after creating an instance.

 *  <p>

 *  All methods in {@link BidiComplexEngine} have a BidiComplexEnvironment

 *  argument. If this argument is specified as <code>null</code>, the

 *  {@link #DEFAULT} environment is used.

 *

 *  <h2>Code Samples</h2>

 *  <p>Example (set all environment parameters)

 *  <pre>

 *

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

 *

 *  </pre>

 *  <p>

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

 *  <p>&nbsp;</p>

 *  @see IBidiComplexProcessor#getFeatures

 *

 *  @author Matitiahu Allouche

 */

public class BidiComplexEnvironment {

	/**

	 *  Constant specifying that the orientation of the GUI component

	 *  where a complex expression will be displayed is LTR.

	 *  It can appear as <code>orientation</code> argument for the

	 *  {@link BidiComplexEnvironment#BidiComplexEnvironment BidiComplexEnvironment constructor}

	 *  and as value returned by {@link #getOrientation}.

	 */

	public static final int ORIENT_LTR = 0;

	/**

	 *  Constant specifying that the orientation of the GUI component

	 *  where a complex expression will be displayed is RTL.

	 *  It can appear as <code>orientation</code> argument for the

	 *  {@link BidiComplexEnvironment#BidiComplexEnvironment BidiComplexEnvironment constructor}

	 *  and as value returned by {@link #getOrientation}.

	 */

	public static final int ORIENT_RTL = 1;

	/**

	 *  Constant specifying that the orientation of the GUI component

	 *  where a complex expression will be displayed is contextual with

	 *  a default of LTR (if no strong character appears in the text).

	 *  It can appear as <code>orientation</code> argument for the

	 *  {@link BidiComplexEnvironment#BidiComplexEnvironment BidiComplexEnvironment constructor}

	 *  and as value returned by {@link #getOrientation}.

	 */

	public static final int ORIENT_CONTEXTUAL_LTR = 2;

	/**

	 *  Constant specifying that the orientation of the GUI component

	 *  where a complex expression will be displayed is contextual with

	 *  a default of RTL (if no strong character appears in the text).

	 *  It can appear as <code>orientation</code> argument for the

	 *  {@link BidiComplexEnvironment#BidiComplexEnvironment BidiComplexEnvironment constructor}

	 *  and as value returned by {@link #getOrientation}.

	 */

	public static final int ORIENT_CONTEXTUAL_RTL = 3;

	/**

	 *  Constant specifying that the orientation of the GUI component

	 *  where a complex expression will be displayed is not known.

	 *  Directional formatting characters must be added as prefix and

	 *  suffix whenever a <i>full</i> text is generated using

	 *  {@link BidiComplexEngine#leanToFullText leanToFullText}.

	 *  It can appear as <code>orientation</code> argument for the

	 *  {@link BidiComplexEnvironment#BidiComplexEnvironment BidiComplexEnvironment constructor}

	 *  and as value returned by {@link #getOrientation}.

	 */

	public static final int ORIENT_UNKNOWN = 4;

	/**

	 *  Constant specifying that whatever the orientation of the

	 *  GUI component where a complex expression will be displayed, no

	 *  directional formatting characters must be added as prefix or

	 *  suffix when a <i>full</i> text is generated using

	 *  {@link BidiComplexEngine#leanToFullText leanToFullText}.

	 *  It can appear as <code>orientation</code> argument for the

	 *  {@link BidiComplexEnvironment#BidiComplexEnvironment BidiComplexEnvironment constructor}

	 *  and as value returned by {@link #getOrientation}.

	 */

	public static final int ORIENT_IGNORE = 5;

	/**

	 *  Pre-defined <code>BidiComplexEnvironment</code> instance with values

	 *  for a non-mirrored GUI and a Left-to-Right presentation component.<br>

	 *  The language is set to <code>null</code>, which defaults to the language

	 *  of the current default locale.

	 */

	public static final BidiComplexEnvironment DEFAULT = new BidiComplexEnvironment(null, false, ORIENT_LTR);

	/**

	 *  This string is a 2-letters code representing a language as defined by

	 *  ISO-639. If left as <code>null</code>, it defaults to the language

	 *  of the current default locale.

	 */

	final String language;

	/**

	 *  Flag specifying that complex expressions 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 <i>full</i> text of the complex expression will

	 *  be displayed.

	 */

	final int orientation;

	static Locale defaultLocale;

	static String defaultLanguage;

	static boolean defaultBidi;

	boolean bidiFlag;

	/**

	 *  Constructor

	 *

	 *  @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.<br>

	 *          If longer than 2 letters, the extra letters are ignored.<br>

	 *          If set to <code>null</code>, 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 complex expression. 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}.<br>

	 *          If different, it defaults to {@link #ORIENT_UNKNOWN ORIENT_UNKNOWN}.

	 *  @see #getOrientation

	 */

	public BidiComplexEnvironment(String lang, boolean mirrored, int orientation) {

		if (lang == null) {

			language = null;

		} else {

			if (lang.length() > 2)

				language = lang.substring(0, 2);

			else

				language = lang;

			bidiFlag = isBidiLanguage(language);

		}

		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 equal to <code>null</code>, it defaults to the language

	 *  of the current default locale.

	 */

	public String getLanguage() {

		return language;

	}

	/**

	 *  Return a flag indicating that complex expressions processed

	 *  within this environment should assume that the GUI is mirrored

	 * (globally going from right to left).

	 */

	public boolean getMirrored() {

		return mirrored;

	}

	/** Return the orientation (a.k.a. base direction) of the GUI

	 *  component in which the <i>full</i> text of the complex expression

	 *  will be displayed.<br>

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

	  *  <p>

	 *  When the orientation is <code>ORIENT_LTR</code> and the complex

	 *  expression has a RTL base direction,

	 *  {@link BidiComplexEngine#leanToFullText leanToFullText}

	 *  adds RLE+RLM at the head of the <i>full</i> text and RLM+PDF at its

	 *  end.

	 *  <p>

	 *  When the orientation is <code>ORIENT_RTL</code> and the complex

	 *  expression has a LTR base direction,

	 *  {@link BidiComplexEngine#leanToFullText leanToFullText}

	 *  adds LRE+LRM at the head of the <i>full</i> text and LRM+PDF at its

	 *  end.

	 *  <p>

	 *  When the orientation is <code>ORIENT_CONTEXTUAL_LTR</code> or

	 *  <code>ORIENT_CONTEXTUAL_RTL</code> and the data content would resolve

	 *  to a RTL orientation while the complex expression has a LTR base

	 *  direction, {@link BidiComplexEngine#leanToFullText leanToFullText}

	 *  adds LRM at the head of the <i>full</i> text.

	 *  <p>

	 *  When the orientation is <code>ORIENT_CONTEXTUAL_LTR</code> or

	 *  <code>ORIENT_CONTEXTUAL_RTL</code> and the data content would resolve

	 *  to a LTR orientation while the complex expression has a RTL base

	 *  direction, {@link BidiComplexEngine#leanToFullText leanToFullText}

	 *  adds RLM at the head of the <i>full</i> text.

	 *  <p>

	 *  When the orientation is <code>ORIENT_UNKNOWN</code> and the complex

	 *  expression has a LTR base direction,

	 *  {@link BidiComplexEngine#leanToFullText leanToFullText}

	 *  adds LRE+LRM at the head of the <i>full</i> text and LRM+PDF at its

	 *  end.

	 *  <p>

	 *  When the orientation is <code>ORIENT_UNKNOWN</code> and the complex

	 *  expression has a RTL base direction,

	 *  {@link BidiComplexEngine#leanToFullText leanToFullText}

	 *  adds RLE+RLM at the head of the <i>full</i> text and RLM+PDF at its

	 *  end.

	 *  <p>

	 *  When the orientation is <code>ORIENT_IGNORE</code>,

	 *  {@link BidiComplexEngine#leanToFullText leanToFullText} does not add any directional

	 *  formatting characters as either prefix or suffix of the <i>full</i> text.

	 *  <p>

	 */

	public int getOrientation() {

		return orientation;

	}

	/**

	 *  Check whether the current language uses a

	 *  bidi script (Arabic, Hebrew, Farsi or Urdu).

	 *

	 *  @return <code>true</code> if the current language uses a bidi script.

	 *          The language may have been set explicitly when creating the

	 *          <code>BidiComplexEnvironment</code> instance, or it may have

	 *          defaulted to the language of the current default locale.

	 *  @see #getLanguage

	 */

	public boolean isBidi() {

		if (defaultLanguage != null && defaultLocale.equals(getDefaultLocale()))

			return defaultBidi;

		if (language == null) {

			defaultLocale = getDefaultLocale();

			defaultLanguage = defaultLocale.getLanguage();

			defaultBidi = isBidiLanguage(defaultLanguage);

			return defaultBidi;

		}

		return bidiFlag;

	}

	static 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$/

		}

		return lineSep;

	}

	static String osName;

	static boolean flagOS;

	private static String getProperty(String key) {

		// use bundle properties

		//      osName = System.getProperty("os.name").toLowerCase(); //$NON-NLS-1$

		BidiComplexActivator bidiComplexActivator = BidiComplexActivator.getInstance();

		return bidiComplexActivator.getProperty(key);

	}

	private Locale getDefaultLocale() {

		BidiComplexActivator bidiComplexActivator = BidiComplexActivator.getInstance();

		return bidiComplexActivator.getDefaultLocale();

	}

	/**

	 *  Check if the current OS is supported by the complex expression packages.

	 *

	 *  @return <code>true</code> 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;

	}

}

/*******************************************************************************

 * Copyright (c) 2010, 2011 IBM Corporation and others.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     IBM Corporation - initial API and implementation

 ******************************************************************************/

package org.eclipse.equinox.bidi;

import java.lang.ref.SoftReference;

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

/**

 *  This class records strings which are complex expressions. 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.

 *  <p>

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

 *  <p>

 *  The pool is managed as a cyclic list. When the pool is full,

 *  each new element overrides the oldest element in the list.

 */

public class BidiComplexStringRecord {

	/**

	 * Number of entries in the pool of recorded strings

	 */

	public static final int POOLSIZE = 100;

	// maximum index allowed

	private static final int MAXINDEX = POOLSIZE - 1;

	// index of the last entered record

	private static int last = MAXINDEX;

	// the pool

	private static BidiComplexStringRecord[] records = new BidiComplexStringRecord[POOLSIZE];

	// complex expression types

	private static final String[] types = BidiComplexStringProcessor.getKnownTypes();

	// maximum type index allowed

	private static int MAXTYPE = types.length - 1;

	// reference to the recorded string

	private SoftReference strRef;

	// hash code of the recorded string

	private int hash;

	// reference to the triplets of the recorded string

	private SoftReference triRef;

	/**

	 *  Constructor.

	 *

	 *  @param  string the string to record

	 *

	 *  @param  triplets

	 *          array of short integers, the number of elements in the array

	 *          must be a multiple of 3, so that the array is made of one or

	 *          more triplets of short integers.

	 *          <p>

	 *          The first element in each triplet is the beginning offset of a

	 *          susbstring of <code>string</code> which is a complex

	 *          expression.

	 *          <p>

	 *          The second element in each triplet is the ending offset of a

	 *          susbstring of <code>string</code> which is a complex

	 *          expression. This offset points to one position beyond the last

	 *          character of the substring.

	 *          <p>

	 *          The third element in each triplet is the numeric type of the

	 *          complex expression.<br>

	 *          The type of a complex expression must be one of the string

	 *          values listed in {@link IBidiComplexExpressionTypes}.<br>

	 *          The corresponding numeric type must be obtained using the

	 *          method {@link #typeStringToShort typeStringToShort}.

	 */

	public BidiComplexStringRecord(String string, short[] triplets) {

		if (string == null || triplets == null)

			throw new IllegalArgumentException("The string and triplets argument must not be null!"); //$NON-NLS-1$

		if ((triplets.length % 3) != 0)

			throw new IllegalArgumentException("The number of elements in triplets must be a multiple of 3!"); //$NON-NLS-1$

		for (int i = 2; i < triplets.length; i += 3)

			if (triplets[i] < 0 || triplets[i] > MAXTYPE)

				throw new IllegalArgumentException("Illegal type value in element" + i);

		strRef = new SoftReference(string);

		triRef = new SoftReference(triplets);

		hash = string.hashCode();

	}

	/**

	 *  Get the numeric type of a complex expression given its string type.

	 *

	 *  @param  type type of complex expression as string. It must be one

	 *          of the strings listed in {@link IBidiComplexExpressionTypes}.

	 *

	 *  @return a value which is the corresponding numeric type. If

	 *          <code>type</code> is invalid, the method returns <code>-1</code>.

	 */

	public static short typeStringToShort(String type) {

		for (int i = 0; i < types.length; i++)

			if (types[i].equals(type))

				return (short) i;

		return -1;

	}

	/**

	 *  Get the string type of a complex expression given its numeric type.

	 *

	 *  @param shType

	 *         the numeric type of a complex expression. It should be a value

	 *         obtained using {@link #typeStringToShort typeStringToShort}.

	 *

	 *  @return the corresponding string type. If <code>shType</code> is invalid,

	 *          the method returns <code>null</code>.

	 */

	public static String typeShortToString(short shType) {

		if (shType < 0 || shType > MAXTYPE)

			return null;

		return types[shType];

	}

	/**

	 *  Add a record to the pool.

	 *

	 *  @param record a BidiComplexStringRecord instance

	 */

	public static synchronized void add(BidiComplexStringRecord record) {

		if (last < MAXINDEX)

			last++;

		else

			last = 0;

		records[last] = record;

	}

	/**

	 *  Check if a string is recorded and retrieve its triplets.

	 *

	 *  @param  string the string to check

	 *

	 *  @return <code>null</code> if the string is not recorded in the pool;

	 *          otherwise, return the triplets associated with this string.

	 */

	public static short[] getTriplets(String string) {

		if (records[0] == null) // no records at all

			return null;

		if (string == null || string.length() < 1)

			return null;

		BidiComplexStringRecord rec;

		String str;

		short[] tri;

		int myLast = last;

		int hash = string.hashCode();

		for (int i = myLast; i >= 0; i--) {

			rec = records[i];

			if (hash == rec.hash && (tri = (short[]) rec.triRef.get()) != null && (str = (String) rec.strRef.get()) != null && string.equals(str)) {

				return tri;

			}

		}

		if (records[MAXINDEX] == null) // never recorded past myLast

			return null;

		for (int i = MAXINDEX; i > myLast; i--) {

			rec = records[i];

			if (hash == rec.hash && (tri = (short[]) rec.triRef.get()) != null && (str = (String) rec.strRef.get()) != null && string.equals(str)) {

				return tri;

			}

		}

		return null;

	}

	/**

	 *  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++) {

			BidiComplexStringRecord sr = records[i];

			if (sr == null)

				break;

			sr.hash = 0;

			sr.strRef.clear();

			sr.triRef.clear();

			records[i] = null;

		}

		last = MAXINDEX;

	}

}

/*******************************************************************************

 * Copyright (c) 2010, 2011 IBM Corporation and others.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     IBM Corporation - initial API and implementation

 ******************************************************************************/

package org.eclipse.equinox.bidi;

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

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

/**

 *  This class provides a number of convenience functions facilitating the

 *  processing of complex expressions.

 *

 *  @noextend This class is not intended to be subclassed by clients.

 *  @noinstantiate This class is not intended to be instantiated by clients.

 *

 *  @author Matitiahu Allouche

 */

final public class BidiComplexUtil {

	/**

	 *  prevent instantiation

	 */

	private BidiComplexUtil() {

		// 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 BidiComplexEngine#leanBidiCharOffsets leanBidiCharOffsets} in order to

	 *  produce a <i>full</i> text corresponding to the source text.

	 *  The directional formatting characters that will be added at the given

	 *  offsets will be LRMs for expressions with LTR base direction and

	 *  RLMs for expressions 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 <code>affix</code>.

	 *

	 *  @param  text is the text of the complex expression.

	 *

	 *  @param  offsets is an array of offsets to characters in <code>text</code>

	 *          before which an LRM or RLM will be inserted.

	 *          Members of the array must be non-negative numbers smaller

	 *          than the length of <code>text</code>.

	 *          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 complex expression.

	 *          It must be one of the values {@link BidiComplexFeatures#DIR_LTR} or

	 *          {@link BidiComplexFeatures#DIR_RTL}.

	 *

	 *  @param  affix specifies if a prefix and a suffix should be added to

	 *          the result to make sure that the <code>direction</code>

	 *          specified as third argument is honored even if the expression

	 *          is displayed in a GUI component with a different orientation.

	 *

	 *  @return a string corresponding to the source <code>text</code> with

	 *          directional marks (LRMs or RLMs) added at the specified offsets,

	 *          and directional formatting characters (LRE, RLE, PDF) added

	 *          as prefix and suffix if so required.

	 */

	public static String insertMarks(String text, int[] offsets, int direction, boolean affix) {

		int textLen = text.length();

		if (textLen == 0)

			return ""; //$NON-NLS-1$

		String curPrefix, curSuffix, full;

		char curMark, c;

		char[] fullChars;

		if (direction == BidiComplexFeatures.DIR_LTR) {

			curMark = LRM;

			curPrefix = "\u202a\u200e"; /* LRE+LRM *///$NON-NLS-1$

			curSuffix = "\u200e\u202c"; /* LRM+PDF *///$NON-NLS-1$

		} else {

			curMark = RLM;

			curPrefix = "\u202b\u200f"; /* RLE+RLM *///$NON-NLS-1$

			curSuffix = "\u200f\u202c"; /* RLM+PDF *///$NON-NLS-1$

		}

		// add marks at offsets

		if ((offsets != null) && (offsets.length > 0)) {

			int offLen = offsets.length;

			fullChars = new char[textLen + offLen];

			int added = 0;

			for (int i = 0, j = 0; i < textLen; i++) {

				c = text.charAt(i);

				if ((j < offLen) && (i == offsets[j])) {

					fullChars[i + added] = curMark;

					added++;

					j++;

				}

				fullChars[i + added] = c;

			}

			full = new String(fullChars);

		} else {

			full = text;

		}

		if (affix)

			return curPrefix + full + curSuffix;

		return full;

	}

	/*************************************************************************/

	/*                                                                       */

	/*  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 (!BidiComplexEnvironment.isSupportedOS())

			return false;

		return BidiComplexEnvironment.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

	 *  {@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.

	 */

	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.

	 *  <p>

	 *  For example, a file path such as <tt>d:\myfolder\FOLDER\MYFILE.java</tt>

	 *  (where capital letters indicate RTL text) should render as

	 *  <tt>d:\myfolder\REDLOF\ELIFYM.java</tt>.</p>

	 *  <p>

	 *  NOTE: this method inserts directional formatting characters into the

	 *  text. Methods like <code>String.equals(String)</code> and

	 *  <code>String.length()</code> called on the resulting string will not

	 *  return the same values as would be returned for the original string.</p>

	 *

	 *  @param  str the text to process.

	 *

	 *  @param  separators separators by which the string will be segmented.

	 *          If <code>null</code>, the default separators are used

	 *          (dot, colon, slash, backslash).

	 *

	 *  @return the processed string.

	 *          If <code>str</code> is <code>null</code>,

	 *          or of length 0, or if the current locale is not a bidi one,

	 *          return the original string.

	 */

	public static String process(String str, String separators) {

		if ((str == null) || (str.length() <= 1) || !isProcessingNeeded())

			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;

		// do not process a string if all the following conditions are true:

		//  a) it has no RTL characters

		//  b) it starts with a LTR character

		//  c) it ends with a LTR character or a digit

		boolean isStringBidi = false;

		int strLength = str.length();

		char c;

		for (int i = 0; i < strLength; i++) {

			c = str.charAt(i);

			if (((c >= 0x05d0) && (c <= 0x07b1)) || ((c >= 0xfb1d) && (c <= 0xfefc))) {

				isStringBidi = true;

				break;

			}

		}

		while (!isStringBidi) {

			if (!Character.isLetter(str.charAt(0)))

				break;

			c = str.charAt(strLength - 1);

			if (!Character.isDigit(c) && !Character.isLetter(c))

				break;

			return str;

		}

		if (separators == null)

			separators = defaultSeparators;

		// make sure that LRE/PDF are added around the string

		BidiComplexEnvironment env = new BidiComplexEnvironment(null, false, BidiComplexEnvironment.ORIENT_UNKNOWN);

		BidiComplexFeatures features = new BidiComplexFeatures(separators, 0, -1, -1, false, false);

		return BidiComplexEngine.leanToFullText(new BidiComplexProcessor(), features, 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

	 *  <code>type</code> argument.

	 *  Each segment has the Unicode Bidi Algorithm applied to it, but the

	 *  order of the segments is governed by the type of the complex expression.

	 *  <p>

	 *  For example, a file path such as <tt>d:\myfolder\FOLDER\MYFILE.java</tt>

	 *  (where capital letters indicate RTL text) should render as

	 *  <tt>d:\myfolder\REDLOF\ELIFYM.java</tt>.</p>

	 *  <p>

	 *  NOTE: this method inserts directional formatting characters into the

	 *  text. Methods like <code>String.equals(String)</code> and

	 *  <code>String.length()</code> called on the resulting string will not

	 *  return the same values as would be returned for the original string.</p>

	 *

	 *  @param  str the text to process.

	 *

	 *  @param  type specifies the type of the complex expression. It must

	 *          be one of the values in {@link IBidiComplexExpressionTypes} or a value.

	 *          added by a plug-in extension.

	 *

	 *  @return the processed string.

	 *          If <code>str</code> is <code>null</code>,

	 *          or of length 0, or if the current locale is not a bidi one,

	 *          return the original string.

	 */

	public static String processTyped(String str, String type) {

		if ((str == null) || (str.length() <= 1) || !isProcessingNeeded())

			return str;

		// do not process a string that has already been processed.

		char c = str.charAt(0);

		if (((c == LRE) || (c == RLE)) && str.charAt(str.length() - 1) == PDF)

			return str;

		// make sure that LRE/PDF are added around the string

		BidiComplexEnvironment env = new BidiComplexEnvironment(null, false, BidiComplexEnvironment.ORIENT_UNKNOWN);

		return BidiComplexEngine.leanToFullText(type, null, 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.

	 */

	public static String deprocess(String str) {

		if ((str == null) || (str.length() <= 1) || !isProcessingNeeded())

			return str;

		StringBuffer buf = new StringBuffer();

		int strLen = str.length();

		for (int i = 0; i < strLen; i++) {

			char c = str.charAt(i);

			switch (c) {

				case LRM :

					continue;

				case LRE :

					continue;

				case PDF :

					continue;

				default :

					buf.append(c);

			}

		}

		return buf.toString();

	}

	/**

	 *  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  type type of the complex expression as specified when

	 *          calling {@link #processTyped processTyped}.

	 *

	 *  @return string with no directional formatting characters.

	 */

	public static String deprocess(String str, String type) {

		if ((str == null) || (str.length() <= 1) || !isProcessingNeeded())

			return str;

		// make sure that LRE/PDF are added around the string

		BidiComplexEnvironment env = new BidiComplexEnvironment(null, false, BidiComplexEnvironment.ORIENT_UNKNOWN);

		return BidiComplexEngine.fullToLeanText(type, null, env, str, null);

	}

}

/*******************************************************************************

 * Copyright (c) 2010, 2011 IBM Corporation and others.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     IBM Corporation - initial API and implementation

 ******************************************************************************/

package org.eclipse.equinox.bidi;

/**

 * Bidirectional processors supplied in this bundle.

 *

 * @noextend This interface is not intended to be extended by clients.

 */

public interface IBidiComplexExpressionTypes {

	/**

	 * Constant indicating a type of complex expression processor adapted

	 * to processing property file statements. It expects the following

	 * string format:

	 * <pre>

	 *  name=value

	 * </pre>

	 */

	public String PROPERTY = "property"; //$NON-NLS-1$

	/**

	 * Constant indicating a type of complex expression processor adapted

	 * to processing compound names.

	 * This type covers names made of one or more parts separated by underscores:

	 * <pre>

	 *  part1_part2_part3

	 * </pre>

	 */

	public String UNDERSCORE = "underscore"; //$NON-NLS-1$

	/**

	 * Constant indicating a type of complex expression processor adapted

	 * to processing comma-delimited lists, such as:

	 * <pre>

	 *  part1,part2,part3

	 * </pre>

	 */

	public String COMMA_DELIMITED = "comma"; //$NON-NLS-1$

	/**

	 * Constant indicating a type of complex expression processor adapted

	 * to processing expressions with the following string format:

	 * <pre>

	 *  system(user)

	 * </pre>

	 */

	public String SYSTEM_USER = "system"; //$NON-NLS-1$

	/**

	 * Constant indicating a type of complex expression processor adapted

	 * to processing directory and file paths.

	 */

	public String FILE = "file"; //$NON-NLS-1$

	/**

	 *  Constant indicating a type of complex expression processor adapted

	 *  to processing e-mail addresses.

	 */

	public String EMAIL = "email"; //$NON-NLS-1$

	/**

	 *  Constant indicating a type of complex expression processor adapted

	 *  to processing URLs.

	 */

	public String URL = "url"; //$NON-NLS-1$

	/**

	 *  Constant indicating a type of complex expression processor adapted

	 *  to processing regular expressions, possibly spanning more than one

	 *  line.

	 */

	public String REGEXP = "regex"; //$NON-NLS-1$

	/**

	 *  Constant indicating a type of complex expression processor adapted

	 *  to processing XPath expressions.

	 */

	public String XPATH = "xpath"; //$NON-NLS-1$

	/**

	 *  Constant indicating a type of complex expression processor adapted

	 *  to processing Java code, possibly spanning more than one line.

	 */

	public String JAVA = "java"; //$NON-NLS-1$

	/**

	 *  Constant indicating a type of complex expression processor adapted

	 *  to processing SQL statements, possibly spanning more than one line.

	 */

	public String SQL = "sql"; //$NON-NLS-1$

	/**

	 *  Constant indicating a type of complex expression processor adapted

	 *  to processing arithmetic expressions with a RTL base direction.

	 */

	public String RTL_ARITHMETIC = "math"; //$NON-NLS-1$

}