ICU-64260.0.1.tar.gz

[apple/icu.git] / icuSources / common / uvector.h

diff --git a/icuSources/common/uvector.h b/icuSources/common/uvector.h
index 994aa43f2a8cceeab576bc1bdd0c6f447d1d42c8..98318d14c60063dcb0279897f80441f7f20d365b 100644 (file)
--- a/icuSources/common/uvector.h
+++ b/icuSources/common/uvector.h
@@ -1,6 +1,8 @@
+// © 2016 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html

 /*
 **********************************************************************
 /*
 **********************************************************************

-*   Copyright (C) 1999-2003, International Business Machines
+*   Copyright (C) 1999-2016, International Business Machines

 *   Corporation and others.  All Rights Reserved.
 **********************************************************************
 *   Date        Name        Description
 *   Corporation and others.  All Rights Reserved.
 **********************************************************************
 *   Date        Name        Description


@@ -14,29 +16,12 @@
 
 #include "unicode/utypes.h"
 #include "unicode/uobject.h"
 
 #include "unicode/utypes.h"
 #include "unicode/uobject.h"

-#include "uhash.h"
+#include "cmemory.h"
+#include "uarrsort.h"
+#include "uelement.h"

 
 U_NAMESPACE_BEGIN
 
 
 U_NAMESPACE_BEGIN
 

-/**
- * A token comparison function.
- * @param tok1 A token (object or integer)
- * @param tok2 A token (object or integer)
- * @return 0 if the two tokens are equal, -1 if tok1 is < tok2, or
- * +1 if tok1 is > tok2.
- */
-typedef int8_t U_CALLCONV USortComparator(UHashTok tok1,
-                                          UHashTok tok2);
-
-/**
- * A token assignment function.  It may copy an integer, copy
- * a pointer, or clone a pointer, as appropriate.
- * @param dst The token to be assigned to
- * @param src The token to assign from
- */
-typedef void U_CALLCONV UTokenAssigner(UHashTok *dst,
-                                       UHashTok *src);
-

 /**
  * <p>Ultralightweight C++ implementation of a <tt>void*</tt> vector
  * that is (mostly) compatible with java.util.Vector.
 /**
  * <p>Ultralightweight C++ implementation of a <tt>void*</tt> vector
  * that is (mostly) compatible with java.util.Vector.


@@ -76,7 +61,7 @@ typedef void U_CALLCONV UTokenAssigner(UHashTok *dst,
  *
  * <p>In order to implement methods such as contains() and indexOf(),
  * UVector needs a way to compare objects for equality.  To do so, it
  *
  * <p>In order to implement methods such as contains() and indexOf(),
  * UVector needs a way to compare objects for equality.  To do so, it

- * uses a comparison frunction, or "comparer."  If the comparer is not
+ * uses a comparison function, or "comparer."  If the comparer is not

  * set, or is set to zero, then all such methods will act as if the
  * vector contains no element.  That is, indexOf() will always return
  * -1, contains() will always return FALSE, etc.
  * set, or is set to zero, then all such methods will act as if the
  * vector contains no element.  That is, indexOf() will always return
  * -1, contains() will always return FALSE, etc.


@@ -89,7 +74,7 @@ typedef void U_CALLCONV UTokenAssigner(UHashTok *dst,
  */
 class U_COMMON_API UVector : public UObject {
     // NOTE: UVector uses the UHashKey (union of void* and int32_t) as
  */
 class U_COMMON_API UVector : public UObject {
     // NOTE: UVector uses the UHashKey (union of void* and int32_t) as

-    // its basic storage type.  It uses UKeyComparator as its
+    // its basic storage type.  It uses UElementsAreEqual as its

     // comparison function.  It uses UObjectDeleter as its deleter
     // function.  These are named for hashtables, but used here as-is
     // rather than duplicating the type.  This allows sharing of
     // comparison function.  It uses UObjectDeleter as its deleter
     // function.  These are named for hashtables, but used here as-is
     // rather than duplicating the type.  This allows sharing of


@@ -100,28 +85,28 @@ private:
 
     int32_t capacity;
 
 
     int32_t capacity;
 

-    UHashTok* elements;
+    UElement* elements;

 
     UObjectDeleter *deleter;
 
 
     UObjectDeleter *deleter;
 

-    UKeyComparator *comparer;
+    UElementsAreEqual *comparer;

 
 public:
     UVector(UErrorCode &status);
 
     UVector(int32_t initialCapacity, UErrorCode &status);
 
 
 public:
     UVector(UErrorCode &status);
 
     UVector(int32_t initialCapacity, UErrorCode &status);
 

-    UVector(UObjectDeleter *d, UKeyComparator *c, UErrorCode &status);
+    UVector(UObjectDeleter *d, UElementsAreEqual *c, UErrorCode &status);

 
 

-    UVector(UObjectDeleter *d, UKeyComparator *c, int32_t initialCapacity, UErrorCode &status);
+    UVector(UObjectDeleter *d, UElementsAreEqual *c, int32_t initialCapacity, UErrorCode &status);

 
 

-    ~UVector();
+    virtual ~UVector();

 
     /**
      * Assign this object to another (make this a copy of 'other').
      * Use the 'assign' function to assign each element.
      */
 
     /**
      * Assign this object to another (make this a copy of 'other').
      * Use the 'assign' function to assign each element.
      */

-    void assign(const UVector& other, UTokenAssigner *assign, UErrorCode &ec);
+    void assign(const UVector& other, UElementAssigner *assign, UErrorCode &ec);

 
     /**
      * Compare this vector with another.  They will be considered
 
     /**
      * Compare this vector with another.  They will be considered


@@ -157,19 +142,19 @@ public:
 
     UBool equals(const UVector &other) const;
 
 
     UBool equals(const UVector &other) const;
 

-    void* firstElement(void) const;
+    inline void* firstElement(void) const;

 
 

-    void* lastElement(void) const;
+    inline void* lastElement(void) const;

 
 

-    int32_t lastElementi(void) const;
+    inline int32_t lastElementi(void) const;

 
     int32_t indexOf(void* obj, int32_t startIndex = 0) const;
 
     int32_t indexOf(int32_t obj, int32_t startIndex = 0) const;
 
 
     int32_t indexOf(void* obj, int32_t startIndex = 0) const;
 
     int32_t indexOf(int32_t obj, int32_t startIndex = 0) const;
 

-    UBool contains(void* obj) const;
+    inline UBool contains(void* obj) const;

 
 

-    UBool contains(int32_t obj) const;
+    inline UBool contains(int32_t obj) const;

 
     UBool containsAll(const UVector& other) const;
 
 
     UBool containsAll(const UVector& other) const;
 


@@ -183,9 +168,9 @@ public:
 
     void removeAllElements();
 
 
     void removeAllElements();
 

-    int32_t size(void) const;
+    inline int32_t size(void) const;

 
 

-    UBool isEmpty(void) const;
+    inline UBool isEmpty(void) const;

 
     UBool ensureCapacity(int32_t minimumCapacity, UErrorCode &status);
 
 
     UBool ensureCapacity(int32_t minimumCapacity, UErrorCode &status);
 


@@ -193,9 +178,9 @@ public:
      * Change the size of this vector as follows: If newSize is
      * smaller, then truncate the array, possibly deleting held
      * elements for i >= newSize.  If newSize is larger, grow the
      * Change the size of this vector as follows: If newSize is
      * smaller, then truncate the array, possibly deleting held
      * elements for i >= newSize.  If newSize is larger, grow the

-     * array, filling in new slows with NULL.
+     * array, filling in new slots with NULL.

      */
      */

-    void setSize(int32_t newSize);
+    void setSize(int32_t newSize, UErrorCode &status);

 
     /**
      * Fill in the given array with all elements of this vector.
 
     /**
      * Fill in the given array with all elements of this vector.


@@ -208,9 +193,9 @@ public:
 
     UObjectDeleter *setDeleter(UObjectDeleter *d);
 
 
     UObjectDeleter *setDeleter(UObjectDeleter *d);
 

-    UKeyComparator *setComparer(UKeyComparator *c);
+    UElementsAreEqual *setComparer(UElementsAreEqual *c);

 
 

-    void* operator[](int32_t index) const;
+    inline void* operator[](int32_t index) const;

 
     /**
      * Removes the element at the given index from this vector and
 
     /**
      * Removes the element at the given index from this vector and


@@ -236,35 +221,53 @@ public:
      * as defined by 'compare'.  The current elements are assumed to
      * be sorted already.
      */
      * as defined by 'compare'.  The current elements are assumed to
      * be sorted already.
      */

-    void sortedInsert(void* obj, USortComparator *compare, UErrorCode& ec);
+    void sortedInsert(void* obj, UElementComparator *compare, UErrorCode& ec);

 
     /**
      * Insert the given integer into this vector at its sorted position
      * as defined by 'compare'.  The current elements are assumed to
      * be sorted already.
      */
 
     /**
      * Insert the given integer into this vector at its sorted position
      * as defined by 'compare'.  The current elements are assumed to
      * be sorted already.
      */

-    void sortedInsert(int32_t obj, USortComparator *compare, UErrorCode& ec);
+    void sortedInsert(int32_t obj, UElementComparator *compare, UErrorCode& ec);
+
+    /**
+     * Sort the contents of the vector, assuming that the contents of the
+     * vector are of type int32_t.
+     */
+    void sorti(UErrorCode &ec);
+
+    /**
+      * Sort the contents of this vector, using a caller-supplied function
+      * to do the comparisons.  (It's confusing that
+      *  UVector's UElementComparator function is different from the
+      *  UComparator function type defined in uarrsort.h)
+      */
+    void sort(UElementComparator *compare, UErrorCode &ec);
+
+    /**
+     * Stable sort the contents of this vector using a caller-supplied function
+     * of type UComparator to do the comparison.  Provides more flexibility
+     * than UVector::sort() because an additional user parameter can be passed to
+     * the comparison function.
+     */
+    void sortWithUComparator(UComparator *compare, const void *context, UErrorCode &ec);

 
     /**
      * ICU "poor man's RTTI", returns a UClassID for this class.
 
     /**
      * ICU "poor man's RTTI", returns a UClassID for this class.

-     *
-     * @draft ICU 2.2

      */
      */

-    static inline UClassID getStaticClassID() { return (UClassID)&fgClassID; }
+    static UClassID U_EXPORT2 getStaticClassID();

 
     /**
      * ICU "poor man's RTTI", returns a UClassID for the actual class.
 
     /**
      * ICU "poor man's RTTI", returns a UClassID for the actual class.

-     *
-     * @draft ICU 2.2

      */
      */

-    virtual inline UClassID getDynamicClassID() const { return getStaticClassID(); }
+    virtual UClassID getDynamicClassID() const;

 
 private:
     void _init(int32_t initialCapacity, UErrorCode &status);
 
 
 private:
     void _init(int32_t initialCapacity, UErrorCode &status);
 

-    int32_t indexOf(UHashTok key, int32_t startIndex = 0, int8_t hint = 0) const;
+    int32_t indexOf(UElement key, int32_t startIndex = 0, int8_t hint = 0) const;

 
 

-    void sortedInsert(UHashTok tok, USortComparator *compare, UErrorCode& ec);
+    void sortedInsert(UElement e, UElementComparator *compare, UErrorCode& ec);

 
     // Disallow
     UVector(const UVector&);
 
     // Disallow
     UVector(const UVector&);


@@ -272,11 +275,6 @@ private:
     // Disallow
     UVector& operator=(const UVector&);
 
     // Disallow
     UVector& operator=(const UVector&);
 

-    /**
-     * The address of this static class variable serves as this class's ID
-     * for ICU "poor man's RTTI".
-     */
-    static const char fgClassID;

 };
 
 
 };
 
 


