~alinuxninja/nginx-edge/trunk

* @param destCapacity The length of dest. If it is 0, then dest may be NULL and the function will only return the length of the result without writing any of the result string (pre-flighting).

543

* @param pErrorCode Must be a valid pointer to an error code value, which must not indicate a failure before the function call.

544

* @return The length of the array of the script ordering.

545

* @see ucol_setReorderCodes

546

* @internal

547

548

U_INTERNAL int32_t U_EXPORT2

549

ucol_getReorderCodes(const UCollator* coll,

550

int32_t* dest,

551

int32_t destCapacity,

552

UErrorCode *pErrorCode);

553

554

/**

555

* Set the ordering of scripts for this collator.

556

* @param coll The UCollator to set.

557

* @param reorderCodes An array of script codes in the new order.

558

* @param reorderCodesLength The length of reorderCodes.

559

* @param pErrorCode Must be a valid pointer to an error code value, which must not indicate a failure before the function call.

560

* @see ucol_getReorderCodes

561

* @internal

562

563

U_INTERNAL void U_EXPORT2

564

ucol_setReorderCodes(UCollator* coll,

565

const int32_t* reorderCodes,

566

int32_t reorderCodesLength,

567

UErrorCode *pErrorCode);

568

569

/**

570

* Get the display name for a UCollator.

571

* The display name is suitable for presentation to a user.

572

* @param objLoc The locale of the collator in question.

573

* @param dispLoc The locale for display.

574

* @param result A pointer to a buffer to receive the attribute.

575

* @param resultLength The maximum size of result.

576

* @param status A pointer to an UErrorCode to receive any errors

577

* @return The total buffer size needed; if greater than resultLength,

578

* the output was truncated.

579

* @stable ICU 2.0

580

581

U_STABLE int32_t U_EXPORT2

582

ucol_getDisplayName( const char *objLoc,

583

const char *dispLoc,

584

UChar *result,

585

int32_t resultLength,

586

UErrorCode *status);

587

588

/**

589

* Get a locale for which collation rules are available.

590

* A UCollator in a locale returned by this function will perform the correct

591

* collation for the locale.

592

* @param localeIndex The index of the desired locale.

593

* @return A locale for which collation rules are available, or 0 if none.

594

* @see ucol_countAvailable

595

* @stable ICU 2.0

596

597

U_STABLE const char* U_EXPORT2

598

ucol_getAvailable(int32_t localeIndex);

599

600

/**

601

* Determine how many locales have collation rules available.

602

* This function is most useful as determining the loop ending condition for

603

* calls to {@link #ucol_getAvailable }.

604

* @return The number of locales for which collation rules are available.

605

* @see ucol_getAvailable

606

* @stable ICU 2.0

607

608

U_STABLE int32_t U_EXPORT2

609

ucol_countAvailable(void);

610

611

#if !UCONFIG_NO_SERVICE

612

/**

613

* Create a string enumerator of all locales for which a valid

614

* collator may be opened.

615

* @param status input-output error code

616

* @return a string enumeration over locale strings. The caller is

617

* responsible for closing the result.

618

* @stable ICU 3.0

619

620

U_STABLE UEnumeration* U_EXPORT2

621

ucol_openAvailableLocales(UErrorCode *status);

622

#endif

623

624

/**

625

* Create a string enumerator of all possible keywords that are relevant to

626

* collation. At this point, the only recognized keyword for this

627

* service is "collation".

628

* @param status input-output error code

629

* @return a string enumeration over locale strings. The caller is

630

* responsible for closing the result.

631

* @stable ICU 3.0

632

633

U_STABLE UEnumeration* U_EXPORT2

634

ucol_getKeywords(UErrorCode *status);

635

636

/**

637

* Given a keyword, create a string enumeration of all values

638

* for that keyword that are currently in use.

639

* @param keyword a particular keyword as enumerated by

640

* ucol_getKeywords. If any other keyword is passed in, *status is set

641

* to U_ILLEGAL_ARGUMENT_ERROR.

642

* @param status input-output error code

643

* @return a string enumeration over collation keyword values, or NULL

644

* upon error. The caller is responsible for closing the result.

645

* @stable ICU 3.0

646

647

U_STABLE UEnumeration* U_EXPORT2

648

ucol_getKeywordValues(const char *keyword, UErrorCode *status);

649

650

/**

651

* Given a key and a locale, returns an array of string values in a preferred

652

* order that would make a difference. These are all and only those values where

653

* the open (creation) of the service with the locale formed from the input locale

654

* plus input keyword and that value has different behavior than creation with the

655

* input locale alone.

656

* @param key one of the keys supported by this service. For now, only

657

* "collation" is supported.

658

* @param locale the locale

659

* @param commonlyUsed if set to true it will return only commonly used values

660

* with the given locale in preferred order. Otherwise,

661

* it will return all the available values for the locale.

662

* @param status error status

663

* @return a string enumeration over keyword values for the given key and the locale.

664

* @stable ICU 4.2

665

666

U_STABLE UEnumeration* U_EXPORT2

667

ucol_getKeywordValuesForLocale(const char* key,

668

const char* locale,

669

UBool commonlyUsed,

670

UErrorCode* status);

671

672

/**

673

* Return the functionally equivalent locale for the given

674

* requested locale, with respect to given keyword, for the

675

* collation service. If two locales return the same result, then

676

* collators instantiated for these locales will behave

677

* equivalently. The converse is not always true; two collators

678

* may in fact be equivalent, but return different results, due to

679

* internal details. The return result has no other meaning than

680

* that stated above, and implies nothing as to the relationship

681

* between the two locales. This is intended for use by

682

* applications who wish to cache collators, or otherwise reuse

683

* collators when possible. The functional equivalent may change

684

* over time. For more information, please see the <a

685

* href="http://icu-project.org/userguide/locale.html#services">

686

* Locales and Services</a> section of the ICU User Guide.

687

* @param result fillin for the functionally equivalent locale

688

* @param resultCapacity capacity of the fillin buffer

689

* @param keyword a particular keyword as enumerated by

690

* ucol_getKeywords.

691

* @param locale the requested locale

692

* @param isAvailable if non-NULL, pointer to a fillin parameter that

693

* indicates whether the requested locale was 'available' to the

694

* collation service. A locale is defined as 'available' if it

695

* physically exists within the collation locale data.

696

* @param status pointer to input-output error code

697

* @return the actual buffer size needed for the locale. If greater

698

* than resultCapacity, the returned full name will be truncated and

699

* an error code will be returned.

700

* @stable ICU 3.0

701

702

U_STABLE int32_t U_EXPORT2

703

ucol_getFunctionalEquivalent(char* result, int32_t resultCapacity,

704

const char* keyword, const char* locale,

705

UBool* isAvailable, UErrorCode* status);

706

707

/**

708

* Get the collation rules from a UCollator.

709

* The rules will follow the rule syntax.

710

* @param coll The UCollator to query.

711

* @param length

712

* @return The collation rules.

713

* @stable ICU 2.0

714

715

U_STABLE const UChar* U_EXPORT2

716

ucol_getRules( const UCollator *coll,

717

int32_t *length);

718

719

/** Get the short definition string for a collator. This API harvests the collator's

720

* locale and the attribute set and produces a string that can be used for opening

721

* a collator with the same properties using the ucol_openFromShortString API.

722

* This string will be normalized.

723

* The structure and the syntax of the string is defined in the "Naming collators"

724

* section of the users guide:

725

* http://icu-project.org/userguide/Collate_Concepts.html#Naming_Collators

726

* This API supports preflighting.

727

* @param coll a collator

728

* @param locale a locale that will appear as a collators locale in the resulting

729

* short string definition. If NULL, the locale will be harvested

730

* from the collator.

731

* @param buffer space to hold the resulting string

732

* @param capacity capacity of the buffer

733

* @param status for returning errors. All the preflighting errors are featured

734

* @return length of the resulting string

735

* @see ucol_openFromShortString

736

* @see ucol_normalizeShortDefinitionString

737

* @stable ICU 3.0

738

739

U_STABLE int32_t U_EXPORT2

740

ucol_getShortDefinitionString(const UCollator *coll,

741

const char *locale,

742

char *buffer,

743

int32_t capacity,

744

UErrorCode *status);

745

746

/** Verifies and normalizes short definition string.

747

* Normalized short definition string has all the option sorted by the argument name,

748

* so that equivalent definition strings are the same.

749

* This API supports preflighting.

750

* @param source definition string

751

* @param destination space to hold the resulting string

752

* @param capacity capacity of the buffer

753

* @param parseError if not NULL, structure that will get filled with error's pre

754

* and post context in case of error.

755

* @param status Error code. This API will return an error if an invalid attribute

756

* or attribute/value combination is specified. All the preflighting

757

* errors are also featured

758

* @return length of the resulting normalized string.

759

760

* @see ucol_openFromShortString

761

* @see ucol_getShortDefinitionString

762

763

* @stable ICU 3.0

764

765

766

U_STABLE int32_t U_EXPORT2

767

ucol_normalizeShortDefinitionString(const char *source,

768

char *destination,

769

int32_t capacity,

770

UParseError *parseError,

771

UErrorCode *status);

772

773

774

/**

775

* Get a sort key for a string from a UCollator.

776

* Sort keys may be compared using <TT>strcmp</TT>.

777

778

* Like ICU functions that write to an output buffer, the buffer contents

779

* is undefined if the buffer capacity (resultLength parameter) is too small.

780

* Unlike ICU functions that write a string to an output buffer,

781

* the terminating zero byte is counted in the sort key length.

782

* @param coll The UCollator containing the collation rules.

783

* @param source The string to transform.

784

* @param sourceLength The length of source, or -1 if null-terminated.

785

* @param result A pointer to a buffer to receive the attribute.

786

* @param resultLength The maximum size of result.

787

* @return The size needed to fully store the sort key.

788

* If there was an internal error generating the sort key,

789

* a zero value is returned.

790

* @see ucol_keyHashCode

791

* @stable ICU 2.0

792

793

U_STABLE int32_t U_EXPORT2

794

ucol_getSortKey(const UCollator *coll,

795

const UChar *source,

796

int32_t sourceLength,

797

uint8_t *result,

798

int32_t resultLength);

799

800

801

/** Gets the next count bytes of a sort key. Caller needs

802

* to preserve state array between calls and to provide

803

* the same type of UCharIterator set with the same string.

804

* The destination buffer provided must be big enough to store

805

* the number of requested bytes. Generated sortkey is not

806

* compatible with sortkeys generated using ucol_getSortKey

807

* API, since we don't do any compression. If uncompressed

808

* sortkeys are required, this API can be used.

809

* @param coll The UCollator containing the collation rules.

810

* @param iter UCharIterator containing the string we need

811

* the sort key to be calculated for.

812

* @param state Opaque state of sortkey iteration.

813

* @param dest Buffer to hold the resulting sortkey part

814

* @param count number of sort key bytes required.

815

* @param status error code indicator.

816

* @return the actual number of bytes of a sortkey. It can be

817

* smaller than count if we have reached the end of

818

* the sort key.

819

* @stable ICU 2.6

820

821

U_STABLE int32_t U_EXPORT2

822

ucol_nextSortKeyPart(const UCollator *coll,

823

UCharIterator *iter,

824

uint32_t state[2],

825

uint8_t *dest, int32_t count,

826

UErrorCode *status);

827

828

/** enum that is taken by ucol_getBound API

829

* See below for explanation

830

* do not change the values assigned to the

831

* members of this enum. Underlying code

832

* depends on them having these numbers

833

* @stable ICU 2.0

834

835

typedef enum {

836

/** lower bound */

