• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Copyright (C) 2016 and later: Unicode, Inc. and others.
2 // License & terms of use: http://www.unicode.org/copyright.html
3 
4 // file: rbbi_cache.h
5 //
6 #ifndef RBBI_CACHE_H
7 #define RBBI_CACHE_H
8 
9 #include "unicode/utypes.h"
10 
11 #if !UCONFIG_NO_BREAK_ITERATION
12 
13 #include "unicode/rbbi.h"
14 #include "unicode/uobject.h"
15 
16 #include "uvectr32.h"
17 
18 U_NAMESPACE_BEGIN
19 
20 /* DictionaryCache  stores the boundaries obtained from a run of dictionary characters.
21  *                 Dictionary boundaries are moved first to this cache, then from here
22  *                 to the main BreakCache, where they may inter-leave with non-dictionary
23  *                 boundaries. The public BreakIterator API always fetches directly
24  *                 from the main BreakCache, not from here.
25  *
26  *                 In common situations, the number of boundaries in a single dictionary run
27  *                 should be quite small, it will be terminated by punctuation, spaces,
28  *                 or any other non-dictionary characters. The main BreakCache may end
29  *                 up with boundaries from multiple dictionary based runs.
30  *
31  *                 The boundaries are stored in a simple ArrayList (vector), with the
32  *                 assumption that they will be accessed sequentially.
33  */
34 class RuleBasedBreakIterator::DictionaryCache: public UMemory {
35   public:
36      DictionaryCache(RuleBasedBreakIterator *bi, UErrorCode &status);
37      ~DictionaryCache();
38 
39      void reset();
40 
41      UBool following(int32_t fromPos, int32_t *pos, int32_t *statusIndex);
42      UBool preceding(int32_t fromPos, int32_t *pos, int32_t *statusIndex);
43 
44     /**
45      * Populate the cache with the dictionary based boundaries within a region of text.
46      * @param startPos  The start position of a range of text
47      * @param endPos    The end position of a range of text
48      * @param firstRuleStatus The rule status index that applies to the break at startPos
49      * @param otherRuleStatus The rule status index that applies to boundaries other than startPos
50      * @internal
51      */
52     void populateDictionary(int32_t startPos, int32_t endPos,
53                          int32_t firstRuleStatus, int32_t otherRuleStatus);
54 
55 
56 
57     RuleBasedBreakIterator *fBI;
58 
59     UVector32           fBreaks;                // A vector containing the boundaries.
60     int32_t             fPositionInCache;       // Index in fBreaks of last boundary returned by following()
61                                                 //    or preceding(). Optimizes sequential access.
62     int32_t             fStart;                 // Text position of first boundary in cache.
63     int32_t             fLimit;                 // Last boundary in cache. Which is the limit of the
64                                                 //    text segment being handled by the dictionary.
65     int32_t             fFirstRuleStatusIndex;  // Rule status info for first boundary.
66     int32_t             fOtherRuleStatusIndex;  // Rule status info for 2nd through last boundaries.
67 };
68 
69 
70 /*
71  * class BreakCache
72  *
73  * Cache of break boundary positions and rule status values.
74  * Break iterator API functions, next(), previous(), etc., will use cached results
75  * when possible, and otherwise cache new results as they are obtained.
76  *
77  * Uniformly caches both dictionary and rule based (non-dictionary) boundaries.
78  *
79  * The cache is implemented as a single circular buffer.
80  */
81 
82 /*
83  * size of the circular cache buffer.
84  */
85 
86 class RuleBasedBreakIterator::BreakCache: public UMemory {
87   public:
88                 BreakCache(RuleBasedBreakIterator *bi, UErrorCode &status);
89     virtual     ~BreakCache();
90     void        reset(int32_t pos = 0, int32_t ruleStatus = 0);
next()91     void        next() {    if (fBufIdx == fEndBufIdx) {
92                                 nextOL();
93                             } else {
94                                 fBufIdx = modChunkSize(fBufIdx + 1);
95                                 fTextIdx = fBI->fPosition = fBoundaries[fBufIdx];
96                                 fBI->fRuleStatusIndex = fStatuses[fBufIdx];
97                             }
98                 };
99 
100 
101     void        nextOL();
102     void        previous(UErrorCode &status);
103 
104     // Move the iteration state to the position following the startPosition.
105     // Input position must be pinned to the input length.
106     void        following(int32_t startPosition, UErrorCode &status);
107 
108     void        preceding(int32_t startPosition, UErrorCode &status);
109 
110     /*
111      * Update the state of the public BreakIterator (fBI) to reflect the
112      * current state of the break iterator cache (this).
113      */
114     int32_t     current();
115 
116     /**
117      * Add boundaries to the cache near the specified position.
118      * The given position need not be a boundary itself.
119      * The input position must be within the range of the text, and
120      * on a code point boundary.
121      * If the requested position is a break boundary, leave the iteration
122      * position on it.
123      * If the requested position is not a boundary, leave the iteration
124      * position on the preceding boundary and include both the
125      * preceding and following boundaries in the cache.
126      * Additional boundaries, either preceding or following, may be added
127      * to the cache as a side effect.
128      *
129      * Return FALSE if the operation failed.
130      */
131     UBool populateNear(int32_t position, UErrorCode &status);
132 
133     /**
134      *  Add boundary(s) to the cache following the current last boundary.
135      *  Return FALSE if at the end of the text, and no more boundaries can be added.
136      *  Leave iteration position at the first newly added boundary, or unchanged if no boundary was added.
137      */
138     UBool populateFollowing();
139 
140     /**
141      *  Add one or more boundaries to the cache preceding the first currently cached boundary.
142      *  Leave the iteration position on the first added boundary.
143      *  Return false if no boundaries could be added (if at the start of the text.)
144      */
145     UBool populatePreceding(UErrorCode &status);
146 
147     enum UpdatePositionValues {
148         RetainCachePosition = 0,
149         UpdateCachePosition = 1
150     };
151 
152     /*
153      * Add the boundary following the current position.
154      * The current position can be left as it was, or changed to the newly added boundary,
155      * as specified by the update parameter.
156      */
157     void addFollowing(int32_t position, int32_t ruleStatusIdx, UpdatePositionValues update);
158 
159 
160     /*
161      * Add the boundary preceding the current position.
162      * The current position can be left as it was, or changed to the newly added boundary,
163      * as specified by the update parameter.
164      */
165     bool addPreceding(int32_t position, int32_t ruleStatusIdx, UpdatePositionValues update);
166 
167     /**
168      *  Set the cache position to the specified position, or, if the position
169      *  falls between to cached boundaries, to the preceding boundary.
170      *  Fails if the requested position is outside of the range of boundaries currently held by the cache.
171      *  The startPosition must be on a code point boundary.
172      *
173      *  Return TRUE if successful, FALSE if the specified position is after
174      *  the last cached boundary or before the first.
175      */
176     UBool                   seek(int32_t startPosition);
177 
178     void dumpCache();
179 
180   private:
modChunkSize(int index)181     static inline int32_t   modChunkSize(int index) { return index & (CACHE_SIZE - 1); };
182 
183     static constexpr int32_t CACHE_SIZE = 128;
184     static_assert((CACHE_SIZE & (CACHE_SIZE-1)) == 0, "CACHE_SIZE must be power of two.");
185 
186     RuleBasedBreakIterator *fBI;
187     int32_t                 fStartBufIdx;
188     int32_t                 fEndBufIdx;    // inclusive
189 
190     int32_t                 fTextIdx;
191     int32_t                 fBufIdx;
192 
193     int32_t                 fBoundaries[CACHE_SIZE];
194     uint16_t                fStatuses[CACHE_SIZE];
195 
196     UVector32               fSideBuffer;
197 };
198 
199 U_NAMESPACE_END
200 
201 #endif // #if !UCONFIG_NO_BREAK_ITERATION
202 
203 #endif // RBBI_CACHE_H
204