Update ICU to 54.1 step 1

source/i18n/unicode/alphaindex.h

 /*
 *******************************************************************************
 *
-*   Copyright (C) 2011-2013 International Business Machines
+*   Copyright (C) 2011-2014 International Business Machines
 *   Corporation and others.  All Rights Reserved.
 *
 *******************************************************************************
 */
 
 #ifndef INDEXCHARS_H
 #define INDEXCHARS_H
 
 #include "unicode/utypes.h"
 #include "unicode/uobject.h"
 #include "unicode/locid.h"
 
-
-#if !UCONFIG_NO_COLLATION && !UCONFIG_NO_NORMALIZATION
+#if !UCONFIG_NO_COLLATION
 
 /**
  * \file
  * \brief C++ API: Index Characters
  */
 
 U_CDECL_BEGIN
 
 /**
  * Constants for Alphabetic Index Label Types.
@@ skipping 150 matching lines @@
  * </pre>
  *
  * <li>The client would put the name (and associated information) into its bucket for bucketIndex. The sort key sk is a
  * sequence of bytes that can be compared with a binary compare, and produce the right localized result.</li>
  * </ul>
  *
  * @stable ICU 4.8
  */
 class U_I18N_API AlphabeticIndex: public UObject {
 public:
-#ifdef U_HIDE_DRAFT_API
-    class Bucket;
-#else
      /**
       * An index "bucket" with a label string and type.
       * It is referenced by getBucketIndex(),
       * and returned by ImmutableIndex.getBucket().
       *
       * The Bucket class is not intended for public subclassing.
-      * @draft ICU 51
+      * @stable ICU 51
       */
      class U_I18N_API Bucket : public UObject {
      public:
         /**
          * Destructor.
-         * @draft ICU 51
+         * @stable ICU 51
          */
         virtual ~Bucket();
 
         /**
          * Returns the label string.
          *
          * @return the label string for the bucket
-         * @draft ICU 51
+         * @stable ICU 51
          */
         const UnicodeString &getLabel() const { return label_; }
         /**
          * Returns whether this bucket is a normal, underflow, overflow, or inflow bucket.
          *
          * @return the bucket label type
-         * @draft ICU 51
+         * @stable ICU 51
          */
         UAlphabeticIndexLabelType getLabelType() const { return labelType_; }
 
      private:
         friend class AlphabeticIndex;
         friend class BucketList;
 
         UnicodeString label_;
         UnicodeString lowerBoundary_;
         UAlphabeticIndexLabelType labelType_;
         Bucket *displayBucket_;
         int32_t displayIndex_;
         UVector *records_;  // Records are owned by the inputList_ vector.
 
         Bucket(const UnicodeString &label,   // Parameter strings are copied.
                const UnicodeString &lowerBoundary,
                UAlphabeticIndexLabelType type);
      };
 
     /**
      * Immutable, thread-safe version of AlphabeticIndex.
      * This class provides thread-safe methods for bucketing,
      * and random access to buckets and their properties,
      * but does not offer adding records to the index.
      *
      * The ImmutableIndex class is not intended for public subclassing.
      *
-     * @draft ICU 51
+     * @stable ICU 51
      */
     class U_I18N_API ImmutableIndex : public UObject {
     public:
         /**
          * Destructor.
-         * @draft ICU 51
+         * @stable ICU 51
          */
         virtual ~ImmutableIndex();
 
         /**
          * Returns the number of index buckets and labels, including underflow/inflow/overflow.
          *
          * @return the number of index buckets
-         * @draft ICU 51
+         * @stable ICU 51
          */
         int32_t getBucketCount() const;
 
         /**
          * Finds the index bucket for the given name and returns the number of that bucket.
          * Use getBucket() to get the bucket's properties.
          *
          * @param name the string to be sorted into an index bucket
          * @return the bucket number for the name
-         * @draft ICU 51
+         * @stable ICU 51
          */
         int32_t getBucketIndex(const UnicodeString &name, UErrorCode &errorCode) const;
 
         /**
          * Returns the index-th bucket. Returns NULL if the index is out of range.
          *
          * @param index bucket number
          * @return the index-th bucket
-         * @draft ICU 51
+         * @stable ICU 51
          */
         const Bucket *getBucket(int32_t index) const;
 
     private:
         friend class AlphabeticIndex;
 
         ImmutableIndex(BucketList *bucketList, Collator *collatorPrimaryOnly)
                 : buckets_(bucketList), collatorPrimaryOnly_(collatorPrimaryOnly) {}
 
         BucketList *buckets_;
         Collator *collatorPrimaryOnly_;
     };
-#endif  /* U_HIDE_DRAFT_API */
 
     /**
      * Construct an AlphabeticIndex object for the specified locale.  If the locale's
      * data does not include index characters, a set of them will be
      * synthesized based on the locale's exemplar characters.  The locale
      * determines the sorting order for both the index characters and the
      * user item names appearing under each Index character.
      *
      * @param locale the desired locale.
      * @param status Error code, will be set with the reason if the construction
      *               of the AlphabeticIndex object fails.
      * @stable ICU 4.8
      */
      AlphabeticIndex(const Locale &locale, UErrorCode &status);
 
-#ifndef U_HIDE_DRAFT_API
    /** 
      * Construct an AlphabeticIndex that uses a specific collator.
      * 
      * The index will be created with no labels; the addLabels() function must be called
      * after creation to add the desired labels to the index.
      * 
      * The index adopts the collator, and is responsible for deleting it. 
      * The caller should make no further use of the collator after creating the index.
      * 
      * @param collator The collator to use to order the contents of this index.
      * @param status Error code, will be set with the reason if the 
      *               operation fails.
-     * @draft ICU 51
+     * @stable ICU 51
      */
     AlphabeticIndex(RuleBasedCollator *collator, UErrorCode &status);
-#endif  /* U_HIDE_DRAFT_API */
 
     /**
      * Add Labels to this Index.  The labels are additions to those
      * that are already in the index; they do not replace the existing
      * ones.
      * @param additions The additional characters to add to the index, such as A-Z.
      * @param status Error code, will be set with the reason if the 
      *               operation fails.
      * @return this, for chaining
      * @stable ICU 4.8
@@ skipping 14 matching lines @@
      * @stable ICU 4.8
      */
     virtual AlphabeticIndex &addLabels(const Locale &locale, UErrorCode &status);
 
      /**
       * Destructor
       * @stable ICU 4.8
       */
     virtual ~AlphabeticIndex();
 
-#ifndef U_HIDE_DRAFT_API
     /**
      * Builds an immutable, thread-safe version of this instance, without data records.
      *
      * @return an immutable index instance
-     * @draft ICU 51
+     * @stable ICU 51
      */
     ImmutableIndex *buildImmutableIndex(UErrorCode &errorCode);
-#endif  /* U_HIDE_DRAFT_API */
 
     /**
      * Get the Collator that establishes the ordering of the items in this index.
      * Ownership of the collator remains with the AlphabeticIndex instance.
      *
      * The returned collator is a reference to the internal collator used by this
      * index.  It may be safely used to compare the names of items or to get
      * sort keys for names.  However if any settings need to be changed,
      * or other non-const methods called, a cloned copy must be made first.
      *
@@ skipping 371 matching lines @@
     UnicodeString  inflowLabel_;
     UnicodeString  overflowLabel_;
     UnicodeString  underflowLabel_;
     UnicodeString  overflowComparisonString_;
 
     UnicodeString emptyString_;
 };
 
 U_NAMESPACE_END
 
-#endif /* UCONFIG_NO_COLLATION / UCONFIG_NO_NORMALIZATION */
+#endif  // !UCONFIG_NO_COLLATION
 #endif