ICU

https://unicode-org.github.io/icu/userguide/
Admin
ICU (International Components for Unicode) provides libraries for software internationalization,...
Tokens:4,538,130
Snippets:30,294
Trust Score:9.7
Update:3 days ago
Show doc for...
Tokens:
Raw
### Install Bundler

Source: https://unicode-org.github.io/icu/userguide/dev/editing.html

Command to install the Bundler gem.

```bash
gem install bundler
```

--------------------------------

### Install Docker on Ubuntu

Source: https://unicode-org.github.io/icu/userguide/dev/fuzzer_targets.html

Command to install the Docker engine on an Ubuntu system.

```bash
sudo apt install docker
```

--------------------------------

### Get first start time

Source: https://unicode-org.github.io/icu/userguide/dev/reports/icu4j_coverage/html/com.ibm.icu.util/AnnualTimeZoneRule.java.html

Retrieves the first start date for the rule.

```java
    /**  
     * {@inheritDoc}  
     *  
     * @stable ICU 3.8  
     */  
    @Override  
    public Date getFirstStart(int prevRawOffset, int prevDSTSavings) {  
        return getStartInYear(startYear, prevRawOffset, prevDSTSavings);  
    }
```

--------------------------------

### Start QSH session

Source: https://unicode-org.github.io/icu/userguide/icu4c/build

Enter the QSH environment to execute subsequent build commands.

```CL
qsh
```

--------------------------------

### Get previous start time

Source: https://unicode-org.github.io/icu/userguide/dev/reports/icu4j_coverage/html/com.ibm.icu.util/AnnualTimeZoneRule.java.html

Calculates the previous start date before a given base time.

```java
    /**  
     * {@inheritDoc}  
     *  
     * @stable ICU 3.8  
     */  
    @Override  
    public Date getPreviousStart(  
            long base, int prevRawOffset, int prevDSTSavings, boolean inclusive) {  
        int year = Grego.timeToYear(base);  
        if (year > endYear) {  
            return getFinalStart(prevRawOffset, prevDSTSavings);  
        }  
        Date d = getStartInYear(year, prevRawOffset, prevDSTSavings);  
        if (d != null && (d.getTime() > base || (!inclusive && (d.getTime() == base)))) {
```

--------------------------------

### Example .txt resource bundle for German (de.txt)

Source: https://unicode-org.github.io/icu/userguide/locale/localizing.html

A sample .txt resource bundle demonstrating key-value pairs and multi-line string concatenation.

```text
de {
    key1 { "Deutsche Sprache "
            "schwere Sprache" }
    key2 { "Düsseldorf" }
}
```

--------------------------------

### Get next start time

Source: https://unicode-org.github.io/icu/userguide/dev/reports/icu4j_coverage/html/com.ibm.icu.util/AnnualTimeZoneRule.java.html

Calculates the next start date after a given base time.

```java
    /**  
     * {@inheritDoc}  
     *  
     * @stable ICU 3.8  
     */  
    @Override  
    public Date getNextStart(long base, int prevRawOffset, int prevDSTSavings, boolean inclusive) {  
        int year = Grego.timeToYear(base);  
        if (year < startYear) {  
            return getFirstStart(prevRawOffset, prevDSTSavings);  
        }  
        Date d = getStartInYear(year, prevRawOffset, prevDSTSavings);  
        if (d != null && (d.getTime() < base || (!inclusive && (d.getTime() == base)))) {  
            d = getStartInYear(year + 1, prevRawOffset, prevDSTSavings);  
        }  
        return d;  
    }
```

--------------------------------

### Open and Close a Resource Bundle in C

Source: https://unicode-org.github.io/icu/userguide/locale/resources

Example of opening the root resource bundle, performing operations, and closing the bundle in C.

```c
UErrorCode status = U_ZERO_ERROR;
UResourceBundle* icuRoot = ures_open(NULL, "root", &status);
if (U_SUCCESS(status)) {
    /* everything is fine */
    ...
    /* do some interesting stuff here - see below */
    ...
    /* and close the bundle afterwards */
    ures_close(icuRoot); /* discussed later */
} else {
    /* there was an error */
    /* report and exit */
}
```

