# Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. — Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

Classes | Typedefs | Enumerations | Functions | Friends

# Boundary Analysis

## Classes

class | boost::locale::boundary::boundary_point< IteratorType >
| This class represents a boundary point in the text. More...
struct | boost::locale::boundary::break_info
| This structure is used for representing boundary point that follows the offset. More...
class | boost::locale::boundary::boundary_indexing< Char >
| This facet generates an index for boundary analysis for a given text. More...
class | boost::locale::boundary::segment_index< BaseIterator >
| This class holds an index of segments in the text range and allows to iterate over them. More...
class | boost::locale::boundary::boundary_point_index< BaseIterator >
| This class holds an index of boundary points and allows iterating over them. More...
class | boost::locale::boundary::segment< IteratorType >
| a segment object that represents a pair of two iterators that define the range where this segment exits and a rule that defines it. More...

## Typedefs

typedef std::vector< break_info > | boost::locale::boundary::index_type
typedef unspecified_iterator_type | boost::locale::boundary::segment_index::iterator
typedef unspecified_iterator_type | boost::locale::boundary::segment_index::const_iterator
typedef segment< base_iterator > | boost::locale::boundary::segment_index::value_type
typedef unspecified_iterator_type | boost::locale::boundary::boundary_point_index::iterator
typedef unspecified_iterator_type | boost::locale::boundary::boundary_point_index::const_iterator
typedef boundary_point < base_iterator > | boost::locale::boundary::boundary_point_index::value_type
typedef segment_index < std::string::const_iterator > | boost::locale::boundary::ssegment_index
typedef segment_index < std::wstring::const_iterator > | boost::locale::boundary::wssegment_index
| convenience typedef
typedef segment_index < std::u16string::const_iterator > | boost::locale::boundary::u16ssegment_index
| convenience typedef
typedef segment_index < std::u32string::const_iterator > | boost::locale::boundary::u32ssegment_index
| convenience typedef
typedef segment_index< char const * > | boost::locale::boundary::csegment_index
| convenience typedef
typedef segment_index< wchar_t const * > | boost::locale::boundary::wcsegment_index
| convenience typedef
typedef segment_index < char16_t const * > | boost::locale::boundary::u16csegment_index
| convenience typedef
typedef segment_index < char32_t const * > | boost::locale::boundary::u32csegment_index
| convenience typedef
typedef boundary_point_index < std::string::const_iterator > | boost::locale::boundary::sboundary_point_index
| convenience typedef
typedef boundary_point_index < std::wstring::const_iterator > | boost::locale::boundary::wsboundary_point_index
| convenience typedef
typedef boundary_point_index < std::u16string::const_iterator > | boost::locale::boundary::u16sboundary_point_index
| convenience typedef
typedef boundary_point_index < std::u32string::const_iterator > | boost::locale::boundary::u32sboundary_point_index
| convenience typedef
typedef boundary_point_index < char const * > | boost::locale::boundary::cboundary_point_index
| convenience typedef
typedef boundary_point_index < wchar_t const * > | boost::locale::boundary::wcboundary_point_index
| convenience typedef
typedef boundary_point_index < char16_t const * > | boost::locale::boundary::u16cboundary_point_index
| convenience typedef
typedef boundary_point_index < char32_t const * > | boost::locale::boundary::u32cboundary_point_index
| convenience typedef
typedef segment < std::string::const_iterator > | boost::locale::boundary::ssegment
| convenience typedef
typedef segment < std::wstring::const_iterator > | boost::locale::boundary::wssegment
| convenience typedef
typedef segment < std::u16string::const_iterator > | boost::locale::boundary::u16ssegment
| convenience typedef
typedef segment < std::u32string::const_iterator > | boost::locale::boundary::u32ssegment
| convenience typedef
typedef segment< char const * > | boost::locale::boundary::csegment
| convenience typedef
typedef segment< wchar_t const * > | boost::locale::boundary::wcsegment
| convenience typedef
typedef segment< char16_t const * > | boost::locale::boundary::u16csegment
| convenience typedef
typedef segment< char32_t const * > | boost::locale::boundary::u32csegment
| convenience typedef
typedef uint32_t | boost::locale::boundary::rule_type
| Flags used with word boundary analysis -- the type of the word, line or sentence boundary found.

## Enumerations

