ecmascript/js_api/js_api_bitvector.cpp

/*
 * Copyright (c) 2024 Huawei Device Co., Ltd.
 * 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.
 */

#include "ecmascript/js_api/js_api_bitvector.h"

#include "ecmascript/tagged_array-inl.h"
#include "ecmascript/shared_objects/concurrent_api_scope.h"

namespace panda::ecmascript {
using ContainerError = containers::ContainerError;
using ErrorFlag = containers::ErrorFlag;
bool JSAPIBitVector::Push(
    JSThread* thread, const JSHandle<JSAPIBitVector>& bitVector, const JSHandle<JSTaggedValue>& value)
{
    [[maybe_unused]] ConcurrentApiScope<JSAPIBitVector, ModType::WRITE> scope(thread,
        JSHandle<JSTaggedValue>::Cast(bitVector));
    uint32_t length = static_cast<uint32_t>(bitVector->GetLength());
    JSHandle<JSNativePointer> np(thread, bitVector->GetNativePointer(thread));
    auto elements = reinterpret_cast<std::vector<std::bitset<BIT_SET_LENGTH>>*>(np->GetExternalPointer());
    if ((length & TAGGED_VALUE_BIT_OFFSET) == 0) {
        std::bitset<BIT_SET_LENGTH> increaseSet;
        if (!value->IsZero()) {
            increaseSet.set(0);
        }
        elements->push_back(increaseSet);
    } else {
        SetBit(elements, length, value.GetTaggedValue());
    }
    bitVector->SetLength(++length);
    return true;
}

JSTaggedValue JSAPIBitVector::Pop(JSThread* thread, const JSHandle<JSAPIBitVector>& bitVector)
{
    [[maybe_unused]] ConcurrentApiScope<JSAPIBitVector, ModType::WRITE> scope(thread,
        JSHandle<JSTaggedValue>::Cast(bitVector));
    if (bitVector->GetLength() <= 0) {
        return JSTaggedValue::Undefined();
    }
    uint32_t lastIndex = static_cast<uint32_t>(bitVector->GetLength() - 1);
    JSHandle<JSNativePointer> np(thread, bitVector->GetNativePointer(thread));
    auto elements = reinterpret_cast<std::vector<std::bitset<BIT_SET_LENGTH>>*>(np->GetExternalPointer());

    JSTaggedValue bit = GetBit(elements, lastIndex);
    if ((lastIndex & TAGGED_VALUE_BIT_OFFSET) == 0) {
        elements->pop_back();
    } else {
        SetBit(elements, lastIndex, JSTaggedValue(0));
    }
    bitVector->SetLength(lastIndex);
    return bit;
}

JSTaggedValue JSAPIBitVector::Set(JSThread* thread, const uint32_t index, JSTaggedValue value)
{
    uint32_t length = static_cast<uint32_t>(GetLength());
    if (index >= length) {
        std::ostringstream oss;
        oss << "The value of \"index\" is out of range. It must be >= 0 && <= " << (length - 1)
            << ". Received value is: " << index;
        JSTaggedValue error = ContainerError::BusinessError(thread, ErrorFlag::RANGE_ERROR, oss.str().c_str());
        THROW_NEW_ERROR_AND_RETURN_VALUE(thread, error, JSTaggedValue::Exception());
    }
    JSNativePointer* np = JSNativePointer::Cast(GetNativePointer(thread).GetTaggedObject());
    auto elements = reinterpret_cast<std::vector<std::bitset<BIT_SET_LENGTH>>*>(np->GetExternalPointer());
    SetBit(elements, index, value);
    return JSTaggedValue::Undefined();
}

JSTaggedValue JSAPIBitVector::Get(JSThread* thread, const uint32_t index)
{
    uint32_t length = static_cast<uint32_t>(GetLength());
    if (index >= length) {
        std::ostringstream oss;
        oss << "The value of \"index\" is out of range. It must be >= 0 && <= " << (length - 1)
            << ". Received value is: " << index;
        JSTaggedValue error = ContainerError::BusinessError(thread, ErrorFlag::RANGE_ERROR, oss.str().c_str());
        THROW_NEW_ERROR_AND_RETURN_VALUE(thread, error, JSTaggedValue::Exception());
    }
    JSNativePointer* np = JSNativePointer::Cast(GetNativePointer(thread).GetTaggedObject());
    auto elements = reinterpret_cast<std::vector<std::bitset<BIT_SET_LENGTH>>*>(np->GetExternalPointer());
    return GetBit(elements, index);
}

bool JSAPIBitVector::Has(JSThread* thread, const JSHandle<JSAPIBitVector>& bitVector,
    const JSHandle<JSTaggedValue>& value, const JSHandle<JSTaggedValue>& start, const JSHandle<JSTaggedValue>& end)
{
    int32_t startIndex = JSTaggedValue::ToInt32(thread, start);
    int32_t endIndex = JSTaggedValue::ToInt32(thread, end);
    int32_t length = bitVector->GetLength();
    int32_t size = length > endIndex ? endIndex : length;
    if (endIndex < 0 || endIndex > length) {
        std::ostringstream oss;
        oss << "The value of \"toIndex\" is out of range. It must be >= 0 && <= " << length
            << ". Received value is: " << endIndex;
        JSTaggedValue error = ContainerError::BusinessError(thread, ErrorFlag::RANGE_ERROR, oss.str().c_str());
        THROW_NEW_ERROR_AND_RETURN_VALUE(thread, error, false);
    }
    if (startIndex < 0 || startIndex >= size) {
        std::ostringstream oss;
        oss << "The value of \"fromIndex\" is out of range. It must be >= 0 && <= " << (size - 1)
            << ". Received value is: " << startIndex;
        JSTaggedValue error = ContainerError::BusinessError(thread, ErrorFlag::RANGE_ERROR, oss.str().c_str());
        THROW_NEW_ERROR_AND_RETURN_VALUE(thread, error, false);
    }
    if (length == 0) {
        return false;
    }
    JSHandle<JSNativePointer> np(thread, bitVector->GetNativePointer(thread));
    auto elements = reinterpret_cast<std::vector<std::bitset<BIT_SET_LENGTH>>*>(np->GetExternalPointer());
    for (int index = startIndex; index <= endIndex; index++) {
        std::pair<uint32_t, uint32_t> pair = ComputeElementIdAndBitId(index);
        uint32_t elementId = pair.first;
        uint32_t bitId = pair.second;
        if ((value->IsZero() && (*elements)[elementId].test(bitId) == 0) ||
            (!value->IsZero() && (*elements)[elementId].test(bitId) != 0)) {
            return true;
        }
    }
    return false;
}

bool JSAPIBitVector::Has(JSThread* thread, const JSTaggedValue& value) const
{
    uint32_t length = GetSize();
    if (length == 0) {
        return false;
    }
    JSNativePointer* np = JSNativePointer::Cast(GetNativePointer(thread).GetTaggedObject());
    auto elements = reinterpret_cast<std::vector<std::bitset<BIT_SET_LENGTH>>*>(np->GetExternalPointer());
    for (uint32_t index = 0; index < length; index++) {
        std::pair<uint32_t, uint32_t> pair = ComputeElementIdAndBitId(index);
        uint32_t elementId = pair.first;
        uint32_t bitId = pair.second;
        if ((value.IsZero() && (*elements)[elementId].test(bitId) == 0) ||
            (!value.IsZero() && (*elements)[elementId].test(bitId) != 0)) {
            return true;
        }
    }
    return false;
}

JSTaggedValue JSAPIBitVector::SetBitsByRange(JSThread* thread, const JSHandle<JSAPIBitVector>& bitVector,
    const JSHandle<JSTaggedValue>& value, const JSHandle<JSTaggedValue>& start, const JSHandle<JSTaggedValue>& end)
{
    [[maybe_unused]] ConcurrentApiScope<JSAPIBitVector, ModType::WRITE> scope(thread,
        JSHandle<JSTaggedValue>::Cast(bitVector));
    int32_t startIndex = JSTaggedValue::ToInt32(thread, start);
    int32_t endIndex = JSTaggedValue::ToInt32(thread, end);
    int32_t length = bitVector->GetLength();
    int32_t size = length > endIndex ? endIndex : length;
    if (endIndex < 0 || endIndex > length) {
        std::ostringstream oss;
        oss << "The value of \"toIndex\" is out of range. It must be >= 0 && <= " << length
            << ". Received value is: " << endIndex;
        JSTaggedValue error = ContainerError::BusinessError(thread, ErrorFlag::RANGE_ERROR, oss.str().c_str());
        THROW_NEW_ERROR_AND_RETURN_VALUE(thread, error, JSTaggedValue::Exception());
    }
    if (startIndex < 0 || startIndex >= size) {
        std::ostringstream oss;
        oss << "The value of \"fromIndex\" is out of range. It must be >= 0 && <= " << (size - 1)
            << ". Received value is: " << startIndex;
        JSTaggedValue error = ContainerError::BusinessError(thread, ErrorFlag::RANGE_ERROR, oss.str().c_str());
        THROW_NEW_ERROR_AND_RETURN_VALUE(thread, error, JSTaggedValue::Exception());
    }

    JSHandle<JSNativePointer> np(thread, bitVector->GetNativePointer(thread));
    auto elements = reinterpret_cast<std::vector<std::bitset<BIT_SET_LENGTH>>*>(np->GetExternalPointer());
    for (int32_t index = startIndex; index < endIndex; index++) {
        SetBit(elements, index, value.GetTaggedValue());
    }
    return JSTaggedValue::Undefined();
}

JSTaggedValue JSAPIBitVector::GetBitsByRange(JSThread* thread, const JSHandle<JSAPIBitVector>& bitVector,
    const JSHandle<JSTaggedValue>& start, const JSHandle<JSTaggedValue>& end)
{
    [[maybe_unused]] ConcurrentApiScope<JSAPIBitVector, ModType::WRITE> scope(thread,
        JSHandle<JSTaggedValue>::Cast(bitVector));
    int32_t startIndex = JSTaggedValue::ToInt32(thread, start);
    int32_t endIndex = JSTaggedValue::ToInt32(thread, end);
    int32_t length = bitVector->GetLength();
    int32_t size = length > endIndex ? endIndex : length;
    if (endIndex < 0 || endIndex > length) {
        std::ostringstream oss;
        oss << "The value of \"toIndex\" is out of range. It must be >= 0 && <= " << length
            << ". Received value is: " << endIndex;
        JSTaggedValue error = ContainerError::BusinessError(thread, ErrorFlag::RANGE_ERROR, oss.str().c_str());
        THROW_NEW_ERROR_AND_RETURN_VALUE(thread, error, JSTaggedValue::Exception());
    }
    if (startIndex < 0 || startIndex >= size) {
        std::ostringstream oss;
        oss << "The value of \"fromIndex\" is out of range. It must be >= 0 && <= " << (size - 1)
            << ". Received value is: " << startIndex;
        JSTaggedValue error = ContainerError::BusinessError(thread, ErrorFlag::RANGE_ERROR, oss.str().c_str());
        THROW_NEW_ERROR_AND_RETURN_VALUE(thread, error, JSTaggedValue::Exception());
    }
    int32_t dstLength = endIndex - startIndex;
    auto factory = thread->GetEcmaVM()->GetFactory();
    JSHandle<JSNativePointer> srcNp(thread, bitVector->GetNativePointer(thread));
    auto srcElements = reinterpret_cast<std::vector<std::bitset<BIT_SET_LENGTH>>*>(srcNp->GetExternalPointer());

    JSHandle<JSAPIBitVector> newBitVector = factory->NewJSAPIBitVector(dstLength);
    JSHandle<JSNativePointer> dstNp(thread, newBitVector->GetNativePointer(thread));
    auto dstElements = reinterpret_cast<std::vector<std::bitset<BIT_SET_LENGTH>>*>(dstNp->GetExternalPointer());

    for (int32_t index = 0; index < dstLength; index++) {
        JSTaggedValue value = GetBit(srcElements, index + startIndex);
        SetBit(dstElements, index, value);
    }
    newBitVector->SetLength(dstLength);
    newBitVector->SetNativePointer(thread, dstNp);

    return newBitVector.GetTaggedValue();
}

JSTaggedValue JSAPIBitVector::SetAllBits(
    JSThread* thread, const JSHandle<JSAPIBitVector>& bitVector, const JSHandle<JSTaggedValue>& value)
{
    [[maybe_unused]] ConcurrentApiScope<JSAPIBitVector, ModType::WRITE> scope(thread,
        JSHandle<JSTaggedValue>::Cast(bitVector));
    JSHandle<JSNativePointer> np(thread, bitVector->GetNativePointer(thread));
    auto elements = reinterpret_cast<std::vector<std::bitset<BIT_SET_LENGTH>>*>(np->GetExternalPointer());
    int size = static_cast<int>(elements->size());
    if (value->IsZero()) {
        for (int index = 0; index < size; index++) {
            (*elements)[index] = std::bitset<BIT_SET_LENGTH>(0);
        }
    } else {
        for (int index = 0; index < size; index++) {
            (*elements)[index] = std::bitset<BIT_SET_LENGTH>(UINT64_MAX);
        }
    }
    return JSTaggedValue::Undefined();
}

JSTaggedValue JSAPIBitVector::GetBitCountByRange(JSThread* thread, const JSHandle<JSAPIBitVector>& bitVector,
    const JSHandle<JSTaggedValue>& value, const JSHandle<JSTaggedValue>& start, const JSHandle<JSTaggedValue>& end)
{
    [[maybe_unused]] ConcurrentApiScope<JSAPIBitVector> scope(thread, JSHandle<JSTaggedValue>::Cast(bitVector));
    int32_t startIndex = JSTaggedValue::ToInt32(thread, start);
    int32_t endIndex = JSTaggedValue::ToInt32(thread, end);
    int32_t length = bitVector->GetLength();
    int32_t size = length > endIndex ? endIndex : length;
    int32_t count = 0;
    if (endIndex < 0 || endIndex > length) {
        std::ostringstream oss;
        oss << "The value of \"toIndex\" is out of range. It must be >= 0 && <= " << length
            << ". Received value is: " << endIndex;
        JSTaggedValue error = ContainerError::BusinessError(thread, ErrorFlag::RANGE_ERROR, oss.str().c_str());
        THROW_NEW_ERROR_AND_RETURN_VALUE(thread, error, JSTaggedValue::Exception());
    }
    if (startIndex < 0 || startIndex >= size) {
        std::ostringstream oss;
        oss << "The value of \"fromIndex\" is out of range. It must be >= 0 && <= " << (size - 1)
            << ". Received value is: " << startIndex;
        JSTaggedValue error = ContainerError::BusinessError(thread, ErrorFlag::RANGE_ERROR, oss.str().c_str());
        THROW_NEW_ERROR_AND_RETURN_VALUE(thread, error, JSTaggedValue::Exception());
    }
    JSHandle<JSNativePointer> np(thread, bitVector->GetNativePointer(thread));
    auto elements = reinterpret_cast<std::vector<std::bitset<BIT_SET_LENGTH>>*>(np->GetExternalPointer());
    for (int32_t index = startIndex; index < endIndex; index++) {
        std::pair<uint32_t, uint32_t> pair = ComputeElementIdAndBitId(index);
        uint32_t elementId = pair.first;
        uint32_t bitId = pair.second;
        if ((value->IsZero() && (*elements)[elementId].test(bitId) == 0) ||
            (!value->IsZero() && (*elements)[elementId].test(bitId) != 0)) {
            count++;
        }
    }
    return JSTaggedValue(count);
}

int JSAPIBitVector::GetIndexOf(JSThread* thread, const JSHandle<JSAPIBitVector>& bitVector,
    const JSHandle<JSTaggedValue>& value, const JSHandle<JSTaggedValue>& start, const JSHandle<JSTaggedValue>& end)
{
    [[maybe_unused]] ConcurrentApiScope<JSAPIBitVector> scope(thread, JSHandle<JSTaggedValue>::Cast(bitVector));
    int32_t startIndex = JSTaggedValue::ToInt32(thread, start);
    int32_t endIndex = JSTaggedValue::ToInt32(thread, end);
    int32_t length = bitVector->GetLength();
    int32_t size = length > endIndex ? endIndex : length;
    if (endIndex < 0 || endIndex > length) {
        std::ostringstream oss;
        oss << "The value of \"toIndex\" is out of range. It must be >= 0 && <= " << length
            << ". Received value is: " << endIndex;
        JSTaggedValue error = ContainerError::BusinessError(thread, ErrorFlag::RANGE_ERROR, oss.str().c_str());
        THROW_NEW_ERROR_AND_RETURN_VALUE(thread, error, -1);
    }
    if (startIndex < 0 || startIndex >= size) {
        std::ostringstream oss;
        oss << "The value of \"fromIndex\" is out of range. It must be >= 0 && <= " << (size - 1)
            << ". Received value is: " << startIndex;
        JSTaggedValue error = ContainerError::BusinessError(thread, ErrorFlag::RANGE_ERROR, oss.str().c_str());
        THROW_NEW_ERROR_AND_RETURN_VALUE(thread, error, -1);
    }
    JSHandle<JSNativePointer> np(thread, bitVector->GetNativePointer(thread));
    auto elements = reinterpret_cast<std::vector<std::bitset<BIT_SET_LENGTH>>*>(np->GetExternalPointer());
    for (int32_t index = startIndex; index < endIndex; index++) {
        std::pair<uint32_t, uint32_t> pair = ComputeElementIdAndBitId(index);
        uint32_t elementId = pair.first;
        uint32_t bitId = pair.second;
        if ((value->IsZero() && (*elements)[elementId].test(bitId) == 0) ||
            (!value->IsZero() && (*elements)[elementId].test(bitId) != 0)) {
            return index;
        }
    }
    return -1;
}

int JSAPIBitVector::GetLastIndexOf(JSThread* thread, const JSHandle<JSAPIBitVector>& bitVector,
    const JSHandle<JSTaggedValue>& value, const JSHandle<JSTaggedValue>& start, const JSHandle<JSTaggedValue>& end)
{
    [[maybe_unused]] ConcurrentApiScope<JSAPIBitVector> scope(thread, JSHandle<JSTaggedValue>::Cast(bitVector));
    int32_t startIndex = JSTaggedValue::ToInt32(thread, start);
    int32_t endIndex = JSTaggedValue::ToInt32(thread, end);
    int32_t length = bitVector->GetLength();
    int32_t size = length > endIndex ? endIndex : length;
    if (endIndex < 0 || endIndex > length) {
        std::ostringstream oss;
        oss << "The value of \"toIndex\" is out of range. It must be >= 0 && <= " << length
            << ". Received value is: " << endIndex;
        JSTaggedValue error = ContainerError::BusinessError(thread, ErrorFlag::RANGE_ERROR, oss.str().c_str());
        THROW_NEW_ERROR_AND_RETURN_VALUE(thread, error, -1);
    }
    if (startIndex < 0 || startIndex >= size) {
        std::ostringstream oss;
        oss << "The value of \"fromIndex\" is out of range. It must be >= 0 && <= " << (size - 1)
            << ". Received value is: " << startIndex;
        JSTaggedValue error = ContainerError::BusinessError(thread, ErrorFlag::RANGE_ERROR, oss.str().c_str());
        THROW_NEW_ERROR_AND_RETURN_VALUE(thread, error, -1);
    }
    JSHandle<JSNativePointer> np(thread, bitVector->GetNativePointer(thread));
    auto elements = reinterpret_cast<std::vector<std::bitset<BIT_SET_LENGTH>>*>(np->GetExternalPointer());
    for (int32_t index = endIndex - 1; index >= startIndex; index--) {
        std::pair<uint32_t, uint32_t> pair = ComputeElementIdAndBitId(index);
        uint32_t elementId = pair.first;
        uint32_t bitId = pair.second;
        if ((value->IsZero() && (*elements)[elementId].test(bitId) == 0) ||
            (!value->IsZero() && (*elements)[elementId].test(bitId) != 0)) {
            return index;
        }
    }
    return -1;
}

JSTaggedValue JSAPIBitVector::FlipBitByIndex(JSThread* thread, const JSHandle<JSAPIBitVector>& bitVector, int index)
{
    [[maybe_unused]] ConcurrentApiScope<JSAPIBitVector, ModType::WRITE> scope(thread,
        JSHandle<JSTaggedValue>::Cast(bitVector));
    if (index >= bitVector->GetLength() || index < 0) {
        std::ostringstream oss;
        oss << "The value of \"index\" is out of range. It must be >= 0 && <= " << (bitVector->GetLength() - 1)
            << ". Received value is: " << index;
        JSTaggedValue error = ContainerError::BusinessError(thread, ErrorFlag::RANGE_ERROR, oss.str().c_str());
        THROW_NEW_ERROR_AND_RETURN_VALUE(thread, error, JSTaggedValue::Exception());
    }

    JSHandle<JSNativePointer> np(thread, bitVector->GetNativePointer(thread));
    auto elements = reinterpret_cast<std::vector<std::bitset<BIT_SET_LENGTH>>*>(np->GetExternalPointer());

    std::pair<uint32_t, uint32_t> pair = ComputeElementIdAndBitId(index);
    uint32_t elementId = pair.first;
    uint32_t bitId = pair.second;
    (*elements)[elementId].flip(bitId);
    return JSTaggedValue::Undefined();
}

JSTaggedValue JSAPIBitVector::FlipBitsByRange(JSThread* thread, const JSHandle<JSAPIBitVector>& bitVector,
    const JSHandle<JSTaggedValue>& start, const JSHandle<JSTaggedValue>& end)
{
    [[maybe_unused]] ConcurrentApiScope<JSAPIBitVector, ModType::WRITE> scope(thread,
        JSHandle<JSTaggedValue>::Cast(bitVector));
    int32_t startIndex = JSTaggedValue::ToInt32(thread, start);
    int32_t endIndex = JSTaggedValue::ToInt32(thread, end);
    int32_t length = bitVector->GetLength();
    int32_t size = length > endIndex ? endIndex : length;
    if (endIndex < 0 || endIndex > length) {
        std::ostringstream oss;
        oss << "The value of \"toIndex\" is out of range. It must be >= 0 && <= " << length
            << ". Received value is: " << endIndex;
        JSTaggedValue error = ContainerError::BusinessError(thread, ErrorFlag::RANGE_ERROR, oss.str().c_str());
        THROW_NEW_ERROR_AND_RETURN_VALUE(thread, error, JSTaggedValue::Exception());
    }
    if (startIndex < 0 || startIndex >= size) {
        std::ostringstream oss;
        oss << "The value of \"fromIndex\" is out of range. It must be >= 0 && <= " << (size - 1)
            << ". Received value is: " << startIndex;
        JSTaggedValue error = ContainerError::BusinessError(thread, ErrorFlag::RANGE_ERROR, oss.str().c_str());
        THROW_NEW_ERROR_AND_RETURN_VALUE(thread, error, JSTaggedValue::Exception());
    }
    JSHandle<JSNativePointer> np(thread, bitVector->GetNativePointer(thread));
    auto elements = reinterpret_cast<std::vector<std::bitset<BIT_SET_LENGTH>>*>(np->GetExternalPointer());
    for (int32_t index = startIndex; index < endIndex; index++) {
        std::pair<uint32_t, uint32_t> pair = ComputeElementIdAndBitId(index);
        uint32_t elementId = pair.first;
        uint32_t bitId = pair.second;
        (*elements)[elementId].flip(bitId);
    }
    return JSTaggedValue::Undefined();
}

void JSAPIBitVector::Resize(JSThread* thread, const JSHandle<JSAPIBitVector>& bitVector, int newSize)
{
    if (newSize < 0) {
        std::ostringstream oss;
        oss << "The value of \"length\" is out of range. It must be >= 0" << ". Received value is: " << newSize;
        JSTaggedValue error = ContainerError::BusinessError(thread, ErrorFlag::RANGE_ERROR, oss.str().c_str());
        THROW_NEW_ERROR_AND_RETURN(thread, error);
    }
    [[maybe_unused]] ConcurrentApiScope<JSAPIBitVector, ModType::WRITE> scope(thread,
        JSHandle<JSTaggedValue>::Cast(bitVector));
    int length = bitVector->GetLength();
    uint32_t elementsLength = static_cast<uint32_t>((length - 1) / BIT_SET_LENGTH + 1);
    uint32_t newElementsLength = static_cast<uint32_t>((newSize - 1) / BIT_SET_LENGTH + 1);

    JSHandle<JSNativePointer> np(thread, bitVector->GetNativePointer(thread));
    auto elements = reinterpret_cast<std::vector<std::bitset<BIT_SET_LENGTH>>*>(np->GetExternalPointer());
    if (elementsLength == newElementsLength && length < newSize) {
        for (int32_t index = length; index < newSize; index++) {
            SetBit(elements, index, JSTaggedValue(0));
        }
    } else if (elementsLength < newElementsLength) {
        std::bitset<JSAPIBitVector::BIT_SET_LENGTH> initBitSet;
        elements->resize(newElementsLength, initBitSet);
    } else if (elementsLength > newElementsLength) {
        elements->resize(newElementsLength);
    }
    bitVector->SetLength(newSize);
}

JSHandle<TaggedArray> JSAPIBitVector::OwnKeys(JSThread* thread, const JSHandle<JSAPIBitVector>& obj)
{
    uint32_t numOfElements = static_cast<uint32_t>(obj->GetLength());
    JSHandle<TaggedArray> keyArray = thread->GetEcmaVM()->GetFactory()->NewTaggedArray(numOfElements);

    if (numOfElements > 0) {
        for (uint32_t i = 0; i < numOfElements; ++i) {
            auto key = base::NumberHelper::IntToEcmaString(thread, i);
            keyArray->Set(thread, i, key);
        }
    }

    return keyArray;
}

JSHandle<TaggedArray> JSAPIBitVector::OwnEnumKeys(JSThread* thread, const JSHandle<JSAPIBitVector>& obj)
{
    return OwnKeys(thread, obj);
}

bool JSAPIBitVector::GetOwnProperty(
    JSThread* thread, const JSHandle<JSAPIBitVector>& obj, const JSHandle<JSTaggedValue>& key)
{
    uint32_t index = 0;
    if (UNLIKELY(!JSTaggedValue::ToElementIndex(thread, key.GetTaggedValue(), &index))) {
        JSHandle<EcmaString> result = JSTaggedValue::ToString(thread, key.GetTaggedValue());
        RETURN_VALUE_IF_ABRUPT_COMPLETION(thread, false);
        CString errorMsg = "The type of \"index\" can not obtain attributes of no-number type. Received value is: " +
                           ConvertToString(thread, *result);
        JSTaggedValue error = ContainerError::BusinessError(thread, ErrorFlag::TYPE_ERROR, errorMsg.c_str());
        THROW_NEW_ERROR_AND_RETURN_VALUE(thread, error, false);
    }

    uint32_t length = static_cast<uint32_t>(obj->GetLength());
    if (index >= length) {
        std::ostringstream oss;
        oss << "The value of \"index\" is out of range. It must be > " << (length - 1)
            << ". Received value is: " << index;
        JSTaggedValue error = ContainerError::BusinessError(thread, ErrorFlag::RANGE_ERROR, oss.str().c_str());
        THROW_NEW_ERROR_AND_RETURN_VALUE(thread, error, false);
    }

    obj->Get(thread, index);
    RETURN_VALUE_IF_ABRUPT_COMPLETION(thread, false);
    return true;
}

JSTaggedValue JSAPIBitVector::GetIteratorObj(JSThread* thread, const JSHandle<JSAPIBitVector>& obj)
{
    ObjectFactory* factory = thread->GetEcmaVM()->GetFactory();
    JSHandle<JSAPIBitVectorIterator> iter(factory->NewJSAPIBitVectorIterator(obj));

    return iter.GetTaggedValue();
}

OperationResult JSAPIBitVector::GetProperty(
    JSThread* thread, const JSHandle<JSAPIBitVector>& obj, const JSHandle<JSTaggedValue>& key)
{
    int length = obj->GetLength();
    int index = key->GetInt();
    if (index < 0 || index >= length) {
        std::ostringstream oss;
        oss << "The value of \"index\" is out of range. It must be >= 0 && <= " << (length - 1)
            << ". Received value is: " << index;
        JSTaggedValue error = ContainerError::BusinessError(thread, ErrorFlag::RANGE_ERROR, oss.str().c_str());
        THROW_NEW_ERROR_AND_RETURN_VALUE(
            thread, error, OperationResult(thread, JSTaggedValue::Exception(), PropertyMetaData(false)));
    }

    return OperationResult(thread, obj->Get(thread, index), PropertyMetaData(false));
}
bool JSAPIBitVector::SetProperty(JSThread* thread, const JSHandle<JSAPIBitVector>& obj,
    const JSHandle<JSTaggedValue>& key, const JSHandle<JSTaggedValue>& value)
{
    int length = obj->GetLength();
    int index = key->GetInt();
    if (index < 0 || index >= length) {
        return false;
    }

    obj->Set(thread, index, value.GetTaggedValue());
    return true;
}

} // namespace panda::ecmascript