@@ -302,42 +300,44 @@ public:
 
     UStack(int32_t initialCapacity, UErrorCode &status);
 
 
     UStack(int32_t initialCapacity, UErrorCode &status);
 

-    UStack(UObjectDeleter *d, UKeyComparator *c, UErrorCode &status);
+    UStack(UObjectDeleter *d, UElementsAreEqual *c, UErrorCode &status);
+
+    UStack(UObjectDeleter *d, UElementsAreEqual *c, int32_t initialCapacity, UErrorCode &status);

 
 

-    UStack(UObjectDeleter *d, UKeyComparator *c, int32_t initialCapacity, UErrorCode &status);
+    virtual ~UStack();

 
     // It's okay not to have a virtual destructor (in UVector)
     // because UStack has no special cleanup to do.
 
 
     // It's okay not to have a virtual destructor (in UVector)
     // because UStack has no special cleanup to do.
 

-    UBool empty(void) const;
+    inline UBool empty(void) const;

 
 

-    void* peek(void) const;
+    inline void* peek(void) const;

 
 

-    int32_t peeki(void) const;
+    inline int32_t peeki(void) const;

     
     void* pop(void);
     
     int32_t popi(void);
     
     
     void* pop(void);
     
     int32_t popi(void);
     

-    void* push(void* obj, UErrorCode &status);
+    inline void* push(void* obj, UErrorCode &status);

 
 

