libs/minikin/LayoutSplitter.h

/*
 * Copyright (C) 2018 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef MINIKIN_LAYOUT_SPLITTER_H
#define MINIKIN_LAYOUT_SPLITTER_H

#define LOG_TAG "Minikin"

#include "minikin/Layout.h"

#include <memory>

#include <unicode/ubidi.h>

#include "minikin/Macros.h"
#include "minikin/U16StringPiece.h"

#include "LayoutUtils.h"

namespace minikin {

// LayoutSplitter split the input text into recycle-able pieces.
//
// LayoutSplitter basically splits the text before and after space characters.
//
// Here is an example of how the LayoutSplitter split the text into layout pieces.
// Input:
//   Text          : T h i s _ i s _ a n _ e x a m p l e _ t e x t .
//   Range         :            |-------------------|
//
// Output:
//   Context Range :          |---|-|---|-|-------------|
//   Piece Range   :            |-|-|---|-|---------|
//
// Input:
//   Text          : T h i s _ i s _ a n _ e x a m p l e _ t e x t .
//   Range         :                          |-------|
//
// Output:
//   Context Range :                      |-------------|
//   Piece Range   :                          |-------|
class LayoutSplitter {
public:
    LayoutSplitter(const U16StringPiece& textBuf, const Range& range, bool isRtl)
            : mTextBuf(textBuf), mRange(range), mIsRtl(isRtl) {}

    class iterator {
    public:
        bool operator==(const iterator& o) const { return mPos == o.mPos && mParent == o.mParent; }

        bool operator!=(const iterator& o) const { return !(*this == o); }

        std::pair<Range, Range> operator*() const {
            return std::make_pair(mContextRange, mPieceRange);
        }

        iterator& operator++() {
            const U16StringPiece& textBuf = mParent->mTextBuf;
            const Range& range = mParent->mRange;
            if (mParent->mIsRtl) {
                mPos = mPieceRange.getStart();
                mContextRange.setStart(getPrevWordBreakForCache(textBuf, mPos));
                mContextRange.setEnd(mPos);
                mPieceRange.setStart(std::max(mContextRange.getStart(), range.getStart()));
                mPieceRange.setEnd(mPos);
            } else {
                mPos = mPieceRange.getEnd();
                mContextRange.setStart(mPos);
                mContextRange.setEnd(getNextWordBreakForCache(textBuf, mPos));
                mPieceRange.setStart(mPos);
                mPieceRange.setEnd(std::min(mContextRange.getEnd(), range.getEnd()));
            }
            return *this;
        }

    private:
        friend class LayoutSplitter;

        iterator(const LayoutSplitter* parent, uint32_t pos) : mParent(parent), mPos(pos) {
            const U16StringPiece& textBuf = mParent->mTextBuf;
            const Range& range = mParent->mRange;
            if (parent->mIsRtl) {
                mContextRange.setStart(getPrevWordBreakForCache(textBuf, pos));
                mContextRange.setEnd(getNextWordBreakForCache(textBuf, pos == 0 ? 0 : pos - 1));
                mPieceRange.setStart(std::max(mContextRange.getStart(), range.getStart()));
                mPieceRange.setEnd(pos);
            } else {
                mContextRange.setStart(
                        getPrevWordBreakForCache(textBuf, pos == range.getEnd() ? pos : pos + 1));
                mContextRange.setEnd(getNextWordBreakForCache(textBuf, pos));
                mPieceRange.setStart(pos);
                mPieceRange.setEnd(std::min(mContextRange.getEnd(), range.getEnd()));
            }
        }

        const LayoutSplitter* mParent;
        uint32_t mPos;
        Range mContextRange;
        Range mPieceRange;
    };

    iterator begin() const { return iterator(this, mIsRtl ? mRange.getEnd() : mRange.getStart()); }
    iterator end() const { return iterator(this, mIsRtl ? mRange.getStart() : mRange.getEnd()); }

private:
    U16StringPiece mTextBuf;
    Range mRange;  // The range in the original buffer. Used for range check.
    bool mIsRtl;   // The paragraph direction.

    MINIKIN_PREVENT_COPY_AND_ASSIGN(LayoutSplitter);
};

}  // namespace minikin

#endif  // MINIKIN_LAYOUT_SPLITTER_H