--------------------------------

### Get final start time

Source: https://unicode-org.github.io/icu/userguide/dev/reports/icu4j_coverage/html/com.ibm.icu.util/AnnualTimeZoneRule.java.html

Retrieves the final start date for the rule, returning null if the end year is the maximum year.

```java
    /**  
     * {@inheritDoc}  
     *  
     * @stable ICU 3.8  
     */  
    @Override  
    public Date getFinalStart(int prevRawOffset, int prevDSTSavings) {  
        if (endYear == MAX_YEAR) {  
            return null;  
        }  
        return getStartInYear(endYear, prevRawOffset, prevDSTSavings);  
    }
```

--------------------------------

### Any-Publishing Transliterator Example

Source: https://unicode-org.github.io/icu/userguide/transforms/general

A comprehensive example combining variables, context, and conversion rules to format text for desktop publishing.

```text
# Variables
$single = \' ;
$space = ' ' ;
$double = \" ;
$back = \` ;
$tab = '\u0008' ;

# the following is for spaces, line ends, (, [, {, ...
$makeRight = [[:separator:][:start punctuation:][:initial punctuation:]] ;

# fix UNIX quotes
$back $back > “ ; # generate right d.q.m. (double quotation mark)
$back > ‘ ;

# fix typewriter quotes, by context
$makeRight { $double <> “ ; # convert a double to right d.q.m. after certain chars
^ { $double > “ ; # convert a double at the start of the line.
$double <> ” ; # otherwise convert to a left q.m.

$makeRight {$single} <> ‘ ; # do the same for s.q.m.s
^ {$single} > ‘ ;
$single <> ’;

# fix multiple spaces and hyphens
$space {$space} > ; # collapse multiple spaces
'--' <> — ; # convert fake dash into real one
```

--------------------------------

### Open Java/JDK Style Resource Bundle

Source: https://unicode-org.github.io/icu/userguide/dev/reports/icu4j_coverage/html/com.ibm.icu.util/UResourceBundle.java.html

Example of how to open a resource bundle using the Java/JDK-style organization.

```java
      UResourceBundle bundle =
          UResourceBundle.getBundleInstance("com.mycompany.resources.LocaleElements",
                                            "en_US", myClassLoader);
```

--------------------------------

### Get Start Hour for DayPeriod

Source: https://unicode-org.github.io/icu/userguide/dev/reports/icu4j_coverage/html/com.ibm.icu.impl/DayPeriodRules.java.html

Determines the start hour for a given day period, handling midnight, noon, and wrap-around cases.

```java
    private int getStartHourForDayPeriod(DayPeriod dayPeriod) throws IllegalArgumentException {  
        if (dayPeriod == DayPeriod.MIDNIGHT) {  
            return 0;  
        }  
        if (dayPeriod == DayPeriod.NOON) {  
            return 12;  
        }  
  
        if (dayPeriodForHour[0] == dayPeriod && dayPeriodForHour[23] == dayPeriod) {  
            // dayPeriod wraps around midnight. Start hour is later than end hour.  
            for (int i = 22; i >= 1; --i) {  
                if (dayPeriodForHour[i] != dayPeriod) {  
                    return (i + 1);  
                }  
            }  
        } else {  
            for (int i = 0; i <= 23; ++i) {  
                if (dayPeriodForHour[i] == dayPeriod) {  
                    return i;  
                }  
            }  
        }  
  
        // dayPeriod doesn't exist in rule set; throw exception.  
        throw new IllegalArgumentException();  
    }
```

--------------------------------

### Initialize and use StringPrep in Java

Source: https://unicode-org.github.io/icu/userguide/strings/stringprep.html

Shows how to load a StringPrep profile from an InputStream and use it to prepare strings. This implementation uses a singleton pattern for the profile instance.

