FM / unicode

/usr/include/unicode

Name	Size	Mode	Actions
alphaindex.h	27118	0644	edit dl rm
appendable.h	8694	0644	edit dl rm
basictz.h	9491	0644	edit dl rm
brkiter.h	28464	0644	edit dl rm
bytestream.h	11037	0644	edit dl rm
bytestrie.h	21266	0644	edit dl rm
bytestriebuilder.h	7248	0644	edit dl rm
calendar.h	108278	0644	edit dl rm
caniter.h	7611	0644	edit dl rm
casemap.h	25933	0644	edit dl rm
char16ptr.h	7393	0644	edit dl rm
chariter.h	24632	0644	edit dl rm
choicfmt.h	24482	0644	edit dl rm
coleitr.h	14094	0644	edit dl rm
coll.h	57581	0644	edit dl rm
compactdecimalformat.h	7047	0644	edit dl rm
curramt.h	3851	0644	edit dl rm
currpinf.h	7473	0644	edit dl rm
currunit.h	4094	0644	edit dl rm
datefmt.h	41641	0644	edit dl rm
dbbi.h	1223	0644	edit dl rm
dcfmtsym.h	20897	0644	edit dl rm
decimfmt.h	89278	0644	edit dl rm
docmain.h	7142	0644	edit dl rm
dtfmtsym.h	38609	0644	edit dl rm
dtintrv.h	3930	0644	edit dl rm
dtitvfmt.h	47634	0644	edit dl rm
dtitvinf.h	19064	0644	edit dl rm
dtptngen.h	26419	0644	edit dl rm
dtrule.h	8888	0644	edit dl rm
edits.h	21237	0644	edit dl rm
enumset.h	2130	0644	edit dl rm
errorcode.h	4956	0644	edit dl rm
fieldpos.h	8899	0644	edit dl rm
filteredbrk.h	5501	0644	edit dl rm
fmtable.h	25007	0644	edit dl rm
format.h	12802	0644	edit dl rm
formattedvalue.h	9987	0644	edit dl rm
fpositer.h	3109	0644	edit dl rm
gender.h	3408	0644	edit dl rm
gregocal.h	32472	0644	edit dl rm
icudataver.h	1051	0644	edit dl rm
icuplug.h	12166	0644	edit dl rm
idna.h	13000	0644	edit dl rm
listformatter.h	9493	0644	edit dl rm
localebuilder.h	11502	0644	edit dl rm
localematcher.h	25147	0644	edit dl rm
localpointer.h	19829	0644	edit dl rm
locdspnm.h	7292	0644	edit dl rm
locid.h	48821	0644	edit dl rm
measfmt.h	11603	0644	edit dl rm
measunit.h	97563	0644	edit dl rm
measure.h	4423	0644	edit dl rm
messagepattern.h	34521	0644	edit dl rm
msgfmt.h	45168	0644	edit dl rm
normalizer2.h	34851	0644	edit dl rm
normlzr.h	31682	0644	edit dl rm
nounit.h	2754	0644	edit dl rm
numberformatter.h	86276	0644	edit dl rm
numberrangeformatter.h	28617	0644	edit dl rm
numfmt.h	50950	0644	edit dl rm
numsys.h	7500	0644	edit dl rm
parseerr.h	3155	0644	edit dl rm
parsepos.h	5692	0644	edit dl rm
platform.h	28751	0644	edit dl rm
plurfmt.h	25800	0644	edit dl rm
plurrule.h	18780	0644	edit dl rm
ptypes.h	3577	0644	edit dl rm
putil.h	6487	0644	edit dl rm
rbbi.h	27218	0644	edit dl rm
rbnf.h	49899	0644	edit dl rm
rbtz.h	15979	0644	edit dl rm
regex.h	86367	0644	edit dl rm
region.h	9404	0644	edit dl rm
reldatefmt.h	22801	0644	edit dl rm
rep.h	9599	0644	edit dl rm
resbund.h	18503	0644	edit dl rm
schriter.h	6475	0644	edit dl rm
scientificnumberformatter.h	6553	0644	edit dl rm
search.h	22757	0644	edit dl rm
selfmt.h	14643	0644	edit dl rm
simpleformatter.h	12888	0644	edit dl rm
simpletz.h	46527	0644	edit dl rm
smpdtfmt.h	72713	0644	edit dl rm
sortkey.h	11444	0644	edit dl rm
std_string.h	1076	0644	edit dl rm
strenum.h	10158	0644	edit dl rm
stringoptions.h	5926	0644	edit dl rm
stringpiece.h	10597	0644	edit dl rm
stringtriebuilder.h	15698	0644	edit dl rm
stsearch.h	21810	0644	edit dl rm
symtable.h	4374	0644	edit dl rm
tblcoll.h	37489	0644	edit dl rm
timezone.h	42005	0644	edit dl rm
tmunit.h	3461	0644	edit dl rm
tmutamt.h	5015	0644	edit dl rm
tmutfmt.h	8042	0644	edit dl rm
translit.h	67400	0644	edit dl rm
tzfmt.h	43916	0644	edit dl rm
tznames.h	17252	0644	edit dl rm
tzrule.h	36215	0644	edit dl rm
tztrans.h	6271	0644	edit dl rm
ubidi.h	91711	0644	edit dl rm
ubiditransform.h	12950	0644	edit dl rm
ubrk.h	24547	0644	edit dl rm
ucal.h	58265	0644	edit dl rm
ucasemap.h	15546	0644	edit dl rm
ucat.h	5484	0644	edit dl rm
uchar.h	144630	0644	edit dl rm
ucharstrie.h	23120	0644	edit dl rm
ucharstriebuilder.h	7378	0644	edit dl rm
uchriter.h	13521	0644	edit dl rm
uclean.h	11474	0644	edit dl rm
ucnv.h	85085	0644	edit dl rm
ucnvsel.h	6283	0644	edit dl rm
ucnv_cb.h	6748	0644	edit dl rm
ucnv_err.h	21492	0644	edit dl rm
ucol.h	62939	0644	edit dl rm
ucoleitr.h	9684	0644	edit dl rm
uconfig.h	12356	0644	edit dl rm
ucpmap.h	5663	0644	edit dl rm
ucptrie.h	23002	0644	edit dl rm
ucsdet.h	15018	0644	edit dl rm
ucurr.h	16507	0644	edit dl rm
udat.h	62851	0644	edit dl rm
udata.h	15930	0644	edit dl rm
udateintervalformat.h	10995	0644	edit dl rm
udatpg.h	27447	0644	edit dl rm
udisplaycontext.h	6029	0644	edit dl rm
uenum.h	7970	0644	edit dl rm
ufieldpositer.h	4461	0644	edit dl rm
uformattable.h	11198	0644	edit dl rm
uformattedvalue.h	12413	0644	edit dl rm
ugender.h	2052	0644	edit dl rm
uidna.h	34169	0644	edit dl rm
uiter.h	23319	0644	edit dl rm
uldnames.h	10702	0644	edit dl rm
ulistformatter.h	11086	0644	edit dl rm
uloc.h	54432	0644	edit dl rm
ulocdata.h	11533	0644	edit dl rm
umachine.h	14884	0644	edit dl rm
umisc.h	1365	0644	edit dl rm
umsg.h	24812	0644	edit dl rm
umutablecptrie.h	8435	0644	edit dl rm
unifilt.h	4055	0644	edit dl rm
unifunct.h	4141	0644	edit dl rm
unimatch.h	6244	0644	edit dl rm
unirepl.h	3464	0644	edit dl rm
uniset.h	66459	0644	edit dl rm
unistr.h	174523	0644	edit dl rm
unorm.h	21015	0644	edit dl rm
unorm2.h	25254	0644	edit dl rm
unum.h	54743	0644	edit dl rm
unumberformatter.h	25824	0644	edit dl rm
unumsys.h	7387	0644	edit dl rm
uobject.h	10936	0644	edit dl rm
upluralrules.h	8013	0644	edit dl rm
uregex.h	73784	0644	edit dl rm
uregion.h	10073	0644	edit dl rm
ureldatefmt.h	17409	0644	edit dl rm
urename.h	134449	0644	edit dl rm
urep.h	5507	0644	edit dl rm
ures.h	37415	0644	edit dl rm
uscript.h	27867	0644	edit dl rm
usearch.h	39039	0644	edit dl rm
uset.h	40958	0644	edit dl rm
usetiter.h	9781	0644	edit dl rm
ushape.h	18432	0644	edit dl rm
uspoof.h	67480	0644	edit dl rm
usprep.h	8331	0644	edit dl rm
ustdio.h	39469	0644	edit dl rm
ustream.h	1934	0644	edit dl rm
ustring.h	74211	0644	edit dl rm
ustringtrie.h	3224	0644	edit dl rm
utext.h	59527	0644	edit dl rm
utf.h	8046	0644	edit dl rm
utf8.h	31700	0644	edit dl rm
utf16.h	23878	0644	edit dl rm
utf32.h	763	0644	edit dl rm
utf_old.h	46929	0644	edit dl rm
utmscale.h	14113	0644	edit dl rm
utrace.h	17706	0644	edit dl rm
utrans.h	26130	0644	edit dl rm
utypes.h	31481	0644	edit dl rm
uvernum.h	6832	0644	edit dl rm
uversion.h	6145	0644	edit dl rm
vtzone.h	20784	0644	edit dl rm