enum | boost::locale::boundary::boundary_type { boost::locale::boundary::character, boost::locale::boundary::word, boost::locale::boundary::sentence, boost::locale::boundary::line }

## Functions

template<typename BaseIterator >
bool | boost::locale::boundary::operator== (BaseIterator const &l, boundary_point< BaseIterator > const &r)
template<typename BaseIterator >
bool | boost::locale::boundary::operator!= (BaseIterator const &l, boundary_point< BaseIterator > const &r)
| boost::locale::boundary::segment_index::segment_index ()
| boost::locale::boundary::segment_index::segment_index (boundary_type type, base_iterator begin, base_iterator end, rule_type mask, std::locale const &loc=std::locale())
| boost::locale::boundary::segment_index::segment_index (boundary_type type, base_iterator begin, base_iterator end, std::locale const &loc=std::locale())
| boost::locale::boundary::segment_index::segment_index (boundary_point_index< base_iterator > const &)
segment_index const & | boost::locale::boundary::segment_index::operator= (boundary_point_index< base_iterator > const &)
void | boost::locale::boundary::segment_index::map (boundary_type type, base_iterator begin, base_iterator end, std::locale const &loc=std::locale())
iterator | boost::locale::boundary::segment_index::begin () const
iterator | boost::locale::boundary::segment_index::end () const
iterator | boost::locale::boundary::segment_index::find (base_iterator p) const
rule_type | boost::locale::boundary::segment_index::rule () const
void | boost::locale::boundary::segment_index::rule (rule_type v)
bool | boost::locale::boundary::segment_index::full_select () const
void | boost::locale::boundary::segment_index::full_select (bool v)
| boost::locale::boundary::boundary_point_index::boundary_point_index ()
| boost::locale::boundary::boundary_point_index::boundary_point_index (boundary_type type, base_iterator begin, base_iterator end, rule_type mask, std::locale const &loc=std::locale())
| boost::locale::boundary::boundary_point_index::boundary_point_index (boundary_type type, base_iterator begin, base_iterator end, std::locale const &loc=std::locale())
| boost::locale::boundary::boundary_point_index::boundary_point_index (segment_index< base_iterator > const &other)
boundary_point_index const & | boost::locale::boundary::boundary_point_index::operator= (segment_index< base_iterator > const &other)
void | boost::locale::boundary::boundary_point_index::map (boundary_type type, base_iterator begin, base_iterator end, std::locale const &loc=std::locale())
iterator | boost::locale::boundary::boundary_point_index::begin () const
iterator | boost::locale::boundary::boundary_point_index::end () const
iterator | boost::locale::boundary::boundary_point_index::find (base_iterator p) const
rule_type | boost::locale::boundary::boundary_point_index::rule () const
void | boost::locale::boundary::boundary_point_index::rule (rule_type v)
template<typename IteratorL , typename IteratorR >
bool | boost::locale::boundary::operator== (segment< IteratorL > const &l, segment< IteratorR > const &r)
| Compare two segments.
template<typename IteratorL , typename IteratorR >
bool | boost::locale::boundary::operator!= (segment< IteratorL > const &l, segment< IteratorR > const &r)
| Compare two segments.
template<typename IteratorL , typename IteratorR >
bool | boost::locale::boundary::operator< (segment< IteratorL > const &l, segment< IteratorR > const &r)
| Compare two segments.
template<typename IteratorL , typename IteratorR >
bool | boost::locale::boundary::operator<= (segment< IteratorL > const &l, segment< IteratorR > const &r)
| Compare two segments.
template<typename IteratorL , typename IteratorR >
bool | boost::locale::boundary::operator> (segment< IteratorL > const &l, segment< IteratorR > const &r)
| Compare two segments.
template<typename IteratorL , typename IteratorR >
bool | boost::locale::boundary::operator>= (segment< IteratorL > const &l, segment< IteratorR > const &r)
| Compare two segments.
template<typename CharType , typename Traits , typename Alloc , typename IteratorR >
bool | boost::locale::boundary::operator== (std::basic_string< CharType, Traits, Alloc > const &l, segment< IteratorR > const &r)
| Compare string and segment.
template<typename CharType , typename Traits , typename Alloc , typename IteratorR >
bool | boost::locale::boundary::operator!= (std::basic_string< CharType, Traits, Alloc > const &l, segment< IteratorR > const &r)
| Compare string and segment.
template<typename CharType , typename Traits , typename Alloc , typename IteratorR >
bool | boost::locale::boundary::operator< (std::basic_string< CharType, Traits, Alloc > const &l, segment< IteratorR > const &r)
| Compare string and segment.
template<typename CharType , typename Traits , typename Alloc , typename IteratorR >
bool | boost::locale::boundary::operator<= (std::basic_string< CharType, Traits, Alloc > const &l, segment< IteratorR > const &r)
| Compare string and segment.
template<typename CharType , typename Traits , typename Alloc , typename IteratorR >
bool | boost::locale::boundary::operator> (std::basic_string< CharType, Traits, Alloc > const &l, segment< IteratorR > const &r)
| Compare string and segment.
template<typename CharType , typename Traits , typename Alloc , typename IteratorR >
bool | boost::locale::boundary::operator>= (std::basic_string< CharType, Traits, Alloc > const &l, segment< IteratorR > const &r)
| Compare string and segment.
template<typename Iterator , typename CharType , typename Traits , typename Alloc >
bool | boost::locale::boundary::operator== (segment< Iterator > const &l, std::basic_string< CharType, Traits, Alloc > const &r)
| Compare string and segment.
template<typename Iterator , typename CharType , typename Traits , typename Alloc >
bool | boost::locale::boundary::operator!= (segment< Iterator > const &l, std::basic_string< CharType, Traits, Alloc > const &r)
| Compare string and segment.
template<typename Iterator , typename CharType , typename Traits , typename Alloc >
bool | boost::locale::boundary::operator< (segment< Iterator > const &l, std::basic_string< CharType, Traits, Alloc > const &r)
| Compare string and segment.
template<typename Iterator , typename CharType , typename Traits , typename Alloc >
bool | boost::locale::boundary::operator<= (segment< Iterator > const &l, std::basic_string< CharType, Traits, Alloc > const &r)
| Compare string and segment.
template<typename Iterator , typename CharType , typename Traits , typename Alloc >
bool | boost::locale::boundary::operator> (segment< Iterator > const &l, std::basic_string< CharType, Traits, Alloc > const &r)
| Compare string and segment.
template<typename Iterator , typename CharType , typename Traits , typename Alloc >
bool | boost::locale::boundary::operator>= (segment< Iterator > const &l, std::basic_string< CharType, Traits, Alloc > const &r)
| Compare string and segment.
template<typename CharType , typename IteratorR >
bool | boost::locale::boundary::operator== (CharType const *l, segment< IteratorR > const &r)
| Compare C string and segment.
template<typename CharType , typename IteratorR >
bool | boost::locale::boundary::operator!= (CharType const *l, segment< IteratorR > const &r)
| Compare C string and segment.
template<typename CharType , typename IteratorR >
bool | boost::locale::boundary::operator< (CharType const *l, segment< IteratorR > const &r)
| Compare C string and segment.
template<typename CharType , typename IteratorR >
bool | boost::locale::boundary::operator<= (CharType const *l, segment< IteratorR > const &r)
| Compare C string and segment.
template<typename CharType , typename IteratorR >
bool | boost::locale::boundary::operator> (CharType const *l, segment< IteratorR > const &r)
| Compare C string and segment.
template<typename CharType , typename IteratorR >
bool | boost::locale::boundary::operator>= (CharType const *l, segment< IteratorR > const &r)
| Compare C string and segment.
template<typename Iterator , typename CharType >
bool | boost::locale::boundary::operator== (segment< Iterator > const &l, CharType const *r)
| Compare C string and segment.
template<typename Iterator , typename CharType >
bool | boost::locale::boundary::operator!= (segment< Iterator > const &l, CharType const *r)
| Compare C string and segment.
template<typename Iterator , typename CharType >
bool | boost::locale::boundary::operator< (segment< Iterator > const &l, CharType const *r)
| Compare C string and segment.
template<typename Iterator , typename CharType >
bool | boost::locale::boundary::operator<= (segment< Iterator > const &l, CharType const *r)
| Compare C string and segment.
template<typename Iterator , typename CharType >
bool | boost::locale::boundary::operator> (segment< Iterator > const &l, CharType const *r)
| Compare C string and segment.
template<typename Iterator , typename CharType >
bool | boost::locale::boundary::operator>= (segment< Iterator > const &l, CharType const *r)
| Compare C string and segment.
template<typename CharType , typename TraitsType , typename Iterator >
std::basic_ostream< CharType, TraitsType > & | boost::locale::boundary::operator<< (std::basic_ostream< CharType, TraitsType > &out, segment< Iterator > const &tok)
rule_type | boost::locale::boundary::boundary_rule (boundary_type t)

