ICU 56 update step 1

source/i18n/collationbuilder.h

 /*
 *******************************************************************************
 * Copyright (C) 2013-2014, International Business Machines
 * Corporation and others.  All Rights Reserved.
 *******************************************************************************
 * collationbuilder.h
 *
 * created on: 2013may06
 * created by: Markus W. Scherer
 */
@@ skipping 38 matching lines @@
                                       UErrorCode &errorCode);
 
     const char *getErrorReason() const { return errorReason; }
 
 private:
     friend class CEFinalizer;
 
     /** Implements CollationRuleParser::Sink. */
     virtual void addReset(int32_t strength, const UnicodeString &str,
                           const char *&errorReason, UErrorCode &errorCode);
+    /**
+     * Returns the secondary or tertiary weight preceding the current node's weight.
+     * node=nodes[index].
+     */
+    uint32_t getWeight16Before(int32_t index, int64_t node, int32_t level);
 
     int64_t getSpecialResetPosition(const UnicodeString &str,
                                     const char *&parserErrorReason, UErrorCode &errorCode);
 
     /** Implements CollationRuleParser::Sink. */
     virtual void addRelation(int32_t strength, const UnicodeString &prefix,
                              const UnicodeString &str, const UnicodeString &extension,
                              const char *&errorReason, UErrorCode &errorCode);
 
     /**
@@ skipping 20 matching lines @@
     /**
      * Inserts a new node into the list, between list-adjacent items.
      * The node's previous and next indexes must not be set yet.
      * @return the new node's index
      */
     int32_t insertNodeBetween(int32_t index, int32_t nextIndex, int64_t node,
                               UErrorCode &errorCode);
 
     /**
      * Finds the node which implies or contains a common=05 weight of the given strength
-     * (secondary or tertiary).
+     * (secondary or tertiary), if the current node is stronger.
      * Skips weaker nodes and tailored nodes if the current node is stronger
      * and is followed by an explicit-common-weight node.
      * Always returns the input index if that node is no stronger than the given strength.
      */
     int32_t findCommonNode(int32_t index, int32_t strength) const;
 
     void setCaseBits(const UnicodeString &nfdString,
                      const char *&parserErrorReason, UErrorCode &errorCode);
 
     /** Implements CollationRuleParser::Sink. */
@@ skipping 98 matching lines @@
             ((int32_t)(tempCE32 >> 8) & 0x3f);
     }
     static inline UBool isTempCE32(uint32_t ce32) {
         return
             (ce32 & 0xff) >= 2 &&  // not a long-primary/long-secondary CE32
             6 <= ((ce32 >> 8) & 0xff) && ((ce32 >> 8) & 0xff) <= 0x45;
     }
 
     static int32_t ceStrength(int64_t ce);
 
-    /** The secondary/tertiary lower limit for tailoring before the common weight. */
-    static const uint32_t BEFORE_WEIGHT16 = Collation::MERGE_SEPARATOR_WEIGHT16;
-
     /** At most 1M nodes, limited by the 20 bits in node bit fields. */
     static const int32_t MAX_INDEX = 0xfffff;
     /**
-     * Node bit 6 is set on a primary node if there are tailored nodes
-     * with secondary values below the common secondary weight (05),
-     * from a reset-secondary-before (&[before 2]).
+     * Node bit 6 is set on a primary node if there are nodes
+     * with secondary values below the common secondary weight (05).
      */
     static const int32_t HAS_BEFORE2 = 0x40;
     /**
-     * Node bit 5 is set on a primary or secondary node if there are tailored nodes
-     * with tertiary values below the common tertiary weight (05),
-     * from a reset-tertiary-before (&[before 3]).
+     * Node bit 5 is set on a primary or secondary node if there are nodes
+     * with tertiary values below the common tertiary weight (05).
      */
     static const int32_t HAS_BEFORE3 = 0x20;
     /**
      * Node bit 3 distinguishes a tailored node, which has no weight value,
      * from a node with an explicit (root or default) weight.
      */
     static const int32_t IS_TAILORED = 8;
 
     static inline int64_t nodeFromWeight32(uint32_t weight32) {
         return (int64_t)weight32 << 32;
@@ skipping 91 matching lines @@
      * create a difference of a certain strength from the preceding node.
      *
      * A root node is followed by either
      * - a root/default node of the same strength, or
      * - a root/default node of the next-weaker strength, or
      * - a tailored node of the same strength.
      *
      * A node of a given strength normally implies "common" weights on weaker levels.
      *
      * A node with HAS_BEFORE2 must be immediately followed by
-     * a secondary node with BEFORE_WEIGHT16, then a secondary tailored node,
+     * a secondary node with an explicit below-common weight, then a secondary tailored node,
      * and later an explicit common-secondary node.
-     * (&[before 2] resets to the BEFORE_WEIGHT16 node so that
+     * The below-common weight can be a root weight,
+     * or it can be BEFORE_WEIGHT16 for tailoring before an implied common weight
+     * or before the lowest root weight.
+     * (&[before 2] resets to an explicit secondary node so that
      * the following addRelation(secondary) tailors right after that.
      * If we did not have this node and instead were to reset on the primary node,
      * then addRelation(secondary) would skip forward to the the COMMON_WEIGHT16 node.)
      *
-     * All secondary tailored nodes between these two explicit ones
-     * will be assigned lower-than-common secondary weights.
      * If the flag is not set, then there are no explicit secondary nodes
      * with the common or lower weights.
      *
      * Same for HAS_BEFORE3 for tertiary nodes and weights.
      * A node must not have both flags set.
      *
      * Tailored CEs are initially represented in a CollationDataBuilder as temporary CEs
      * which point to stable indexes in this list,
      * and temporary CEs stored in a CollationDataBuilder only point to tailored nodes.
      *
@@ skipping 34 matching lines @@
      * in a pointer list so that they can be indexed from temporary CEs,
      * and they would require more memory allocations.
      */
     UVector64 nodes;
 };
 
 U_NAMESPACE_END
 
 #endif  // !UCONFIG_NO_COLLATION
 #endif  // __COLLATIONBUILDER_H__