837

UCOL_BOUND_LOWER = 0,

838

/** upper bound that will match strings of exact size */

839

UCOL_BOUND_UPPER = 1,

840

/** upper bound that will match all the strings that have the same initial substring as the given string */

841

UCOL_BOUND_UPPER_LONG = 2,

842

UCOL_BOUND_VALUE_COUNT

843

} UColBoundMode;

844

845

/**

846

* Produce a bound for a given sortkey and a number of levels.

847

* Return value is always the number of bytes needed, regardless of

848

* whether the result buffer was big enough or even valid.

849

* Resulting bounds can be used to produce a range of strings that are

850

* between upper and lower bounds. For example, if bounds are produced

851

* for a sortkey of string "smith", strings between upper and lower

852

* bounds with one level would include "Smith", "SMITH", "sMiTh".

853

* There are two upper bounds that can be produced. If UCOL_BOUND_UPPER

854

* is produced, strings matched would be as above. However, if bound

855

* produced using UCOL_BOUND_UPPER_LONG is used, the above example will

856

* also match "Smithsonian" and similar.

857

* For more on usage, see example in cintltst/capitst.c in procedure

858

* TestBounds.

859

* Sort keys may be compared using <TT>strcmp</TT>.

860

* @param source The source sortkey.

861

* @param sourceLength The length of source, or -1 if null-terminated.

862

* (If an unmodified sortkey is passed, it is always null

863

* terminated).

864

* @param boundType Type of bound required. It can be UCOL_BOUND_LOWER, which

865

* produces a lower inclusive bound, UCOL_BOUND_UPPER, that

866

* produces upper bound that matches strings of the same length

867

* or UCOL_BOUND_UPPER_LONG that matches strings that have the

868

* same starting substring as the source string.

869

* @param noOfLevels Number of levels required in the resulting bound (for most

870

* uses, the recommended value is 1). See users guide for

871

* explanation on number of levels a sortkey can have.

872

* @param result A pointer to a buffer to receive the resulting sortkey.

873

* @param resultLength The maximum size of result.

874

* @param status Used for returning error code if something went wrong. If the

875

* number of levels requested is higher than the number of levels

876

* in the source key, a warning (U_SORT_KEY_TOO_SHORT_WARNING) is

877

* issued.

878

* @return The size needed to fully store the bound.

879

* @see ucol_keyHashCode

880

* @stable ICU 2.1

881

882

U_STABLE int32_t U_EXPORT2

883

ucol_getBound(const uint8_t *source,

884

int32_t sourceLength,

885

UColBoundMode boundType,

886

uint32_t noOfLevels,

887

uint8_t *result,

888

int32_t resultLength,

889

UErrorCode *status);

890

891

/**

892

* Gets the version information for a Collator. Version is currently

893

* an opaque 32-bit number which depends, among other things, on major

894

* versions of the collator tailoring and UCA.

895

* @param coll The UCollator to query.

896

* @param info the version # information, the result will be filled in

897

* @stable ICU 2.0

898

899

U_STABLE void U_EXPORT2

900

ucol_getVersion(const UCollator* coll, UVersionInfo info);

901

902

/**

903

* Gets the UCA version information for a Collator. Version is the

904

* UCA version number (3.1.1, 4.0).

905

* @param coll The UCollator to query.

906

* @param info the version # information, the result will be filled in

907

* @stable ICU 2.8

908

909

U_STABLE void U_EXPORT2

910

ucol_getUCAVersion(const UCollator* coll, UVersionInfo info);

911

912

/**

913

* Merge two sort keys. The levels are merged with their corresponding counterparts

914

* (primaries with primaries, secondaries with secondaries etc.). Between the values

915

* from the same level a separator is inserted.

916

* example (uncompressed):

917

* 191B1D 01 050505 01 910505 00 and 1F2123 01 050505 01 910505 00

918

* will be merged as

919

* 191B1D 02 1F212301 050505 02 050505 01 910505 02 910505 00

920

* This allows for concatenating of first and last names for sorting, among other things.

921

* If the destination buffer is not big enough, the results are undefined.

922

* If any of source lengths are zero or any of source pointers are NULL/undefined,

923

* result is of size zero.

924

* @param src1 pointer to the first sortkey

925

* @param src1Length length of the first sortkey

926

* @param src2 pointer to the second sortkey

927

* @param src2Length length of the second sortkey

928

* @param dest buffer to hold the result

929

* @param destCapacity size of the buffer for the result

930

* @return size of the result. If the buffer is big enough size is always

931

* src1Length+src2Length-1

932

* @stable ICU 2.0

933

934

U_STABLE int32_t U_EXPORT2

935

ucol_mergeSortkeys(const uint8_t *src1, int32_t src1Length,

936

const uint8_t *src2, int32_t src2Length,

937

uint8_t *dest, int32_t destCapacity);

938

939

/**

940

* Universal attribute setter

941

* @param coll collator which attributes are to be changed

942

* @param attr attribute type

943

* @param value attribute value

944

* @param status to indicate whether the operation went on smoothly or there were errors

945

* @see UColAttribute

946

* @see UColAttributeValue

947

* @see ucol_getAttribute

948

* @stable ICU 2.0

949

950

U_STABLE void U_EXPORT2

951

ucol_setAttribute(UCollator *coll, UColAttribute attr, UColAttributeValue value, UErrorCode *status);

952

953

/**

954

* Universal attribute getter

955

* @param coll collator which attributes are to be changed

956

* @param attr attribute type

957

* @return attribute value

958

* @param status to indicate whether the operation went on smoothly or there were errors

959

* @see UColAttribute

960

* @see UColAttributeValue

961

* @see ucol_setAttribute

962

* @stable ICU 2.0

963

964

U_STABLE UColAttributeValue U_EXPORT2

965

ucol_getAttribute(const UCollator *coll, UColAttribute attr, UErrorCode *status);

966

967

/** Variable top

968

* is a two byte primary value which causes all the codepoints with primary values that

969

* are less or equal than the variable top to be shifted when alternate handling is set

970

* to UCOL_SHIFTED.

971

* Sets the variable top to a collation element value of a string supplied.

972

* @param coll collator which variable top needs to be changed

973

* @param varTop one or more (if contraction) UChars to which the variable top should be set

974

* @param len length of variable top string. If -1 it is considered to be zero terminated.

975

* @param status error code. If error code is set, the return value is undefined.

976

* Errors set by this function are:

977

* U_CE_NOT_FOUND_ERROR if more than one character was passed and there is no such

978

* a contraction

979

* U_PRIMARY_TOO_LONG_ERROR if the primary for the variable top has more than two bytes

980

* @return a 32 bit value containing the value of the variable top in upper 16 bits.

981

* Lower 16 bits are undefined

982

* @see ucol_getVariableTop

983

* @see ucol_restoreVariableTop

984

* @stable ICU 2.0

985

986

U_STABLE uint32_t U_EXPORT2

987

ucol_setVariableTop(UCollator *coll,

988

const UChar *varTop, int32_t len,

989

UErrorCode *status);

990

991

/**

992

* Gets the variable top value of a Collator.

993

* Lower 16 bits are undefined and should be ignored.

994

* @param coll collator which variable top needs to be retrieved

995

* @param status error code (not changed by function). If error code is set,

996

* the return value is undefined.

997

* @return the variable top value of a Collator.

998

* @see ucol_setVariableTop

999

* @see ucol_restoreVariableTop

1000

* @stable ICU 2.0

1001

1002

U_STABLE uint32_t U_EXPORT2 ucol_getVariableTop(const UCollator *coll, UErrorCode *status);

1003

1004

/**

1005

* Sets the variable top to a collation element value supplied. Variable top is

1006

* set to the upper 16 bits.

1007

* Lower 16 bits are ignored.

1008

* @param coll collator which variable top needs to be changed

1009

* @param varTop CE value, as returned by ucol_setVariableTop or ucol)getVariableTop

1010

* @param status error code (not changed by function)

1011

* @see ucol_getVariableTop

1012

* @see ucol_setVariableTop

1013

* @stable ICU 2.0

1014

1015

U_STABLE void U_EXPORT2

1016

ucol_restoreVariableTop(UCollator *coll, const uint32_t varTop, UErrorCode *status);

1017

1018

/**

1019

* Thread safe cloning operation. The result is a clone of a given collator.

1020

* @param coll collator to be cloned

1021

* @param stackBuffer user allocated space for the new clone.

1022

* If NULL new memory will be allocated.

1023

* If buffer is not large enough, new memory will be allocated.

1024

* Clients can use the U_COL_SAFECLONE_BUFFERSIZE.

1025

* This will probably be enough to avoid memory allocations.

1026

* @param pBufferSize pointer to size of allocated space.

1027

* If *pBufferSize == 0, a sufficient size for use in cloning will

1028

* be returned ('pre-flighting')

1029

* If *pBufferSize is not enough for a stack-based safe clone,

1030

* new memory will be allocated.

1031

* @param status to indicate whether the operation went on smoothly or there were errors

1032

* An informational status value, U_SAFECLONE_ALLOCATED_ERROR, is used if any

1033

* allocations were necessary.

1034

* @return pointer to the new clone

1035

* @see ucol_open

1036

* @see ucol_openRules

1037

* @see ucol_close

1038

* @stable ICU 2.0

1039

1040

U_STABLE UCollator* U_EXPORT2

1041

ucol_safeClone(const UCollator *coll,

1042

void *stackBuffer,

1043

int32_t *pBufferSize,

1044

UErrorCode *status);

1045

1046

/** default memory size for the new clone. It needs to be this large for os/400 large pointers

1047

* @stable ICU 2.0

1048

1049

#define U_COL_SAFECLONE_BUFFERSIZE 512

1050

1051

/**

1052

* Returns current rules. Delta defines whether full rules are returned or just the tailoring.

1053

* Returns number of UChars needed to store rules. If buffer is NULL or bufferLen is not enough

1054

* to store rules, will store up to available space.

1055

* @param coll collator to get the rules from

1056

* @param delta one of UCOL_TAILORING_ONLY, UCOL_FULL_RULES.

1057

* @param buffer buffer to store the result in. If NULL, you'll get no rules.

1058

* @param bufferLen lenght of buffer to store rules in. If less then needed you'll get only the part that fits in.

1059

* @return current rules

1060

* @stable ICU 2.0

1061

1062

U_STABLE int32_t U_EXPORT2

1063

ucol_getRulesEx(const UCollator *coll, UColRuleOption delta, UChar *buffer, int32_t bufferLen);

1064

1065

/**

1066

* gets the locale name of the collator. If the collator

1067

* is instantiated from the rules, then this function returns

1068

* NULL.

1069

* @param coll The UCollator for which the locale is needed

1070

* @param type You can choose between requested, valid and actual

1071

* locale. For description see the definition of

1072

* ULocDataLocaleType in uloc.h

1073

* @param status error code of the operation

1074

* @return real locale name from which the collation data comes.

1075

* If the collator was instantiated from rules, returns

1076

* NULL.

1077

* @deprecated ICU 2.8 Use ucol_getLocaleByType instead

1078

1079

U_DEPRECATED const char * U_EXPORT2

1080

ucol_getLocale(const UCollator *coll, ULocDataLocaleType type, UErrorCode *status);

1081

1082

1083

/**

1084

* gets the locale name of the collator. If the collator

1085

* is instantiated from the rules, then this function returns

1086

* NULL.

1087

* @param coll The UCollator for which the locale is needed

1088

* @param type You can choose between requested, valid and actual

1089

* locale. For description see the definition of

1090

* ULocDataLocaleType in uloc.h

1091

* @param status error code of the operation

1092

* @return real locale name from which the collation data comes.

1093

* If the collator was instantiated from rules, returns

1094

* NULL.

1095

* @stable ICU 2.8

1096

1097

U_STABLE const char * U_EXPORT2

1098

ucol_getLocaleByType(const UCollator *coll, ULocDataLocaleType type, UErrorCode *status);

1099

1100

/**

1101

* Get an Unicode set that contains all the characters and sequences tailored in

1102

* this collator. The result must be disposed of by using uset_close.

1103

* @param coll The UCollator for which we want to get tailored chars

1104

* @param status error code of the operation

1105

* @return a pointer to newly created USet. Must be be disposed by using uset_close

1106

* @see ucol_openRules

1107

* @see uset_close

1108

* @stable ICU 2.4

1109

1110

U_STABLE USet * U_EXPORT2

1111

ucol_getTailoredSet(const UCollator *coll, UErrorCode *status);

1112

1113

/**

1114

* Universal attribute getter that returns UCOL_DEFAULT if the value is default

1115

* @param coll collator which attributes are to be changed

1116

* @param attr attribute type

1117

* @return attribute value or UCOL_DEFAULT if the value is default

1118

* @param status to indicate whether the operation went on smoothly or there were errors

1119

* @see UColAttribute

1120

* @see UColAttributeValue

1121

* @see ucol_setAttribute

1122

* @internal ICU 3.0

1123

1124

U_INTERNAL UColAttributeValue U_EXPORT2

1125

ucol_getAttributeOrDefault(const UCollator *coll, UColAttribute attr, UErrorCode *status);

1126

1127

/** Check whether two collators are equal. Collators are considered equal if they

1128

* will sort strings the same. This means that both the current attributes and the

1129

* rules must be equivalent. Currently used for RuleBasedCollator::operator==.

1130

* @param source first collator

1131

* @param target second collator

1132

* @return TRUE or FALSE

1133

* @internal ICU 3.0

1134

1135

U_INTERNAL UBool U_EXPORT2

1136

ucol_equals(const UCollator *source, const UCollator *target);

1137

1138

/** Calculates the set of unsafe code points, given a collator.

1139

* A character is unsafe if you could append any character and cause the ordering to alter significantly.

1140

* Collation sorts in normalized order, so anything that rearranges in normalization can cause this.

1141

* Thus if you have a character like a_umlaut, and you add a lower_dot to it,

1142

* then it normalizes to a_lower_dot + umlaut, and sorts differently.

1143

* @param coll Collator

1144

* @param unsafe a fill-in set to receive the unsafe points

1145

* @param status for catching errors

1146

* @return number of elements in the set

1147

* @internal ICU 3.0

1148

1149

U_INTERNAL int32_t U_EXPORT2

1150

ucol_getUnsafeSet( const UCollator *coll,

1151

USet *unsafe,

1152

UErrorCode *status);

1153

1154

/** Reset UCA's static pointers. You don't want to use this, unless your static memory can go away.

1155

* @internal ICU 3.2.1

1156

1157

U_INTERNAL void U_EXPORT2

1158

ucol_forgetUCA(void);

1159

1160

/** Touches all resources needed for instantiating a collator from a short string definition,

1161

* thus filling up the cache.

1162

* @param definition A short string containing a locale and a set of attributes.

1163

* Attributes not explicitly mentioned are left at the default

1164

* state for a locale.

1165

* @param parseError if not NULL, structure that will get filled with error's pre

1166

* and post context in case of error.

1167

* @param forceDefaults if FALSE, the settings that are the same as the collator

1168

* default settings will not be applied (for example, setting

1169

* French secondary on a French collator would not be executed).

1170

* If TRUE, all the settings will be applied regardless of the

1171

* collator default value. If the definition

1172

* strings are to be cached, should be set to FALSE.

1173

* @param status Error code. Apart from regular error conditions connected to

1174

* instantiating collators (like out of memory or similar), this

1175

* API will return an error if an invalid attribute or attribute/value

1176

* combination is specified.

1177

* @see ucol_openFromShortString

1178

* @internal ICU 3.2.1

1179

1180

U_INTERNAL void U_EXPORT2

1181

ucol_prepareShortStringOpen( const char *definition,

1182

UBool forceDefaults,

1183

UParseError *parseError,

1184

UErrorCode *status);

1185

1186

/** Creates a binary image of a collator. This binary image can be stored and

1187

* later used to instantiate a collator using ucol_openBinary.

1188

* This API supports preflighting.

1189

* @param coll Collator

1190

* @param buffer a fill-in buffer to receive the binary image

1191

* @param capacity capacity of the destination buffer

1192

* @param status for catching errors

1193

* @return size of the image

1194

* @see ucol_openBinary

1195

* @stable ICU 3.2

1196

1197

U_STABLE int32_t U_EXPORT2

1198

ucol_cloneBinary(const UCollator *coll,

1199

uint8_t *buffer, int32_t capacity,

1200

UErrorCode *status);

1201

1202

/** Opens a collator from a collator binary image created using

1203

* ucol_cloneBinary. Binary image used in instantiation of the

1204

* collator remains owned by the user and should stay around for

1205

* the lifetime of the collator. The API also takes a base collator

1206

* which usualy should be UCA.

1207

* @param bin binary image owned by the user and required through the

1208

* lifetime of the collator

1209

* @param length size of the image. If negative, the API will try to

1210

* figure out the length of the image

1211

* @param base fallback collator, usually UCA. Base is required to be

1212

* present through the lifetime of the collator. Currently

1213

* it cannot be NULL.

1214

* @param status for catching errors

1215

* @return newly created collator

1216

* @see ucol_cloneBinary

1217

* @stable ICU 3.2

1218

1219

U_STABLE UCollator* U_EXPORT2

1220

ucol_openBinary(const uint8_t *bin, int32_t length,

1221

const UCollator *base,

1222

UErrorCode *status);

1223

1224

1225

#endif /* #if !UCONFIG_NO_COLLATION */

1226

1227

#endif

Older »