## Friends

class | boost::locale::boundary::segment_index::boundary_point_index< base_iterator >
class | boost::locale::boundary::boundary_point_index::segment_index< base_iterator >

## Flags that describe a type of word selected

static const rule_type | boost::locale::boundary::word_none = 0x0000F
| Not a word, like white space or punctuation mark.
static const rule_type | boost::locale::boundary::word_number = 0x000F0
| Word that appear to be a number.
static const rule_type | boost::locale::boundary::word_letter = 0x00F00
| Word that contains letters, excluding kana and ideographic characters.
static const rule_type | boost::locale::boundary::word_kana = 0x0F000
| Word that contains kana characters.
static const rule_type | boost::locale::boundary::word_ideo = 0xF0000
| Word that contains ideographic characters.
static const rule_type | boost::locale::boundary::word_any = 0xFFFF0
| Any word including numbers, 0 is special flag, equivalent to 15.
static const rule_type | boost::locale::boundary::word_letters = 0xFFF00
| Any word, excluding numbers but including letters, kana and ideograms.
static const rule_type | boost::locale::boundary::word_kana_ideo = 0xFF000
| Word that includes kana or ideographic characters.
static const rule_type | boost::locale::boundary::word_mask = 0xFFFFF

## Flags that describe a type of line break

static const rule_type | boost::locale::boundary::line_soft = 0x0F
| Soft line break: optional but not required.
static const rule_type | boost::locale::boundary::line_hard = 0xF0
| Hard line break: like break is required (as per CR/LF).
static const rule_type | boost::locale::boundary::line_any = 0xFF
| Soft or Hard line break.
static const rule_type | boost::locale::boundary::line_mask = 0xFF
| Select all types of line breaks.

