Class TCompressedArray

catboost/libs/helpers/compression.h:77–235

class TCompressedArray {
public:
    TCompressedArray() = default;

    TCompressedArray(ui64 size, ui32 bitsPerKey, NCB::TMaybeOwningArrayHolder<ui64> storage)
        : Size(size)
        , IndexHelper(bitsPerKey)
        , Storage(std::move(storage))
    {}

    TCompressedArray(ui64 size, ui32 bitsPerKey, TVector<ui64>&& storage)
        : Size(size)
        , IndexHelper(bitsPerKey)
        , Storage(NCB::TMaybeOwningArrayHolder<ui64>::CreateOwning(std::move(storage)))
    {}

    // init later using GetRawArray or GetRawPtr
    static TCompressedArray CreateWithUninitializedData(ui64 size, ui32 bitsPerKey) {
        TIndexHelper<ui64> indexHelper(bitsPerKey);
        TVector<ui64> storage;
        storage.yresize(indexHelper.CompressedSize(size));
        return TCompressedArray(size, bitsPerKey, std::move(storage));
    }

    SAVELOAD(Size, IndexHelper, Storage);

    ui64 GetSize() const {
        return Size;
    }

    ui32 GetBitsPerKey() const {
        return IndexHelper.GetBitsPerKey();
    }

    template <class T = ui32>
    T operator[](ui32 index) const {
        Y_ASSERT(index < Size);
        return IndexHelper.Extract<T>(*Storage, index);
    }

    // comparison is strict by default, useful for unit tests
    bool operator==(const TCompressedArray& rhs) const {
        return EqualTo(rhs, /*strict*/ true);
    }

    template <class T>
    bool operator==(TConstArrayRef<T> rhs) const {
        static_assert(std::is_integral<T>::value);

        if (Size != rhs.size()) {
            return false;
        }

        for (auto i : xrange(Size)) {
            if ((*this)[i] != rhs[i]) {
                return false;
            }
        }