You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@couchdb.apache.org by be...@apache.org on 2014/02/13 19:12:38 UTC
[40/57] [abbrv] remove couch_collate
http://git-wip-us.apache.org/repos/asf/couchdb/blob/81332b78/apps/couch_collate/platform/osx/icu/unicode/caniter.h
----------------------------------------------------------------------
diff --git a/apps/couch_collate/platform/osx/icu/unicode/caniter.h b/apps/couch_collate/platform/osx/icu/unicode/caniter.h
deleted file mode 100644
index 84a6595..0000000
--- a/apps/couch_collate/platform/osx/icu/unicode/caniter.h
+++ /dev/null
@@ -1,201 +0,0 @@
-/*
- *******************************************************************************
- * Copyright (C) 1996-2006, International Business Machines Corporation and *
- * others. All Rights Reserved. *
- *******************************************************************************
- */
-
-#ifndef CANITER_H
-#define CANITER_H
-
-#include "unicode/utypes.h"
-
-#if !UCONFIG_NO_NORMALIZATION
-
-#include "unicode/uobject.h"
-#include "unicode/unistr.h"
-
-/**
- * \file
- * \brief C++ API: Canonical Iterator
- */
-
-/** Should permutation skip characters with combining class zero
- * Should be either TRUE or FALSE. This is a compile time option
- * @stable ICU 2.4
- */
-#ifndef CANITER_SKIP_ZEROES
-#define CANITER_SKIP_ZEROES TRUE
-#endif
-
-U_NAMESPACE_BEGIN
-
-class Hashtable;
-
-/**
- * This class allows one to iterate through all the strings that are canonically equivalent to a given
- * string. For example, here are some sample results:
-Results for: {LATIN CAPITAL LETTER A WITH RING ABOVE}{LATIN SMALL LETTER D}{COMBINING DOT ABOVE}{COMBINING CEDILLA}
-1: \\u0041\\u030A\\u0064\\u0307\\u0327
- = {LATIN CAPITAL LETTER A}{COMBINING RING ABOVE}{LATIN SMALL LETTER D}{COMBINING DOT ABOVE}{COMBINING CEDILLA}
-2: \\u0041\\u030A\\u0064\\u0327\\u0307
- = {LATIN CAPITAL LETTER A}{COMBINING RING ABOVE}{LATIN SMALL LETTER D}{COMBINING CEDILLA}{COMBINING DOT ABOVE}
-3: \\u0041\\u030A\\u1E0B\\u0327
- = {LATIN CAPITAL LETTER A}{COMBINING RING ABOVE}{LATIN SMALL LETTER D WITH DOT ABOVE}{COMBINING CEDILLA}
-4: \\u0041\\u030A\\u1E11\\u0307
- = {LATIN CAPITAL LETTER A}{COMBINING RING ABOVE}{LATIN SMALL LETTER D WITH CEDILLA}{COMBINING DOT ABOVE}
-5: \\u00C5\\u0064\\u0307\\u0327
- = {LATIN CAPITAL LETTER A WITH RING ABOVE}{LATIN SMALL LETTER D}{COMBINING DOT ABOVE}{COMBINING CEDILLA}
-6: \\u00C5\\u0064\\u0327\\u0307
- = {LATIN CAPITAL LETTER A WITH RING ABOVE}{LATIN SMALL LETTER D}{COMBINING CEDILLA}{COMBINING DOT ABOVE}
-7: \\u00C5\\u1E0B\\u0327
- = {LATIN CAPITAL LETTER A WITH RING ABOVE}{LATIN SMALL LETTER D WITH DOT ABOVE}{COMBINING CEDILLA}
-8: \\u00C5\\u1E11\\u0307
- = {LATIN CAPITAL LETTER A WITH RING ABOVE}{LATIN SMALL LETTER D WITH CEDILLA}{COMBINING DOT ABOVE}
-9: \\u212B\\u0064\\u0307\\u0327
- = {ANGSTROM SIGN}{LATIN SMALL LETTER D}{COMBINING DOT ABOVE}{COMBINING CEDILLA}
-10: \\u212B\\u0064\\u0327\\u0307
- = {ANGSTROM SIGN}{LATIN SMALL LETTER D}{COMBINING CEDILLA}{COMBINING DOT ABOVE}
-11: \\u212B\\u1E0B\\u0327
- = {ANGSTROM SIGN}{LATIN SMALL LETTER D WITH DOT ABOVE}{COMBINING CEDILLA}
-12: \\u212B\\u1E11\\u0307
- = {ANGSTROM SIGN}{LATIN SMALL LETTER D WITH CEDILLA}{COMBINING DOT ABOVE}
- *<br>Note: the code is intended for use with small strings, and is not suitable for larger ones,
- * since it has not been optimized for that situation.
- * Note, CanonicalIterator is not intended to be subclassed.
- * @author M. Davis
- * @author C++ port by V. Weinstein
- * @stable ICU 2.4
- */
-class U_COMMON_API CanonicalIterator : public UObject {
-public:
- /**
- * Construct a CanonicalIterator object
- * @param source string to get results for
- * @param status Fill-in parameter which receives the status of this operation.
- * @stable ICU 2.4
- */
- CanonicalIterator(const UnicodeString &source, UErrorCode &status);
-
- /** Destructor
- * Cleans pieces
- * @stable ICU 2.4
- */
- virtual ~CanonicalIterator();
-
- /**
- * Gets the NFD form of the current source we are iterating over.
- * @return gets the source: NOTE: it is the NFD form of source
- * @stable ICU 2.4
- */
- UnicodeString getSource();
-
- /**
- * Resets the iterator so that one can start again from the beginning.
- * @stable ICU 2.4
- */
- void reset();
-
- /**
- * Get the next canonically equivalent string.
- * <br><b>Warning: The strings are not guaranteed to be in any particular order.</b>
- * @return the next string that is canonically equivalent. A bogus string is returned when
- * the iteration is done.
- * @stable ICU 2.4
- */
- UnicodeString next();
-
- /**
- * Set a new source for this iterator. Allows object reuse.
- * @param newSource the source string to iterate against. This allows the same iterator to be used
- * while changing the source string, saving object creation.
- * @param status Fill-in parameter which receives the status of this operation.
- * @stable ICU 2.4
- */
- void setSource(const UnicodeString &newSource, UErrorCode &status);
-
- /**
- * Dumb recursive implementation of permutation.
- * TODO: optimize
- * @param source the string to find permutations for
- * @param skipZeros determine if skip zeros
- * @param result the results in a set.
- * @param status Fill-in parameter which receives the status of this operation.
- * @internal
- */
- static void U_EXPORT2 permute(UnicodeString &source, UBool skipZeros, Hashtable *result, UErrorCode &status);
-
- /**
- * ICU "poor man's RTTI", returns a UClassID for this class.
- *
- * @stable ICU 2.2
- */
- static UClassID U_EXPORT2 getStaticClassID();
-
- /**
- * ICU "poor man's RTTI", returns a UClassID for the actual class.
- *
- * @stable ICU 2.2
- */
- virtual UClassID getDynamicClassID() const;
-
-private:
- // ===================== PRIVATES ==============================
- // private default constructor
- CanonicalIterator();
-
-
- /**
- * Copy constructor. Private for now.
- * @internal
- */
- CanonicalIterator(const CanonicalIterator& other);
-
- /**
- * Assignment operator. Private for now.
- * @internal
- */
- CanonicalIterator& operator=(const CanonicalIterator& other);
-
- // fields
- UnicodeString source;
- UBool done;
-
- // 2 dimensional array holds the pieces of the string with
- // their different canonically equivalent representations
- UnicodeString **pieces;
- int32_t pieces_length;
- int32_t *pieces_lengths;
-
- // current is used in iterating to combine pieces
- int32_t *current;
- int32_t current_length;
-
- // transient fields
- UnicodeString buffer;
-
- // we have a segment, in NFD. Find all the strings that are canonically equivalent to it.
- UnicodeString *getEquivalents(const UnicodeString &segment, int32_t &result_len, UErrorCode &status); //private String[] getEquivalents(String segment)
-
- //Set getEquivalents2(String segment);
- Hashtable *getEquivalents2(Hashtable *fillinResult, const UChar *segment, int32_t segLen, UErrorCode &status);
- //Hashtable *getEquivalents2(const UnicodeString &segment, int32_t segLen, UErrorCode &status);
-
- /**
- * See if the decomposition of cp2 is at segment starting at segmentPos
- * (with canonical rearrangment!)
- * If so, take the remainder, and return the equivalents
- */
- //Set extract(int comp, String segment, int segmentPos, StringBuffer buffer);
- Hashtable *extract(Hashtable *fillinResult, UChar32 comp, const UChar *segment, int32_t segLen, int32_t segmentPos, UErrorCode &status);
- //Hashtable *extract(UChar32 comp, const UnicodeString &segment, int32_t segLen, int32_t segmentPos, UErrorCode &status);
-
- void cleanPieces();
-
-};
-
-U_NAMESPACE_END
-
-#endif /* #if !UCONFIG_NO_NORMALIZATION */
-
-#endif
http://git-wip-us.apache.org/repos/asf/couchdb/blob/81332b78/apps/couch_collate/platform/osx/icu/unicode/chariter.h
----------------------------------------------------------------------
diff --git a/apps/couch_collate/platform/osx/icu/unicode/chariter.h b/apps/couch_collate/platform/osx/icu/unicode/chariter.h
deleted file mode 100644
index 12fc924..0000000
--- a/apps/couch_collate/platform/osx/icu/unicode/chariter.h
+++ /dev/null
@@ -1,716 +0,0 @@
-/*
-********************************************************************
-*
-* Copyright (C) 1997-2005, International Business Machines
-* Corporation and others. All Rights Reserved.
-*
-********************************************************************
-*/
-
-#ifndef CHARITER_H
-#define CHARITER_H
-
-#include "unicode/utypes.h"
-#include "unicode/uobject.h"
-#include "unicode/unistr.h"
-/**
- * \file
- * \brief C++ API: Character Iterator
- */
-
-U_NAMESPACE_BEGIN
-/**
- * Abstract class that defines an API for forward-only iteration
- * on text objects.
- * This is a minimal interface for iteration without random access
- * or backwards iteration. It is especially useful for wrapping
- * streams with converters into an object for collation or
- * normalization.
- *
- * <p>Characters can be accessed in two ways: as code units or as
- * code points.
- * Unicode code points are 21-bit integers and are the scalar values
- * of Unicode characters. ICU uses the type UChar32 for them.
- * Unicode code units are the storage units of a given
- * Unicode/UCS Transformation Format (a character encoding scheme).
- * With UTF-16, all code points can be represented with either one
- * or two code units ("surrogates").
- * String storage is typically based on code units, while properties
- * of characters are typically determined using code point values.
- * Some processes may be designed to work with sequences of code units,
- * or it may be known that all characters that are important to an
- * algorithm can be represented with single code units.
- * Other processes will need to use the code point access functions.</p>
- *
- * <p>ForwardCharacterIterator provides nextPostInc() to access
- * a code unit and advance an internal position into the text object,
- * similar to a <code>return text[position++]</code>.<br>
- * It provides next32PostInc() to access a code point and advance an internal
- * position.</p>
- *
- * <p>next32PostInc() assumes that the current position is that of
- * the beginning of a code point, i.e., of its first code unit.
- * After next32PostInc(), this will be true again.
- * In general, access to code units and code points in the same
- * iteration loop should not be mixed. In UTF-16, if the current position
- * is on a second code unit (Low Surrogate), then only that code unit
- * is returned even by next32PostInc().</p>
- *
- * <p>For iteration with either function, there are two ways to
- * check for the end of the iteration. When there are no more
- * characters in the text object:
- * <ul>
- * <li>The hasNext() function returns FALSE.</li>
- * <li>nextPostInc() and next32PostInc() return DONE
- * when one attempts to read beyond the end of the text object.</li>
- * </ul>
- *
- * Example:
- * \code
- * void function1(ForwardCharacterIterator &it) {
- * UChar32 c;
- * while(it.hasNext()) {
- * c=it.next32PostInc();
- * // use c
- * }
- * }
- *
- * void function1(ForwardCharacterIterator &it) {
- * UChar c;
- * while((c=it.nextPostInc())!=ForwardCharacterIterator::DONE) {
- * // use c
- * }
- * }
- * \endcode
- * </p>
- *
- * @stable ICU 2.0
- */
-class U_COMMON_API ForwardCharacterIterator : public UObject {
-public:
- /**
- * Value returned by most of ForwardCharacterIterator's functions
- * when the iterator has reached the limits of its iteration.
- * @stable ICU 2.0
- */
- enum { DONE = 0xffff };
-
- /**
- * Destructor.
- * @stable ICU 2.0
- */
- virtual ~ForwardCharacterIterator();
-
- /**
- * Returns true when both iterators refer to the same
- * character in the same character-storage object.
- * @param that The ForwardCharacterIterator to be compared for equality
- * @return true when both iterators refer to the same
- * character in the same character-storage object
- * @stable ICU 2.0
- */
- virtual UBool operator==(const ForwardCharacterIterator& that) const = 0;
-
- /**
- * Returns true when the iterators refer to different
- * text-storage objects, or to different characters in the
- * same text-storage object.
- * @param that The ForwardCharacterIterator to be compared for inequality
- * @return true when the iterators refer to different
- * text-storage objects, or to different characters in the
- * same text-storage object
- * @stable ICU 2.0
- */
- inline UBool operator!=(const ForwardCharacterIterator& that) const;
-
- /**
- * Generates a hash code for this iterator.
- * @return the hash code.
- * @stable ICU 2.0
- */
- virtual int32_t hashCode(void) const = 0;
-
- /**
- * Returns a UClassID for this ForwardCharacterIterator ("poor man's
- * RTTI").<P> Despite the fact that this function is public,
- * DO NOT CONSIDER IT PART OF CHARACTERITERATOR'S API!
- * @return a UClassID for this ForwardCharacterIterator
- * @stable ICU 2.0
- */
- virtual UClassID getDynamicClassID(void) const = 0;
-
- /**
- * Gets the current code unit for returning and advances to the next code unit
- * in the iteration range
- * (toward endIndex()). If there are
- * no more code units to return, returns DONE.
- * @return the current code unit.
- * @stable ICU 2.0
- */
- virtual UChar nextPostInc(void) = 0;
-
- /**
- * Gets the current code point for returning and advances to the next code point
- * in the iteration range
- * (toward endIndex()). If there are
- * no more code points to return, returns DONE.
- * @return the current code point.
- * @stable ICU 2.0
- */
- virtual UChar32 next32PostInc(void) = 0;
-
- /**
- * Returns FALSE if there are no more code units or code points
- * at or after the current position in the iteration range.
- * This is used with nextPostInc() or next32PostInc() in forward
- * iteration.
- * @returns FALSE if there are no more code units or code points
- * at or after the current position in the iteration range.
- * @stable ICU 2.0
- */
- virtual UBool hasNext() = 0;
-
-protected:
- /** Default constructor to be overridden in the implementing class. @stable ICU 2.0*/
- ForwardCharacterIterator();
-
- /** Copy constructor to be overridden in the implementing class. @stable ICU 2.0*/
- ForwardCharacterIterator(const ForwardCharacterIterator &other);
-
- /**
- * Assignment operator to be overridden in the implementing class.
- * @stable ICU 2.0
- */
- ForwardCharacterIterator &operator=(const ForwardCharacterIterator&) { return *this; }
-};
-
-/**
- * Abstract class that defines an API for iteration
- * on text objects.
- * This is an interface for forward and backward iteration
- * and random access into a text object.
- *
- * <p>The API provides backward compatibility to the Java and older ICU
- * CharacterIterator classes but extends them significantly:
- * <ol>
- * <li>CharacterIterator is now a subclass of ForwardCharacterIterator.</li>
- * <li>While the old API functions provided forward iteration with
- * "pre-increment" semantics, the new one also provides functions
- * with "post-increment" semantics. They are more efficient and should
- * be the preferred iterator functions for new implementations.
- * The backward iteration always had "pre-decrement" semantics, which
- * are efficient.</li>
- * <li>Just like ForwardCharacterIterator, it provides access to
- * both code units and code points. Code point access versions are available
- * for the old and the new iteration semantics.</li>
- * <li>There are new functions for setting and moving the current position
- * without returning a character, for efficiency.</li>
- * </ol>
- *
- * See ForwardCharacterIterator for examples for using the new forward iteration
- * functions. For backward iteration, there is also a hasPrevious() function
- * that can be used analogously to hasNext().
- * The old functions work as before and are shown below.</p>
- *
- * <p>Examples for some of the new functions:</p>
- *
- * Forward iteration with hasNext():
- * \code
- * void forward1(CharacterIterator &it) {
- * UChar32 c;
- * for(it.setToStart(); it.hasNext();) {
- * c=it.next32PostInc();
- * // use c
- * }
- * }
- * \endcode
- * Forward iteration more similar to loops with the old forward iteration,
- * showing a way to convert simple for() loops:
- * \code
- * void forward2(CharacterIterator &it) {
- * UChar c;
- * for(c=it.firstPostInc(); c!=CharacterIterator::DONE; c=it.nextPostInc()) {
- * // use c
- * }
- * }
- * \endcode
- * Backward iteration with setToEnd() and hasPrevious():
- * \code
- * void backward1(CharacterIterator &it) {
- * UChar32 c;
- * for(it.setToEnd(); it.hasPrevious();) {
- * c=it.previous32();
- * // use c
- * }
- * }
- * \endcode
- * Backward iteration with a more traditional for() loop:
- * \code
- * void backward2(CharacterIterator &it) {
- * UChar c;
- * for(c=it.last(); c!=CharacterIterator::DONE; c=it.previous()) {
- * // use c
- * }
- * }
- * \endcode
- *
- * Example for random access:
- * \code
- * void random(CharacterIterator &it) {
- * // set to the third code point from the beginning
- * it.move32(3, CharacterIterator::kStart);
- * // get a code point from here without moving the position
- * UChar32 c=it.current32();
- * // get the position
- * int32_t pos=it.getIndex();
- * // get the previous code unit
- * UChar u=it.previous();
- * // move back one more code unit
- * it.move(-1, CharacterIterator::kCurrent);
- * // set the position back to where it was
- * // and read the same code point c and move beyond it
- * it.setIndex(pos);
- * if(c!=it.next32PostInc()) {
- * exit(1); // CharacterIterator inconsistent
- * }
- * }
- * \endcode
- *
- * <p>Examples, especially for the old API:</p>
- *
- * Function processing characters, in this example simple output
- * <pre>
- * \code
- * void processChar( UChar c )
- * {
- * cout << " " << c;
- * }
- * \endcode
- * </pre>
- * Traverse the text from start to finish
- * <pre>
- * \code
- * void traverseForward(CharacterIterator& iter)
- * {
- * for(UChar c = iter.first(); c != CharacterIterator.DONE; c = iter.next()) {
- * processChar(c);
- * }
- * }
- * \endcode
- * </pre>
- * Traverse the text backwards, from end to start
- * <pre>
- * \code
- * void traverseBackward(CharacterIterator& iter)
- * {
- * for(UChar c = iter.last(); c != CharacterIterator.DONE; c = iter.previous()) {
- * processChar(c);
- * }
- * }
- * \endcode
- * </pre>
- * Traverse both forward and backward from a given position in the text.
- * Calls to notBoundary() in this example represents some additional stopping criteria.
- * <pre>
- * \code
- * void traverseOut(CharacterIterator& iter, int32_t pos)
- * {
- * UChar c;
- * for (c = iter.setIndex(pos);
- * c != CharacterIterator.DONE && (Unicode::isLetter(c) || Unicode::isDigit(c));
- * c = iter.next()) {}
- * int32_t end = iter.getIndex();
- * for (c = iter.setIndex(pos);
- * c != CharacterIterator.DONE && (Unicode::isLetter(c) || Unicode::isDigit(c));
- * c = iter.previous()) {}
- * int32_t start = iter.getIndex() + 1;
- *
- * cout << "start: " << start << " end: " << end << endl;
- * for (c = iter.setIndex(start); iter.getIndex() < end; c = iter.next() ) {
- * processChar(c);
- * }
- * }
- * \endcode
- * </pre>
- * Creating a StringCharacterIterator and calling the test functions
- * <pre>
- * \code
- * void CharacterIterator_Example( void )
- * {
- * cout << endl << "===== CharacterIterator_Example: =====" << endl;
- * UnicodeString text("Ein kleiner Satz.");
- * StringCharacterIterator iterator(text);
- * cout << "----- traverseForward: -----------" << endl;
- * traverseForward( iterator );
- * cout << endl << endl << "----- traverseBackward: ----------" << endl;
- * traverseBackward( iterator );
- * cout << endl << endl << "----- traverseOut: ---------------" << endl;
- * traverseOut( iterator, 7 );
- * cout << endl << endl << "-----" << endl;
- * }
- * \endcode
- * </pre>
- *
- * @stable ICU 2.0
- */
-class U_COMMON_API CharacterIterator : public ForwardCharacterIterator {
-public:
- /**
- * Origin enumeration for the move() and move32() functions.
- * @stable ICU 2.0
- */
- enum EOrigin { kStart, kCurrent, kEnd };
-
- /**
- * Returns a pointer to a new CharacterIterator of the same
- * concrete class as this one, and referring to the same
- * character in the same text-storage object as this one. The
- * caller is responsible for deleting the new clone.
- * @return a pointer to a new CharacterIterator
- * @stable ICU 2.0
- */
- virtual CharacterIterator* clone(void) const = 0;
-
- /**
- * Sets the iterator to refer to the first code unit in its
- * iteration range, and returns that code unit.
- * This can be used to begin an iteration with next().
- * @return the first code unit in its iteration range.
- * @stable ICU 2.0
- */
- virtual UChar first(void) = 0;
-
- /**
- * Sets the iterator to refer to the first code unit in its
- * iteration range, returns that code unit, and moves the position
- * to the second code unit. This is an alternative to setToStart()
- * for forward iteration with nextPostInc().
- * @return the first code unit in its iteration range.
- * @stable ICU 2.0
- */
- virtual UChar firstPostInc(void);
-
- /**
- * Sets the iterator to refer to the first code point in its
- * iteration range, and returns that code unit,
- * This can be used to begin an iteration with next32().
- * Note that an iteration with next32PostInc(), beginning with,
- * e.g., setToStart() or firstPostInc(), is more efficient.
- * @return the first code point in its iteration range.
- * @stable ICU 2.0
- */
- virtual UChar32 first32(void) = 0;
-
- /**
- * Sets the iterator to refer to the first code point in its
- * iteration range, returns that code point, and moves the position
- * to the second code point. This is an alternative to setToStart()
- * for forward iteration with next32PostInc().
- * @return the first code point in its iteration range.
- * @stable ICU 2.0
- */
- virtual UChar32 first32PostInc(void);
-
- /**
- * Sets the iterator to refer to the first code unit or code point in its
- * iteration range. This can be used to begin a forward
- * iteration with nextPostInc() or next32PostInc().
- * @return the start position of the iteration range
- * @stable ICU 2.0
- */
- inline int32_t setToStart();
-
- /**
- * Sets the iterator to refer to the last code unit in its
- * iteration range, and returns that code unit.
- * This can be used to begin an iteration with previous().
- * @return the last code unit.
- * @stable ICU 2.0
- */
- virtual UChar last(void) = 0;
-
- /**
- * Sets the iterator to refer to the last code point in its
- * iteration range, and returns that code unit.
- * This can be used to begin an iteration with previous32().
- * @return the last code point.
- * @stable ICU 2.0
- */
- virtual UChar32 last32(void) = 0;
-
- /**
- * Sets the iterator to the end of its iteration range, just behind
- * the last code unit or code point. This can be used to begin a backward
- * iteration with previous() or previous32().
- * @return the end position of the iteration range
- * @stable ICU 2.0
- */
- inline int32_t setToEnd();
-
- /**
- * Sets the iterator to refer to the "position"-th code unit
- * in the text-storage object the iterator refers to, and
- * returns that code unit.
- * @param position the "position"-th code unit in the text-storage object
- * @return the "position"-th code unit.
- * @stable ICU 2.0
- */
- virtual UChar setIndex(int32_t position) = 0;
-
- /**
- * Sets the iterator to refer to the beginning of the code point
- * that contains the "position"-th code unit
- * in the text-storage object the iterator refers to, and
- * returns that code point.
- * The current position is adjusted to the beginning of the code point
- * (its first code unit).
- * @param position the "position"-th code unit in the text-storage object
- * @return the "position"-th code point.
- * @stable ICU 2.0
- */
- virtual UChar32 setIndex32(int32_t position) = 0;
-
- /**
- * Returns the code unit the iterator currently refers to.
- * @return the current code unit.
- * @stable ICU 2.0
- */
- virtual UChar current(void) const = 0;
-
- /**
- * Returns the code point the iterator currently refers to.
- * @return the current code point.
- * @stable ICU 2.0
- */
- virtual UChar32 current32(void) const = 0;
-
- /**
- * Advances to the next code unit in the iteration range
- * (toward endIndex()), and returns that code unit. If there are
- * no more code units to return, returns DONE.
- * @return the next code unit.
- * @stable ICU 2.0
- */
- virtual UChar next(void) = 0;
-
- /**
- * Advances to the next code point in the iteration range
- * (toward endIndex()), and returns that code point. If there are
- * no more code points to return, returns DONE.
- * Note that iteration with "pre-increment" semantics is less
- * efficient than iteration with "post-increment" semantics
- * that is provided by next32PostInc().
- * @return the next code point.
- * @stable ICU 2.0
- */
- virtual UChar32 next32(void) = 0;
-
- /**
- * Advances to the previous code unit in the iteration range
- * (toward startIndex()), and returns that code unit. If there are
- * no more code units to return, returns DONE.
- * @return the previous code unit.
- * @stable ICU 2.0
- */
- virtual UChar previous(void) = 0;
-
- /**
- * Advances to the previous code point in the iteration range
- * (toward startIndex()), and returns that code point. If there are
- * no more code points to return, returns DONE.
- * @return the previous code point.
- * @stable ICU 2.0
- */
- virtual UChar32 previous32(void) = 0;
-
- /**
- * Returns FALSE if there are no more code units or code points
- * before the current position in the iteration range.
- * This is used with previous() or previous32() in backward
- * iteration.
- * @return FALSE if there are no more code units or code points
- * before the current position in the iteration range, return TRUE otherwise.
- * @stable ICU 2.0
- */
- virtual UBool hasPrevious() = 0;
-
- /**
- * Returns the numeric index in the underlying text-storage
- * object of the character returned by first(). Since it's
- * possible to create an iterator that iterates across only
- * part of a text-storage object, this number isn't
- * necessarily 0.
- * @returns the numeric index in the underlying text-storage
- * object of the character returned by first().
- * @stable ICU 2.0
- */
- inline int32_t startIndex(void) const;
-
- /**
- * Returns the numeric index in the underlying text-storage
- * object of the position immediately BEYOND the character
- * returned by last().
- * @return the numeric index in the underlying text-storage
- * object of the position immediately BEYOND the character
- * returned by last().
- * @stable ICU 2.0
- */
- inline int32_t endIndex(void) const;
-
- /**
- * Returns the numeric index in the underlying text-storage
- * object of the character the iterator currently refers to
- * (i.e., the character returned by current()).
- * @return the numberic index in the text-storage object of
- * the character the iterator currently refers to
- * @stable ICU 2.0
- */
- inline int32_t getIndex(void) const;
-
- /**
- * Returns the length of the entire text in the underlying
- * text-storage object.
- * @return the length of the entire text in the text-storage object
- * @stable ICU 2.0
- */
- inline int32_t getLength() const;
-
- /**
- * Moves the current position relative to the start or end of the
- * iteration range, or relative to the current position itself.
- * The movement is expressed in numbers of code units forward
- * or backward by specifying a positive or negative delta.
- * @param delta the position relative to origin. A positive delta means forward;
- * a negative delta means backward.
- * @param origin Origin enumeration {kStart, kCurrent, kEnd}
- * @return the new position
- * @stable ICU 2.0
- */
- virtual int32_t move(int32_t delta, EOrigin origin) = 0;
-
- /**
- * Moves the current position relative to the start or end of the
- * iteration range, or relative to the current position itself.
- * The movement is expressed in numbers of code points forward
- * or backward by specifying a positive or negative delta.
- * @param delta the position relative to origin. A positive delta means forward;
- * a negative delta means backward.
- * @param origin Origin enumeration {kStart, kCurrent, kEnd}
- * @return the new position
- * @stable ICU 2.0
- */
- virtual int32_t move32(int32_t delta, EOrigin origin) = 0;
-
- /**
- * Copies the text under iteration into the UnicodeString
- * referred to by "result".
- * @param result Receives a copy of the text under iteration.
- * @stable ICU 2.0
- */
- virtual void getText(UnicodeString& result) = 0;
-
-protected:
- /**
- * Empty constructor.
- * @stable ICU 2.0
- */
- CharacterIterator();
-
- /**
- * Constructor, just setting the length field in this base class.
- * @stable ICU 2.0
- */
- CharacterIterator(int32_t length);
-
- /**
- * Constructor, just setting the length and position fields in this base class.
- * @stable ICU 2.0
- */
- CharacterIterator(int32_t length, int32_t position);
-
- /**
- * Constructor, just setting the length, start, end, and position fields in this base class.
- * @stable ICU 2.0
- */
- CharacterIterator(int32_t length, int32_t textBegin, int32_t textEnd, int32_t position);
-
- /**
- * Copy constructor.
- *
- * @param that The CharacterIterator to be copied
- * @stable ICU 2.0
- */
- CharacterIterator(const CharacterIterator &that);
-
- /**
- * Assignment operator. Sets this CharacterIterator to have the same behavior,
- * as the one passed in.
- * @param that The CharacterIterator passed in.
- * @return the newly set CharacterIterator.
- * @stable ICU 2.0
- */
- CharacterIterator &operator=(const CharacterIterator &that);
-
- /**
- * Base class text length field.
- * Necessary this for correct getText() and hashCode().
- * @stable ICU 2.0
- */
- int32_t textLength;
-
- /**
- * Base class field for the current position.
- * @stable ICU 2.0
- */
- int32_t pos;
-
- /**
- * Base class field for the start of the iteration range.
- * @stable ICU 2.0
- */
- int32_t begin;
-
- /**
- * Base class field for the end of the iteration range.
- * @stable ICU 2.0
- */
- int32_t end;
-};
-
-inline UBool
-ForwardCharacterIterator::operator!=(const ForwardCharacterIterator& that) const {
- return !operator==(that);
-}
-
-inline int32_t
-CharacterIterator::setToStart() {
- return move(0, kStart);
-}
-
-inline int32_t
-CharacterIterator::setToEnd() {
- return move(0, kEnd);
-}
-
-inline int32_t
-CharacterIterator::startIndex(void) const {
- return begin;
-}
-
-inline int32_t
-CharacterIterator::endIndex(void) const {
- return end;
-}
-
-inline int32_t
-CharacterIterator::getIndex(void) const {
- return pos;
-}
-
-inline int32_t
-CharacterIterator::getLength(void) const {
- return textLength;
-}
-
-U_NAMESPACE_END
-#endif
http://git-wip-us.apache.org/repos/asf/couchdb/blob/81332b78/apps/couch_collate/platform/osx/icu/unicode/choicfmt.h
----------------------------------------------------------------------
diff --git a/apps/couch_collate/platform/osx/icu/unicode/choicfmt.h b/apps/couch_collate/platform/osx/icu/unicode/choicfmt.h
deleted file mode 100644
index 8484648..0000000
--- a/apps/couch_collate/platform/osx/icu/unicode/choicfmt.h
+++ /dev/null
@@ -1,746 +0,0 @@
-/*
-********************************************************************************
-* Copyright (C) 1997-2008, International Business Machines
-* Corporation and others. All Rights Reserved.
-********************************************************************************
-*
-* File CHOICFMT.H
-*
-* Modification History:
-*
-* Date Name Description
-* 02/19/97 aliu Converted from java.
-* 03/20/97 helena Finished first cut of implementation and got rid
-* of nextDouble/previousDouble and replaced with
-* boolean array.
-* 4/10/97 aliu Clean up. Modified to work on AIX.
-* 8/6/97 nos Removed overloaded constructor, member var 'buffer'.
-* 07/22/98 stephen Removed operator!= (implemented in Format)
-********************************************************************************
-*/
-
-#ifndef CHOICFMT_H
-#define CHOICFMT_H
-
-#include "unicode/utypes.h"
-
-/**
- * \file
- * \brief C++ API: Choice Format.
- */
-
-#if !UCONFIG_NO_FORMATTING
-
-#include "unicode/unistr.h"
-#include "unicode/numfmt.h"
-#include "unicode/fieldpos.h"
-#include "unicode/format.h"
-
-U_NAMESPACE_BEGIN
-
-class MessageFormat;
-
-/**
- * ChoiceFormat converts between ranges of numeric values
- * and string names for those ranges. A <code>ChoiceFormat</code> splits
- * the real number line <code>-Inf</code> to <code>+Inf</code> into two
- * or more contiguous ranges. Each range is mapped to a
- * string. <code>ChoiceFormat</code> is generally used in a
- * <code>MessageFormat</code> for displaying grammatically correct
- * plurals such as "There are 2 files."</p>
- *
- * <p>There are two methods of defining a <code>ChoiceFormat</code>; both
- * are equivalent. The first is by using a string pattern. This is the
- * preferred method in most cases. The second method is through direct
- * specification of the arrays that make up the
- * <code>ChoiceFormat</code>.</p>
- *
- * <p><strong>Patterns</strong></p>
- *
- * <p>In most cases, the preferred way to define a
- * <code>ChoiceFormat</code> is with a pattern. Here is an example of a
- * <code>ChoiceFormat</code> pattern:</p>
- *
- * \htmlonly<pre> 0≤are no files|1≤is one file|1<are many files</pre>\endhtmlonly
- *
- * <p>or equivalently,</p>
- *
- * \htmlonly<pre> 0#are no files|1#is one file|1<are many files</pre>\endhtmlonly
- *
- * <p>The pattern consists of a number or <em>range specifiers</em>
- * separated by vertical bars '|' (U+007C). There is no
- * vertical bar after the last range. Each range specifier is of the
- * form:</p>
- *
- * \htmlonly<blockquote><em>Number Separator String</em></blockquote>\endhtmlonly
- *
- * <p><em>Number</em> is a floating point number that can be parsed by a
- * default <code>NumberFormat</code> for the US locale. It gives the
- * lower limit of this range. The lower limit is either inclusive or
- * exclusive, depending on the <em>separator</em>. The upper limit is
- * given by the lower limit of the next range. The Unicode infinity
- * sign \htmlonly∞ \endhtmlonly (U+221E) is recognized for positive infinity. It may be preceded by
- * '-' (U+002D) to indicate negative infinity.</p>
- *
- * <p><em>String</em> is the format string for this range, with special
- * characters enclosed in single quotes (<code>'The #
- * sign'</code>). Single quotes themselves are indicated by two single
- * quotes in a row (<code>'o''clock'</code>).</p>
- *
- * <p><em>Separator</em> is one of the following single characters:
- *
- * <ul>
- * <li>\htmlonly'≤' \endhtmlonly (U+2264) or '#' (U+0023)
- * indicates that the lower limit given by <em>Number</em> is
- * inclusive. (The two characters are equivalent to ChoiceFormat.)
- * This means that the limit value <em>Number</em> belongs to this
- * range. Another way of saying this is that the corresponding
- * closure is <code>FALSE</code>.</li>
- *
- * <li>'<' (U+003C) indicates that the lower limit given by
- * <em>Number</em> is exclusive. This means that the value
- * <em>Number</em> belongs to the prior range.</li> Another way of
- * saying this is that the corresponding closure is
- * <code>TRUE</code>.
- * </ul>
- *
- * <p>See below for more information about closures.</p>
- *
- * <p><strong>Arrays</strong></p>
- *
- * <p>A <code>ChoiceFormat</code> defining <code>n</code> intervals
- * (<code>n</code> >= 2) is specified by three arrays of
- * <code>n</code> items:
- *
- * <ul>
- * <li><code>double limits[]</code> gives the start of each
- * interval. This must be a non-decreasing list of values, none of
- * which may be <code>NaN</code>.</li>
- * <li><code>UBool closures[]</code> determines whether each limit
- * value is contained in the interval below it or in the interval
- * above it. If <code>closures[i]</code> is <code>FALSE</code>, then
- * <code>limits[i]</code> is a member of interval
- * <code>i</code>. Otherwise it is a member of interval
- * <code>i+1</code>. If no closures array is specified, this is
- * equivalent to having all closures be <code>FALSE</code>. Closures
- * allow one to specify half-open, open, or closed intervals.</li>
- * <li><code>UnicodeString formats[]</code> gives the string label
- * associated with each interval.</li>
- * </ul>
- *
- * <p><strong>Formatting and Parsing</strong></p>
- *
- * <p>During formatting, a number is converted to a
- * string. <code>ChoiceFormat</code> accomplishes this by mapping the
- * number to an interval using the following rule. Given a number
- * <code>X</code> and and index value <code>j</code> in the range
- * <code>0..n-1</code>, where <code>n</code> is the number of ranges:</p>
- *
- * \htmlonly<blockquote>\endhtmlonly<code>X</code> matches <code>j</code> if and only if
- * <code>limit[j] <= X < limit[j+1]</code>
- * \htmlonly</blockquote>\endhtmlonly
- *
- * <p>(This assumes that all closures are <code>FALSE</code>. If some
- * closures are <code>TRUE</code> then the relations must be changed to
- * <code><=</code> or <code><</code> as appropriate.) If there is
- * no match, then either the first or last index is used, depending on
- * whether the number is too low or too high. Once a number is mapped to
- * an interval <code>j</code>, the string <code>formats[j]</code> is
- * output.</p>
- *
- * <p>During parsing, a string is converted to a
- * number. <code>ChoiceFormat</code> finds the element
- * <code>formats[j]</code> equal to the string, and returns
- * <code>limits[j]</code> as the parsed value.</p>
- *
- * <p><strong>Notes</strong></p>
- *
- * <p>The first limit value does not define a range boundary. For
- * example, in the pattern \htmlonly"<code>1.0#a|2.0#b</code>"\endhtmlonly, the
- * intervals are [-Inf, 2.0) and [2.0, +Inf]. It appears that the first
- * interval should be [1.0, 2.0). However, since all values that are too
- * small are mapped to range zero, the first interval is effectively
- * [-Inf, 2.0). However, the first limit value <em>is</em> used during
- * formatting. In this example, <code>parse("a")</code> returns
- * 1.0.</p>
- *
- * <p>There are no gaps between intervals and the entire number line is
- * covered. A <code>ChoiceFormat</code> maps <em>all</em> possible
- * double values to a finite set of intervals.</p>
- *
- * <p>The non-number <code>NaN</code> is mapped to interval zero during
- * formatting.</p>
- *
- * <p><strong>Examples</strong></p>
- *
- * <p>Here is an example of two arrays that map the number
- * <code>1..7</code> to the English day of the week abbreviations
- * <code>Sun..Sat</code>. No closures array is given; this is the same as
- * specifying all closures to be <code>FALSE</code>.</p>
- *
- * <pre> {1,2,3,4,5,6,7},
- * {"Sun","Mon","Tue","Wed","Thur","Fri","Sat"}</pre>
- *
- * <p>Here is an example that maps the ranges [-Inf, 1), [1, 1], and (1,
- * +Inf] to three strings. That is, the number line is split into three
- * ranges: x < 1.0, x = 1.0, and x > 1.0.</p>
- *
- * <pre> {0, 1, 1},
- * {FALSE, FALSE, TRUE},
- * {"no files", "one file", "many files"}</pre>
- *
- * <p>Here is a simple example that shows formatting and parsing: </p>
- *
- * \code
- * #include <unicode/choicfmt.h>
- * #include <unicode/unistr.h>
- * #include <iostream.h>
- *
- * int main(int argc, char *argv[]) {
- * double limits[] = {1,2,3,4,5,6,7};
- * UnicodeString monthNames[] = {
- * "Sun","Mon","Tue","Wed","Thu","Fri","Sat"};
- * ChoiceFormat fmt(limits, monthNames, 7);
- * UnicodeString str;
- * char buf[256];
- * for (double x = 1.0; x <= 8.0; x += 1.0) {
- * fmt.format(x, str);
- * str.extract(0, str.length(), buf, 256, "");
- * str.truncate(0);
- * cout << x << " -> "
- * << buf << endl;
- * }
- * cout << endl;
- * return 0;
- * }
- * \endcode
- *
- * <p>Here is a more complex example using a <code>ChoiceFormat</code>
- * constructed from a pattern together with a
- * <code>MessageFormat</code>.</p>
- *
- * \code
- * #include <unicode/choicfmt.h>
- * #include <unicode/msgfmt.h>
- * #include <unicode/unistr.h>
- * #include <iostream.h>
- *
- * int main(int argc, char *argv[]) {
- * UErrorCode status = U_ZERO_ERROR;
- * double filelimits[] = {0,1,2};
- * UnicodeString filepart[] =
- * {"are no files","is one file","are {0} files"};
- * ChoiceFormat* fileform = new ChoiceFormat(filelimits, filepart, 3 );
- * Format* testFormats[] =
- * {fileform, NULL, NumberFormat::createInstance(status)};
- * MessageFormat pattform("There {0} on {1}", status );
- * pattform.adoptFormats(testFormats, 3);
- * Formattable testArgs[] = {0L, "Disk A"};
- * FieldPosition fp(0);
- * UnicodeString str;
- * char buf[256];
- * for (int32_t i = 0; i < 4; ++i) {
- * Formattable fInt(i);
- * testArgs[0] = fInt;
- * pattform.format(testArgs, 2, str, fp, status );
- * str.extract(0, str.length(), buf, "");
- * str.truncate(0);
- * cout << "Output for i=" << i << " : " << buf << endl;
- * }
- * cout << endl;
- * return 0;
- * }
- * \endcode
- *
- * <p><em>User subclasses are not supported.</em> While clients may write
- * subclasses, such code will not necessarily work and will not be
- * guaranteed to work stably from release to release.
- */
-class U_I18N_API ChoiceFormat: public NumberFormat {
-public:
- /**
- * Construct a new ChoiceFormat with the limits and the corresponding formats
- * based on the pattern.
- *
- * @param pattern Pattern used to construct object.
- * @param status Output param to receive success code. If the
- * pattern cannot be parsed, set to failure code.
- * @stable ICU 2.0
- */
- ChoiceFormat(const UnicodeString& pattern,
- UErrorCode& status);
-
-
- /**
- * Construct a new ChoiceFormat with the given limits and formats. Copy
- * the limits and formats instead of adopting them.
- *
- * @param limits Array of limit values.
- * @param formats Array of formats.
- * @param count Size of 'limits' and 'formats' arrays.
- * @stable ICU 2.0
- */
-
- ChoiceFormat(const double* limits,
- const UnicodeString* formats,
- int32_t count );
-
- /**
- * Construct a new ChoiceFormat with the given limits and formats.
- * Copy the limits and formats (instead of adopting them). By
- * default, each limit in the array specifies the inclusive lower
- * bound of its range, and the exclusive upper bound of the previous
- * range. However, if the isLimitOpen element corresponding to a
- * limit is TRUE, then the limit is the exclusive lower bound of its
- * range, and the inclusive upper bound of the previous range.
- * @param limits Array of limit values
- * @param closures Array of booleans specifying whether each
- * element of 'limits' is open or closed. If FALSE, then the
- * corresponding limit is a member of the range above it. If TRUE,
- * then the limit belongs to the range below it.
- * @param formats Array of formats
- * @param count Size of 'limits', 'closures', and 'formats' arrays
- * @stable ICU 2.4
- */
- ChoiceFormat(const double* limits,
- const UBool* closures,
- const UnicodeString* formats,
- int32_t count);
-
- /**
- * Copy constructor.
- *
- * @param that ChoiceFormat object to be copied from
- * @stable ICU 2.0
- */
- ChoiceFormat(const ChoiceFormat& that);
-
- /**
- * Assignment operator.
- *
- * @param that ChoiceFormat object to be copied
- * @stable ICU 2.0
- */
- const ChoiceFormat& operator=(const ChoiceFormat& that);
-
- /**
- * Destructor.
- * @stable ICU 2.0
- */
- virtual ~ChoiceFormat();
-
- /**
- * Clone this Format object polymorphically. The caller owns the
- * result and should delete it when done.
- *
- * @return a copy of this object
- * @stable ICU 2.0
- */
- virtual Format* clone(void) const;
-
- /**
- * Return true if the given Format objects are semantically equal.
- * Objects of different subclasses are considered unequal.
- *
- * @param other ChoiceFormat object to be compared
- * @return true if other is the same as this.
- * @stable ICU 2.0
- */
- virtual UBool operator==(const Format& other) const;
-
- /**
- * Sets the pattern.
- * @param pattern The pattern to be applied.
- * @param status Output param set to success/failure code on
- * exit. If the pattern is invalid, this will be
- * set to a failure result.
- * @stable ICU 2.0
- */
- virtual void applyPattern(const UnicodeString& pattern,
- UErrorCode& status);
-
- /**
- * Sets the pattern.
- * @param pattern The pattern to be applied.
- * @param parseError Struct to recieve information on position
- * of error if an error is encountered
- * @param status Output param set to success/failure code on
- * exit. If the pattern is invalid, this will be
- * set to a failure result.
- * @stable ICU 2.0
- */
- virtual void applyPattern(const UnicodeString& pattern,
- UParseError& parseError,
- UErrorCode& status);
- /**
- * Gets the pattern.
- *
- * @param pattern Output param which will recieve the pattern
- * Previous contents are deleted.
- * @return A reference to 'pattern'
- * @stable ICU 2.0
- */
- virtual UnicodeString& toPattern(UnicodeString &pattern) const;
-
- /**
- * Set the choices to be used in formatting.
- *
- * @param limitsToCopy Contains the top value that you want
- * parsed with that format,and should be in
- * ascending sorted order. When formatting X,
- * the choice will be the i, where limit[i]
- * <= X < limit[i+1].
- * @param formatsToCopy The format strings you want to use for each limit.
- * @param count The size of the above arrays.
- * @stable ICU 2.0
- */
- virtual void setChoices(const double* limitsToCopy,
- const UnicodeString* formatsToCopy,
- int32_t count );
-
- /**
- * Set the choices to be used in formatting. See class description
- * for documenatation of the limits, closures, and formats arrays.
- * @param limits Array of limits
- * @param closures Array of limit booleans
- * @param formats Array of format string
- * @param count The size of the above arrays
- * @stable ICU 2.4
- */
- virtual void setChoices(const double* limits,
- const UBool* closures,
- const UnicodeString* formats,
- int32_t count);
-
- /**
- * Get the limits passed in the constructor.
- *
- * @param count The size of the limits arrays
- * @return the limits.
- * @stable ICU 2.0
- */
- virtual const double* getLimits(int32_t& count) const;
-
- /**
- * Get the limit booleans passed in the constructor. The caller
- * must not delete the result.
- *
- * @param count The size of the arrays
- * @return the closures
- * @stable ICU 2.4
- */
- virtual const UBool* getClosures(int32_t& count) const;
-
- /**
- * Get the formats passed in the constructor.
- *
- * @param count The size of the arrays
- * @return the formats.
- * @stable ICU 2.0
- */
- virtual const UnicodeString* getFormats(int32_t& count) const;
-
- /**
- * Format a double or long number using this object's choices.
- *
- * @param number The value to be formatted.
- * @param appendTo Output parameter to receive result.
- * Result is appended to existing contents.
- * @param pos On input: an alignment field, if desired.
- * On output: the offsets of the alignment field.
- * @return Reference to 'appendTo' parameter.
- * @stable ICU 2.0
- */
- virtual UnicodeString& format(double number,
- UnicodeString& appendTo,
- FieldPosition& pos) const;
- /**
- * Format a int_32t number using this object's choices.
- *
- * @param number The value to be formatted.
- * @param appendTo Output parameter to receive result.
- * Result is appended to existing contents.
- * @param pos On input: an alignment field, if desired.
- * On output: the offsets of the alignment field.
- * @return Reference to 'appendTo' parameter.
- * @stable ICU 2.0
- */
- virtual UnicodeString& format(int32_t number,
- UnicodeString& appendTo,
- FieldPosition& pos) const;
-
- /**
- * Format an int64_t number using this object's choices.
- *
- * @param number The value to be formatted.
- * @param appendTo Output parameter to receive result.
- * Result is appended to existing contents.
- * @param pos On input: an alignment field, if desired.
- * On output: the offsets of the alignment field.
- * @return Reference to 'appendTo' parameter.
- * @stable ICU 2.8
- */
- virtual UnicodeString& format(int64_t number,
- UnicodeString& appendTo,
- FieldPosition& pos) const;
-
- /**
- * Format an array of objects using this object's choices.
- *
- * @param objs The array of objects to be formatted.
- * @param cnt The size of objs.
- * @param appendTo Output parameter to receive result.
- * Result is appended to existing contents.
- * @param pos On input: an alignment field, if desired.
- * On output: the offsets of the alignment field.
- * @param success Output param set to success/failure code on
- * exit.
- * @return Reference to 'appendTo' parameter.
- * @stable ICU 2.0
- */
- virtual UnicodeString& format(const Formattable* objs,
- int32_t cnt,
- UnicodeString& appendTo,
- FieldPosition& pos,
- UErrorCode& success) const;
- /**
- * Format an object using this object's choices.
- *
- *
- * @param obj The object to be formatted.
- * @param appendTo Output parameter to receive result.
- * Result is appended to existing contents.
- * @param pos On input: an alignment field, if desired.
- * On output: the offsets of the alignment field.
- * @param status Output param set to success/failure code on
- * exit.
- * @return Reference to 'appendTo' parameter.
- * @stable ICU 2.0
- */
- virtual UnicodeString& format(const Formattable& obj,
- UnicodeString& appendTo,
- FieldPosition& pos,
- UErrorCode& status) const;
-
- /**
- * Redeclared NumberFormat method.
- *
- * @param obj The object to be formatted.
- * @param appendTo Output parameter to receive result.
- * Result is appended to existing contents.
- * @param status Output param set to success/failure code on
- * exit.
- * @return Reference to 'appendTo' parameter.
- * @stable ICU 2.0
- */
- UnicodeString& format(const Formattable& obj,
- UnicodeString& appendTo,
- UErrorCode& status) const;
-
- /**
- * Redeclared NumberFormat method.
- * Format a double number. These methods call the NumberFormat
- * pure virtual format() methods with the default FieldPosition.
- *
- * @param number The value to be formatted.
- * @param appendTo Output parameter to receive result.
- * Result is appended to existing contents.
- * @return Reference to 'appendTo' parameter.
- * @stable ICU 2.0
- */
- UnicodeString& format( double number,
- UnicodeString& appendTo) const;
-
- /**
- * Redeclared NumberFormat method.
- * Format a long number. These methods call the NumberFormat
- * pure virtual format() methods with the default FieldPosition.
- *
- * @param number The value to be formatted.
- * @param appendTo Output parameter to receive result.
- * Result is appended to existing contents.
- * @return Reference to 'appendTo' parameter.
- * @stable ICU 2.0
- */
- UnicodeString& format( int32_t number,
- UnicodeString& appendTo) const;
-
- /**
- * Return a long if possible (e.g. within range LONG_MAX,
- * LONG_MAX], and with no decimals), otherwise a double. If
- * IntegerOnly is set, will stop at a decimal point (or equivalent;
- * e.g. for rational numbers "1 2/3", will stop after the 1).
- * <P>
- * If no object can be parsed, parsePosition is unchanged, and NULL is
- * returned.
- *
- * @param text The text to be parsed.
- * @param result Formattable to be set to the parse result.
- * If parse fails, return contents are undefined.
- * @param parsePosition The position to start parsing at on input.
- * On output, moved to after the last successfully
- * parse character. On parse failure, does not change.
- * @see NumberFormat::isParseIntegerOnly
- * @stable ICU 2.0
- */
- virtual void parse(const UnicodeString& text,
- Formattable& result,
- ParsePosition& parsePosition) const;
-
- /**
- * Return a long if possible (e.g. within range LONG_MAX,
- * LONG_MAX], and with no decimals), otherwise a double. If
- * IntegerOnly is set, will stop at a decimal point (or equivalent;
- * e.g. for rational numbers "1 2/3", will stop after the 1).
- * <P>
- * If no object can be parsed, parsePosition is unchanged, and NULL is
- * returned.
- *
- * @param text The text to be parsed.
- * @param result Formattable to be set to the parse result.
- * If parse fails, return contents are undefined.
- * @param status Output param with the formatted string.
- * @see NumberFormat::isParseIntegerOnly
- * @stable ICU 2.0
- */
- virtual void parse(const UnicodeString& text,
- Formattable& result,
- UErrorCode& status) const;
-
-
-public:
- /**
- * Returns a unique class ID POLYMORPHICALLY. Pure virtual override.
- * This method is to implement a simple version of RTTI, since not all
- * C++ compilers support genuine RTTI. Polymorphic operator==() and
- * clone() methods call this method.
- *
- * @return The class ID for this object. All objects of a
- * given class have the same class ID. Objects of
- * other classes have different class IDs.
- * @stable ICU 2.0
- */
- virtual UClassID getDynamicClassID(void) const;
-
- /**
- * Return the class ID for this class. This is useful only for
- * comparing to a return value from getDynamicClassID(). For example:
- * <pre>
- * . Base* polymorphic_pointer = createPolymorphicObject();
- * . if (polymorphic_pointer->getDynamicClassID() ==
- * . Derived::getStaticClassID()) ...
- * </pre>
- * @return The class ID for all objects of this class.
- * @stable ICU 2.0
- */
- static UClassID U_EXPORT2 getStaticClassID(void);
-
-private:
- // static cache management (thread-safe)
- // static NumberFormat* getNumberFormat(UErrorCode &status); // call this function to 'check out' a numberformat from the cache.
- // static void releaseNumberFormat(NumberFormat *adopt); // call this function to 'return' the number format to the cache.
-
- /**
- * Converts a string to a double value using a default NumberFormat object
- * which is static (shared by all ChoiceFormat instances).
- * @param string the string to be converted with.
- * @return the converted double number.
- */
- static double stod(const UnicodeString& string);
-
- /**
- * Converts a double value to a string using a default NumberFormat object
- * which is static (shared by all ChoiceFormat instances).
- * @param value the double number to be converted with.
- * @param string the result string.
- * @return the converted string.
- */
- static UnicodeString& dtos(double value, UnicodeString& string);
-
- ChoiceFormat(); // default constructor not implemented
-
- /**
- * Construct a new ChoiceFormat with the limits and the corresponding formats
- * based on the pattern.
- *
- * @param newPattern Pattern used to construct object.
- * @param parseError Struct to recieve information on position
- * of error if an error is encountered.
- * @param status Output param to receive success code. If the
- * pattern cannot be parsed, set to failure code.
- * @stable ICU 2.0
- */
- ChoiceFormat(const UnicodeString& newPattern,
- UParseError& parseError,
- UErrorCode& status);
-
- friend class MessageFormat;
- /**
- * Each ChoiceFormat divides the range -Inf..+Inf into fCount
- * intervals. The intervals are:
- *
- * 0: fChoiceLimits[0]..fChoiceLimits[1]
- * 1: fChoiceLimits[1]..fChoiceLimits[2]
- * ...
- * fCount-2: fChoiceLimits[fCount-2]..fChoiceLimits[fCount-1]
- * fCount-1: fChoiceLimits[fCount-1]..+Inf
- *
- * Interval 0 is special; during formatting (mapping numbers to
- * strings), it also contains all numbers less than
- * fChoiceLimits[0], as well as NaN values.
- *
- * Interval i maps to and from string fChoiceFormats[i]. When
- * parsing (mapping strings to numbers), then intervals map to
- * their lower limit, that is, interval i maps to fChoiceLimit[i].
- *
- * The intervals may be closed, half open, or open. This affects
- * formatting but does not affect parsing. Interval i is affected
- * by fClosures[i] and fClosures[i+1]. If fClosures[i]
- * is FALSE, then the value fChoiceLimits[i] is in interval i.
- * That is, intervals i and i are:
- *
- * i-1: ... x < fChoiceLimits[i]
- * i: fChoiceLimits[i] <= x ...
- *
- * If fClosures[i] is TRUE, then the value fChoiceLimits[i] is
- * in interval i-1. That is, intervals i-1 and i are:
- *
- * i-1: ... x <= fChoiceLimits[i]
- * i: fChoiceLimits[i] < x ...
- *
- * Because of the nature of interval 0, fClosures[0] has no
- * effect.
-
- */
- double* fChoiceLimits;
- UBool* fClosures;
- UnicodeString* fChoiceFormats;
- int32_t fCount;
-};
-
-inline UnicodeString&
-ChoiceFormat::format(const Formattable& obj,
- UnicodeString& appendTo,
- UErrorCode& status) const {
- // Don't use Format:: - use immediate base class only,
- // in case immediate base modifies behavior later.
- return NumberFormat::format(obj, appendTo, status);
-}
-
-inline UnicodeString&
-ChoiceFormat::format(double number,
- UnicodeString& appendTo) const {
- return NumberFormat::format(number, appendTo);
-}
-
-inline UnicodeString&
-ChoiceFormat::format(int32_t number,
- UnicodeString& appendTo) const {
- return NumberFormat::format(number, appendTo);
-}
-U_NAMESPACE_END
-
-#endif /* #if !UCONFIG_NO_FORMATTING */
-
-#endif // _CHOICFMT
-//eof
http://git-wip-us.apache.org/repos/asf/couchdb/blob/81332b78/apps/couch_collate/platform/osx/icu/unicode/coleitr.h
----------------------------------------------------------------------
diff --git a/apps/couch_collate/platform/osx/icu/unicode/coleitr.h b/apps/couch_collate/platform/osx/icu/unicode/coleitr.h
deleted file mode 100644
index 4025a41..0000000
--- a/apps/couch_collate/platform/osx/icu/unicode/coleitr.h
+++ /dev/null
@@ -1,400 +0,0 @@
-/*
- ******************************************************************************
- * Copyright (C) 1997-2008, International Business Machines
- * Corporation and others. All Rights Reserved.
- ******************************************************************************
- */
-
-/**
- * \file
- * \brief C++ API: Collation Element Iterator.
- */
-
-/**
-* File coleitr.h
-*
-*
-*
-* Created by: Helena Shih
-*
-* Modification History:
-*
-* Date Name Description
-*
-* 8/18/97 helena Added internal API documentation.
-* 08/03/98 erm Synched with 1.2 version CollationElementIterator.java
-* 12/10/99 aliu Ported Thai collation support from Java.
-* 01/25/01 swquek Modified into a C++ wrapper calling C APIs (ucoliter.h)
-* 02/19/01 swquek Removed CollationElementsIterator() since it is
-* private constructor and no calls are made to it
-*/
-
-#ifndef COLEITR_H
-#define COLEITR_H
-
-#include "unicode/utypes.h"
-
-
-#if !UCONFIG_NO_COLLATION
-
-#include "unicode/uobject.h"
-#include "unicode/tblcoll.h"
-#include "unicode/ucoleitr.h"
-
-/**
- * The UCollationElements struct.
- * For usage in C programs.
- * @stable ICU 2.0
- */
-typedef struct UCollationElements UCollationElements;
-
-U_NAMESPACE_BEGIN
-
-/**
-* The CollationElementIterator class is used as an iterator to walk through
-* each character of an international string. Use the iterator to return the
-* ordering priority of the positioned character. The ordering priority of a
-* character, which we refer to as a key, defines how a character is collated in
-* the given collation object.
-* For example, consider the following in Spanish:
-* <pre>
-* "ca" -> the first key is key('c') and second key is key('a').
-* "cha" -> the first key is key('ch') and second key is key('a').</pre>
-* And in German,
-* <pre> \htmlonly "æb"-> the first key is key('a'), the second key is key('e'), and
-* the third key is key('b'). \endhtmlonly </pre>
-* The key of a character, is an integer composed of primary order(short),
-* secondary order(char), and tertiary order(char). Java strictly defines the
-* size and signedness of its primitive data types. Therefore, the static
-* functions primaryOrder(), secondaryOrder(), and tertiaryOrder() return
-* int32_t to ensure the correctness of the key value.
-* <p>Example of the iterator usage: (without error checking)
-* <pre>
-* \code
-* void CollationElementIterator_Example()
-* {
-* UnicodeString str = "This is a test";
-* UErrorCode success = U_ZERO_ERROR;
-* RuleBasedCollator* rbc =
-* (RuleBasedCollator*) RuleBasedCollator::createInstance(success);
-* CollationElementIterator* c =
-* rbc->createCollationElementIterator( str );
-* int32_t order = c->next(success);
-* c->reset();
-* order = c->previous(success);
-* delete c;
-* delete rbc;
-* }
-* \endcode
-* </pre>
-* <p>
-* CollationElementIterator::next returns the collation order of the next
-* character based on the comparison level of the collator.
-* CollationElementIterator::previous returns the collation order of the
-* previous character based on the comparison level of the collator.
-* The Collation Element Iterator moves only in one direction between calls to
-* CollationElementIterator::reset. That is, CollationElementIterator::next()
-* and CollationElementIterator::previous can not be inter-used. Whenever
-* CollationElementIterator::previous is to be called after
-* CollationElementIterator::next() or vice versa,
-* CollationElementIterator::reset has to be called first to reset the status,
-* shifting pointers to either the end or the start of the string. Hence at the
-* next call of CollationElementIterator::previous or
-* CollationElementIterator::next(), the first or last collation order will be
-* returned.
-* If a change of direction is done without a CollationElementIterator::reset(),
-* the result is undefined.
-* The result of a forward iterate (CollationElementIterator::next) and
-* reversed result of the backward iterate (CollationElementIterator::previous)
-* on the same string are equivalent, if collation orders with the value
-* UCOL_IGNORABLE are ignored.
-* Character based on the comparison level of the collator. A collation order
-* consists of primary order, secondary order and tertiary order. The data
-* type of the collation order is <strong>t_int32</strong>.
-*
-* Note, CollationElementIterator should not be subclassed.
-* @see Collator
-* @see RuleBasedCollator
-* @version 1.8 Jan 16 2001
-*/
-class U_I18N_API CollationElementIterator : public UObject {
-public:
-
- // CollationElementIterator public data member ------------------------------
-
- enum {
- /**
- * NULLORDER indicates that an error has occured while processing
- * @stable ICU 2.0
- */
- NULLORDER = (int32_t)0xffffffff
- };
-
- // CollationElementIterator public constructor/destructor -------------------
-
- /**
- * Copy constructor.
- *
- * @param other the object to be copied from
- * @stable ICU 2.0
- */
- CollationElementIterator(const CollationElementIterator& other);
-
- /**
- * Destructor
- * @stable ICU 2.0
- */
- virtual ~CollationElementIterator();
-
- // CollationElementIterator public methods ----------------------------------
-
- /**
- * Returns true if "other" is the same as "this"
- *
- * @param other the object to be compared
- * @return true if "other" is the same as "this"
- * @stable ICU 2.0
- */
- UBool operator==(const CollationElementIterator& other) const;
-
- /**
- * Returns true if "other" is not the same as "this".
- *
- * @param other the object to be compared
- * @return true if "other" is not the same as "this"
- * @stable ICU 2.0
- */
- UBool operator!=(const CollationElementIterator& other) const;
-
- /**
- * Resets the cursor to the beginning of the string.
- * @stable ICU 2.0
- */
- void reset(void);
-
- /**
- * Gets the ordering priority of the next character in the string.
- * @param status the error code status.
- * @return the next character's ordering. otherwise returns NULLORDER if an
- * error has occured or if the end of string has been reached
- * @stable ICU 2.0
- */
- int32_t next(UErrorCode& status);
-
- /**
- * Get the ordering priority of the previous collation element in the string.
- * @param status the error code status.
- * @return the previous element's ordering. otherwise returns NULLORDER if an
- * error has occured or if the start of string has been reached
- * @stable ICU 2.0
- */
- int32_t previous(UErrorCode& status);
-
- /**
- * Gets the primary order of a collation order.
- * @param order the collation order
- * @return the primary order of a collation order.
- * @stable ICU 2.0
- */
- static inline int32_t primaryOrder(int32_t order);
-
- /**
- * Gets the secondary order of a collation order.
- * @param order the collation order
- * @return the secondary order of a collation order.
- * @stable ICU 2.0
- */
- static inline int32_t secondaryOrder(int32_t order);
-
- /**
- * Gets the tertiary order of a collation order.
- * @param order the collation order
- * @return the tertiary order of a collation order.
- * @stable ICU 2.0
- */
- static inline int32_t tertiaryOrder(int32_t order);
-
- /**
- * Return the maximum length of any expansion sequences that end with the
- * specified comparison order.
- * @param order a collation order returned by previous or next.
- * @return maximum size of the expansion sequences ending with the collation
- * element or 1 if collation element does not occur at the end of any
- * expansion sequence
- * @stable ICU 2.0
- */
- int32_t getMaxExpansion(int32_t order) const;
-
- /**
- * Gets the comparison order in the desired strength. Ignore the other
- * differences.
- * @param order The order value
- * @stable ICU 2.0
- */
- int32_t strengthOrder(int32_t order) const;
-
- /**
- * Sets the source string.
- * @param str the source string.
- * @param status the error code status.
- * @stable ICU 2.0
- */
- void setText(const UnicodeString& str, UErrorCode& status);
-
- /**
- * Sets the source string.
- * @param str the source character iterator.
- * @param status the error code status.
- * @stable ICU 2.0
- */
- void setText(CharacterIterator& str, UErrorCode& status);
-
- /**
- * Checks if a comparison order is ignorable.
- * @param order the collation order.
- * @return TRUE if a character is ignorable, FALSE otherwise.
- * @stable ICU 2.0
- */
- static inline UBool isIgnorable(int32_t order);
-
- /**
- * Gets the offset of the currently processed character in the source string.
- * @return the offset of the character.
- * @stable ICU 2.0
- */
- int32_t getOffset(void) const;
-
- /**
- * Sets the offset of the currently processed character in the source string.
- * @param newOffset the new offset.
- * @param status the error code status.
- * @return the offset of the character.
- * @stable ICU 2.0
- */
- void setOffset(int32_t newOffset, UErrorCode& status);
-
- /**
- * ICU "poor man's RTTI", returns a UClassID for the actual class.
- *
- * @stable ICU 2.2
- */
- virtual UClassID getDynamicClassID() const;
-
- /**
- * ICU "poor man's RTTI", returns a UClassID for this class.
- *
- * @stable ICU 2.2
- */
- static UClassID U_EXPORT2 getStaticClassID();
-
-protected:
-
- // CollationElementIterator protected constructors --------------------------
- /**
- * @stable ICU 2.0
- */
- friend class RuleBasedCollator;
-
- /**
- * CollationElementIterator constructor. This takes the source string and the
- * collation object. The cursor will walk thru the source string based on the
- * predefined collation rules. If the source string is empty, NULLORDER will
- * be returned on the calls to next().
- * @param sourceText the source string.
- * @param order the collation object.
- * @param status the error code status.
- * @stable ICU 2.0
- */
- CollationElementIterator(const UnicodeString& sourceText,
- const RuleBasedCollator* order, UErrorCode& status);
-
- /**
- * CollationElementIterator constructor. This takes the source string and the
- * collation object. The cursor will walk thru the source string based on the
- * predefined collation rules. If the source string is empty, NULLORDER will
- * be returned on the calls to next().
- * @param sourceText the source string.
- * @param order the collation object.
- * @param status the error code status.
- * @stable ICU 2.0
- */
- CollationElementIterator(const CharacterIterator& sourceText,
- const RuleBasedCollator* order, UErrorCode& status);
-
- // CollationElementIterator protected methods -------------------------------
-
- /**
- * Assignment operator
- *
- * @param other the object to be copied
- * @stable ICU 2.0
- */
- const CollationElementIterator&
- operator=(const CollationElementIterator& other);
-
-private:
- CollationElementIterator(); // default constructor not implemented
-
- // CollationElementIterator private data members ----------------------------
-
- /**
- * Data wrapper for collation elements
- */
- UCollationElements *m_data_;
-
- /**
- * Indicates if m_data_ belongs to this object.
- */
- UBool isDataOwned_;
-
-};
-
-// CollationElementIterator inline method defination --------------------------
-
-/**
-* Get the primary order of a collation order.
-* @param order the collation order
-* @return the primary order of a collation order.
-*/
-inline int32_t CollationElementIterator::primaryOrder(int32_t order)
-{
- order &= RuleBasedCollator::PRIMARYORDERMASK;
- return (order >> RuleBasedCollator::PRIMARYORDERSHIFT);
-}
-
-/**
-* Get the secondary order of a collation order.
-* @param order the collation order
-* @return the secondary order of a collation order.
-*/
-inline int32_t CollationElementIterator::secondaryOrder(int32_t order)
-{
- order = order & RuleBasedCollator::SECONDARYORDERMASK;
- return (order >> RuleBasedCollator::SECONDARYORDERSHIFT);
-}
-
-/**
-* Get the tertiary order of a collation order.
-* @param order the collation order
-* @return the tertiary order of a collation order.
-*/
-inline int32_t CollationElementIterator::tertiaryOrder(int32_t order)
-{
- return (order &= RuleBasedCollator::TERTIARYORDERMASK);
-}
-
-inline int32_t CollationElementIterator::getMaxExpansion(int32_t order) const
-{
- return ucol_getMaxExpansion(m_data_, (uint32_t)order);
-}
-
-inline UBool CollationElementIterator::isIgnorable(int32_t order)
-{
- return (primaryOrder(order) == RuleBasedCollator::PRIMIGNORABLE);
-}
-
-U_NAMESPACE_END
-
-#endif /* #if !UCONFIG_NO_COLLATION */
-
-#endif