```java
private static final StringPrep nfscsi = null;
//singleton instance
private static final NFSCSIStringPrep prep=new NFSCSIStringPrep();
private NFSCSIStringPrep() {
    try {
        InputStream nfscsiFile = TestUtil.getDataStream("nfscsi.spp");
        nfscsi = new StringPrep(nfscsiFile);
        nfscsiFile.close();
    } catch(IOException e) {
        throw new RuntimeException(e.toString());
    }
}
private static byte[] prepare(byte[] src, StringPrep prep)
        throws StringPrepParseException, UnsupportedEncodingException {
    String s = new String(src, "UTF-8");
    UCharacterIterator iter = UCharacterIterator.getInstance(s);
    StringBuffer out = prep.prepare(iter,StringPrep.DEFAULT);
    return out.toString().getBytes("UTF-8");
}
```

--------------------------------

### Get start date of an era

Source: https://unicode-org.github.io/icu/userguide/dev/reports/icu4j_coverage/html/com.ibm.icu.impl/EraRules.java.html

Retrieves the start date of a specific era in the proleptic Gregorian calendar, optionally filling a provided array.

```java
public int[] getStartDate(int eraCode, int[] fillIn) {
        int startDate = 0;
        if (eraCode < minEra) {
            if (inheritEraRules != null) {
                return inheritEraRules.getStartDate(eraCode, fillIn);
            }
        } else {
            int startIdx = eraCode - minEra;
            if (startIdx < startDates.length) {
                startDate = startDates[startIdx];
            }
        }
        if (isSet(startDate)) {
            return decodeDate(startDate, fillIn);
        }
        // We did not find the requested eraCode in our data
```

--------------------------------

### setup method

Source: https://unicode-org.github.io/icu/userguide/dev/reports/icu4j_coverage/html/com.ibm.icu.text/DateIntervalInfo.java.html

Initializes the DateIntervalInfo instance by determining the calendar type from the locale and loading resource bundles.

```java
private void setup(ULocale locale) {  
    int DEFAULT_HASH_SIZE = 19;  
    fIntervalPatterns = new HashMap<>(DEFAULT_HASH_SIZE);  
    // initialize to guard if there is no interval date format defined in  
    // resource files  
    fFallbackIntervalPattern = "{0} – {1}";  

    try {  
        // Get the correct calendar type  
        String calendarTypeToUse = locale.getKeywordValue("calendar");  
        if (calendarTypeToUse == null) {  
            String[] preferredCalendarTypes =  
                    Calendar.getKeywordValuesForLocale("calendar", locale, true);  
            calendarTypeToUse = preferredCalendarTypes[0]; // the most preferred calendar  
        }  
        if (calendarTypeToUse == null) {  
            calendarTypeToUse = "gregorian"; // fallback  
        }  

        // Instantiate the sink to process the data and the resource bundle  
        DateIntervalSink sink = new DateIntervalSink(this);  
        ICUResourceBundle resource =  
                (ICUResourceBundle)  
                        UResourceBundle.getBundleInstance(ICUData.ICU_BASE_NAME, locale);  

        // Get the fallback pattern  
        String fallbackPattern =  
                resource.getStringWithFallback(  
                        CALENDAR_KEY  
                                + "/"  
                                + calendarTypeToUse  
                                + "/"
```

--------------------------------

### Find the next word start

Source: https://unicode-org.github.io/icu/userguide/dev/reports/icu4j_coverage/html/com.ibm.icu.text/BreakIterator.java.html

This example demonstrates how to use BreakIterator to find the start of the next word, while ignoring punctuation and whitespace using getRuleStatus.

```java
public static int nextWordStartAfter(int pos, String text) {
    BreakIterator wb = BreakIterator.getWordInstance();
    wb.setText(text);
    int wordStart = wb.following(pos);
    for (;;) {
        int wordLimit = wb.next();
        if (wordLimit == BreakIterator.DONE) {
            return BreakIterator.DONE;
        }
        int wordStatus = wb.getRuleStatus();
        if (wordStatus != BreakIterator.WORD_NONE) {
            return wordStart;
        }
        wordStart = wordLimit;
    }
}
```