## Flags that describe a type of sentence break

static const rule_type | boost::locale::boundary::sentence_term = 0x0F
| The sentence was terminated with a sentence terminator like ".", "!" possible followed by hard separator like CR, LF, PS.
static const rule_type | boost::locale::boundary::sentence_sep = 0xF0
| The sentence does not contain terminator like ".", "!" but ended with hard separator like CR, LF, PS or end of input.
static const rule_type | boost::locale::boundary::sentence_any = 0xFF
| Either first or second sentence break type;.
static const rule_type | boost::locale::boundary::sentence_mask = 0xFF
| Select all sentence breaking points.

## Flags that describe a type of character break.

At this point break iterator does not distinguish different kinds of characters so it is used for consistency.
static const rule_type | boost::locale::boundary::character_any = 0xF
| Not in use, just for consistency.
static const rule_type | boost::locale::boundary::character_mask = 0xF
| Select all character breaking points.

## Detailed Description

This module contains all operations required for boundary analysis of text: character, word, like and sentence boundaries

This module contains all operations required for boundary analysis of text: character, word, like and sentence boundaries

## Typedef Documentation

template<typename BaseIterator>

typedef unspecified_iterator_type boost::locale::boundary::segment_index< BaseIterator >::const_iterator`[inherited]`

The bidirectional iterator that iterates over value_type objects.

- The iterators may be invalidated by use of any non-const member function including but not limited to rule(rule_type) and full_select(bool).
- The returned value_type object is valid as long as iterator points to it. So this following code is wrong as t used after p was updated:

           segment_index<some_iterator>::iterator p=index.begin();
           segment<some_iterator> &t = *p;
           ++p;
           cout << t.str() << endl;

template<typename BaseIterator >

typedef unspecified_iterator_type boost::locale::boundary::boundary_point_index< BaseIterator >::const_iterator`[inherited]`

The bidirectional iterator that iterates over value_type objects.

- The iterators may be invalidated by use of any non-const member function including but not limited to rule(rule_type) member function.
- The returned value_type object is valid as long as iterator points to it. So this following code is wrong as t used after p was updated:

           boundary_point_index<some_iterator>::iterator p=index.begin();
           boundary_point<some_iterator> &t = *p;
           ++p;
           rule_type r = t->rule();

