1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
|
/*
* Copyright (C) 2006 Lars Knoll <lars@trolltech.com>
* Copyright (C) 2007, 2011, 2012 Apple Inc. All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*
*/
#ifndef TextBreakIterator_h
#define TextBreakIterator_h
#include <wtf/text/AtomicString.h>
#include <wtf/unicode/Unicode.h>
namespace WebCore {
class TextBreakIterator;
// Note: The returned iterator is good only until you get another iterator, with the exception of acquireLineBreakIterator.
// This is similar to character break iterator in most cases, but is subject to
// platform UI conventions. One notable example where this can be different
// from character break iterator is Thai prepend characters, see bug 24342.
// Use this for insertion point and selection manipulations.
TextBreakIterator* cursorMovementIterator(const UChar*, int length);
TextBreakIterator* wordBreakIterator(const UChar*, int length);
TextBreakIterator* acquireLineBreakIterator(const LChar*, int length, const AtomicString& locale, const UChar* priorContext, unsigned priorContextLength);
TextBreakIterator* acquireLineBreakIterator(const UChar*, int length, const AtomicString& locale, const UChar* priorContext, unsigned priorContextLength);
void releaseLineBreakIterator(TextBreakIterator*);
TextBreakIterator* sentenceBreakIterator(const UChar*, int length);
int textBreakFirst(TextBreakIterator*);
int textBreakLast(TextBreakIterator*);
int textBreakNext(TextBreakIterator*);
int textBreakPrevious(TextBreakIterator*);
int textBreakCurrent(TextBreakIterator*);
int textBreakPreceding(TextBreakIterator*, int);
int textBreakFollowing(TextBreakIterator*, int);
bool isTextBreak(TextBreakIterator*, int);
bool isWordTextBreak(TextBreakIterator*);
const int TextBreakDone = -1;
class LazyLineBreakIterator {
public:
LazyLineBreakIterator()
: m_iterator(0)
, m_cachedPriorContext(0)
, m_cachedPriorContextLength(0)
{
resetPriorContext();
}
LazyLineBreakIterator(String string, const AtomicString& locale = AtomicString())
: m_string(string)
, m_locale(locale)
, m_iterator(0)
, m_cachedPriorContext(0)
, m_cachedPriorContextLength(0)
{
resetPriorContext();
}
~LazyLineBreakIterator()
{
if (m_iterator)
releaseLineBreakIterator(m_iterator);
}
String string() const { return m_string; }
UChar lastCharacter() const
{
COMPILE_ASSERT(WTF_ARRAY_LENGTH(m_priorContext) == 2, TextBreakIterator_unexpected_prior_context_length);
return m_priorContext[1];
}
UChar secondToLastCharacter() const
{
COMPILE_ASSERT(WTF_ARRAY_LENGTH(m_priorContext) == 2, TextBreakIterator_unexpected_prior_context_length);
return m_priorContext[0];
}
void setPriorContext(UChar last, UChar secondToLast)
{
COMPILE_ASSERT(WTF_ARRAY_LENGTH(m_priorContext) == 2, TextBreakIterator_unexpected_prior_context_length);
m_priorContext[0] = secondToLast;
m_priorContext[1] = last;
}
void updatePriorContext(UChar last)
{
COMPILE_ASSERT(WTF_ARRAY_LENGTH(m_priorContext) == 2, TextBreakIterator_unexpected_prior_context_length);
m_priorContext[0] = m_priorContext[1];
m_priorContext[1] = last;
}
void resetPriorContext()
{
COMPILE_ASSERT(WTF_ARRAY_LENGTH(m_priorContext) == 2, TextBreakIterator_unexpected_prior_context_length);
m_priorContext[0] = 0;
m_priorContext[1] = 0;
}
unsigned priorContextLength() const
{
unsigned priorContextLength = 0;
COMPILE_ASSERT(WTF_ARRAY_LENGTH(m_priorContext) == 2, TextBreakIterator_unexpected_prior_context_length);
if (m_priorContext[1]) {
++priorContextLength;
if (m_priorContext[0])
++priorContextLength;
}
return priorContextLength;
}
// Obtain text break iterator, possibly previously cached, where this iterator is (or has been)
// initialized to use the previously stored string as the primary breaking context and using
// previously stored prior context if non-empty.
TextBreakIterator* get(unsigned priorContextLength)
{
ASSERT(priorContextLength <= priorContextCapacity);
const UChar* priorContext = priorContextLength ? &m_priorContext[priorContextCapacity - priorContextLength] : 0;
if (!m_iterator) {
if (m_string.is8Bit())
m_iterator = acquireLineBreakIterator(m_string.characters8(), m_string.length(), m_locale, priorContext, priorContextLength);
else
m_iterator = acquireLineBreakIterator(m_string.characters16(), m_string.length(), m_locale, priorContext, priorContextLength);
m_cachedPriorContext = priorContext;
m_cachedPriorContextLength = priorContextLength;
} else if (priorContext != m_cachedPriorContext || priorContextLength != m_cachedPriorContextLength) {
this->resetStringAndReleaseIterator(m_string, m_locale);
return this->get(priorContextLength);
}
return m_iterator;
}
void resetStringAndReleaseIterator(String string, const AtomicString& locale)
{
if (m_iterator)
releaseLineBreakIterator(m_iterator);
m_string = string;
m_locale = locale;
m_iterator = 0;
m_cachedPriorContext = 0;
m_cachedPriorContextLength = 0;
}
private:
static const unsigned priorContextCapacity = 2;
String m_string;
AtomicString m_locale;
TextBreakIterator* m_iterator;
UChar m_priorContext[priorContextCapacity];
const UChar* m_cachedPriorContext;
unsigned m_cachedPriorContextLength;
};
// Iterates over "extended grapheme clusters", as defined in UAX #29.
// Note that platform implementations may be less sophisticated - e.g. ICU prior to
// version 4.0 only supports "legacy grapheme clusters".
// Use this for general text processing, e.g. string truncation.
class NonSharedCharacterBreakIterator {
WTF_MAKE_NONCOPYABLE(NonSharedCharacterBreakIterator);
public:
NonSharedCharacterBreakIterator(const UChar*, int length);
~NonSharedCharacterBreakIterator();
operator TextBreakIterator*() const { return m_iterator; }
private:
TextBreakIterator* m_iterator;
};
// Counts the number of grapheme clusters. A surrogate pair or a sequence
// of a non-combining character and following combining characters is
// counted as 1 grapheme cluster.
unsigned numGraphemeClusters(const String&);
// Returns the number of characters which will be less than or equal to
// the specified grapheme cluster length.
unsigned numCharactersInGraphemeClusters(const String&, unsigned);
}
#endif
|
