// 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