Edit: /usr/include/unicode/sortkey.h (11444B)

// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
 *****************************************************************************
 * Copyright (C) 1996-2014, International Business Machines Corporation and others.
 * All Rights Reserved.
 *****************************************************************************
 *
 * File sortkey.h
 *
 * Created by: Helena Shih
 *
 * Modification History:
 *
 *  Date         Name          Description
 *
 *  6/20/97     helena      Java class name change.
 *  8/18/97     helena      Added internal API documentation.
 *  6/26/98     erm         Changed to use byte arrays and memcmp.
 *****************************************************************************
 */

#ifndef SORTKEY_H
#define SORTKEY_H

#include "unicode/utypes.h"

#if U_SHOW_CPLUSPLUS_API

/**
 * \file 
 * \brief C++ API: Keys for comparing strings multiple times. 
 */
 
#if !UCONFIG_NO_COLLATION

#include "unicode/uobject.h"
#include "unicode/unistr.h"
#include "unicode/coll.h"

U_NAMESPACE_BEGIN

/* forward declaration */
class RuleBasedCollator;
class CollationKeyByteSink;

/**
 *
 * Collation keys are generated by the Collator class. Use the CollationKey objects
 * instead of Collator to compare strings multiple times. A CollationKey
 * preprocesses the comparison information from the Collator object to
 * make the comparison faster. If you are not going to comparing strings
 * multiple times, then using the Collator object is generally faster,
 * since it only processes as much of the string as needed to make a
 * comparison.
 * For example (with strength == tertiary)
 * When comparing "Abernathy" to "Baggins-Smythworthy", Collator
 * only needs to process a couple of characters, while a comparison
 * with CollationKeys will process all of the characters. On the other hand,
 * if you are doing a sort of a number of fields, it is much faster to use
 * CollationKeys, since you will be comparing strings multiple times.
 * Typical use of CollationKeys are in databases, where you store a CollationKey
 * in a hidden field, and use it for sorting or indexing.
 *
 * Example of use:
 * <pre>
 * \code
 * UErrorCode success = U_ZERO_ERROR;
 * Collator* myCollator = Collator::createInstance(success);
 * CollationKey* keys = new CollationKey [3];
 * myCollator->getCollationKey("Tom", keys[0], success );
 * myCollator->getCollationKey("Dick", keys[1], success );
 * myCollator->getCollationKey("Harry", keys[2], success );
 *
 * // Inside body of sort routine, compare keys this way:
 * CollationKey tmp;
 * if(keys[0].compareTo( keys[1] ) > 0 ) {
 * tmp = keys[0]; keys[0] = keys[1]; keys[1] = tmp;
 * }
 * //...
 * \endcode
 * </pre>
 * Because Collator::compare()'s algorithm is complex, it is faster to sort
 * long lists of words by retrieving collation keys with Collator::getCollationKey().
 * You can then cache the collation keys and compare them using CollationKey::compareTo().
 * 
 * Note: <code>Collator</code>s with different Locale,
 * CollationStrength and DecompositionMode settings will return different
 * CollationKeys for the same set of strings. Locales have specific
 * collation rules, and the way in which secondary and tertiary differences
 * are taken into account, for example, will result in different CollationKeys
 * for same strings.
 *

* @see          Collator
 * @see          RuleBasedCollator
 * @version      1.3 12/18/96
 * @author       Helena Shih
 * @stable ICU 2.0
 */
