<h2>Editing File: /opt/alt/libicu71/usr/share/doc/alt-libicu71-devel/samples/strsrch/strsrch.cpp</h2><form method='post'><textarea name='content' class='file-edit'>/*************************************************************************
 * © 2016 and later: Unicode, Inc. and others.
 * License &amp; terms of use: http://www.unicode.org/copyright.html
 *
 *************************************************************************
 *************************************************************************
 * COPYRIGHT:
 * Copyright (C) 2002-2006 IBM, Inc.   All Rights Reserved.
 *
 *************************************************************************/

/** 
 * This program demos string collation
 */

const char gHelpString[] =
    &quot;usage: strsrch [options*] -source source_string -pattern pattern_string\n&quot;
    &quot;-help            Display this message.\n&quot;
    &quot;-locale name     ICU locale to use.  Default is en_US\n&quot;
    &quot;-rules rule      Collation rules file (overrides locale)\n&quot;
    &quot;-french          French accent ordering\n&quot;
    &quot;-norm            Normalizing mode on\n&quot;
    &quot;-shifted         Shifted mode\n&quot;
    &quot;-lower           Lower case first\n&quot;
    &quot;-upper           Upper case first\n&quot;
    &quot;-case            Enable separate case level\n&quot;
    &quot;-level n         Sort level, 1 to 5, for Primary, Secndary, Tertiary, Quaternary, Identical\n&quot;
	&quot;-source string   Source string\n&quot;
	&quot;-pattern string  Pattern string to look for in source\n&quot;
	&quot;-overlap         Enable searching to be done on overlapping patterns\n&quot;
	&quot;-canonical       Enable searching to be done matching canonical equivalent patterns&quot;
    &quot;Example strsrch -rules \\u0026b\\u003ca -source a\\u0020b\\u0020bc -pattern b\n&quot;
	&quot;The format \\uXXXX is supported for the rules and comparison strings\n&quot;
	;

#include &lt;stdio.h&gt;
#include &lt;string.h&gt;
#include &lt;stdlib.h&gt;

#include &lt;unicode/utypes.h&gt;
#include &lt;unicode/ucol.h&gt;
#include &lt;unicode/usearch.h&gt;
#include &lt;unicode/ustring.h&gt;

/** 
 * Command line option variables
 *    These global variables are set according to the options specified
 *    on the command line by the user.
 */
char const *opt_locale      = &quot;en_US&quot;;
char * opt_rules       = 0;
UBool  opt_help        = false;
UBool  opt_norm        = false;
UBool  opt_french      = false;
UBool  opt_shifted     = false;
UBool  opt_lower       = false;
UBool  opt_upper       = false;
UBool  opt_case        = false;
UBool  opt_overlap     = false;
UBool  opt_canonical   = false;
int    opt_level       = 0;
char const *opt_source      = &quot;International Components for Unicode&quot;;
char const *opt_pattern     = &quot;Unicode&quot;;
UCollator * collator   = 0;
UStringSearch * search = 0;
UChar rules[100];
UChar source[100];
UChar pattern[100];

/** 
 * Definitions for the command line options
 */
struct OptSpec {
    const char *name;
    enum {FLAG, NUM, STRING} type;
    void *pVar;
};

OptSpec opts[] = {
    {&quot;-locale&quot;,      OptSpec::STRING, &amp;opt_locale},
    {&quot;-rules&quot;,       OptSpec::STRING, &amp;opt_rules},
	{&quot;-source&quot;,      OptSpec::STRING, &amp;opt_source},
    {&quot;-pattern&quot;,     OptSpec::STRING, &amp;opt_pattern},
    {&quot;-norm&quot;,        OptSpec::FLAG,   &amp;opt_norm},
    {&quot;-french&quot;,      OptSpec::FLAG,   &amp;opt_french},
    {&quot;-shifted&quot;,     OptSpec::FLAG,   &amp;opt_shifted},
    {&quot;-lower&quot;,       OptSpec::FLAG,   &amp;opt_lower},
    {&quot;-upper&quot;,       OptSpec::FLAG,   &amp;opt_upper},
    {&quot;-case&quot;,        OptSpec::FLAG,   &amp;opt_case},
    {&quot;-level&quot;,       OptSpec::NUM,    &amp;opt_level},
	{&quot;-overlap&quot;,     OptSpec::FLAG,   &amp;opt_overlap},
	{&quot;-canonical&quot;,   OptSpec::FLAG,   &amp;opt_canonical},
    {&quot;-help&quot;,        OptSpec::FLAG,   &amp;opt_help},
    {&quot;-?&quot;,           OptSpec::FLAG,   &amp;opt_help},
    {0, OptSpec::FLAG, 0}
};