--------------------------------

### Setup Method for Locale and Formatting

Source: https://unicode-org.github.io/icu/userguide/dev/reports/icu4j_coverage/html/com.ibm.icu.text/TimeUnitFormat.java.html

Initializes locale, number formatting, and plural rules if not already set, and prepares time unit patterns.

```java
    private void setup() {  
        if (locale == null) {  
            if (format != null) {  
                locale = format.getLocale(null);  
            } else {  
                locale = ULocale.getDefault(Category.FORMAT);  
            }  
            // Needed for getLocale(ULocale.VALID_LOCALE)  
            setLocale(locale, locale);  
        }  
        if (format == null) {  
            format = NumberFormat.getNumberInstance(locale);  
        }  
        pluralRules = PluralRules.forLocale(locale);  
        timeUnitToCountToPatterns = new HashMap<>();  
        Set<String> pluralKeywords = pluralRules.getKeywords();  
        setup("units/duration", timeUnitToCountToPatterns, FULL_NAME, pluralKeywords);  
        setup("unitsShort/duration", timeUnitToCountToPatterns, ABBREVIATED_NAME, pluralKeywords);  
        isReady = true;  
    }
```

--------------------------------

### Get Ante-Context Length

Source: https://unicode-org.github.io/icu/userguide/dev/reports/icu4j_coverage/html/com.ibm.icu.text/TransliterationRule.java.html

Returns the length of the preceding context, accounting for start anchors.

```java
    /**  
     * Return the preceding context length. This method is needed to support the <code>  
     * Transliterator</code> method <code>getMaximumContextLength()</code>.  
     */  
    public int getAnteContextLength() {  
        return anteContextLength + (((flags & ANCHOR_START) != 0) ? 1 : 0);  
    }
```

--------------------------------

### Getting en_US Collator rules

Source: https://unicode-org.github.io/icu/userguide/dev/reports/icu4j_coverage/html/com.ibm.icu.text/RuleBasedCollator.java.html

Example of retrieving the rules from a standard locale-based Collator.

```java
// get en_US Collator rules
RuleBasedCollator en_USCollator
                       = (RuleBasedCollator)Collator.getInstance(Locale.US);
```

--------------------------------

### Initialize Visual C++ Command Line Environment

Source: https://unicode-org.github.io/icu/userguide/icu4c/build

Run the appropriate batch file to set up the environment for 32-bit or 64-bit builds before compiling.

```batch
C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\bin\vcvars32.bat
```

```batch
C:\Program Files (x86)\Microsoft Visual Studio 14\VC\bin\x86_amd64\vcvarsx86_amd64.bat
```

--------------------------------

### Getting Literal or Variable Reference

Source: https://unicode-org.github.io/icu/userguide/dev/reports/icu4j_coverage/html/com.ibm.icu.message2/MFParser.java.html

Determines whether the next element is a variable reference (starting with '$') or a literal.

```java
    private MFDataModel.LiteralOrVariableRef getLiteralOrVariableRef() throws MFParseException {  
        int cp = input.peekChar();  
        if (cp == '$') {  
            return getVariableRef();  
        }  
        return getLiteral(false);  
    }
```

--------------------------------

### Initial Window Use Configuration

Source: https://unicode-org.github.io/icu/userguide/dev/reports/icu4j_coverage/html/com.ibm.icu.charset/CharsetSCSU.java.html

Default configuration for dynamic window usage.

```java
static final byte initialWindowUse[] = {7, 0, 3, 2, 4, 5, 6, 1};
```

--------------------------------

### Open and use StringPrep profile in C++

Source: https://unicode-org.github.io/icu/userguide/strings/stringprep.html

Demonstrates opening a profile, preparing a string, and closing the profile. Applications should reuse the profile object rather than opening and closing it repeatedly.

