[/
 / Copyright (c) 2008 Eric Niebler
 /
 / Distributed under the Boost Software License, Version 1.0. (See accompanying
 / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 /]

[section Examples]

Below you can find six complete sample programs.
\n

----

[h4 See if a whole string matches a regex]

This is the example from the Introduction. It is reproduced here for your convenience.

    #include <iostream>
    #include <boost/xpressive/xpressive.hpp>

    using namespace boost::xpressive;

    int main()
    {
        std::string hello( "hello world!" );

        sregex rex = sregex::compile( "(\\w+) (\\w+)!" );
        smatch what;

        if( regex_match( hello, what, rex ) )
        {
            std::cout << what[0] << '\n'; // whole match
            std::cout << what[1] << '\n'; // first capture
            std::cout << what[2] << '\n'; // second capture
        }

        return 0;
    }

This program outputs the following:

[pre
hello world!
hello
world
]
\n
[link boost_xpressive.user_s_guide.examples top]

----

[h4 See if a string contains a sub-string that matches a regex]

Notice in this example how we use custom `mark_tag`s to make the pattern more readable.
We can use the `mark_tag`s later to index into the _match_results_.

    #include <iostream>
    #include <boost/xpressive/xpressive.hpp>

    using namespace boost::xpressive;

    int main()
    {
        char const *str = "I was born on 5/30/1973 at 7am.";

        // define some custom mark_tags with names more meaningful than s1, s2, etc.
        mark_tag day(1), month(2), year(3), delim(4);

        // this regex finds a date
        cregex date = (month= repeat<1,2>(_d))           // find the month ...
                   >> (delim= (set= '/','-'))            // followed by a delimiter ...
                   >> (day=   repeat<1,2>(_d)) >> delim  // and a day followed by the same delimiter ...
                   >> (year=  repeat<1,2>(_d >> _d));    // and the year.

        cmatch what;

        if( regex_search( str, what, date ) )
        {
            std::cout << what[0]     << '\n'; // whole match
            std::cout << what[day]   << '\n'; // the day
            std::cout << what[month] << '\n'; // the month
            std::cout << what[year]  << '\n'; // the year
            std::cout << what[delim] << '\n'; // the delimiter
        }

        return 0;
    }

This program outputs the following:

[pre
5/30/1973
30
5
1973
/
]
\n
[link boost_xpressive.user_s_guide.examples top]

----

[h4 Replace all sub-strings that match a regex]

The following program finds dates in a string and marks them up with pseudo-HTML.

    #include <iostream>
    #include <boost/xpressive/xpressive.hpp>

    using namespace boost::xpressive;

    int main()
    {
        std::string str( "I was born on 5/30/1973 at 7am." );

        // essentially the same regex as in the previous example, but using a dynamic regex
        sregex date = sregex::compile( "(\\d{1,2})([/-])(\\d{1,2})\\2((?:\\d{2}){1,2})" );

        // As in Perl, $& is a reference to the sub-string that matched the regex
        std::string format( "<date>$&</date>" );

        str = regex_replace( str, date, format );
        std::cout << str << '\n';

        return 0;
    }

This program outputs the following:

[pre
I was born on <date>5/30/1973</date> at 7am.
]
\n
[link boost_xpressive.user_s_guide.examples top]

----

[h4 Find all the sub-strings that match a regex and step through them one at a time]

The following program finds the words in a wide-character string.
It uses `wsregex_iterator`. Notice that dereferencing a `wsregex_iterator`
yields a `wsmatch` object.

    #include <iostream>
    #include <boost/xpressive/xpressive.hpp>

    using namespace boost::xpressive;

    int main()
    {
        std::wstring str( L"This is his face." );

        // find a whole word
        wsregex token = +alnum;

        wsregex_iterator cur( str.begin(), str.end(), token );
        wsregex_iterator end;

        for( ; cur != end; ++cur )
        {
            wsmatch const &what = *cur;
            std::wcout << what[0] << L'\n';
        }

        return 0;
    }

This program outputs the following:

[pre
This
is
his
face
]
\n
[link boost_xpressive.user_s_guide.examples top]

----

[h4 Split a string into tokens that each match a regex]

The following program finds race times in a string and displays first
the minutes and then the seconds. It uses _regex_token_iterator_.

    #include <iostream>
    #include <boost/xpressive/xpressive.hpp>

    using namespace boost::xpressive;

    int main()
    {
        std::string str( "Eric: 4:40, Karl: 3:35, Francesca: 2:32" );

        // find a race time
        sregex time = sregex::compile( "(\\d):(\\d\\d)" );

        // for each match, the token iterator should first take the value of
        // the first marked sub-expression followed by the value of the second
        // marked sub-expression
        int const subs[] = { 1, 2 };

        sregex_token_iterator cur( str.begin(), str.end(), time, subs );
        sregex_token_iterator end;

        for( ; cur != end; ++cur )
        {
            std::cout << *cur << '\n';
        }

        return 0;
    }

This program outputs the following:

[pre
4
40
3
35
2
32
]
\n
[link boost_xpressive.user_s_guide.examples top]

----

[h4 Split a string using a regex as a delimiter]

The following program takes some text that has been marked up with html and strips
out the mark-up. It uses a regex that matches an HTML tag and a _regex_token_iterator_
that returns the parts of the string that do ['not] match the regex.

    #include <iostream>
    #include <boost/xpressive/xpressive.hpp>

    using namespace boost::xpressive;

    int main()
    {
        std::string str( "Now <bold>is the time <i>for all good men</i> to come to the aid of their</bold> country." );

        // find a HTML tag
        sregex html = '<' >> optional('/') >> +_w >> '>';

        // the -1 below directs the token iterator to display the parts of
        // the string that did NOT match the regular expression.
        sregex_token_iterator cur( str.begin(), str.end(), html, -1 );
        sregex_token_iterator end;

        for( ; cur != end; ++cur )
        {
            std::cout << '{' << *cur << '}';
        }
        std::cout << '\n';

        return 0;
    }

This program outputs the following:

[pre
{Now }{is the time }{for all good men}{ to come to the aid of their}{ country.}
]
\n
[link boost_xpressive.user_s_guide.examples top]

----

[h4 Display a tree of nested results]

Here is a helper class to demonstrate how you might display a tree of nested results:

    // Displays nested results to std::cout with indenting
    struct output_nested_results
    {
        int tabs_;

        output_nested_results( int tabs = 0 )
            : tabs_( tabs )
        {
        }

        template< typename BidiIterT >
        void operator ()( match_results< BidiIterT > const &what ) const
        {
            // first, do some indenting
            typedef typename std::iterator_traits< BidiIterT >::value_type char_type;
            char_type space_ch = char_type(' ');
            std::fill_n( std::ostream_iterator<char_type>( std::cout ), tabs_ * 4, space_ch );

            // output the match
            std::cout << what[0] << '\n';

            // output any nested matches
            std::for_each(
                what.nested_results().begin(),
                what.nested_results().end(),
                output_nested_results( tabs_ + 1 ) );
        }
    };

[link boost_xpressive.user_s_guide.examples top]

[endsect]