organicmaps/icu
13
Fork 0
mirror of https://github.com/unicode-org/icu.git synced 2025-04-21 12:40:02 +00:00
Code Issues 1 Projects Releases Wiki Activity Actions 1

ICU-2686 Various documentation updates.

Browse source 
X-SVN-Rev: 10937
This commit is contained in:
George Rhoten 2003-01-30 22:48:58 +00:00
parent 578d384880
commit 4d7921d1b8
5 changed files with 254 additions and 222 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

71
icu4c/source/common/unicode/docmain.h
View file

@ -62,12 +62,12 @@
* <h2><a name="Module">Module List</h2>
* <table border="1" cols="3" align="center">
* <tr>
* <td><strong>Description</strong></td>
* <td><strong>Module Name</strong></td>
* <td><strong>C</strong></td>
* <td><strong>C++</strong></td>
* </tr>
* <tr>
* <td>Basic types and constants</td>
* <td>Basic Types and Constants</td>
* <td>utypes.h</td>
* <td>utypes.h</td>
* </tr>
@ -77,14 +77,19 @@
* <td>UnicodeString, CharacterIterator</td>
* </tr>
* <tr>
* <td>Unicode character<br>properties and names</td>
* <td>Unicode Character<br>Properties and Names</td>
* <td>uchar.h</td>
* <td>uchar.h C API<br>(the C++ Unicode class is deprecated)</td>
* <td>uchar.h C API</td>
* </tr>
* <tr>
* <td>Codepage conversion</td>
* <td>Codepage Conversion</td>
* <td>ucnv.h</td>
* <td>ucnv.h C API<br>(UnicodeConverter is deprecated)</td>
* <td>ucnv.h C API</td>
* </tr>
* <tr>
* <td>Unicode Text Compression</td>
* <td>ucnv.h<br>(encoding name "SCSU" or "BOCU-1")</td>
* <td>ucnv.h C API</td>
* </tr>
* <tr>
* <td>Locales </td>
@ -97,9 +102,9 @@
* <td>ResourceBundle</td>
* </tr>
* <tr>
* <td>Date and Time Formatting</td>
* <td>udat.h</td>
* <td>DateFormat</td>
* <td>Normalization</td>
* <td>unorm.h</td>
* <td>Normalizer</td>
* </tr>
* <tr>
* <td>Calendars</td>
@ -107,6 +112,11 @@
* <td>Calendar</td>
* </tr>
* <tr>
* <td>Date and Time Formatting</td>
* <td>udat.h</td>
* <td>DateFormat</td>
* </tr>
* <tr>
* <td>Message Formatting</td>
* <td>umsg.h</td>
* <td>MessageFormat</td>
@ -117,34 +127,19 @@
* <td>NumberFormat</td>
* </tr>
* <tr>
* <td>Normalization</td>
* <td>unorm.h</td>
* <td>Normalizer</td>
* <td>Number Spellout<br>(Rule Based Number Formatting)</td>
* <td>unum.h<br>(use UNUM_SPELLOUT)</td>
* <td>RuleBasedNumberFormat</td>
* </tr>
* <tr>
* <td>Transliteration</td>
* <td>Text Transformation<br>(Transliteration)</td>
* <td>utrans.h</td>
* <td>Transliterator</td>
* </tr>
* <tr>
* <td>Bidirectional Algorithm</td>
* <td>ubidi.h</td>
* <td>ubidi.h C API<br>(BiDi is deprecated)</td>
* </tr>
* <tr>
* <td>Collation and Searching</td>
* <td>ucol.h, usearch.h</td>
* <td>Collator, StringSearch</td>
* </tr>
* <tr>
* <td>Text boundary analysis<br>(Break Iteration)</td>
* <td>ubrk.h</td>
* <td>BreakIterator</td>
* </tr>
* <tr>
* <td>Unicode Text Compression</td>
* <td>ucnv.h<br>(encoding name "SCSU")<br>(scsu.h is deprecated)</td>
* <td>ucnv.h C API</td>
* <td>ubidi.h C API</td>
* </tr>
* <tr>
* <td>Arabic Shaping</td>
@ -152,12 +147,22 @@
* <td>ushape.h C API</td>
* </tr>
* <tr>
* <td>Number Spellout/Rule based number format</td>
* <td>unum.h using UNUM_SPELLOUT</td>
* <td>RuleBasedNumberFormat</td>
* <td>Collation</td>
* <td>ucol.h</td>
* <td>Collator</td>
* </tr>
* <tr>
* <td>Unicode set</td>
* <td>String Searching</td>
* <td>usearch.h</td>
* <td>StringSearch</td>
* </tr>
* <tr>
* <td>Text Boundary Analysis<br>(Break Iteration)</td>
* <td>ubrk.h</td>
* <td>BreakIterator</td>
* </tr>
* <tr>
* <td>Unicode Set</td>
* <td>uset.h</td>
* <td>UnicodeSet</td>
* </tr>