```cpp
UErrorCode status = U_ZERO_ERROR;
UParseError parseError;
/* open the StringPrep profile */
UStringPrepProfile* nameprep = usprep_open("/usr/joe/mydata",
                                           "nfscsi", &status);
if(U_FAILURE(status)) {
    /* handle the error */
}
/* prepare the string for use according
 * to the rules specified in the profile
 */
int32_t retLen = usprep_prepare(src, srcLength, dest,
                                destCapacity, USPREP_ALLOW_UNASSIGNED,
                                nameprep, &parseError, &status);
/* close the profile */
usprep_close(nameprep);
```

--------------------------------

### getStart()

Source: https://unicode-org.github.io/icu/userguide/dev/reports/icu4j_coverage/html/com.ibm.icu.text/ConstrainedFieldPosition.java.html

Gets the INCLUSIVE start index for the current position. The return value is well-defined only after FormattedValue.nextPosition returns true.

```APIDOC
## getStart()

### Description
Gets the INCLUSIVE start index for the current position. The return value is well-defined only after FormattedValue.nextPosition returns true.

### Method
public int getStart()

### Returns
- **int** - The start index saved in the instance.

### Stability
@stable ICU 64
```

--------------------------------

### setup Method for Resource Loading

Source: https://unicode-org.github.io/icu/userguide/dev/reports/icu4j_coverage/html/com.ibm.icu.text/TimeUnitFormat.java.html

Initializes time unit patterns by loading from ICU resource bundles and performing consistency checks with fallback rules.

```java
private void setup(
			String resourceKey,
			Map<TimeUnit, Map<String, Object[]>> timeUnitToCountToPatterns,
			int style,
			Set<String> pluralKeywords) {
		// fill timeUnitToCountToPatterns from resource file
		try {

			ICUResourceBundle resource =
					(ICUResourceBundle)
							UResourceBundle.getBundleInstance(ICUData.ICU_UNIT_BASE_NAME, locale);

			TimeUnitFormatSetupSink sink =
					new TimeUnitFormatSetupSink(
							timeUnitToCountToPatterns, style, pluralKeywords, locale);
			resource.getAllItemsWithFallback(resourceKey, sink);
		} catch (MissingResourceException e) {
		}
		final TimeUnit[] timeUnits = TimeUnit.values();
		Set<String> keywords = pluralRules.getKeywords();
		for (int i = 0; i < timeUnits.length; ++i) {
			final TimeUnit timeUnit = timeUnits[i];
			Map<String, Object[]> countToPatterns = timeUnitToCountToPatterns.get(timeUnit);
			if (countToPatterns == null) {
				countToPatterns = new TreeMap<>();
				timeUnitToCountToPatterns.put(timeUnit, countToPatterns);
			}
			for (String pluralCount : keywords) {
				if (countToPatterns.get(pluralCount) == null
						|| countToPatterns.get(pluralCount)[style] == null) {
					// look through parents
					searchInTree(
							resourceKey,
							style,
							timeUnit,
							pluralCount,
							pluralCount,
							countToPatterns);
				}
			}
		}
	}
```

--------------------------------

### Get Extended Name Iterator

Source: https://unicode-org.github.io/icu/userguide/dev/reports/icu4j_coverage/html/com.ibm.icu.lang/UCharacter.java.html

Example demonstrating how to use getExtendedNameIterator to iterate over codepoints and retrieve their extended Unicode names.

```java
ValueIterator iterator = UCharacter.getExtendedNameIterator();
ValueIterator.Element element = new ValueIterator.Element();
while (iterator.next(element)) {
    System.out.println("Codepoint \u" +
                       Integer.toHexString(element.codepoint) +
                       " has the name " + (String)element.value);
}
```

--------------------------------

### Get Specific Date Fields in C++

Source: https://unicode-org.github.io/icu/userguide/format_parse/datetime/examples.html

Uses FieldPosition with DateFormat to identify the start and end indices of a specific date field.

```cpp
UErrorCode status = U_ZERO_ERROR;
FieldPosition pos(DateFormat::YEAR_FIELD)
UDate myDate = Calendar::getNow();
UnicodeString str;
DateFormat* df = DateFormat::createDateInstance
  ( DateFormat::LONG, Locale::getFrance());

df->format(myDate, str, pos, status);
cout << pos.getBeginIndex() << "," << pos. getEndIndex() << endl;
```

