realm / realm-core / 2496

coverage: 90.985% (-0.02%) from 91.001%
2496

push

Evergreen

web-flow 
RCORE-2190 Sync client can crash if a session is resumed before UNBIND message finishes sending (#7874)

* Pulled 'make_client_reset_handler()' changes from role change feature branch
* Added test to reproduce and fix for the 'recognize_sync_version()' assert failure
* Moved new test under REALM_ENABLE_AUTH_TESTS define
* Reverted request_download_completion_notification() and updates from review

102398 of 180616 branches covered (56.69%)

113 of 119 new or added lines in 4 files covered. (94.96%)

81 existing lines in 15 files now uncovered.

215488 of 236838 relevant lines covered (90.99%)

5829632.87 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

94.02
/src/realm/array_mixed.cpp
1 
/*************************************************************************
2 
 *
3 
 * Copyright 2018 Realm Inc.
4 
 *
5 
 * Licensed under the Apache License, Version 2.0 (the "License");
6 
 * you may not use this file except in compliance with the License.
7 
 * You may obtain a copy of the License at
8 
 *
9 
 * http://www.apache.org/licenses/LICENSE-2.0
10 
 *
11 
 * Unless required by applicable law or agreed to in writing, software
12 
 * distributed under the License is distributed on an "AS IS" BASIS,
13 
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 
 * See the License for the specific language governing permissions and
15 
 * limitations under the License.
16 
 *
17 
 **************************************************************************/
18 









19



#include <realm/array_mixed.hpp>










20



#include <realm/array_basic.hpp>










21












22



using namespace realm;










23












24



ArrayMixed::ArrayMixed(Allocator& a)










25



    : Array(a)




2,865,594✔





26



    , m_composite(a)




2,865,594✔





27



    , m_ints(a)




2,865,594✔





28



    , m_int_pairs(a)




2,865,594✔





29



    , m_strings(a)




2,865,594✔





30



    , m_refs(a)




2,865,594✔





31



{




5,735,352✔





32



    m_composite.set_parent(this, payload_idx_type);




5,735,352✔





33



}




5,735,352✔





34












35



void ArrayMixed::create()










36



{




363,603✔





37



    Array::create(type_HasRefs, false, payload_idx_size);




363,603✔





38



    m_composite.create(type_Normal);




363,603✔





39



    m_composite.update_parent();




363,603✔





40



}




363,603✔





41












42



void ArrayMixed::init_from_mem(MemRef mem) noexcept










43



{




4,178,622✔





44



    Array::init_from_mem(mem);




4,178,622✔





45



    m_composite.init_from_parent();




4,178,622✔





46



    m_ints.detach();




4,178,622✔





47



    m_int_pairs.detach();




4,178,622✔





48



    m_strings.detach();




4,178,622✔





49



    m_refs.detach();




4,178,622✔





50



}




4,178,622✔





51












52



void ArrayMixed::add(Mixed value)










53



{




50,907✔





54



    if (value.is_null()) {





50,907✔





55



        m_composite.add(0);




54✔





56



        return;




54✔





57



    }




54✔





58



    m_composite.add(store(value));




50,853✔





59



}




50,853✔





60












61












62



void ArrayMixed::set(size_t ndx, Mixed value)










63



{




421,779✔





64



    auto old_type = get_type(ndx);




421,779✔





65



    // If we replace a collections ref value with one of the










66



    // same type, then it is just an update of of the










67



    // ref stored in the parent. If the new type is a different










68



    // type then it means that we are overwriting a collection










69



    // with some other value and hence the collection must be










70



    // destroyed as well as the possible key.










71



    bool destroy_collection = !value.is_type(old_type);




421,779✔





72












73



    if (value.is_null()) {





421,779✔





74



        set_null(ndx);




1,878✔





75



    }




1,878✔





76



    else {




419,901✔





77



        erase_linked_payload(ndx, destroy_collection);




419,901✔





78



        m_composite.set(ndx, store(value));




419,901✔





79



    }




419,901✔





80












81



    if (destroy_collection && Array::size() > payload_idx_key) {





421,779✔





82



        if (auto ref = Array::get_as_ref(payload_idx_key)) {





163,116✔





83



            Array keys(Array::get_alloc());




144,915✔





84



            keys.set_parent(const_cast<ArrayMixed*>(this), payload_idx_key);




144,915✔





85



            keys.init_from_ref(ref);




144,915✔





86



            if (ndx < keys.size())





144,915✔





87



                keys.set(ndx, 0);




144,870✔





88



        }




144,915✔





89



    }




163,116✔





90



}




421,779✔





91












92



void ArrayMixed::insert(size_t ndx, Mixed value)










93



{




1,019,514✔





94



    if (value.is_null()) {





1,019,514✔





95



        m_composite.insert(ndx, 0);




172,146✔





96



    }




172,146✔





97



    else {




847,368✔





98



        m_composite.insert(ndx, store(value));




847,368✔





99



    }




847,368✔





100



    if (Array::size() > payload_idx_key) {





1,019,514✔





101



        if (auto ref = Array::get_as_ref(payload_idx_key)) {





1,018,992✔





102



            Array keys(Array::get_alloc());




169,293✔





103



            keys.set_parent(const_cast<ArrayMixed*>(this), payload_idx_key);




169,293✔





104



            keys.init_from_ref(ref);




169,293✔





105



            keys.insert(ndx, 0);




169,293✔





106



        }




169,293✔





107



    }




1,018,992✔





108



}




1,019,514✔





109












110



void ArrayMixed::set_null(size_t ndx)










111



{




1,878✔





112



    auto val = m_composite.get(ndx);




1,878✔





113



    if (val) {





1,878✔





114



        erase_linked_payload(ndx, true);




1,854✔





115



        m_composite.set(ndx, 0);




1,854✔





116



    }




1,854✔





117



}




1,878✔





118












119



Mixed ArrayMixed::get(size_t ndx) const










120



{




4,727,835✔





121



    int64_t val = m_composite.get(ndx);




4,727,835✔





122












123



    if (val) {





4,727,835✔





124



        int64_t int_val = val >> s_data_shift;




4,535,367✔





125



        size_t payload_ndx = size_t(int_val);




4,535,367✔





126



        DataType type = DataType((val & s_data_type_mask) - 1);




4,535,367✔





127



        switch (type) {




4,535,367✔





128



            case type_Int: {





552,576✔





129



                if (val & s_payload_idx_mask) {





552,576✔





130



                    ensure_int_array();




4,830✔





131



                    return Mixed(m_ints.get(payload_ndx));




4,830✔





132



                }




4,830✔





133



                return Mixed(int_val);




547,746✔





134



            }




552,576✔





135



            case type_Bool:





20,073✔





136



                return Mixed(int_val != 0);




20,073✔





137



            case type_Float:





27,366✔





138



                ensure_int_array();




27,366✔





139



                return Mixed(type_punning<float>(m_ints.get(payload_ndx)));




27,366✔





140



            case type_Double:





59,667✔





141



                ensure_int_array();




59,667✔





142



                return Mixed(type_punning<double>(m_ints.get(payload_ndx)));




59,667✔





143



            case type_String: {





558,378✔





144



                ensure_string_array();




558,378✔





145



                REALM_ASSERT(size_t(int_val) < m_strings.size());





558,378✔





146



                return Mixed(m_strings.get(payload_ndx));




558,378✔





147



            }




552,576✔





148



            case type_Binary: {





20,031✔





149



                ensure_string_array();




20,031✔





150



                REALM_ASSERT(size_t(int_val) < m_strings.size());





20,031✔





151



                auto s = m_strings.get(payload_ndx);




20,031✔





152



                return Mixed(BinaryData(s.data(), s.size()));




20,031✔





153



            }




552,576✔





154



            case type_Timestamp: {





18,207✔





155



                ensure_int_pair_array();




18,207✔





156



                payload_ndx <<= 1;




18,207✔





157



                REALM_ASSERT(payload_ndx + 1 < m_int_pairs.size());





18,207✔





158



                return Mixed(Timestamp(m_int_pairs.get(payload_ndx), int32_t(m_int_pairs.get(payload_ndx + 1))));




18,207✔





159



            }




552,576✔





160



            case type_ObjectId: {





26,829✔





161



                ensure_string_array();




26,829✔





162



                REALM_ASSERT(size_t(int_val) < m_strings.size());





26,829✔





163



                auto s = m_strings.get(payload_ndx);




26,829✔





164



                ObjectId id;




26,829✔





165



                memcpy(&id, s.data(), sizeof(ObjectId));




26,829✔





166



                return Mixed(id);




26,829✔





167



            }




552,576✔





168



            case type_Decimal: {





51,618✔





169



                ensure_int_pair_array();




51,618✔





170



                Decimal128::Bid128 raw;




51,618✔





171



                payload_ndx <<= 1;




51,618✔





172



                REALM_ASSERT(payload_ndx + 1 < m_int_pairs.size());





51,618✔





173



                raw.w[0] = m_int_pairs.get(payload_ndx);




51,618✔





174



                raw.w[1] = m_int_pairs.get(payload_ndx + 1);




51,618✔





175



                return Mixed(Decimal128(raw));




51,618✔





176



            }




552,576✔





177



            case type_Link:




✔





178



                ensure_int_array();




×







179



                return Mixed(ObjKey(m_ints.get(payload_ndx)));




×







180



            case type_TypedLink: {





1,554,552✔





181



                ensure_int_pair_array();




1,554,552✔





182



                payload_ndx <<= 1;




1,554,552✔





183



                REALM_ASSERT(payload_ndx + 1 < m_int_pairs.size());





1,554,552✔





184



                ObjLink ret{TableKey(uint32_t(m_int_pairs.get(payload_ndx))),




1,554,552✔





185



                            ObjKey(m_int_pairs.get(payload_ndx + 1))};




1,554,552✔





186



                return Mixed(ret);




1,554,552✔





187



            }




552,576✔





188



            case type_UUID: {





29,037✔





189



                ensure_string_array();




29,037✔





190



                REALM_ASSERT(size_t(int_val) < m_strings.size());





29,037✔





191



                auto s = m_strings.get(payload_ndx);




29,037✔





192



                UUID::UUIDBytes bytes{};




29,037✔





193



                std::copy_n(s.data(), bytes.size(), bytes.begin());




29,037✔





194



                return Mixed(UUID(bytes));




29,037✔





195



            }




552,576✔





196



            default:





1,618,173✔





197



                if (size_t((val & s_payload_idx_mask) >> s_payload_idx_shift) == payload_idx_ref) {





1,618,173✔





198



                    ensure_ref_array();




1,618,173✔





199



                    return Mixed(m_refs.get(payload_ndx), CollectionType(int(type)));




1,618,173✔





200



                }




1,618,173✔






UNCOV

201



                break;




×







202



        }




4,535,367✔





203



    }




4,535,367✔





204












205



    return {};




192,468✔





206



}




4,727,835✔





207












208



void ArrayMixed::clear()










209



{




690✔





210



    m_composite.clear();




690✔





211



    m_ints.destroy();




690✔





212



    m_int_pairs.destroy();




690✔





213



    m_strings.destroy();




690✔





214



    m_refs.destroy_deep();




690✔





215



    Array::set(payload_idx_int, 0);




690✔





216



    Array::set(payload_idx_pair, 0);




690✔





217



    Array::set(payload_idx_str, 0);




690✔





218



    if (Array::size() > payload_idx_ref) {





690✔





219



        Array::set(payload_idx_ref, 0);




690✔





220



    }




690✔





221



    if (Array::size() > payload_idx_key) {





690✔





222



        if (auto ref = Array::get_as_ref(payload_idx_key)) {





690✔





223



            Array::destroy(ref, m_composite.get_alloc());




6✔





224



            Array::set(payload_idx_key, 0);




6✔





225



        }




6✔





226



    }




690✔





227



}




690✔





228












229



void ArrayMixed::erase(size_t ndx)










230



{




165,549✔





231



    erase_linked_payload(ndx, true);




165,549✔





232



    m_composite.erase(ndx);




165,549✔





233



    if (Array::size() > payload_idx_key) {





165,549✔





234



        if (auto ref = Array::get_as_ref(payload_idx_key)) {





165,537✔





235



            Array keys(Array::get_alloc());




144,402✔





236



            keys.set_parent(const_cast<ArrayMixed*>(this), payload_idx_key);




144,402✔





237



            keys.init_from_ref(ref);




144,402✔





238



            keys.erase(ndx);




144,402✔





239



        }




144,402✔





240



    }




165,537✔





241



}




165,549✔





242












243



void ArrayMixed::move(ArrayMixed& dst, size_t ndx)










244



{




534✔





245



    auto sz = size();




534✔





246



    size_t i = ndx;




534✔





247



    const size_t original_dst_size = dst.size();




534✔





248



    while (i < sz) {





51,327✔





249



        auto val = get(i++);




50,793✔





250



        dst.add(val);




50,793✔





251



    }




50,793✔





252



    if (Array::size() > payload_idx_key) {





534✔





253



        if (auto ref = Array::get_as_ref(payload_idx_key)) {





534✔





254



            dst.ensure_keys();




528✔





255



            Array keys(Array::get_alloc());




528✔





256



            keys.set_parent(const_cast<ArrayMixed*>(this), payload_idx_key);




528✔





257



            keys.init_from_ref(ref);




528✔





258



            for (size_t j = original_dst_size, i = ndx; i < sz; i++, j++) {





51,267✔





259



                dst.set_key(j, keys.get(i));




50,739✔





260



            }




50,739✔





261



            keys.truncate(ndx);




528✔





262



        }




528✔





263



    }




534✔





264



    while (i > ndx) {





51,327✔





265



        erase_linked_payload(--i, false);




50,793✔





266



    }




50,793✔





267



    m_composite.truncate(ndx);




534✔





268



}




534✔





269












270



size_t ArrayMixed::find_first(Mixed value, size_t begin, size_t end) const noexcept










271



{




67,476✔





272



    if (value.is_null()) {





67,476✔





273



        return m_composite.find_first(0, begin, end);




468✔





274



    }




468✔





275



    DataType type = value.get_type();




67,008✔





276



    if (end == realm::npos)





67,008✔





277



        end = size();




6✔





278



    for (size_t i = begin; i < end; i++) {





633,570✔





279



        if (Mixed::data_types_are_comparable(this->get_type(i), type) && get(i) == value) {





630,816✔





280



            return i;




64,254✔





281



        }




64,254✔





282



    }




630,816✔





283



    return realm::npos;




2,754✔





284



}




67,008✔





285












286



bool ArrayMixed::ensure_keys()










287



{




101,412✔





288



    if (Array::size() < payload_idx_key + 1 || Array::get(payload_idx_key) == 0) {





101,412✔





289



        Array keys(Array::get_alloc());




75,420✔





290



        keys.set_parent(const_cast<ArrayMixed*>(this), payload_idx_key);




75,420✔





291



        keys.create(type_Normal, false, size(), 0);




75,420✔





292



        keys.update_parent();




75,420✔





293












294



        return false;




75,420✔





295



    }




75,420✔





296



    return true;




25,992✔





297



}




101,412✔





298












299



size_t ArrayMixed::find_key(int64_t key) const noexcept










300



{




596,133✔





301



    if (ref_type ref = get_as_ref(payload_idx_key)) {





596,133✔





302



        Array keys(Array::get_alloc());




596,061✔





303



        keys.init_from_ref(ref);




596,061✔





304



        return keys.find_first(key);




596,061✔





305



    }




596,061✔





306



    return realm::not_found;




72✔





307



}




596,133✔





308












309



void ArrayMixed::set_key(size_t ndx, int64_t key)










310



{




299,001✔





311



    Array keys(Array::get_alloc());




299,001✔





312



    ensure_array_accessor(keys, payload_idx_key);




299,001✔





313



    while (keys.size() <= ndx) {





353,214✔





314



        keys.add(0);




54,213✔





315



    }




54,213✔





316



    keys.set(ndx, key);




299,001✔





317



}




299,001✔





318












319



int64_t ArrayMixed::get_key(size_t ndx) const










320



{




1,559,844✔





321



    Array keys(Array::get_alloc());




1,559,844✔





322



    if (ref_type ref = get_as_ref(payload_idx_key)) {





1,559,844✔





323



        keys.init_from_ref(ref);




1,559,622✔





324



        return (ndx < keys.size()) ? keys.get(ndx) : 0;





2,148,263,263✔





325



    }




1,559,622✔





326



    return 0;




222✔





327



}




1,559,844✔





328












329



void ArrayMixed::verify() const










330



{




14,910✔





331



    // TODO: Implement










332



}




14,910✔





333












334



void ArrayMixed::ensure_array_accessor(Array& arr, size_t ndx_in_parent) const










335



{




4,996,230✔





336



    if (!arr.is_attached()) {





4,996,230✔





337



        ref_type ref = get_as_ref(ndx_in_parent);




2,931,195✔





338



        arr.set_parent(const_cast<ArrayMixed*>(this), ndx_in_parent);




2,931,195✔





339



        if (ref) {





2,931,195✔





340



            arr.init_from_ref(ref);




2,592,741✔





341



        }




2,592,741✔





342



        else {




338,454✔





343



            arr.create(ndx_in_parent == payload_idx_ref ? type_HasRefs : type_Normal);





338,454✔





344



            arr.update_parent();




338,454✔





345



        }




338,454✔





346



    }




2,931,195✔





347



}




4,996,230✔





348












349



void ArrayMixed::ensure_int_array() const










350



{




113,061✔





351



    ensure_array_accessor(m_ints, payload_idx_int);




113,061✔





352



}




113,061✔





353












354



void ArrayMixed::ensure_int_pair_array() const










355



{




1,968,645✔





356



    ensure_array_accessor(m_int_pairs, payload_idx_pair);




1,968,645✔





357



}




1,968,645✔





358












359



void ArrayMixed::ensure_string_array() const










360



{




900,216✔





361



    if (!m_strings.is_attached()) {





900,216✔





362



        ref_type ref = get_as_ref(payload_idx_str);




476,334✔





363



        m_strings.set_parent(const_cast<ArrayMixed*>(this), payload_idx_str);




476,334✔





364



        if (ref) {





476,334✔





365



            m_strings.init_from_ref(ref);




325,524✔





366



        }




325,524✔





367



        else {




150,810✔





368



            m_strings.create();




150,810✔





369



            m_strings.update_parent();




150,810✔





370



        }




150,810✔





371



    }




476,334✔





372



}




900,216✔





373












374



void ArrayMixed::ensure_ref_array() const










375



{




2,616,465✔





376



    while (Array::size() < payload_idx_ref + 1) {





2,616,465✔





377



        const_cast<ArrayMixed*>(this)->Array::add(0);




×







378



    }




×







379



    ensure_array_accessor(m_refs, payload_idx_ref);




2,616,465✔





380



}




2,616,465✔





381












382



void ArrayMixed::replace_index(size_t old_ndx, size_t new_ndx, size_t payload_arr_index)










383



{




203,976✔





384



    if (old_ndx != new_ndx) {





203,976✔





385



        size_t sz = m_composite.size();




203,976✔





386



        for (size_t i = 0; i != sz; i++) {





20,059,674✔





387



            int64_t val = m_composite.get(i);




20,059,674✔





388



            if (size_t((val & s_payload_idx_mask) >> s_payload_idx_shift) == payload_arr_index &&





20,059,674✔





389



                (val >> s_data_shift) == int64_t(old_ndx)) {





20,059,674✔





390



                m_composite.set(i, int64_t(new_ndx << s_data_shift) | (val & 0xff));




203,976✔





391



                return;




203,976✔





392



            }




203,976✔





393



        }




20,059,674✔





394



    }




203,976✔





395



}




203,976✔





396












397



void ArrayMixed::erase_linked_payload(size_t ndx, bool free_linked_arrays)










398



{




638,079✔





399



    auto val = m_composite.get(ndx);




638,079✔





400



    auto payload_arr_index = size_t((val & s_payload_idx_mask) >> s_payload_idx_shift);




638,079✔





401












402



    if (payload_arr_index) {





638,079✔





403



        // A value is stored in one of the payload arrays










404



        size_t last_ndx = 0;




470,688✔





405



        size_t erase_ndx = size_t(val >> s_data_shift);




470,688✔





406



        // Clean up current value by moving last over










407



        switch (payload_arr_index) {




470,688✔





408



            case payload_idx_int: {





4,617✔





409



                ensure_int_array();




4,617✔





410



                last_ndx = m_ints.size() - 1;




4,617✔





411



                if (erase_ndx != last_ndx) {





4,617✔





412



                    m_ints.set(erase_ndx, m_ints.get(last_ndx));




3,366✔





413



                    replace_index(last_ndx, erase_ndx, payload_arr_index);




3,366✔





414



                }




3,366✔





415



                m_ints.erase(last_ndx);




4,617✔





416



                break;




4,617✔





417



            }




×







418



            case payload_idx_str: {





6,072✔





419



                ensure_string_array();




6,072✔





420



                last_ndx = m_strings.size() - 1;




6,072✔





421



                if (erase_ndx != last_ndx) {





6,072✔





422



                    StringData tmp = m_strings.get(last_ndx);




3,336✔





423



                    std::string tmp_val(tmp.data(), tmp.size());




3,336✔





424



                    m_strings.set(erase_ndx, StringData(tmp_val));




3,336✔





425



                    replace_index(last_ndx, erase_ndx, payload_arr_index);




3,336✔





426



                }




3,336✔





427



                m_strings.erase(last_ndx);




6,072✔





428



                break;




6,072✔





429



            }




×







430



            case payload_idx_pair: {





12,102✔





431



                ensure_int_pair_array();




12,102✔





432



                last_ndx = m_int_pairs.size() - 2;




12,102✔





433



                erase_ndx <<= 1;




12,102✔





434



                if (erase_ndx != last_ndx) {





12,102✔





435



                    m_int_pairs.set(erase_ndx, m_int_pairs.get(last_ndx));




5,394✔





436



                    m_int_pairs.set(erase_ndx + 1, m_int_pairs.get(last_ndx + 1));




5,394✔





437



                    replace_index(last_ndx >> 1, erase_ndx >> 1, payload_arr_index);




5,394✔





438



                }




5,394✔





439



                m_int_pairs.truncate(last_ndx);




12,102✔





440



                break;




12,102✔





441



            }




×







442



            case payload_idx_ref: {





447,897✔





443



                ensure_ref_array();




447,897✔





444



                last_ndx = m_refs.size() - 1;




447,897✔





445



                auto old_ref = m_refs.get(erase_ndx);




447,897✔





446



                if (erase_ndx != last_ndx) {





447,897✔





447



                    m_refs.set(erase_ndx, m_refs.get(last_ndx));




191,880✔





448



                    replace_index(last_ndx, erase_ndx, payload_arr_index);




191,880✔





449



                }




191,880✔





450



                m_refs.erase(last_ndx);




447,897✔





451



                if (old_ref && free_linked_arrays)





447,897✔





452



                    Array::destroy_deep(old_ref, m_composite.get_alloc());




145,020✔





453



                break;




447,897✔





454



            }




×







455



            default:




✔





456



                break;




×







457



        }




470,688✔





458



    }




470,688✔





459



}




638,079✔





460












461



int64_t ArrayMixed::store(const Mixed& value)










462



{




1,318,020✔





463



    DataType type = value.get_type();




1,318,020✔





464



    int64_t val;




1,318,020✔





465



    switch (type) {




1,318,020✔





466



        case type_Int: {





159,858✔





467



            int64_t int_val = value.get_int();




159,858✔





468



            if (std::numeric_limits<int32_t>::min() <= int_val && int_val <= std::numeric_limits<int32_t>::max()) {





159,858✔





469



                val = (static_cast<uint64_t>(int_val) << s_data_shift);




155,811✔





470



            }




155,811✔





471



            else {




4,047✔





472



                ensure_int_array();




4,047✔





473



                size_t ndx = m_ints.size();




4,047✔





474



                m_ints.add(int_val);




4,047✔





475



                val = int64_t(ndx << s_data_shift) | (payload_idx_int << s_payload_idx_shift);




4,047✔





476



            }




4,047✔





477



            break;




159,858✔





478



        }




×







479



        case type_Bool:





2,832✔





480



            val = (value.get_bool() << s_data_shift);




2,832✔





481



            break;




2,832✔





482



        case type_Float: {





6,006✔





483



            ensure_int_array();




6,006✔





484



            size_t ndx = m_ints.size();




6,006✔





485



            m_ints.add(type_punning<int64_t>(value.get_float()));




6,006✔





486



            val = int64_t(ndx << s_data_shift) | (payload_idx_int << s_payload_idx_shift);




6,006✔





487



            break;




6,006✔





488



        }




×







489



        case type_Double: {





6,528✔





490



            ensure_int_array();




6,528✔





491



            size_t ndx = m_ints.size();




6,528✔





492



            m_ints.add(type_punning<int64_t>(value.get_double()));




6,528✔





493



            val = int64_t(ndx << s_data_shift) | (payload_idx_int << s_payload_idx_shift);




6,528✔





494



            break;




6,528✔





495



        }




×







496



        case type_String: {





246,168✔





497



            ensure_string_array();




246,168✔





498



            size_t ndx = m_strings.size();




246,168✔





499



            m_strings.add(value.get_string());




246,168✔





500



            val = int64_t(ndx << s_data_shift) | (payload_idx_str << s_payload_idx_shift);




246,168✔





501



            break;




246,168✔





502



        }




×







503



        case type_Binary: {





5,052✔





504



            ensure_string_array();




5,052✔





505



            size_t ndx = m_strings.size();




5,052✔





506



            auto bin = value.get<Binary>();




5,052✔





507



            m_strings.add(StringData(bin.data(), bin.size()));




5,052✔





508



            val = int64_t(ndx << s_data_shift) | (payload_idx_str << s_payload_idx_shift);




5,052✔





509



            break;




5,052✔





510



        }




×







511



        case type_Timestamp: {





3,528✔





512



            ensure_int_pair_array();




3,528✔





513



            size_t ndx = m_int_pairs.size() / 2;




3,528✔





514



            auto t = value.get_timestamp();




3,528✔





515



            m_int_pairs.add(t.get_seconds());




3,528✔





516



            m_int_pairs.add(t.get_nanoseconds());




3,528✔





517



            val = int64_t(ndx << s_data_shift) | (payload_idx_pair << s_payload_idx_shift);




3,528✔





518



            break;




3,528✔





519



        }




×







520



        case type_ObjectId: {





3,684✔





521



            ensure_string_array();




3,684✔





522



            size_t ndx = m_strings.size();




3,684✔





523



            auto id = value.get<ObjectId>();




3,684✔





524



            char buffer[sizeof(ObjectId)];




3,684✔





525



            memcpy(buffer, &id, sizeof(ObjectId));




3,684✔





526



            m_strings.add(StringData(buffer, sizeof(ObjectId)));




3,684✔





527



            val = int64_t(ndx << s_data_shift) | (payload_idx_str << s_payload_idx_shift);




3,684✔





528



            break;




3,684✔





529



        }




×







530



        case type_Decimal: {





5,538✔





531



            ensure_int_pair_array();




5,538✔





532



            size_t ndx = m_int_pairs.size() / 2;




5,538✔





533



            auto t = value.get<Decimal128>();




5,538✔





534



            m_int_pairs.add(t.raw()->w[0]);




5,538✔





535



            m_int_pairs.add(t.raw()->w[1]);




5,538✔





536



            val = int64_t(ndx << s_data_shift) | (payload_idx_pair << s_payload_idx_shift);




5,538✔





537



            break;




5,538✔





538



        }




×







539



        case type_Link: {




✔





540



            ensure_int_array();




×







541



            size_t ndx = m_ints.size();




×







542



            m_ints.add(value.get<ObjKey>().value);




×







543



            val = int64_t(ndx << s_data_shift) | (payload_idx_int << s_payload_idx_shift);




×







544



            break;




×







545



        }




×







546



        case type_TypedLink: {





323,166✔





547



            ensure_int_pair_array();




323,166✔





548



            size_t ndx = m_int_pairs.size() / 2;




323,166✔





549



            auto t = value.get<ObjLink>();




323,166✔





550



            m_int_pairs.add(int64_t(t.get_table_key().value));




323,166✔





551



            m_int_pairs.add(t.get_obj_key().value);




323,166✔





552



            val = int64_t(ndx << s_data_shift) | (payload_idx_pair << s_payload_idx_shift);




323,166✔





553



            break;




323,166✔





554



        }




×







555



        case type_UUID: {





5,052✔





556



            ensure_string_array();




5,052✔





557



            size_t ndx = m_strings.size();




5,052✔





558



            auto id = value.get<UUID>();




5,052✔





559



            const auto uuid_bytes = id.to_bytes();




5,052✔





560



            m_strings.add(StringData(reinterpret_cast<const char*>(uuid_bytes.data()), uuid_bytes.size()));




5,052✔





561



            val = int64_t(ndx << s_data_shift) | (payload_idx_str << s_payload_idx_shift);




5,052✔





562



            break;




5,052✔





563



        }




×







564



        default:





550,695✔





565



            REALM_ASSERT(type == type_List || type == type_Dictionary);





550,695✔





566



            ensure_ref_array();




550,695✔





567



            size_t ndx = m_refs.size();




550,695✔





568



            m_refs.add(value.get_ref());




550,695✔





569



            val = int64_t(ndx << s_data_shift) | (payload_idx_ref << s_payload_idx_shift);




550,695✔





570



            break;




550,695✔





571



    }




1,318,020✔





572



    return val + int(type) + 1;




1,317,852✔





573



}




1,318,020✔



















    

  • 

    •