Method make

valdi_core/src/valdi_core/cpp/Text/CharacterSet.cpp:103–148

}

Ref<CharacterSet> CharacterSet::make(const CharacterRange* ranges, size_t length) {
    std::vector<CharacterRange> sortedRanges;
    if (needsSort(ranges, length)) {
        sortedRanges = std::vector<CharacterRange>(ranges, ranges + length);
        std::sort(sortedRanges.begin(), sortedRanges.end(), [](const auto& left, const auto& right) {
            return left.from < right.from;
        });

        ranges = sortedRanges.data();
    }

    std::optional<uint32_t> minOffsetIndex;
    uint32_t lastOffsetIndex = 0;
    uint32_t resolvedBitsetsCount = 0;
    processCharacters(ranges, length, [&](uint32_t offsetIndex, uint32_t bitsetsCount, uint32_t /*offsetValue*/) {
        if (!minOffsetIndex || minOffsetIndex.value() > offsetIndex) {
            minOffsetIndex = {offsetIndex};
        }
        resolvedBitsetsCount = bitsetsCount;
        lastOffsetIndex = std::max(lastOffsetIndex, offsetIndex);
    });

    auto resolvedMinOffsetIndex = minOffsetIndex ? minOffsetIndex.value() : 0;
    auto totalOffsetsCount = (lastOffsetIndex - resolvedMinOffsetIndex) + 1;
    auto totalBitsetsCount = resolvedBitsetsCount + 1;

    auto offsetsAllocSize = totalOffsetsCount * sizeof(uint16_t);
    auto bitsetsAllocSize = totalBitsetsCount * sizeof(Bitset);

    auto baseAllocSize = sizeof(CharacterSet);
    auto withOffsetsAllocSize = Valdi::alignUp(baseAllocSize + offsetsAllocSize, alignof(uint16_t));
    auto withBitsetsAllocSize = Valdi::alignUp(withOffsetsAllocSize + bitsetsAllocSize, alignof(Bitset));

    std::allocator<uint8_t> allocator;
    auto* region = allocator.allocate(withBitsetsAllocSize);
    std::memset(region, 0, withBitsetsAllocSize);

    auto* offsets = reinterpret_cast<uint16_t*>(&region[withOffsetsAllocSize - offsetsAllocSize]);
    auto* bitsets = reinterpret_cast<Bitset*>(&region[withBitsetsAllocSize - bitsetsAllocSize]);

    initializeBitsets(ranges, length, resolvedMinOffsetIndex, offsets, bitsets);

    new (region)(CharacterSet)(resolvedMinOffsetIndex, lastOffsetIndex, offsets, bitsets);

    return Ref<CharacterSet>(reinterpret_cast<CharacterSet*>(region));
}

bool CharacterSet::operator==(const CharacterSet& other) const {
    if (_minOffset != other._minOffset || _maxOffset != other._maxOffset) {