| Dir : /opt/alt/alt-nodejs19/root/usr/include/unicode/ |
| Server: Linux ngx353.inmotionhosting.com 4.18.0-553.22.1.lve.1.el8.x86_64 #1 SMP Tue Oct 8 15:52:54 UTC 2024 x86_64 IP: 209.182.202.254 |
| Dir : //opt/alt/alt-nodejs19/root/usr/include/unicode/ubiditransform.h |
/*
******************************************************************************
*
* © 2016 and later: Unicode, Inc. and others.
* License & terms of use: http://www.unicode.org/copyright.html
*
******************************************************************************
* file name: ubiditransform.h
* encoding: UTF-8
* tab size: 8 (not used)
* indentation:4
*
* created on: 2016jul24
* created by: Lina Kemmel
*
*/
#ifndef UBIDITRANSFORM_H
#define UBIDITRANSFORM_H
#include "unicode/utypes.h"
#include "unicode/ubidi.h"
#include "unicode/uchar.h"
#if U_SHOW_CPLUSPLUS_API
#include "unicode/localpointer.h"
#endif // U_SHOW_CPLUSPLUS_API
/**
* \file
* \brief C API: Bidi Transformations
*/
/**
* `UBiDiOrder` indicates the order of text.
*
* This bidi transformation engine supports all possible combinations (4 in
* total) of input and output text order:
*
* - <logical input, visual output>: unless the output direction is RTL, this
* corresponds to a normal operation of the Bidi algorithm as described in the
* Unicode Technical Report and implemented by `UBiDi` when the
* reordering mode is set to `UBIDI_REORDER_DEFAULT`. Visual RTL
* mode is not supported by `UBiDi` and is accomplished through
* reversing a visual LTR string,
*
* - <visual input, logical output>: unless the input direction is RTL, this
* corresponds to an "inverse bidi algorithm" in `UBiDi` with the
* reordering mode set to `UBIDI_REORDER_INVERSE_LIKE_DIRECT`.
* Visual RTL mode is not not supported by `UBiDi` and is
* accomplished through reversing a visual LTR string,
*
* - <logical input, logical output>: if the input and output base directions
* mismatch, this corresponds to the `UBiDi` implementation with the
* reordering mode set to `UBIDI_REORDER_RUNS_ONLY`; and if the
* input and output base directions are identical, the transformation engine
* will only handle character mirroring and Arabic shaping operations without
* reordering,
*
* - <visual input, visual output>: this reordering mode is not supported by
* the `UBiDi` engine; it implies character mirroring, Arabic
* shaping, and - if the input/output base directions mismatch - string
* reverse operations.
* @see ubidi_setInverse
* @see ubidi_setReorderingMode
* @see UBIDI_REORDER_DEFAULT
* @see UBIDI_REORDER_INVERSE_LIKE_DIRECT
* @see UBIDI_REORDER_RUNS_ONLY
* @stable ICU 58
*/
typedef enum {
/** 0: Constant indicating a logical order.
* This is the default for input text.
* @stable ICU 58
*/
UBIDI_LOGICAL = 0,
/** 1: Constant indicating a visual order.
* This is a default for output text.
* @stable ICU 58
*/
UBIDI_VISUAL
} UBiDiOrder;
/**
* <code>UBiDiMirroring</code> indicates whether or not characters with the
* "mirrored" property in RTL runs should be replaced with their mirror-image
* counterparts.
* @see UBIDI_DO_MIRRORING
* @see ubidi_setReorderingOptions
* @see ubidi_writeReordered
* @see ubidi_writeReverse
* @stable ICU 58
*/
typedef enum {
/** 0: Constant indicating that character mirroring should not be
* performed.
* This is the default.
* @stable ICU 58
*/
UBIDI_MIRRORING_OFF = 0,
/** 1: Constant indicating that character mirroring should be performed.
* This corresponds to calling <code>ubidi_writeReordered</code> or
* <code>ubidi_writeReverse</code> with the
* <code>UBIDI_DO_MIRRORING</code> option bit set.
* @stable ICU 58
*/
UBIDI_MIRRORING_ON
} UBiDiMirroring;
/**
* Forward declaration of the <code>UBiDiTransform</code> structure that stores
* information used by the layout transformation engine.
* @stable ICU 58
*/
typedef struct UBiDiTransform UBiDiTransform;
/**
* Performs transformation of text from the bidi layout defined by the input
* ordering scheme to the bidi layout defined by the output ordering scheme,
* and applies character mirroring and Arabic shaping operations.<p>
* In terms of <code>UBiDi</code>, such a transformation implies:
* <ul>
* <li>calling <code>ubidi_setReorderingMode</code> as needed (when the
* reordering mode is other than normal),</li>
* <li>calling <code>ubidi_setInverse</code> as needed (when text should be
* transformed from a visual to a logical form),</li>
* <li>resolving embedding levels of each character in the input text by
* calling <code>ubidi_setPara</code>,</li>
* <li>reordering the characters based on the computed embedding levels, also
* performing character mirroring as needed, and streaming the result to the
* output, by calling <code>ubidi_writeReordered</code>,</li>
* <li>performing Arabic digit and letter shaping on the output text by calling
* <code>u_shapeArabic</code>.</li>
* </ul>
* An "ordering scheme" encompasses the base direction and the order of text,
* and these characteristics must be defined by the caller for both input and
* output explicitly .<p>
* There are 36 possible combinations of <input, output> ordering schemes,
* which are partially supported by <code>UBiDi</code> already. Examples of the
* currently supported combinations:
* <ul>
* <li><Logical LTR, Visual LTR>: this is equivalent to calling
* <code>ubidi_setPara</code> with <code>paraLevel == UBIDI_LTR</code>,</li>
* <li><Logical RTL, Visual LTR>: this is equivalent to calling
* <code>ubidi_setPara</code> with <code>paraLevel == UBIDI_RTL</code>,</li>
* <li><Logical Default ("Auto") LTR, Visual LTR>: this is equivalent to
* calling <code>ubidi_setPara</code> with
* <code>paraLevel == UBIDI_DEFAULT_LTR</code>,</li>
* <li><Logical Default ("Auto") RTL, Visual LTR>: this is equivalent to
* calling <code>ubidi_setPara</code> with
* <code>paraLevel == UBIDI_DEFAULT_RTL</code>,</li>
* <li><Visual LTR, Logical LTR>: this is equivalent to
* calling <code>ubidi_setInverse(UBiDi*, true)</code> and then
* <code>ubidi_setPara</code> with <code>paraLevel == UBIDI_LTR</code>,</li>
* <li><Visual LTR, Logical RTL>: this is equivalent to
* calling <code>ubidi_setInverse(UBiDi*, true)</code> and then
* <code>ubidi_setPara</code> with <code>paraLevel == UBIDI_RTL</code>.</li>
* </ul>
* All combinations that involve the Visual RTL scheme are unsupported by
* <code>UBiDi</code>, for instance:
* <ul>
* <li><Logical LTR, Visual RTL>,</li>
* <li><Visual RTL, Logical RTL>.</li>
* </ul>
* <p>Example of usage of the transformation engine:<br>
* <pre>
* \code
* UChar text1[] = {'a', 'b', 'c', 0x0625, '1', 0};
* UChar text2[] = {'a', 'b', 'c', 0x0625, '1', 0};
* UErrorCode errorCode = U_ZERO_ERROR;
* // Run a transformation.
* ubiditransform_transform(pBidiTransform,
* text1, -1, text2, -1,
* UBIDI_LTR, UBIDI_VISUAL,
* UBIDI_RTL, UBIDI_LOGICAL,
* UBIDI_MIRRORING_OFF,
* U_SHAPE_DIGITS_AN2EN | U_SHAPE_DIGIT_TYPE_AN_EXTENDED,
* &errorCode);
* // Do something with text2.
* text2[4] = '2';
* // Run a reverse transformation.
* ubiditransform_transform(pBidiTransform,
* text2, -1, text1, -1,
* UBIDI_RTL, UBIDI_LOGICAL,
* UBIDI_LTR, UBIDI_VISUAL,
* UBIDI_MIRRORING_OFF,
* U_SHAPE_DIGITS_EN2AN | U_SHAPE_DIGIT_TYPE_AN_EXTENDED,
* &errorCode);
*\endcode
* </pre>
* </p>
*
* @param pBiDiTransform A pointer to a <code>UBiDiTransform</code> object
* allocated with <code>ubiditransform_open()</code> or
* <code>NULL</code>.<p>
* This object serves for one-time setup to amortize initialization
* overheads. Use of this object is not thread-safe. All other threads
* should allocate a new <code>UBiDiTransform</code> object by calling
* <code>ubiditransform_open()</code> before using it. Alternatively,
* a caller can set this parameter to <code>NULL</code>, in which case
* the object will be allocated by the engine on the fly.</p>
* @param src A pointer to the text that the Bidi layout transformations will
* be performed on.
* <p><strong>Note:</strong> the text must be (at least)
* <code>srcLength</code> long.</p>
* @param srcLength The length of the text, in number of UChars. If
* <code>length == -1</code> then the text must be zero-terminated.
* @param dest A pointer to where the processed text is to be copied.
* @param destSize The size of the <code>dest</code> buffer, in number of
* UChars. If the <code>U_SHAPE_LETTERS_UNSHAPE</code> option is set,
* then the destination length could be as large as
* <code>srcLength * 2</code>. Otherwise, the destination length will
* not exceed <code>srcLength</code>. If the caller reserves the last
* position for zero-termination, it should be excluded from
* <code>destSize</code>.
* <p><code>destSize == -1</code> is allowed and makes sense when
* <code>dest</code> was holds some meaningful value, e.g. that of
* <code>src</code>. In this case <code>dest</code> must be
* zero-terminated.</p>
* @param inParaLevel A base embedding level of the input as defined in
* <code>ubidi_setPara</code> documentation for the
* <code>paraLevel</code> parameter.
* @param inOrder An order of the input, which can be one of the
* <code>UBiDiOrder</code> values.
* @param outParaLevel A base embedding level of the output as defined in
* <code>ubidi_setPara</code> documentation for the
* <code>paraLevel</code> parameter.
* @param outOrder An order of the output, which can be one of the
* <code>UBiDiOrder</code> values.
* @param doMirroring Indicates whether or not to perform character mirroring,
* and can accept one of the <code>UBiDiMirroring</code> values.
* @param shapingOptions Arabic digit and letter shaping options defined in the
* ushape.h documentation.
* <p><strong>Note:</strong> Direction indicator options are computed by
* the transformation engine based on the effective ordering schemes, so
* user-defined direction indicators will be ignored.</p>
* @param pErrorCode A pointer to an error code value.
*
* @return The destination length, i.e. the number of UChars written to
* <code>dest</code>. If the transformation fails, the return value
* will be 0 (and the error code will be written to
* <code>pErrorCode</code>).
*
* @see UBiDiLevel
* @see UBiDiOrder
* @see UBiDiMirroring
* @see ubidi_setPara
* @see u_shapeArabic
* @stable ICU 58
*/
U_CAPI uint32_t U_EXPORT2
ubiditransform_transform(UBiDiTransform *pBiDiTransform,
const UChar *src, int32_t srcLength,
UChar *dest, int32_t destSize,
UBiDiLevel inParaLevel, UBiDiOrder inOrder,
UBiDiLevel outParaLevel, UBiDiOrder outOrder,
UBiDiMirroring doMirroring, uint32_t shapingOptions,
UErrorCode *pErrorCode);
/**
* Allocates a <code>UBiDiTransform</code> object. This object can be reused,
* e.g. with different ordering schemes, mirroring or shaping options.<p>
* <strong>Note:</strong>The object can only be reused in the same thread.
* All other threads should allocate a new <code>UBiDiTransform</code> object
* before using it.<p>
* Example of usage:<p>
* <pre>
* \code
* UErrorCode errorCode = U_ZERO_ERROR;
* // Open a new UBiDiTransform.
* UBiDiTransform* transform = ubiditransform_open(&errorCode);
* // Run a transformation.
* ubiditransform_transform(transform,
* text1, -1, text2, -1,
* UBIDI_RTL, UBIDI_LOGICAL,
* UBIDI_LTR, UBIDI_VISUAL,
* UBIDI_MIRRORING_ON,
* U_SHAPE_DIGITS_EN2AN,
* &errorCode);
* // Do something with the output text and invoke another transformation using
* // that text as input.
* ubiditransform_transform(transform,
* text2, -1, text3, -1,
* UBIDI_LTR, UBIDI_VISUAL,
* UBIDI_RTL, UBIDI_VISUAL,
* UBIDI_MIRRORING_ON,
* 0, &errorCode);
*\endcode
* </pre>
* <p>
* The <code>UBiDiTransform</code> object must be deallocated by calling
* <code>ubiditransform_close()</code>.
*
* @return An empty <code>UBiDiTransform</code> object.
* @stable ICU 58
*/
U_CAPI UBiDiTransform* U_EXPORT2
ubiditransform_open(UErrorCode *pErrorCode);
/**
* Deallocates the given <code>UBiDiTransform</code> object.
* @stable ICU 58
*/
U_CAPI void U_EXPORT2
ubiditransform_close(UBiDiTransform *pBidiTransform);
#if U_SHOW_CPLUSPLUS_API
U_NAMESPACE_BEGIN
/**
* \class LocalUBiDiTransformPointer
* "Smart pointer" class, closes a UBiDiTransform via ubiditransform_close().
* For most methods see the LocalPointerBase base class.
*
* @see LocalPointerBase
* @see LocalPointer
* @stable ICU 58
*/
U_DEFINE_LOCAL_OPEN_POINTER(LocalUBiDiTransformPointer, UBiDiTransform, ubiditransform_close);
U_NAMESPACE_END
#endif
#endif