-    int32_t push(int32_t i, UErrorCode &status);
+    inline int32_t push(int32_t i, UErrorCode &status);

 
 

+    /*
+    If the object o occurs as an item in this stack,
+    this method returns the 1-based distance from the top of the stack.
+    */

     int32_t search(void* obj) const;
 
     /**
      * ICU "poor man's RTTI", returns a UClassID for this class.
     int32_t search(void* obj) const;
 
     /**
      * ICU "poor man's RTTI", returns a UClassID for this class.

-     *
-     * @draft ICU 2.2

      */
      */

-    static inline UClassID getStaticClassID() { return (UClassID)&fgClassID; }
+    static UClassID U_EXPORT2 getStaticClassID();

 
     /**
      * ICU "poor man's RTTI", returns a UClassID for the actual class.
 
     /**
      * ICU "poor man's RTTI", returns a UClassID for the actual class.

-     *
-     * @draft ICU 2.2

      */
      */

-    virtual inline UClassID getDynamicClassID() const { return getStaticClassID(); }
+    virtual UClassID getDynamicClassID() const;

 
 private:
     // Disallow
 
 private:
     // Disallow


@@ -345,12 +345,6 @@ private:
 
     // Disallow
     UStack& operator=(const UStack&);
 
     // Disallow
     UStack& operator=(const UStack&);

-
-    /**
-     * The address of this static class variable serves as this class's ID
-     * for ICU "poor man's RTTI".
-     */
-    static const char fgClassID;

 };
 
 
 };