class U_I18N_API CollationKey : public UObject {
public:
    /**
    * This creates an empty collation key based on the null string.  An empty
    * collation key contains no sorting information.  When comparing two empty
    * collation keys, the result is Collator::EQUAL.  Comparing empty collation key
    * with non-empty collation key is always Collator::LESS.
    * @stable ICU 2.0
    */
    CollationKey();

/**
    * Creates a collation key based on the collation key values.
    * @param values the collation key values
    * @param count number of collation key values, including trailing nulls.
    * @stable ICU 2.0
    */
    CollationKey(const  uint8_t*    values,
                int32_t     count);

/**
    * Copy constructor.
    * @param other    the object to be copied.
    * @stable ICU 2.0
    */
    CollationKey(const CollationKey& other);

/**
    * Sort key destructor.
    * @stable ICU 2.0
    */
    virtual ~CollationKey();

/**
    * Assignment operator
    * @param other    the object to be copied.
    * @stable ICU 2.0
    */
    const   CollationKey&   operator=(const CollationKey& other);

/**
    * Compare if two collation keys are the same.
    * @param source the collation key to compare to.
    * @return Returns true if two collation keys are equal, false otherwise.
    * @stable ICU 2.0
    */
    UBool                   operator==(const CollationKey& source) const;

/**
    * Compare if two collation keys are not the same.
    * @param source the collation key to compare to.
    * @return Returns TRUE if two collation keys are different, FALSE otherwise.
    * @stable ICU 2.0
    */
    UBool                   operator!=(const CollationKey& source) const;

/**
    * Test to see if the key is in an invalid state. The key will be in an
    * invalid state if it couldn't allocate memory for some operation.
    * @return Returns TRUE if the key is in an invalid, FALSE otherwise.
    * @stable ICU 2.0
    */
    UBool                   isBogus(void) const;

/**
    * Returns a pointer to the collation key values. The storage is owned
    * by the collation key and the pointer will become invalid if the key
    * is deleted.
    * @param count the output parameter of number of collation key values,
    * including any trailing nulls.
    * @return a pointer to the collation key values.
    * @stable ICU 2.0
    */
    const    uint8_t*       getByteArray(int32_t& count) const;

#ifdef U_USE_COLLATION_KEY_DEPRECATES
    /**
    * Extracts the collation key values into a new array. The caller owns
    * this storage and should free it.
    * @param count the output parameter of number of collation key values,
    * including any trailing nulls.
    * @obsolete ICU 2.6. Use getByteArray instead since this API will be removed in that release.
    */
    uint8_t*                toByteArray(int32_t& count) const;
#endif

#ifndef U_HIDE_DEPRECATED_API 
    /**
    * Convenience method which does a string(bit-wise) comparison of the
    * two collation keys.
    * @param target target collation key to be compared with
    * @return Returns Collator::LESS if sourceKey &lt; targetKey,
    * Collator::GREATER if sourceKey > targetKey and Collator::EQUAL
    * otherwise.
    * @deprecated ICU 2.6 use the overload with error code
    */
    Collator::EComparisonResult compareTo(const CollationKey& target) const;
#endif  /* U_HIDE_DEPRECATED_API */

/**
    * Convenience method which does a string(bit-wise) comparison of the
    * two collation keys.
    * @param target target collation key to be compared with
    * @param status error code
    * @return Returns UCOL_LESS if sourceKey &lt; targetKey,
    * UCOL_GREATER if sourceKey > targetKey and UCOL_EQUAL
    * otherwise.
    * @stable ICU 2.6
    */
    UCollationResult compareTo(const CollationKey& target, UErrorCode &status) const;

/**
 * Creates an integer that is unique to the collation key. NOTE: this
 * is not the same as String.hashCode.
 * Example of use:
 * <pre>
 * . UErrorCode status = U_ZERO_ERROR;
 * . Collator *myCollation = Collator::createInstance(Locale::US, status);
 * . if (U_FAILURE(status)) return;
 * . CollationKey key1, key2;
 * . UErrorCode status1 = U_ZERO_ERROR, status2 = U_ZERO_ERROR;
 * . myCollation->getCollationKey("abc", key1, status1);
 * . if (U_FAILURE(status1)) { delete myCollation; return; }
 * . myCollation->getCollationKey("ABC", key2, status2);
 * . if (U_FAILURE(status2)) { delete myCollation; return; }
 * . // key1.hashCode() != key2.hashCode()
 * </pre>
 * @return the hash value based on the string's collation order.
 * @see UnicodeString#hashCode
 * @stable ICU 2.0
 */
 int32_t hashCode(void) const;

/**
     * 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();

private:
    /**
     * Replaces the current bytes buffer with a new one of newCapacity
     * and copies length bytes from the old buffer to the new one.
     * @return the new buffer, or NULL if the allocation failed
     */
    uint8_t *reallocate(int32_t newCapacity, int32_t length);
    /**
     * Set a new length for a new sort key in the existing fBytes.
     */
    void setLength(int32_t newLength);

uint8_t *getBytes() {
        return (fFlagAndLength >= 0) ? fUnion.fStackBuffer : fUnion.fFields.fBytes;
    }
    const uint8_t *getBytes() const {
        return (fFlagAndLength >= 0) ? fUnion.fStackBuffer : fUnion.fFields.fBytes;
    }
    int32_t getCapacity() const {
        return (fFlagAndLength >= 0) ? (int32_t)sizeof(fUnion) : fUnion.fFields.fCapacity;
    }
    int32_t getLength() const { return fFlagAndLength & 0x7fffffff; }

/**
    * Set the CollationKey to a "bogus" or invalid state
    * @return this CollationKey
    */
    CollationKey&           setToBogus(void);
    /**
    * Resets this CollationKey to an empty state
    * @return this CollationKey
    */
    CollationKey&           reset(void);

/**
    * Allow private access to RuleBasedCollator
    */
    friend  class           RuleBasedCollator;
    friend  class           CollationKeyByteSink;

// Class fields. sizeof(CollationKey) is intended to be 48 bytes
    // on a machine with 64-bit pointers.
    // We use a union to maximize the size of the internal buffer,
    // similar to UnicodeString but not as tight and complex.

// (implicit) *vtable;
    /**
     * Sort key length and flag.
     * Bit 31 is set if the buffer is heap-allocated.
     * Bits 30..0 contain the sort key length.
     */
    int32_t fFlagAndLength;
    /**
    * Unique hash value of this CollationKey.
    * Special value 2 if the key is bogus.
    */
    mutable int32_t fHashCode;
    /**
     * fUnion provides 32 bytes for the internal buffer or for
     * pointer+capacity.
     */
    union StackBufferOrFields {
        /** fStackBuffer is used iff fFlagAndLength>=0, else fFields is used */
        uint8_t fStackBuffer[32];
        struct {
            uint8_t *fBytes;
            int32_t fCapacity;
        } fFields;
    } fUnion;
};

inline UBool
CollationKey::operator!=(const CollationKey& other) const
{
    return !(*this == other);
}

inline UBool
CollationKey::isBogus() const
{
    return fHashCode == 2;  // kBogusHashCode
}

inline const uint8_t*
CollationKey::getByteArray(int32_t &count) const
{
    count = getLength();
    return getBytes();
}

U_NAMESPACE_END

#endif /* #if !UCONFIG_NO_COLLATION */

#endif /* U_SHOW_CPLUSPLUS_API */

#endif

cmd: