ICU 56 update step 1

source/i18n/collationrootelements.h

 /*
 *******************************************************************************
 * Copyright (C) 2013-2014, International Business Machines
 * Corporation and others.  All Rights Reserved.
 *******************************************************************************
 * collationrootelements.h
 *
 * created on: 2013mar01
 * created by: Markus W. Scherer
 */
@@ skipping 171 matching lines @@
     int32_t findPrimary(uint32_t p) const;
 
     /**
      * Returns the primary weight after p where index=findPrimary(p).
      * p must be at least the first root primary.
      */
     uint32_t getPrimaryAfter(uint32_t p, int32_t index, UBool isCompressible) const;
     /**
      * Returns the secondary weight after [p, s] where index=findPrimary(p)
      * except use index=0 for p=0.
+     *
+     * Must return a weight for every root [p, s] as well as for every weight
+     * returned by getSecondaryBefore(). If p!=0 then s can be BEFORE_WEIGHT16.
+     *
+     * Exception: [0, 0] is handled by the CollationBuilder:
+     * Both its lower and upper boundaries are special.
      */
     uint32_t getSecondaryAfter(int32_t index, uint32_t s) const;
     /**
      * Returns the tertiary weight after [p, s, t] where index=findPrimary(p)
      * except use index=0 for p=0.
+     *
+     * Must return a weight for every root [p, s, t] as well as for every weight
+     * returned by getTertiaryBefore(). If s!=0 then t can be BEFORE_WEIGHT16.
+     *
+     * Exception: [0, 0, 0] is handled by the CollationBuilder:
+     * Both its lower and upper boundaries are special.
      */
     uint32_t getTertiaryAfter(int32_t index, uint32_t s, uint32_t t) const;
 
 private:
     /**
+     * Returns the first secondary & tertiary weights for p where index=findPrimary(p)+1.
+     */
+    uint32_t getFirstSecTerForPrimary(int32_t index) const;
+
+    /**
      * Finds the largest index i where elements[i]<=p.
      * Requires first primary<=p<0xffffff00 (PRIMARY_SENTINEL).
      * Does not require that p is a root collator primary.
      */
     int32_t findP(uint32_t p) const;
 
     static inline UBool isEndOfPrimaryRange(uint32_t q) {
         return (q & SEC_TER_DELTA_FLAG) == 0 && (q & PRIMARY_STEP_MASK) != 0;
     }
 
     /**
      * Data structure:
      *
      * The first few entries are indexes, up to elements[IX_FIRST_TERTIARY_INDEX].
      * See the comments on the IX_ constants.
      *
      * All other elements are a compact form of the root collator CEs
-     * in collation order.
+     * in mostly collation order.
      *
-     * Primary weights have the SEC_TER_DELTA_FLAG flag not set.
-     * A primary-weight element by itself represents a root CE
-     * with Collation::COMMON_SEC_AND_TER_CE.
+     * A sequence of one or more root CEs with the same primary weight is stored as
+     * one element with the primary weight, with the SEC_TER_DELTA_FLAG flag not set,
+     * followed by elements with only the secondary/tertiary weights,
+     * each with that flag set.
+     * If the lowest secondary/tertiary combination is Collation::COMMON_SEC_AND_TER_CE,
+     * then the element for that combination is omitted.
      *
-     * If there are root CEs with the same primary but other secondary/tertiary weights,
-     * then for each such CE there is an element with those secondary and tertiary weights,
-     * and with the SEC_TER_DELTA_FLAG flag set.
+     * Note: If the first actual secondary/tertiary combination is higher than
+     * Collation::COMMON_SEC_AND_TER_CE (which is unusual),
+     * the runtime code will assume anyway that Collation::COMMON_SEC_AND_TER_CE is present.
      *
      * A range of only-primary CEs with a consistent "step" increment
      * from each primary to the next may be stored as a range.
      * Only the first and last primary are stored, and the last has the step
      * value in the low bits (PRIMARY_STEP_MASK).
      *
      * An range-end element may also either start a new range or be followed by
      * elements with secondary/tertiary deltas.
      *
      * A primary element that is not a range end has zero step bits.
      *
      * There is no element for the completely ignorable CE (all weights 0).
      *
      * Before elements[IX_FIRST_PRIMARY_INDEX], all elements are secondary/tertiary deltas,
      * for all of the ignorable root CEs.
      *
      * There are no elements for unassigned-implicit primary CEs.
      * All primaries stored here are at most 3 bytes long.
      */
     const uint32_t *elements;
     int32_t length;
 };
 
 U_NAMESPACE_END
 
 #endif  // !UCONFIG_NO_COLLATION
 #endif  // __COLLATIONROOTELEMENTS_H__