--------------------------------

### Initialize and use LocaleMatcher

Source: https://unicode-org.github.io/icu/userguide/dev/reports/icu4j_coverage/html/com.ibm.icu.util/LocaleMatcher.java.html

Demonstrates how to build a LocaleMatcher instance with supported locales and retrieve the best match for a given user locale.

```java
LocaleMatcher matcher = LocaleMatcher.builder().setSupportedLocales("fr, en-GB, en").build();
Locale bestSupported = matcher.getBestLocale(Locale.US);  // "en"
```

--------------------------------

### Build and Run C++ Application

Source: https://unicode-org.github.io/icu/userguide/format_parse/messages/try-mf2.html

Commands to compile the hello_mf2.cpp application and execute the resulting binary.

```batch
 set DESTDIR=%ICU_SANDBOX%\icu_release
 cl /std:c++17 /EHsc /I %DESTDIR%\include %DESTDIR%/lib64/*.lib hello_mf2.cpp
    
 rem set PATH only once, not every time
 set PATH=%DESTDIR%\bin64;%PATH%
    
 .\hello_mf2.exe
```

--------------------------------

### CodePointMap.StringIterator.previous()

Source: https://unicode-org.github.io/icu/userguide/dev/reports/icu4j_coverage/html/com.ibm.icu.util/CodePointMap.java.html

Reads the previous code point, pre-decrements the string index, and gets a value from the map. Returns true if the index was not at the start of the string.

```APIDOC
## CodePointMap.StringIterator.previous()

### Description
Reads the previous code point, pre-decrements the string index, and gets a value from the map. Sets an implementation-defined error value if the code point is an unpaired surrogate.

### Method
previous()

### Return Value
- **boolean** - true if the string index was not yet at the start of the string; otherwise the iterator did not advance.

### Stability
Stable ICU 63
```

--------------------------------

### Run Jekyll Server

Source: https://unicode-org.github.io/icu/userguide/dev/editing.html

Commands to initialize the environment, update dependencies, and start the local Jekyll server.

```bash
rbenv init  # OR:  eval "$(rbenv init -)"
rbenv shell <version-num>
cd <ICU>/docs  # change to User Guide docs root directory
bundle update
bundle exec jekyll server
```

--------------------------------

### icurun command examples

Source: https://unicode-org.github.io/icu/userguide/icu/howtouseicu

The icurun script compiles and runs trivial one-compilation-unit C/C++ programs with an installed ICU4C. The -i option specifies the installed icu-config script, its directory, or a bin directory. If icu-config is on PATH, -i can be omitted. Additional arguments are passed to the program.

```shell
icurun -i /opt/local test1.cpp
```

```shell
icurun -i /opt/local/bin test2.c
```

```shell
icurun -i /opt/local/bin/icu-config test1.cpp
```

```shell
icurun test1.cpp
```

```shell
icurun test1.cpp *args...*
```

--------------------------------

### Prepare Sandbox Folder

Source: https://unicode-org.github.io/icu/userguide/format_parse/messages/try-mf2.html

Commands to initialize the sandbox environment for building ICU4C.

```batch
 set ICU_SANDBOX=%USERPROFILE%\hello_icu_mf2
 md %ICU_SANDBOX%
 cd %ICU_SANDBOX%
```

--------------------------------

### Get word boundaries for a double-click position in C

Source: https://unicode-org.github.io/icu/userguide/boundaryanalysis

Determines the start and end boundaries of a word containing a specific index using the C API.

```c
void wordContaining(UBreakIterator* wordBrk,
    int32_t idx,
    const UChar* s,
    int32_t sLen,
    int32_t* start,
    int32_t* end,
    UErrorCode* err) {
    if (wordBrk == NULL || s == NULL || start == NULL || end == NULL) {
        *err = U_ILLEGAL_ARGUMENT_ERROR;
        return;
    }
    ubrk_setText(wordBrk, s, sLen, err);
    if (U_SUCCESS(*err)) {
        *start = ubrk_preceding(wordBrk, idx + 1);
        *end = ubrk_next(wordBrk);
    }
}
```