typedef std::vector<break_info> boost::locale::boundary::index_type

This type holds the analysis of the text - all its break points with marks

template<typename BaseIterator>

typedef unspecified_iterator_type boost::locale::boundary::segment_index< BaseIterator >::iterator`[inherited]`

The bidirectional iterator that iterates over value_type objects.

- The iterators may be invalidated by use of any non-const member function including but not limited to rule(rule_type) and full_select(bool).
- The returned value_type object is valid as long as iterator points to it. So this following code is wrong as t used after p was updated:

           segment_index<some_iterator>::iterator p=index.begin();
           segment<some_iterator> &t = *p;
           ++p;
           cout << t.str() << endl;

template<typename BaseIterator >

typedef unspecified_iterator_type boost::locale::boundary::boundary_point_index< BaseIterator >::iterator`[inherited]`

The bidirectional iterator that iterates over value_type objects.

- The iterators may be invalidated by use of any non-const member function including but not limited to rule(rule_type) member function.
- The returned value_type object is valid as long as iterator points to it. So this following code is wrong as t used after p was updated:

           boundary_point_index<some_iterator>::iterator p=index.begin();
           boundary_point<some_iterator> &t = *p;
           ++p;
           rule_type r = t->rule();

typedef uint32_t boost::locale::boundary::rule_type

Flags used with word boundary analysis -- the type of the word, line or sentence boundary found.

It is a bit-mask that represents various combinations of rules used to select this specific boundary.

typedef segment_index<std::string::const_iterator> boost::locale::boundary::ssegment_index

convenience typedef

template<typename BaseIterator>

typedef segment<base_iterator> boost::locale::boundary::segment_index< BaseIterator >::value_type`[inherited]`

The type dereferenced by the iterator and const_iterator. It is an object that represents selected segment.

template<typename BaseIterator >

typedef boundary_point<base_iterator> boost::locale::boundary::boundary_point_index< BaseIterator >::value_type`[inherited]`

The type dereferenced by the iterator and const_iterator. It is an object that represents the selected boundary point.

## Enumeration Type Documentation

enum boost::locale::boundary::boundary_type

This type describes a possible boundary analysis alternatives.

Enumerator:

  character | Analyse the text for character boundaries.
  word | Analyse the text for word boundaries.
  sentence | Analyse the text for Find sentence boundaries.
  line | Analyse the text for positions suitable for line breaks.

## Function Documentation

template<typename BaseIterator>

iterator boost::locale::boundary::segment_index< BaseIterator >::begin | ( |  | ) | const`[inline, inherited]`

Get the iterator on the beginning of the segments range.

Preconditions: the segment_index should have a mapping

Note:

The returned iterator is invalidated by access to any non-const member functions of this object

template<typename BaseIterator >

iterator boost::locale::boundary::boundary_point_index< BaseIterator >::begin | ( |  | ) | const`[inline, inherited]`

Get the iterator on the beginning of the boundary points range.

Preconditions: this boundary_point_index should have a mapping

Note:

The returned iterator is invalidated by access to any non-const member functions of this object

template<typename BaseIterator >

boost::locale::boundary::boundary_point_index< BaseIterator >::boundary_point_index | ( | boundary_type | type,
|  | base_iterator | begin,
|  | base_iterator | end,
|  | rule_type | mask,
|  | std::locale const & | loc = `std::locale()` |
| ) |  |  | `[inline, inherited]`

Create a segment_index for boundary analysis type of the text in range [begin,end) using a rule mask for locale loc.

template<typename BaseIterator >

boost::locale::boundary::boundary_point_index< BaseIterator >::boundary_point_index | ( | boundary_type | type,
|  | base_iterator | begin,
|  | base_iterator | end,
|  | std::locale const & | loc = `std::locale()` |
| ) |  |  | `[inline, inherited]`

Create a segment_index for boundary analysis type of the text in range [begin,end) selecting all possible boundary points (full mask) for locale loc.

template<typename BaseIterator >

boost::locale::boundary::boundary_point_index< BaseIterator >::boundary_point_index | ( | segment_index< base_iterator > const & | other | ) | `[inherited]`

