// Copyright (C) 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html

// file: rbbi_cache.h
//
#ifndef RBBI_CACHE_H
#define RBBI_CACHE_H

#include "unicode/utypes.h"

// #if !UCONFIG_NO_BREAK_ITERATION

// #include "unicode/rbbi.h"
// #include "unicode/uobject.h"

// #include "uvectr32.h"

// U_NAMESPACE_BEGIN

// /* DictionaryCache  stores the boundaries obtained from a run of dictionary characters.
//  *                 Dictionary boundaries are moved first to this cache, then from here
//  *                 to the main BreakCache, where they may inter-leave with non-dictionary
//  *                 boundaries. The public BreakIterator API always fetches directly
//  *                 from the main BreakCache, not from here.
//  *
//  *                 In common situations, the number of boundaries in a single dictionary run
//  *                 should be quite small, it will be terminated by punctuation, spaces,
//  *                 or any other non-dictionary characters. The main BreakCache may end
//  *                 up with boundaries from multiple dictionary based runs.
//  *
//  *                 The boundaries are stored in a simple ArrayList (vector), with the
//  *                 assumption that they will be accessed sequentially.
//  */
// class RuleBasedBreakIterator::DictionaryCache: public UMemory {
//   public:
//      DictionaryCache(RuleBasedBreakIterator *bi, UErrorCode &status);
//      ~DictionaryCache();

//      void reset();

//      UBool following(int32_t fromPos, int32_t *pos, int32_t *statusIndex);
//      UBool preceding(int32_t fromPos, int32_t *pos, int32_t *statusIndex);

//     /**
//      * Populate the cache with the dictionary based boundaries within a region of text.
//      * @param startPos  The start position of a range of text
//      * @param endPos    The end position of a range of text
//      * @param firstRuleStatus The rule status index that applies to the break at startPos
//      * @param otherRuleStatus The rule status index that applies to boundaries other than startPos
//      * @internal
//      */
//     void populateDictionary(int32_t startPos, int32_t endPos,
//                          int32_t firstRuleStatus, int32_t otherRuleStatus);



//     RuleBasedBreakIterator *fBI;

//     UVector32           fBreaks;                // A vector containing the boundaries.
//     int32_t             fPositionInCache;       // Index in fBreaks of last boundary returned by following()
//                                                 //    or preceding(). Optimizes sequential access.
//     int32_t             fStart;                 // Text position of first boundary in cache.
//     int32_t             fLimit;                 // Last boundary in cache. Which is the limit of the
//                                                 //    text segment being handled by the dictionary.
//     int32_t             fFirstRuleStatusIndex;  // Rule status info for first boundary.
//     int32_t             fOtherRuleStatusIndex;  // Rule status info for 2nd through last boundaries.
// };


// /*
//  * class BreakCache
//  *
//  * Cache of break boundary positions and rule status values.
//  * Break iterator API functions, next(), previous(), etc., will use cached results
//  * when possible, and otherwise cache new results as they are obtained.
//  *
//  * Uniformly caches both dictionary and rule based (non-dictionary) boundaries.
//  *
//  * The cache is implemented as a single circular buffer.
//  */

// /*
//  * size of the circular cache buffer.
//  */

// class RuleBasedBreakIterator::BreakCache: public UMemory {
//   public:
//                 BreakCache(RuleBasedBreakIterator *bi, UErrorCode &status);
//     virtual     ~BreakCache();
//     void        reset(int32_t pos = 0, int32_t ruleStatus = 0);
//     void        next() {    if (fBufIdx == fEndBufIdx) {
//                                 nextOL();
//                             } else {
//                                 fBufIdx = modChunkSize(fBufIdx + 1);
//                                 fTextIdx = fBI->fPosition = fBoundaries[fBufIdx];
//                                 fBI->fRuleStatusIndex = fStatuses[fBufIdx];
//                             }
//                 }


//     void        nextOL();
//     void        previous(UErrorCode &status);

//     // Move the iteration state to the position following the startPosition.
//     // Input position must be pinned to the input length.
//     void        following(int32_t startPosition, UErrorCode &status);

//     void        preceding(int32_t startPosition, UErrorCode &status);

//     /*
//      * Update the state of the public BreakIterator (fBI) to reflect the
//      * current state of the break iterator cache (this).
//      */
//     int32_t     current();

//     /**
//      * Add boundaries to the cache near the specified position.
//      * The given position need not be a boundary itself.
//      * The input position must be within the range of the text, and
//      * on a code point boundary.
//      * If the requested position is a break boundary, leave the iteration
//      * position on it.
//      * If the requested position is not a boundary, leave the iteration
//      * position on the preceding boundary and include both the
//      * preceding and following boundaries in the cache.
//      * Additional boundaries, either preceding or following, may be added
//      * to the cache as a side effect.
//      *
//      * Return FALSE if the operation failed.
//      */
//     UBool populateNear(int32_t position, UErrorCode &status);

//     /**
//      *  Add boundary(s) to the cache following the current last boundary.
//      *  Return FALSE if at the end of the text, and no more boundaries can be added.
//      *  Leave iteration position at the first newly added boundary, or unchanged if no boundary was added.
//      */
//     UBool populateFollowing();

//     /**
//      *  Add one or more boundaries to the cache preceding the first currently cached boundary.
//      *  Leave the iteration position on the first added boundary.
//      *  Return false if no boundaries could be added (if at the start of the text.)
//      */
//     UBool populatePreceding(UErrorCode &status);

//     enum UpdatePositionValues {
//         RetainCachePosition = 0,
//         UpdateCachePosition = 1
//     };

//     /*
//      * Add the boundary following the current position.
//      * The current position can be left as it was, or changed to the newly added boundary,
//      * as specified by the update parameter.
//      */
//     void addFollowing(int32_t position, int32_t ruleStatusIdx, UpdatePositionValues update);


//     /*
//      * Add the boundary preceding the current position.
//      * The current position can be left as it was, or changed to the newly added boundary,
//      * as specified by the update parameter.
//      */
//     bool addPreceding(int32_t position, int32_t ruleStatusIdx, UpdatePositionValues update);

//     /**
//      *  Set the cache position to the specified position, or, if the position
//      *  falls between to cached boundaries, to the preceding boundary.
//      *  Fails if the requested position is outside of the range of boundaries currently held by the cache.
//      *  The startPosition must be on a code point boundary.
//      *
//      *  Return TRUE if successful, FALSE if the specified position is after
//      *  the last cached boundary or before the first.
//      */
//     UBool                   seek(int32_t startPosition);

//     void dumpCache();

//   private:
//     static inline int32_t   modChunkSize(int index) { return index & (CACHE_SIZE - 1); }

//     static constexpr int32_t CACHE_SIZE = 128;
//     static_assert((CACHE_SIZE & (CACHE_SIZE-1)) == 0, "CACHE_SIZE must be power of two.");

//     RuleBasedBreakIterator *fBI;
//     int32_t                 fStartBufIdx;
//     int32_t                 fEndBufIdx;    // inclusive

//     int32_t                 fTextIdx;
//     int32_t                 fBufIdx;

//     int32_t                 fBoundaries[CACHE_SIZE];
//     uint16_t                fStatuses[CACHE_SIZE];

//     UVector32               fSideBuffer;
// };

// U_NAMESPACE_END

// #endif // #if !UCONFIG_NO_BREAK_ITERATION

// #endif // RBBI_CACHE_H