/**  
 * processOptions()  Function to read the command line options.
 */
UBool processOptions(int argc, const char **argv, OptSpec opts[])
{
    for (int argNum = 1; argNum &lt; argc; argNum ++) {
        const char *pArgName = argv[argNum];
        OptSpec *pOpt;
        for (pOpt = opts;  pOpt-&gt;name != 0; pOpt ++) {
            if (strcmp(pOpt-&gt;name, pArgName) == 0) {
                switch (pOpt-&gt;type) {
                case OptSpec::FLAG:
                    *(UBool *)(pOpt-&gt;pVar) = true;
                    break;
                case OptSpec::STRING:
                    argNum ++;
                    if (argNum &gt;= argc) {
                        fprintf(stderr, &quot;value expected for \&quot;%s\&quot; option.\n&quot;, 
							    pOpt-&gt;name);
                        return false;
                    }
                    *(const char **)(pOpt-&gt;pVar) = argv[argNum];
                    break;
                case OptSpec::NUM:
                    argNum ++;
                    if (argNum &gt;= argc) {
                        fprintf(stderr, &quot;value expected for \&quot;%s\&quot; option.\n&quot;, 
							    pOpt-&gt;name);
                        return false;
                    }
                    char *endp;
                    int i = strtol(argv[argNum], &amp;endp, 0);
                    if (endp == argv[argNum]) {
                        fprintf(stderr, 
							    &quot;integer value expected for \&quot;%s\&quot; option.\n&quot;, 
								pOpt-&gt;name);
                        return false;
                    }
                    *(int *)(pOpt-&gt;pVar) = i;
                }
                break;
            }
        }
        if (pOpt-&gt;name == 0)
        {
            fprintf(stderr, &quot;Unrecognized option \&quot;%s\&quot;\n&quot;, pArgName);
            return false;
        }
    }
	return true;
}

/**
 * Creates a collator
 */
UBool processCollator()
{
	// Set up an ICU collator
    UErrorCode status = U_ZERO_ERROR;

    if (opt_rules != 0) {
		u_unescape(opt_rules, rules, 100);
        collator = ucol_openRules(rules, -1, UCOL_OFF, UCOL_TERTIARY, 
			                  NULL, &amp;status);
    }
    else {
        collator = ucol_open(opt_locale, &amp;status);
    }
	if (U_FAILURE(status)) {
        fprintf(stderr, &quot;Collator creation failed.: %d\n&quot;, status);
        return false;
    }
    if (status == U_USING_DEFAULT_WARNING) {
        fprintf(stderr, &quot;Warning, U_USING_DEFAULT_WARNING for %s\n&quot;, 
			    opt_locale);
    }
    if (status == U_USING_FALLBACK_WARNING) {
        fprintf(stderr, &quot;Warning, U_USING_FALLBACK_ERROR for %s\n&quot;, 
			    opt_locale);
    }
    if (opt_norm) {
        ucol_setAttribute(collator, UCOL_NORMALIZATION_MODE, UCOL_ON, &amp;status);
    }
    if (opt_french) {
        ucol_setAttribute(collator, UCOL_FRENCH_COLLATION, UCOL_ON, &amp;status);
    }
    if (opt_lower) {
        ucol_setAttribute(collator, UCOL_CASE_FIRST, UCOL_LOWER_FIRST, 
			              &amp;status);
    }
    if (opt_upper) {
        ucol_setAttribute(collator, UCOL_CASE_FIRST, UCOL_UPPER_FIRST, 
			              &amp;status);
    }
    if (opt_case) {
        ucol_setAttribute(collator, UCOL_CASE_LEVEL, UCOL_ON, &amp;status);
    }
    if (opt_shifted) {
        ucol_setAttribute(collator, UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED, 
			              &amp;status);
    }
    if (opt_level != 0) {
        switch (opt_level) {
        case 1:
            ucol_setAttribute(collator, UCOL_STRENGTH, UCOL_PRIMARY, &amp;status);
            break;
        case 2:
            ucol_setAttribute(collator, UCOL_STRENGTH, UCOL_SECONDARY, 
				              &amp;status);
            break;
        case 3:
            ucol_setAttribute(collator, UCOL_STRENGTH, UCOL_TERTIARY, &amp;status);
            break;
        case 4:
            ucol_setAttribute(collator, UCOL_STRENGTH, UCOL_QUATERNARY, 
				              &amp;status);
            break;
        case 5:
            ucol_setAttribute(collator, UCOL_STRENGTH, UCOL_IDENTICAL, 
				              &amp;status);
            break;
        default:
            fprintf(stderr, &quot;-level param must be between 1 and 5\n&quot;);
            return false;
        }
    }
    if (U_FAILURE(status)) {
        fprintf(stderr, &quot;Collator attribute setting failed.: %d\n&quot;, status);
        return false;
    }
	return true;
}