Create a boundary_point_index from a segment_index. It copies all indexing information and uses the default rule (all possible boundary points)

This operation is very cheap, so if you use boundary_point_index and segment_index on same text range it is much better to create one from another rather then indexing the same range twice.

Note:
  rule() flags are not copied

template<typename BaseIterator >

boost::locale::boundary::boundary_point_index< BaseIterator >::boundary_point_index | ( |  | ) | `[inline, inherited]`

Default constructor.

Note:

When this object is constructed by default it does not include a valid index, thus calling begin(), end() or find() member functions would lead to undefined behavior

rule_type boost::locale::boundary::boundary_rule | ( | boundary_type | t | ) | `[inline]`

This function returns the mask that covers all variants for specific boundary type

template<typename BaseIterator>

iterator boost::locale::boundary::segment_index< BaseIterator >::end | ( |  | ) | const`[inline, inherited]`

Get the iterator on the ending of the segments range.

Preconditions: the segment_index should have a mapping

The returned iterator is invalidated by access to any non-const member functions of this object

template<typename BaseIterator >

iterator boost::locale::boundary::boundary_point_index< BaseIterator >::end | ( |  | ) | const`[inline, inherited]`

Get the iterator on the ending of the boundary points range.

Preconditions: this boundary_point_index should have a mapping

Note:

The returned iterator is invalidated by access to any non-const member functions of this object

template<typename BaseIterator>

iterator boost::locale::boundary::segment_index< BaseIterator >::find | ( | base_iterator | p | ) | const`[inline, inherited]`

Find a first valid segment following a position p.

If p is inside a valid segment this segment is selected:

For example: For word boundary analysis with word_any rule():

- "to| be or ", would point to "be",
- "t|o be or ", would point to "to",
- "to be or| ", would point to end.

Preconditions: the segment_index should have a mapping and p should be valid iterator to the text in the mapped range.

The returned iterator is invalidated by access to any non-const member functions of this object

template<typename BaseIterator >

iterator boost::locale::boundary::boundary_point_index< BaseIterator >::find | ( | base_iterator | p | ) | const`[inline, inherited]`

Find a first valid boundary point on a position p or following it.

For example: For word boundary analysis of the text "to be or"

- "|to be", would return boundary point at "|to be",
- "t|o be", would point to "to| be"

Preconditions: the boundary_point_index should have a mapping and p should be valid iterator to the text in the mapped range.

The returned iterator is invalidated by access to any non-const member functions of this object

template<typename BaseIterator>

bool boost::locale::boundary::segment_index< BaseIterator >::full_select | ( |  | ) | const`[inline, inherited]`

Get the full_select property value - should segment include in the range values that not belong to specific rule() or not.

The default value is false.

For example for sentence boundary with rule sentence_term the segments of text "Hello! How\nare you?" are "Hello!\", "are you?" when full_select() is false because "How\n" is selected as sentence by a rule spits the text by line feed. If full_select() is true the returned segments are "Hello! ", "How\nare you?" where "How\n" is joined with the following part "are you?"

template<typename BaseIterator>

void boost::locale::boundary::segment_index< BaseIterator >::full_select | ( | bool | v | ) | `[inline, inherited]`

Set the full_select property value - should segment include in the range values that not belong to specific rule() or not.

The default value is false.

For example for sentence boundary with rule sentence_term the segments of text "Hello! How\nare you?" are "Hello!\", "are you?" when full_select() is false because "How\n" is selected as sentence by a rule spits the text by line feed. If full_select() is true the returned segments are "Hello! ", "How\nare you?" where "How\n" is joined with the following part "are you?"

template<typename BaseIterator >

void boost::locale::boundary::boundary_point_index< BaseIterator >::map | ( | boundary_type | type,
|  | base_iterator | begin,
|  | base_iterator | end,
|  | std::locale const & | loc = `std::locale()` |
| ) |  |  | `[inline, inherited]`

Create a new index for boundary analysis type of the text in range [begin,end) for locale loc.

Note:
  rule() remains unchanged.

template<typename BaseIterator>

void boost::locale::boundary::segment_index< BaseIterator >::map | ( | boundary_type | type,
|  | base_iterator | begin,
|  | base_iterator | end,
|  | std::locale const & | loc = `std::locale()` |
| ) |  |  | `[inline, inherited]`

