The Tor Browser: intl/icu/source/i18n/tridpars.h@fc2d59ddac77 (annotated)

intl/icu/source/i18n/tridpars.h@fc2d59ddac77 (annotated)

intl/icu/source/i18n/tridpars.h

Wed, 31 Dec 2014 07:22:50 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 07:22:50 +0100
branch: TOR_BUG_3246
changeset 4: fc2d59ddac77
permissions: -rw-r--r--

Correct previous dual key logic pending first delivery installment.

 /*
  **************************************************************************
  *   Copyright (c) 2002-2010, International Business Machines Corporation *
  *   and others.  All Rights Reserved.                                    *
  **************************************************************************
  *   Date        Name        Description                                  *
  *   01/28/2002  aliu        Creation.                                    *
  **************************************************************************
  */
 #ifndef TRIDPARS_H
 #define TRIDPARS_H
 #include "unicode/utypes.h"
 #if !UCONFIG_NO_TRANSLITERATION
 #include "unicode/uobject.h"
 #include "unicode/unistr.h"
 U_NAMESPACE_BEGIN
 class Transliterator;
 class UnicodeSet;
 class UVector;
 /**
  * Parsing component for transliterator IDs.  This class contains only
  * static members; it cannot be instantiated.  Methods in this class
  * parse various ID formats, including the following:
  *
  * A basic ID, which contains source, target, and variant, but no
  * filter and no explicit inverse.  Examples include
  * "Latin-Greek/UNGEGN" and "Null".
  *
  * A single ID, which is a basic ID plus optional filter and optional
  * explicit inverse.  Examples include "[a-zA-Z] Latin-Greek" and
  * "Lower (Upper)".
  *
  * A compound ID, which is a sequence of one or more single IDs,
  * separated by semicolons, with optional forward and reverse global
  * filters.  The global filters are UnicodeSet patterns prepended or
  * appended to the IDs, separated by semicolons.  An appended filter
  * must be enclosed in parentheses and applies in the reverse
  * direction.
  *
  * @author Alan Liu
  */
 class TransliteratorIDParser /* not : public UObject because all methods are static */ {
  public:
     /**
      * A structure containing the parsed data of a filtered ID, that
      * is, a basic ID optionally with a filter.
      *
      * 'source' and 'target' will always be non-null.  The 'variant'
      * will be non-null only if a non-empty variant was parsed.
      *
      * 'sawSource' is true if there was an explicit source in the
      * parsed id.  If there was no explicit source, then an implied
      * source of ANY is returned and 'sawSource' is set to false.
      *
      * 'filter' is the parsed filter pattern, or null if there was no
      * filter.
      */
     class Specs : public UMemory {
     public:
         UnicodeString source; // not null
         UnicodeString target; // not null
         UnicodeString variant; // may be null
         UnicodeString filter; // may be null
         UBool sawSource;
         Specs(const UnicodeString& s, const UnicodeString& t,
               const UnicodeString& v, UBool sawS,
               const UnicodeString& f);
     private:
         Specs(const Specs &other); // forbid copying of this class
         Specs &operator=(const Specs &other); // forbid copying of this class
     };
     /**
      * A structure containing the canonicalized data of a filtered ID,
      * that is, a basic ID optionally with a filter.
      *
      * 'canonID' is always non-null.  It may be the empty string "".
      * It is the id that should be assigned to the created
      * transliterator.  It _cannot_ be instantiated directly.
      *
      * 'basicID' is always non-null and non-empty.  It is always of
      * the form S-T or S-T/V.  It is designed to be fed to low-level
      * instantiation code that only understands these two formats.
      *
      * 'filter' may be null, if there is none, or non-null and
      * non-empty.
      */
     class SingleID : public UMemory {
     public:
         UnicodeString canonID;
         UnicodeString basicID;
         UnicodeString filter;
         SingleID(const UnicodeString& c, const UnicodeString& b,
                  const UnicodeString& f);
         SingleID(const UnicodeString& c, const UnicodeString& b);
         Transliterator* createInstance();
     private:
         SingleID(const SingleID &other); // forbid copying of this class
         SingleID &operator=(const SingleID &other); // forbid copying of this class
     };
     /**
      * Parse a filter ID, that is, an ID of the general form
      * "[f1] s1-t1/v1", with the filters optional, and the variants optional.
      * @param id the id to be parsed
      * @param pos INPUT-OUTPUT parameter.  On input, the position of
      * the first character to parse.  On output, the position after
      * the last character parsed.
      * @return a SingleID object or null if the parse fails
      */
     static SingleID* parseFilterID(const UnicodeString& id, int32_t& pos);
     /**
      * Parse a single ID, that is, an ID of the general form
      * "[f1] s1-t1/v1 ([f2] s2-t3/v2)", with the parenthesized element
      * optional, the filters optional, and the variants optional.
      * @param id the id to be parsed
      * @param pos INPUT-OUTPUT parameter.  On input, the position of
      * the first character to parse.  On output, the position after
      * the last character parsed.
      * @param dir the direction.  If the direction is REVERSE then the
      * SingleID is constructed for the reverse direction.
      * @return a SingleID object or null
      */
     static SingleID* parseSingleID(const UnicodeString& id, int32_t& pos,
                                   int32_t dir, UErrorCode& status);
     /**
      * Parse a global filter of the form "[f]" or "([f])", depending
      * on 'withParens'.
      * @param id the pattern the parse
      * @param pos INPUT-OUTPUT parameter.  On input, the position of
      * the first character to parse.  On output, the position after
      * the last character parsed.
      * @param dir the direction.
      * @param withParens INPUT-OUTPUT parameter.  On entry, if
      * withParens[0] is 0, then parens are disallowed.  If it is 1,
      * then parens are required.  If it is -1, then parens are
      * optional, and the return result will be set to 0 or 1.
      * @param canonID OUTPUT parameter.  The pattern for the filter
      * added to the canonID, either at the end, if dir is FORWARD, or
      * at the start, if dir is REVERSE.  The pattern will be enclosed
      * in parentheses if appropriate, and will be suffixed with an
      * ID_DELIM character.  May be null.
      * @return a UnicodeSet object or null.  A non-null results
      * indicates a successful parse, regardless of whether the filter
      * applies to the given direction.  The caller should discard it
      * if withParens != (dir == REVERSE).
      */
     static UnicodeSet* parseGlobalFilter(const UnicodeString& id, int32_t& pos,
                                          int32_t dir,
                                          int32_t& withParens,
                                          UnicodeString* canonID);
     /**
      * Parse a compound ID, consisting of an optional forward global
      * filter, a separator, one or more single IDs delimited by
      * separators, an an optional reverse global filter.  The
      * separator is a semicolon.  The global filters are UnicodeSet
      * patterns.  The reverse global filter must be enclosed in
      * parentheses.
      * @param id the pattern the parse
      * @param dir the direction.
      * @param canonID OUTPUT parameter that receives the canonical ID,
      * consisting of canonical IDs for all elements, as returned by
      * parseSingleID(), separated by semicolons.  Previous contents
      * are discarded.
      * @param list OUTPUT parameter that receives a list of SingleID
      * objects representing the parsed IDs.  Previous contents are
      * discarded.
      * @param globalFilter OUTPUT parameter that receives a pointer to
      * a newly created global filter for this ID in this direction, or
      * null if there is none.
      * @return true if the parse succeeds, that is, if the entire
      * id is consumed without syntax error.
      */
     static UBool parseCompoundID(const UnicodeString& id, int32_t dir,
                                  UnicodeString& canonID,
                                  UVector& list,
                                  UnicodeSet*& globalFilter);
     /**
      * Convert the elements of the 'list' vector, which are SingleID
      * objects, into actual Transliterator objects.  In the course of
      * this, some (or all) entries may be removed.  If all entries
      * are removed, the Null transliterator will be added.
      *
      * Delete entries with empty basicIDs; these are generated by
      * elements like "(A)" in the forward direction, or "A()" in
      * the reverse.  THIS MAY RESULT IN AN EMPTY VECTOR.  Convert
      * SingleID entries to actual transliterators.
      *
      * @param list vector of SingleID objects.  On exit, vector
      * of one or more Transliterators.
      * @param ec Output param to receive a success or an error code.
      * @return new value of insertIndex.  The index will shift if
      * there are empty items, like "(Lower)", with indices less than
      * insertIndex.
      */
     static void instantiateList(UVector& list,
                                 UErrorCode& ec);
     /**
      * Parse an ID into pieces.  Take IDs of the form T, T/V, S-T,
      * S-T/V, or S/V-T.  If the source is missing, return a source of
      * ANY.
      * @param id the id string, in any of several forms
      * @param source          the given source.
      * @param target          the given target.
      * @param variant         the given variant
      * @param isSourcePresent If TRUE then the source is present.
      *                        If the source is not present, ANY will be
      *                        given as the source, and isSourcePresent will be null
      * @return an array of 4 strings: source, target, variant, and
      * isSourcePresent.  If the source is not present, ANY will be
      * given as the source, and isSourcePresent will be null.  Otherwise
      * isSourcePresent will be non-null.  The target may be empty if the
      * id is not well-formed.  The variant may be empty.
      */
     static void IDtoSTV(const UnicodeString& id,
                         UnicodeString& source,
                         UnicodeString& target,
                         UnicodeString& variant,
                         UBool& isSourcePresent);
     /**
      * Given source, target, and variant strings, concatenate them into a
      * full ID.  If the source is empty, then "Any" will be used for the
      * source, so the ID will always be of the form s-t/v or s-t.
      */
     static void STVtoID(const UnicodeString& source,
                         const UnicodeString& target,
                         const UnicodeString& variant,
                         UnicodeString& id);
     /**
      * Register two targets as being inverses of one another.  For
      * example, calling registerSpecialInverse("NFC", "NFD", true) causes
      * Transliterator to form the following inverse relationships:
      *
      * <pre>NFC => NFD
      * Any-NFC => Any-NFD
      * NFD => NFC
      * Any-NFD => Any-NFC</pre>
      *
      * (Without the special inverse registration, the inverse of NFC
      * would be NFC-Any.)  Note that NFD is shorthand for Any-NFD, but
      * that the presence or absence of "Any-" is preserved.
      *
      * <p>The relationship is symmetrical; registering (a, b) is
      * equivalent to registering (b, a).
      *
      * <p>The relevant IDs must still be registered separately as
      * factories or classes.
      *
      * <p>Only the targets are specified.  Special inverses always
      * have the form Any-Target1 <=> Any-Target2.  The target should
      * have canonical casing (the casing desired to be produced when
      * an inverse is formed) and should contain no whitespace or other
      * extraneous characters.
      *
      * @param target the target against which to register the inverse
      * @param inverseTarget the inverse of target, that is
      * Any-target.getInverse() => Any-inverseTarget
      * @param bidirectional if true, register the reverse relation
      * as well, that is, Any-inverseTarget.getInverse() => Any-target
      */
     static void registerSpecialInverse(const UnicodeString& target,
                                        const UnicodeString& inverseTarget,
                                        UBool bidirectional,
                                        UErrorCode &status);
     /**
      * Free static memory.
      */
     static void cleanup();
  private:
     //----------------------------------------------------------------
     // Private implementation
     //----------------------------------------------------------------
     // forbid instantiation
     TransliteratorIDParser();
     /**
      * Parse an ID into component pieces.  Take IDs of the form T,
      * T/V, S-T, S-T/V, or S/V-T.  If the source is missing, return a
      * source of ANY.
      * @param id the id string, in any of several forms
      * @param pos INPUT-OUTPUT parameter.  On input, pos[0] is the
      * offset of the first character to parse in id.  On output,
      * pos[0] is the offset after the last parsed character.  If the
      * parse failed, pos[0] will be unchanged.
      * @param allowFilter if true, a UnicodeSet pattern is allowed
      * at any location between specs or delimiters, and is returned
      * as the fifth string in the array.
      * @return a Specs object, or null if the parse failed.  If
      * neither source nor target was seen in the parsed id, then the
      * parse fails.  If allowFilter is true, then the parsed filter
      * pattern is returned in the Specs object, otherwise the returned
      * filter reference is null.  If the parse fails for any reason
      * null is returned.
      */
     static Specs* parseFilterID(const UnicodeString& id, int32_t& pos,
                                 UBool allowFilter);
     /**
      * Givens a Specs object, convert it to a SingleID object.  The
      * Spec object is a more unprocessed parse result.  The SingleID
      * object contains information about canonical and basic IDs.
      * @param specs the given Specs object.
      * @param dir   either FORWARD or REVERSE.
      * @return a SingleID; never returns null.  Returned object always
      * has 'filter' field of null.
      */
     static SingleID* specsToID(const Specs* specs, int32_t dir);
     /**
      * Given a Specs object, return a SingleID representing the
      * special inverse of that ID.  If there is no special inverse
      * then return null.
      * @param specs the given Specs.
      * @return a SingleID or null.  Returned object always has
      * 'filter' field of null.
      */
     static SingleID* specsToSpecialInverse(const Specs& specs, UErrorCode &status);
     /**
      * Glue method to get around access problems in C++.
      * @param id the id string for the transliterator, in any of several forms
      * @param canonID the given canonical ID
      */
     static Transliterator* createBasicInstance(const UnicodeString& id,
                                                const UnicodeString* canonID);
     /**
      * Initialize static memory.
      */
     static void init(UErrorCode &status);
     friend class SingleID;
 };
 U_NAMESPACE_END
 #endif /* #if !UCONFIG_NO_TRANSLITERATION */
 #endif

The Tor Browser / annotate

intl/icu/source/i18n/tridpars.h@fc2d59ddac77 (annotated)

intl/icu/source/i18n/tridpars.h