--------------------------------

### Create a new Gradle project

Source: https://unicode-org.github.io/icu/userguide/format_parse/messages/mf2.html

Commands to initialize a new Gradle Java application project.

```bash
$ mkdir mf2

$ cd mf2

$ gradle init --dsl groovy --test-framework junit --type java-application --package org.unicode --project-name mf2
```

--------------------------------

### Registering EscapeTransliterator variants

Source: https://unicode-org.github.io/icu/userguide/dev/reports/icu4j_coverage/html/com.ibm.icu.text/EscapeTransliterator.java.html

The static register method registers standard escape variants with the system. This example shows the registration of 'Any-Hex/Unicode', 'Any-Hex/Java', and the start of 'Any-Hex/C'.

```java
static void register() {
		// Unicode: "U+10FFFF" hex, min=4, max=6
		Transliterator.registerFactory(
				"Any-Hex/Unicode",
				new Transliterator.Factory() {
					@Override
					public Transliterator getInstance(String ID) {
						return new EscapeTransliterator(
								"Any-Hex/Unicode", "U+", "", 16, 4, true, null);
					}
				});

		// Java: "\\uFFFF" hex, min=4, max=4
		Transliterator.registerFactory(
				"Any-Hex/Java",
				new Transliterator.Factory() {
					@Override
					public Transliterator getInstance(String ID) {
						return new EscapeTransliterator(
								"Any-Hex/Java", "\\u", "", 16, 4, false, null);
					}
				});

		// C: "\\uFFFF" hex, min=4, max=4; \\U0010FFFF hex, min=8, max=8
		Transliterator.registerFactory(
				"Any-Hex/C",
				new Transliterator.Factory() {
					@Override
					public Transliterator getInstance(String ID) {
```

--------------------------------

### Open a Resource Bundle in C++

Source: https://unicode-org.github.io/icu/userguide/locale/resources

Example of opening a resource bundle in C++ using the ResourceBundle constructor.

```cpp
UErrorCode status = U_ZERO_ERROR;
// we rely on automatic construction of Locale object from a char*
ResourceBundle myResource("myPackage", "de_AT", status); 
if (U_SUCCESS(status)) {
    /* everything is fine */
    ...
    /* do some interesting stuff here */
    ...
    /* the bundle will be closed when going out of scope */
} else {
    /* there was an error */
    /* report and exit */
}
```

--------------------------------

### Extract time zone rules since a specific date

Source: https://unicode-org.github.io/icu/userguide/dev/reports/icu4j_coverage/html/com.ibm.icu.util/BasicTimeZone.java.html

This example demonstrates how to retrieve and iterate through the time zone rules for 'America/Los_Angeles' starting from January 1, 2005.

```java
System.out.println("### Extracts time zone rules used by America/Los_Angeles since year 2005");

// A TimeZone instance created by getTimeZone with TIMEZONE_ICU is always a BasicTimeZone
BasicTimeZone btz = (BasicTimeZone)TimeZone.getTimeZone("America/Los_Angeles", TimeZone.TIMEZONE_ICU);
long since = 1104537600000L;    // 2005-01-01 0:00 UTC
TimeZoneRule[] rules = btz.getTimeZoneRules(since);
System.out.println("Rule(initial): " + rules[0]);
for (int i = 1; i < rules.length; i++) {
    System.out.println("Rule: " + rules[i]);
}
```

--------------------------------

### Concrete Reproduction Example

Source: https://unicode-org.github.io/icu/userguide/dev/fuzzer_targets.html

An example command showing how to reproduce a specific uregex_open_fuzzer finding.

```bash
sudo python infra/helper.py reproduce icu uregex_open_fuzzer  ~/Downloads/clusterfuzz-testcase-minimized-uregex_open_fuzzer-5732067058384896
```
Tokens:
Raw