34
icu4c/source/common/unicode/uset.h
View file

@ -16,17 +16,25 @@
* C version of UnicodeSet.
*/
/**
* \file
* \brief C API: Unicode Set
*
* <p>This is a C wrapper around the C++ UnicodeSet class.</p>
*/
#ifndef __USET_H__
#define __USET_H__
#include "unicode/utypes.h"
struct USet;
/**
* A UnicodeSet. Use the uset_* API to manipulate. Create with
* uset_open*, and destroy with uset_close.
* @draft ICU 2.4
*/
struct USet;
typedef struct USet USet;
enum {
@ -38,12 +46,28 @@ enum {
* possible directly on a serialized set. See below.
* @draft ICU 2.4
*/
struct USerializedSet {
typedef struct USerializedSet {
/**
* The serialized Unicode Set.
* @draft ICU 2.4
*/
const uint16_t *array;
int32_t bmpLength, length;
/**
* The length of the array that contains BMP characters.
* @draft ICU 2.4
*/
int32_t bmpLength;
/**
* The total length of the array.
* @draft ICU 2.4
*/
int32_t length;
/**
* A small buffer for the array to reduce memory allocations.
* @draft ICU 2.4
*/
uint16_t staticArray[USET_SERIALIZED_STATIC_ARRAY_CAPACITY];
};
typedef struct USerializedSet USerializedSet;
} USerializedSet;
/*********************************************************************

2
icu4c/source/i18n/unicode/decimfmt.h
View file

@ -998,7 +998,7 @@ public:
UParseError& parseError,
UErrorCode& status);
/*
/**
* Apply the given pattern to this Format object.
*
* @param pattern The localized pattern to be applied.

367
icu4c/source/i18n/unicode/regex.h
View file

@ -1,37 +1,40 @@
/*
**********************************************************************
* Copyright (C) 2002, International Business Machines
* Copyright (C) 2002-2003, International Business Machines
* Corporation and others. All Rights Reserved.
**********************************************************************
* file name: regex.h
* encoding: US-ASCII
* indentation:4
*
* created on: 2002oct22
* created by: Andy Heninger
*
* ICU Regular Expressions, API for C++
*/
//
// file: regex.h
//
// ICU Regular Expressions, API for C++
//
#ifndef REGEX_H
#define REGEX_H
/**
* \file
* \brief C++ API: Regular Expressions
*
* <h2>Regular Expression API</h2>
*
* <p>The ICU API for processing regular expressions consists of two classes,
* <code>RegexPattern</code> and <code>RegexMatcher</code>.
* <code>RegexPattern</code> objects represent a pre-processed, or compiled
* regular expression. They are created from a regular expression pattern string,
* and can be used to create <RegexMatcher> objects for the pattern. </p>
*
* <p> Class <code>RegexMatcher</code> bundles together a regular expression pattern
* and a target string to which the search pattern will be applied.
* <code>RegexMatcher</code> includes API for doing plain find or search
* operations, for search and replace operations, and for obtaining detailed
* information about bounds of a match. </p>
*/
* \file
* \brief C++ API: Regular Expressions
*
* <h2>Regular Expression API</h2>
*
* <p>The ICU API for processing regular expressions consists of two classes,
* <code>RegexPattern</code> and <code>RegexMatcher</code>.
* <code>RegexPattern</code> objects represent a pre-processed, or compiled
* regular expression. They are created from a regular expression pattern string,
* and can be used to create <RegexMatcher> objects for the pattern.</p>
*
* <p>Class <code>RegexMatcher</code> bundles together a regular expression
* pattern and a target string to which the search pattern will be applied.
* <code>RegexMatcher</code> includes API for doing plain find or search
* operations, for search and replace operations, and for obtaining detailed
* information about bounds of a match. </p>
*/
#include "unicode/utypes.h"
@ -43,7 +46,9 @@
U_NAMESPACE_BEGIN
// Forward Declarations...
class RegexMatcher;
class UVector;
class UVector32;
@ -54,23 +59,23 @@ struct REStackFrame;
/**
* Constants for Regular Expression Match Modes.
* <p>Note that non-default match modes will not be supported until ICU 2.6</p>
* @draft ICU 2.4
* @draft ICU 2.4
*/
enum {
/** Forces normalization of pattern and strings. @draft ICU 2.4 */
UREGEX_CANON_EQ = 128,
/** Enable case insensitive matching. @draft ICU 2.4 */
UREGEX_CASE_INSENSITIVE = 2,
/** Allow white space and comments within patterns @draft ICU 2.4 */
UREGEX_COMMENTS = 4,
/** If set, '.' matches line terminators, otherwise '.' matching stops at line end.
* @draft ICU 2.4 */
UREGEX_DOTALL = 32,
/** Control behavior of "$" and "^"
* If set, recognize line terminators within string,
* otherwise, match only at start and end of input string.
* @draft ICU 2.4 */
UREGEX_MULTILINE = 8
/** Forces normalization of pattern and strings. @draft ICU 2.4 */
UREGEX_CANON_EQ = 128,
/** Enable case insensitive matching. @draft ICU 2.4 */
UREGEX_CASE_INSENSITIVE = 2,
/** Allow white space and comments within patterns @draft ICU 2.4 */
UREGEX_COMMENTS = 4,
/** If set, '.' matches line terminators, otherwise '.' matching stops at line end.
* @draft ICU 2.4 */
UREGEX_DOTALL = 32,
/** Control behavior of "$" and "^"
* If set, recognize line terminators within string,
* otherwise, match only at start and end of input string.
* @draft ICU 2.4 */
UREGEX_MULTILINE = 8
};
@ -88,20 +93,19 @@ enum {
*/
class U_I18N_API RegexPattern: public UObject {
public:
/**
* default constructor. Create a RegexPattern object that refers to no actual
* pattern. Not normally needed; RegexPattern objects are usually
* created using the factory method <code>compile()</code.
* created using the factory method <code>compile()</code.
*
* @draft ICU 2.4
*/
RegexPattern();
/**
* Copy Constructor. Create a new RegexPattern object that is equivalent
* to the source object.
* to the source object.
* @draft ICU 2.4
*/
RegexPattern(const RegexPattern &source);
@ -112,7 +116,7 @@ public:
* @draft ICU 2.4
*/
virtual ~RegexPattern();
/**
* Comparison operator. Two RegexPattern objects are considered equal if they
* were constructed from identical source patterns using the same match flag
@ -121,7 +125,7 @@ public:
* @return TRUE if the objects are equivalent.
* @draft ICU 2.4
*/
UBool operator==(const RegexPattern& that) const;
UBool operator==(const RegexPattern& that) const;
/**
* Comparison operator. Two RegexPattern objects are considered equal if they
@ -131,8 +135,8 @@ public:
* @return TRUE if the objects are different.
* @draft ICU 2.4
*/
inline UBool operator!=(const RegexPattern& that) const {return ! operator ==(that);};
inline UBool operator!=(const RegexPattern& that) const {return ! operator ==(that);};
/**
* Assignment operator. After assignment, this RegexPattern will behave identically
* to the source object.
@ -149,7 +153,7 @@ public:
*/
virtual RegexPattern *clone() const;
/**
* Compiles the regular expression in string form into a RegexPattern
* object. These compile methods, rather than the constructors, are the usual
@ -172,8 +176,8 @@ public:
*/
static RegexPattern *compile( const UnicodeString &regex,
UParseError &pe,
UErrorCode &status);
UErrorCode &status);
/**
* Compiles the regular expression in string form into a RegexPattern
* object using the specified match mode flags. These compile methods,
@ -197,7 +201,7 @@ public:
static RegexPattern *compile( const UnicodeString &regex,
uint32_t flags,
UParseError &pe,
UErrorCode &status);
UErrorCode &status);
/**
@ -206,8 +210,8 @@ public:
* @draft ICU 2.4
*/
virtual uint32_t flags() const;
/*
/**
* Creates a RegexMatcher that will match the given input against this pattern. The
* RegexMatcher can then be used to perform match, find or replace operations
* on the input. Note that a RegexPattern object must not be deleted while
@ -221,11 +225,11 @@ public:
*/
virtual RegexMatcher *matcher(const UnicodeString &input,
UErrorCode &status) const;
/**
* Test whether a string matches a regular expression. This convenience function
* both compiles the reguluar expression and applies it in a single operation.
* both compiles the reguluar expression and applies it in a single operation.
* Note that if the same pattern needs to be applied repeatedly, this method will be
* less efficient than creating and reusing a RegexPattern object.
*
@ -240,41 +244,41 @@ public:
static UBool matches(const UnicodeString &regex,
const UnicodeString &input,
UParseError &pe,
UErrorCode &status);
UErrorCode &status);
/**
* Returns the regular expression from which this pattern was compiled.
* Returns the regular expression from which this pattern was compiled.
* @draft ICU 2.4
*/
virtual UnicodeString pattern() const;
/**
* Split a string around matches of the pattern. Somewhat like split() from Perl.
* @param input The string to be split into fields. The field delimiters
* match the pattern (in the "this" object)
* @param dest An array of UnicodeStrings to receive the results of the split.
* This is an array of actual UnicodeString objects, not an
* array of pointers to strings. Local (stack based) arrays can
* work well here.
* @param destCapacity The number of elements in the destination array.
* If the number of fields found is less than destCapacity, the
* extra strings in the destination array are not altered.
* If the number of destination strings is less than the number
* of fields, the trailing part of the input string, including any
* field delimiters, is placed in the last destination string.
* @param status A reference to a UErrorCode to receive any errors.
* @return The number of fields into which the input string was split.
* @draft ICU 2.4
*/
* Split a string around matches of the pattern. Somewhat like split() from Perl.
* @param input The string to be split into fields. The field delimiters
* match the pattern (in the "this" object)
* @param dest An array of UnicodeStrings to receive the results of the split.
* This is an array of actual UnicodeString objects, not an
* array of pointers to strings. Local (stack based) arrays can
* work well here.
* @param destCapacity The number of elements in the destination array.
* If the number of fields found is less than destCapacity, the
* extra strings in the destination array are not altered.
* If the number of destination strings is less than the number
* of fields, the trailing part of the input string, including any
* field delimiters, is placed in the last destination string.
* @param status A reference to a UErrorCode to receive any errors.
* @return The number of fields into which the input string was split.
* @draft ICU 2.4
*/
virtual int32_t split(const UnicodeString &input,
UnicodeString dest[],
int32_t destCapacity,
UErrorCode &status) const;
/**
* dump Debug function, displays the compiled form of a pattern.
* @internal
@ -287,23 +291,23 @@ public:
* @draft ICU 2.4
*/
virtual inline UClassID getDynamicClassID() const { return getStaticClassID(); }
/**
* ICU "poor man's RTTI", returns a UClassID for this class.
*
* @draft ICU 2.4
*/
* ICU "poor man's RTTI", returns a UClassID for this class.
*
* @draft ICU 2.4
*/
static inline UClassID getStaticClassID() { return (UClassID)&fgClassID; }
private:
//
// Implementation Data
//
UnicodeString fPattern; // The original pattern string.
uint32_t fFlags; // The flags used when compiling the pattern.
//
//
UVector32 *fCompiledPat; // The compiled pattern.
UnicodeString fLiteralText; // Any literal string data from the pattern,
UnicodeString fLiteralText; // Any literal string data from the pattern,
// after un-escaping, for use during the match.
UVector *fSets; // Any UnicodeSets referenced from the pattern.
UBool fBadState; // True if some prior error has left this
@ -313,7 +317,7 @@ private:
// split(), to avoid having to
// make new ones on each call.
int32_t fFrameSize; // Size of a state stack frame in the
int32_t fFrameSize; // Size of a state stack frame in the
// execution engine.
int32_t fDataSize; // The size of the data needed by the pattern that
@ -345,7 +349,6 @@ private:
void dumpOp(int32_t index) const;
};
@ -357,15 +360,15 @@ private:
/**
* class RegexMatcher bundles together a reular expression pattern and
* input text to which the expression can be applied. It includes methods
* for testing for matches, and for find and replace operations.
*
* <p>Class RegexMatcher is not intended to be subclassed.</p>
*
* @draft ICU 2.4
*/
class U_I18N_API RegexMatcher: public UObject {
* class RegexMatcher bundles together a reular expression pattern and
* input text to which the expression can be applied. It includes methods
* for testing for matches, and for find and replace operations.
*
* <p>Class RegexMatcher is not intended to be subclassed.</p>
*
* @draft ICU 2.4
*/
class U_I18N_API RegexMatcher: public UObject {
public:
/**
* Destructor. Note that there are no public constructors; creation is
@ -375,17 +378,17 @@ public:
*/
virtual ~RegexMatcher();
/**
* Attempts to match the entire input string against the pattern.
* @param status A reference to a UErrorCode to receive any errors.
* @param status A reference to a UErrorCode to receive any errors.
* @return TRUE if there is a match
* @draft ICU 2.4
*/
virtual UBool matches(UErrorCode &status);
/**
* Attempts to match the input string, starting from the beginning, against the pattern.
* Like the matches() method, this function always starts at the beginning of the input string;
@ -394,92 +397,92 @@ public:
* <p>If the match succeeds then more information can be obtained via the <code>start()</code>,
* <code>end()</code>, and <code>group()</code> functions.</p>
*
* @param status A reference to a UErrorCode to receive any errors.
* @param status A reference to a UErrorCode to receive any errors.
* @return TRUE if there is a match at the start of the input string.
* @draft ICU 2.4
*/
virtual UBool lookingAt(UErrorCode &status);
/**
* Find the next pattern match in the input string.
* The find begins searching the input at the location following the end of
* the previous match, or at the start of the string if there is no previous match.
* If a match is found, <code>start(), end()</code> and <code>group()</code>
* will provide more information regarding the match.
* <p>Note that if the input string is changed by the application,
* <p>Note that if the input string is changed by the application,
* use find(startPos, status) instead of find(), because the saved starting
* position may not be valid with the altered input string.</p>
* @return TRUE if a match is found.
* @draft ICU 2.4
*/
virtual UBool find();
/**
* Resets this RegexMatcher and then attempts to find the next substring of the
* input string that matches the pattern, starting at the specified index.
* Resets this RegexMatcher and then attempts to find the next substring of the
* input string that matches the pattern, starting at the specified index.
*
* @param start the position in the input string to begin the search
* @param status A reference to a UErrorCode to receive any errors.
* @param status A reference to a UErrorCode to receive any errors.
* @return TRUE if a match is found.
* @draft ICU 2.4
*/
virtual UBool find(int32_t start, UErrorCode &status);
/*
* Returns a string containing the text matched by the previous match.
virtual UBool find(int32_t start, UErrorCode &status);
/**
* Returns a string containing the text matched by the previous match.
* If the pattern can match an empty string, an empty string may be returned.
* @param status A reference to a UErrorCode to receive any errors.
* @param status A reference to a UErrorCode to receive any errors.
* Possible errors are U_REGEX_INVALID_STATE if no match
* has been attempted or the last match failed.
* @return a string containing the matched input text.
* has been attempted or the last match failed.
* @return a string containing the matched input text.
* @draft ICU 2.4
*/
virtual UnicodeString group(UErrorCode &status) const;
/**
* Returns a string containing the text captured by the given group
* during the previous match operation. Group(0) is the entire match.
*
*
* @param group the capture group number
* @param status A reference to a UErrorCode to receive any errors.
* @param status A reference to a UErrorCode to receive any errors.
* Possible errors are U_REGEX_INVALID_STATE if no match
* has been attempted or the last match failed and
* U_INDEX_OUTOFBOUNDS_ERROR for a bad capture group number.
* @return the captured text
* @draft ICU 2.4
*/
virtual UnicodeString group(int32_t groupNum, UErrorCode &status) const;
virtual UnicodeString group(int32_t groupNum, UErrorCode &status) const;
/**
* Returns the number of capturing groups in this matcher's pattern.
* @return the number of capture groups
* @draft ICU 2.4
*/
virtual int32_t groupCount() const;
/**
* Returns the index in the input string of the start of the text matched
* during the previous match operation.
* @param status a reference to a UErrorCode to receive any errors.
* Returns the index in the input string of the start of the text matched
* during the previous match operation.
* @param status a reference to a UErrorCode to receive any errors.
* @return The position in the input string of the start of the last match.
* @draft ICU 2.4
*/
virtual int32_t start(UErrorCode &status) const;
/**
* Returns the index in the input string of the start of the text matched by the
* specified capture group during the previous match operation. Return -1 if
* the capture group exists in the pattern, but was not part of the last match.
*
* @param group the capture group number
* @param status A reference to a UErrorCode to receive any errors. Possible
* @param status A reference to a UErrorCode to receive any errors. Possible
* errors are U_REGEX_INVALID_STATE if no match has been
* attempted or the last match failed, and
* U_INDEX_OUTOFBOUNDS_ERROR for a bad capture group number
@ -487,36 +490,36 @@ public:
* @draft ICU 2.4
*/
virtual int32_t start(int group, UErrorCode &status) const;
/**
* Returns the index in the input string of the character following the
* text matched during the previous match operation.
* @param status A reference to a UErrorCode to receive any errors. Possible
* text matched during the previous match operation.
* @param status A reference to a UErrorCode to receive any errors. Possible
* errors are U_REGEX_INVALID_STATE if no match has been
* attempted or the last match failed.
* @return the index of the last character matched, plus one.
* @draft ICU 2.4
*/
virtual int32_t end(UErrorCode &status) const;
/**
* Returns the index in the input string of the character following the
* text matched by the specified capture group during the previous match operation.
* @param group the capture group number
* @param status A reference to a UErrorCode to receive any errors. Possible
* @param status A reference to a UErrorCode to receive any errors. Possible
* errors are U_REGEX_INVALID_STATE if no match has been
* attempted or the last match failed and
* U_INDEX_OUTOFBOUNDS_ERROR for a bad capture group number
* @return the index of the last character, plus one, of the text
* captured by the specifed group during the previous match operation.
* @return the index of the last character, plus one, of the text
* captured by the specifed group during the previous match operation.
* Return -1 if the capture group was not part of the match.
* @draft ICU 2.4
*/
virtual int32_t end(int group, UErrorCode &status) const;
virtual int32_t end(int group, UErrorCode &status) const;
/**
* Resets this matcher. The effect is to remove any memory of previous matches,
* and to cause subsequent find() operations to begin at the beginning of
@ -526,8 +529,8 @@ public:
* @draft ICU 2.4
*/
virtual RegexMatcher &reset();
/**
* Resets this matcher with a new input string. This allows instances of RegexMatcher
* to be reused, which is more efficient than creating a new RegexMatcher for
@ -535,45 +538,45 @@ public:
* @return this RegexMatcher.
* @draft ICU 2.4
*/
virtual RegexMatcher &reset(const UnicodeString &input);
virtual RegexMatcher &reset(const UnicodeString &input);
/**
* Returns the input string being matched. The returned string is not a copy,
* but the live input string. It should not be altered or deleted.
* @return the input string
* @draft ICU 2.4
*/
virtual const UnicodeString &input() const;
virtual const UnicodeString &input() const;
/**
* Returns the pattern that is interpreted by this matcher.
* @return the RegexPattern for this RegexMatcher
* @draft ICU 2.4
*/
virtual const RegexPattern &pattern() const;
/**
* Replaces every substring of the input that matches the pattern
* with the given replacement string. This is a convenience function that
* provides a complete find-and-replace-all operation.
*
* This method first resets this matcher. It then scans the input string
* looking for matches of the pattern. Input that is not part of any
* looking for matches of the pattern. Input that is not part of any
* match is left unchanged; each match is replaced in the result by the
* replacement string. The replacement string may contain references to
* capture groups.
* capture groups.
*
* @param replacement a string containing the replacement text.
* @param status a reference to a UErrorCode to receive any errors.
* @param status a reference to a UErrorCode to receive any errors.
* @return a string containing the results of the find and replace.
* @draft ICU 2.4
*/
virtual UnicodeString replaceAll(const UnicodeString &replacement, UErrorCode &status);
virtual UnicodeString replaceAll(const UnicodeString &replacement, UErrorCode &status);
/**
* Replaces the first substring of the input that matches
* the pattern with the replacement string. This is a convenience
@ -588,14 +591,14 @@ public:
* <p>The state of the matcher (the position at which a subsequent find()
* would begin) after completing a replaceFirst() is not specified. The
* RegexMatcher should be reset before doing additional find() operations.</p>
*
*
* @param replacement a string containing the replacement text.
* @param status a reference to a UErrorCode to receive any errors.
* @param status a reference to a UErrorCode to receive any errors.
* @return a string containing the results of the find and replace.
* @draft ICU 2.4
*/
virtual UnicodeString replaceFirst(const UnicodeString &replacement, UErrorCode &status);
virtual UnicodeString replaceFirst(const UnicodeString &replacement, UErrorCode &status);
/**
* Implements a replace operation intended to be used as part of an
* incremental find-and-replace.
@ -613,32 +616,32 @@ public:
* the input text that matched the regexp pattern. The replacement
* text may contain references to captured text from the
* input.
* @param status A reference to a UErrorCode to receive any errors. Possible
* @param status A reference to a UErrorCode to receive any errors. Possible
* errors are U_REGEX_INVALID_STATE if no match has been
* attempted or the last match failed, and U_INDEX_OUTOFBOUNDS_ERROR
* if the replacement text specifies a capture group that
* does not exist in the pattern.
*
*
* @return this RegexMatcher
* @draft ICU 2.4
*
*/
virtual RegexMatcher &appendReplacement(UnicodeString &dest,
const UnicodeString &replacement, UErrorCode &status);
/**
* As the final step in a find-and-replace operation, append the remainder
* of the input string, starting at the position following the last match,
* to the destination string. <code>appendTail()</code> is intended to be invoked after one
* or more invocations of the <code>RegexMatcher::appendReplacement()</code>.
* or more invocations of the <code>RegexMatcher::appendReplacement()</code>.
*
* @param dest A UnicodeString to which the results of the find-and-replace are appended.
* @return the destination string.
* @draft ICU 2.4
*/
virtual UnicodeString &appendTail(UnicodeString &dest);
virtual UnicodeString &appendTail(UnicodeString &dest);
/**
* ICU "poor man's RTTI", returns a UClassID for the actual class.
@ -646,19 +649,19 @@ public:
* @draft ICU 2.2
*/
virtual inline UClassID getDynamicClassID() const { return getStaticClassID(); }
/**
* ICU "poor man's RTTI", returns a UClassID for this class.
*
* @draft ICU 2.2
*/
static inline UClassID getStaticClassID() { return (UClassID)&fgClassID; }
private:
// Constructors and other object boilerplate are private.
// Instances of RegexMatcher can not be assigned, copied, cloned, etc.
// Creation by users is only through the factory method in class RegexPattern
RegexMatcher(const RegexPattern *pat);
RegexMatcher(const RegexPattern *pat);
RegexMatcher(const RegexMatcher &other);
RegexMatcher &operator =(const RegexMatcher &rhs);
friend class RegexPattern;
@ -668,11 +671,11 @@ private:
// MatchAt This is the internal interface to the match engine itself.
// Match status comes back in matcher member variables.
//
void MatchAt(int32_t startIdx, UErrorCode &status);
void MatchAt(int32_t startIdx, UErrorCode &status);
inline void backTrack(int32_t &inputIdx, int32_t &patIdx);
UBool isWordBoundary(int32_t pos); // perform the \b test
REStackFrame *resetStack();
inline REStackFrame *StateSave(REStackFrame *fp, int32_t savePatIdx,
inline REStackFrame *StateSave(REStackFrame *fp, int32_t savePatIdx,
int32_t frameSize, UErrorCode &status);
@ -701,7 +704,7 @@ private:
static const char fgClassID;
};
};
U_NAMESPACE_END
#endif // UCONFIG_NO_REGULAR_EXPRESSIONS

2
icu4c/source/i18n/unicode/udat.h
View file

@ -455,10 +455,10 @@ typedef enum UDateFormatSymbolType {
UDAT_LOCALIZED_CHARS
} UDateFormatSymbolType;
struct UDateFormatSymbols;
/** Date format symbols.
* For usage in C programs.
*/
struct UDateFormatSymbols;
typedef struct UDateFormatSymbols UDateFormatSymbols;
/**