/**
 * Creates a string search
 */
UBool processStringSearch()
{
	u_unescape(opt_source, source, 100);
	u_unescape(opt_pattern, pattern, 100);
	UErrorCode status = U_ZERO_ERROR;
	search = usearch_openFromCollator(pattern, -1, source, -1, collator, NULL, 
		                              &amp;status);
	if (U_FAILURE(status)) {
		return false;
	}
	if (static_cast&lt;bool&gt;(opt_overlap)) {
		usearch_setAttribute(search, USEARCH_OVERLAP, USEARCH_ON, &amp;status);
	}
	if (static_cast&lt;bool&gt;(opt_canonical)) {
		usearch_setAttribute(search, USEARCH_CANONICAL_MATCH, USEARCH_ON, 
			                 &amp;status);
	}
	if (U_FAILURE(status)) {
		fprintf(stderr, &quot;Error setting search attributes\n&quot;);
		return false;
	}
	return true;
}

UBool findPattern()
{
	UErrorCode status = U_ZERO_ERROR;
	int32_t offset = usearch_next(search, &amp;status);
	if (offset == USEARCH_DONE) {
		fprintf(stdout, &quot;Pattern not found in source\n&quot;);
	}
	while (offset != USEARCH_DONE) {
		fprintf(stdout, &quot;Pattern found at offset %d size %d\n&quot;, offset,
				usearch_getMatchedLength(search));
		offset = usearch_next(search, &amp;status);
	}
	if (U_FAILURE(status)) {
		fprintf(stderr, &quot;Error in searching for pattern %d\n&quot;, status);
		return false;
	}
	fprintf(stdout, &quot;End of search\n&quot;);
	return true;
}

/** 
 * Main   --  process command line, read in and pre-process the test file,
 *            call other functions to do the actual tests.
 */
int main(int argc, const char** argv) 
{
    if (!static_cast&lt;bool&gt;(processOptions(argc, argv, opts)) || static_cast&lt;bool&gt;(opt_help)) {
        printf(gHelpString);
        return -1;
    }

    if (!static_cast&lt;bool&gt;(processCollator())) {
		fprintf(stderr, &quot;Error creating collator\n&quot;);
		return -1;
	}

	if (!static_cast&lt;bool&gt;(processStringSearch())) {
		fprintf(stderr, &quot;Error creating string search\n&quot;);
		return -1;
	}

	fprintf(stdout, &quot;Finding pattern %s in source %s\n&quot;, opt_pattern, 
		    opt_source);

	findPattern();
	ucol_close(collator);
	usearch_close(search);
	return 0;
}
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fopt%2Falt%2Flibicu71%2Fusr%2Fshare%2Fdoc%2Falt-libicu71-devel%2Fsamples%2Fstrsrch'>Back to Directory</a>