Update ICU to 54.1 step 1

source/common/unicode/uset.h

 /*
 *******************************************************************************
 *
-*   Copyright (C) 2002-2012, International Business Machines
+*   Copyright (C) 2002-2014, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 *
 *******************************************************************************
 *   file name:  uset.h
 *   encoding:   US-ASCII
 *   tab size:   8 (not used)
 *   indentation:4
 *
 *   created on: 2002mar07
 *   created by: Markus W. Scherer
@@ skipping 76 matching lines @@
      */
     USET_ADD_CASE_MAPPINGS = 4
 };
 
 /**
  * Argument values for whether span() and similar functions continue while
  * the current character is contained vs. not contained in the set.
  *
  * The functionality is straightforward for sets with only single code points,
  * without strings (which is the common case):
- * - USET_SPAN_CONTAINED and USET_SPAN_SIMPLE
- *   work the same.
+ * - USET_SPAN_CONTAINED and USET_SPAN_SIMPLE work the same.
+ * - USET_SPAN_CONTAINED and USET_SPAN_SIMPLE are inverses of USET_SPAN_NOT_CONTAINED.
  * - span() and spanBack() partition any string the same way when
  *   alternating between span(USET_SPAN_NOT_CONTAINED) and
  *   span(either "contained" condition).
  * - Using a complemented (inverted) set and the opposite span conditions
  *   yields the same results.
  *
  * When a set contains multi-code point strings, then these statements may not
  * be true, depending on the strings in the set (for example, whether they
  * overlap with each other) and the string that is processed.
  * For a set with strings:
@@ skipping 29 matching lines @@
  * never in the middle of a surrogate pair.
  * Illegal UTF-8 sequences are treated like U+FFFD.
  * When processing UTF-8 strings, malformed set strings
  * (strings with unpaired surrogates which cannot be converted to UTF-8)
  * are ignored.
  *
  * @stable ICU 3.8
  */
 typedef enum USetSpanCondition {
     /**
-     * Continue a span() while there is no set element at the current position.
+     * Continues a span() while there is no set element at the current position.
+     * Increments by one code point at a time.
      * Stops before the first set element (character or string).
      * (For code points only, this is like while contains(current)==FALSE).
      *
      * When span() returns, the substring between where it started and the position
      * it returned consists only of characters that are not in the set,
      * and none of its strings overlap with the span.
      *
      * @stable ICU 3.8
      */
     USET_SPAN_NOT_CONTAINED = 0,
     /**
-     * Continue a span() while there is a set element at the current position.
+     * Spans the longest substring that is a concatenation of set elements (characters or strings).
      * (For characters only, this is like while contains(current)==TRUE).
      *
      * When span() returns, the substring between where it started and the position
      * it returned consists only of set elements (characters or strings) that are in the set.
      *
-     * If a set contains strings, then the span will be the longest substring
-     * matching any of the possible concatenations of set elements (characters or strings).
-     * (There must be a single, non-overlapping concatenation of characters or strings.)
-     * This is equivalent to a POSIX regular expression for (OR of each set element)*.
+     * If a set contains strings, then the span will be the longest substring for which there
+     * exists at least one non-overlapping concatenation of set elements (characters or strings).
+     * This is equivalent to a POSIX regular expression for <code>(OR of each set element)*</code>.
+     * (Java/ICU/Perl regex stops at the first match of an OR.)
      *
      * @stable ICU 3.8
      */
     USET_SPAN_CONTAINED = 1,
     /**
-     * Continue a span() while there is a set element at the current position.
+     * Continues a span() while there is a set element at the current position.
+     * Increments by the longest matching element at each position.
      * (For characters only, this is like while contains(current)==TRUE).
      *
      * When span() returns, the substring between where it started and the position
      * it returned consists only of set elements (characters or strings) that are in the set.
      *
      * If a set only contains single characters, then this is the same
      * as USET_SPAN_CONTAINED.
      *
      * If a set contains strings, then the span will be the longest substring
      * with a match at each position with the longest single set element (character or string).
@@ skipping 925 matching lines @@
  * @param pEnd pointer to variable to receive last character in range,
  * inclusive
  * @return true if rangeIndex is valid, otherwise false
  * @stable ICU 2.4
  */
 U_STABLE UBool U_EXPORT2
 uset_getSerializedRange(const USerializedSet* set, int32_t rangeIndex,
                         UChar32* pStart, UChar32* pEnd);
 
 #endif