LatinIME/native/jni/src/utils/int_array_view.h

/*
 * Copyright (C) 2014 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 LATINIME_INT_ARRAY_VIEW_H
#define LATINIME_INT_ARRAY_VIEW_H

#include <algorithm>
#include <array>
#include <cstdint>
#include <cstring>
#include <vector>

#include "defines.h"

namespace latinime {

/**
 * Helper class used to provide a read-only view of a given range of integer array. This class
 * does not take ownership of the underlying integer array but is designed to be a lightweight
 * object that obeys value semantics.
 *
 * Example:
 * <code>
 * bool constinsX(IntArrayView view) {
 *     for (size_t i = 0; i < view.size(); ++i) {
 *         if (view[i] == 'X') {
 *             return true;
 *         }
 *     }
 *     return false;
 * }
 *
 * const int codePointArray[] = { 'A', 'B', 'X', 'Z' };
 * auto view = IntArrayView(codePointArray, NELEMS(codePointArray));
 * const bool hasX = constinsX(view);
 * </code>
 */
class IntArrayView {
 public:
    IntArrayView() : mPtr(nullptr), mSize(0) {}

    IntArrayView(const int *const ptr, const size_t size)
            : mPtr(ptr), mSize(size) {}

    explicit IntArrayView(const std::vector<int> &vector)
            : mPtr(vector.data()), mSize(vector.size()) {}

    template <size_t N>
    AK_FORCE_INLINE static IntArrayView fromArray(const std::array<int, N> &array) {
        return IntArrayView(array.data(), array.size());
    }

    // Returns a view that points one int object.
    AK_FORCE_INLINE static IntArrayView singleElementView(const int *const ptr) {
        return IntArrayView(ptr, 1);
    }

    AK_FORCE_INLINE int operator[](const size_t index) const {
        ASSERT(index < mSize);
        return mPtr[index];
    }

    AK_FORCE_INLINE bool empty() const {
        return size() == 0;
    }

    AK_FORCE_INLINE size_t size() const {
        return mSize;
    }

    AK_FORCE_INLINE const int *data() const {
        return mPtr;
    }

    AK_FORCE_INLINE const int *begin() const {
        return mPtr;
    }

    AK_FORCE_INLINE const int *end() const {
        return mPtr + mSize;
    }

    AK_FORCE_INLINE bool contains(const int value) const {
        return std::find(begin(), end(), value) != end();
    }

    // Returns the view whose size is smaller than or equal to the given count.
    AK_FORCE_INLINE const IntArrayView limit(const size_t maxSize) const {
        return IntArrayView(mPtr, std::min(maxSize, mSize));
    }

    AK_FORCE_INLINE const IntArrayView skip(const size_t n) const {
        if (mSize <= n) {
            return IntArrayView();
        }
        return IntArrayView(mPtr + n, mSize - n);
    }

    template <size_t N>
    void copyToArray(std::array<int, N> *const buffer, const size_t offset) const {
        ASSERT(mSize + offset <= N);
        memmove(buffer->data() + offset, mPtr, sizeof(int) * mSize);
    }

    AK_FORCE_INLINE int firstOrDefault(const int defaultValue) const {
        if (empty()) {
            return defaultValue;
        }
        return mPtr[0];
    }

    AK_FORCE_INLINE int lastOrDefault(const int defaultValue) const {
        if (empty()) {
            return defaultValue;
        }
        return mPtr[mSize - 1];
    }

    AK_FORCE_INLINE std::vector<int> toVector() const {
        return std::vector<int>(begin(), end());
    }

    std::vector<IntArrayView> split(const int separator, const int limit = S_INT_MAX) const {
        if (limit <= 0) {
            return std::vector<IntArrayView>();
        }
        std::vector<IntArrayView> result;
        if (limit == 1) {
            result.emplace_back(mPtr, mSize);
            return result;
        }
        size_t startIndex = 0;
        for (size_t i = 0; i < mSize; ++i) {
            if (mPtr[i] == separator) {
                result.emplace_back(mPtr + startIndex, i - startIndex);
                startIndex = i + 1;
                if (result.size() >= static_cast<size_t>(limit - 1)) {
                    break;
                }
            }
        }
        result.emplace_back(mPtr + startIndex, mSize - startIndex);
        return result;
    }

 private:
    DISALLOW_ASSIGNMENT_OPERATOR(IntArrayView);

    const int *const mPtr;
    const size_t mSize;
};

using WordIdArrayView = IntArrayView;
using PtNodePosArrayView = IntArrayView;
using CodePointArrayView = IntArrayView;
template <size_t size>
using WordIdArray = std::array<int, size>;

} // namespace latinime
#endif // LATINIME_MEMORY_VIEW_H