Create a new index for boundary analysis type of the text in range [begin,end) for locale loc.

Note:
  rule() and full_select() remain unchanged.

template<typename BaseIterator >

bool boost::locale::boundary::operator!= | ( | BaseIterator const & | l,
|  | boundary_point< BaseIterator > const & | r |
| ) |  |  |

Check if the boundary point r points to different location from an iterator l

template<typename CharType , typename TraitsType , typename Iterator >

std::basic_ostream<CharType,TraitsType>& boost::locale::boundary::operator<< | ( | std::basic_ostream< CharType, TraitsType > & | out,
|  | segment< Iterator > const & | tok |
| ) |  |  |

Write the segment to the stream character by character

template<typename BaseIterator >

boundary_point_index const& boost::locale::boundary::boundary_point_index< BaseIterator >::operator= | ( | segment_index< base_iterator > const & | other | ) | `[inherited]`

Copy a boundary_point_index from a segment_index. It copies all indexing information and keeps the current rule() unchanged

This operation is very cheap, so if you use boundary_point_index and segment_index on same text range it is much better to create one from another rather then indexing the same range twice.

Note:
  rule() flags are not copied

template<typename BaseIterator>

segment_index const& boost::locale::boundary::segment_index< BaseIterator >::operator= | ( | boundary_point_index< base_iterator > const & |  | ) | `[inherited]`

Copy an index from a boundary_point_index. It copies all indexing information and uses the default rule (all possible segments)

This operation is very cheap, so if you use boundary_point_index and segment_index on same text range it is much better to create one from another rather then indexing the same range twice.

Note:
  rule() flags are not copied

template<typename BaseIterator >

bool boost::locale::boundary::operator== | ( | BaseIterator const & | l,
|  | boundary_point< BaseIterator > const & | r |
| ) |  |  |

Check if the boundary point r points to same location as an iterator l

template<typename BaseIterator>

rule_type boost::locale::boundary::segment_index< BaseIterator >::rule | ( |  | ) | const`[inline, inherited]`

Get the mask of rules that are used

template<typename BaseIterator >

void boost::locale::boundary::boundary_point_index< BaseIterator >::rule | ( | rule_type | v | ) | `[inline, inherited]`

Set the mask of rules that are used

template<typename BaseIterator >

rule_type boost::locale::boundary::boundary_point_index< BaseIterator >::rule | ( |  | ) | const`[inline, inherited]`

Get the mask of rules that are used

template<typename BaseIterator>

void boost::locale::boundary::segment_index< BaseIterator >::rule | ( | rule_type | v | ) | `[inline, inherited]`

Set the mask of rules that are used

template<typename BaseIterator>

boost::locale::boundary::segment_index< BaseIterator >::segment_index | ( | boundary_type | type,
|  | base_iterator | begin,
|  | base_iterator | end,
|  | std::locale const & | loc = `std::locale()` |
| ) |  |  | `[inline, inherited]`

Create a segment_index for boundary analysis type of the text in range [begin,end) selecting all possible segments (full mask) for locale loc.

template<typename BaseIterator>

boost::locale::boundary::segment_index< BaseIterator >::segment_index | ( | boundary_type | type,
|  | base_iterator | begin,
|  | base_iterator | end,
|  | rule_type | mask,
|  | std::locale const & | loc = `std::locale()` |
| ) |  |  | `[inline, inherited]`

Create a segment_index for boundary analysis type of the text in range [begin,end) using a rule mask for locale loc.

template<typename BaseIterator>

boost::locale::boundary::segment_index< BaseIterator >::segment_index | ( |  | ) | `[inline, inherited]`

Default constructor.

Note:

When this object is constructed by default it does not include a valid index, thus calling begin(), end() or find() member functions would lead to undefined behavior

template<typename BaseIterator>

boost::locale::boundary::segment_index< BaseIterator >::segment_index | ( | boundary_point_index< base_iterator > const & |  | ) | `[inherited]`

Create a segment_index from a boundary_point_index. It copies all indexing information and used default rule (all possible segments)

This operation is very cheap, so if you use boundary_point_index and segment_index on same text range it is much better to create one from another rather then indexing the same range twice.

Note:
  rule() flags are not copied

## Variable Documentation

const rule_type boost::locale::boundary::word_mask = 0xFFFFF`[static]`

Full word mask - select all possible variants