realm / realm-core / 2471

coverage: 90.991% (+0.007%) from 90.984%
2471

push

Evergreen

web-flow 
RCORE-2185 Sync client should steal file ident of fresh realm when performing client reset (#7850)

* Initial changes to use the file ident from the fresh realm during client reset

* Fixed failing realm_sync_test tests

* Don't send UPLOAD Messages while downloading fresh realm

* Allow sending QUERY bootstrap for fresh download sessions

* Added SHARED_GROUP_FRESH_PATH to generate path for fresh realm

* Removed SHARED_GROUP_FRESH_PATH and used session_reason setting instead

* Some cleanup after tests passing

* Added test to verify no UPLOAD messages are sent during fresh realm download

* Use is_fresh_path to determine if hook event called by client reset fresh realm download session

* Fixed tsan failure around REQUIRE() within hook event callback in flx_migration test

* Updates from review and streamlined changes based on recommendations

* Reverted some test changes that are no longer needed

* Updated logic for when to perform a client reset diff

* Updated fresh realm download to update upload progress but not send upload messages

* Removed has_client_reset_config flag in favor of get_cliet_reset_config()

* Updats from the review - renamed m_allow_uploads to m_delay_uploads

* Updated assert

* Updated test to start with file ident, added comment about client reset and no file ident

* Updated comment for m_delay_uploads

102310 of 180462 branches covered (56.69%)

140 of 147 new or added lines in 10 files covered. (95.24%)

59 existing lines in 16 files now uncovered.

215227 of 236537 relevant lines covered (90.99%)

5885555.54 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,866,206✔





26



    , m_composite(a)




2,866,206✔





27



    , m_ints(a)




2,866,206✔





28



    , m_int_pairs(a)




2,866,206✔





29



    , m_strings(a)




2,866,206✔





30



    , m_refs(a)




2,866,206✔





31



{




5,735,739✔





32



    m_composite.set_parent(this, payload_idx_type);




5,735,739✔





33



}




5,735,739✔





34












35



void ArrayMixed::create()










36



{




363,606✔





37



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




363,606✔





38



    m_composite.create(type_Normal);




363,606✔





39



    m_composite.update_parent();




363,606✔





40



}




363,606✔





41












42



void ArrayMixed::init_from_mem(MemRef mem) noexcept










43



{




4,177,488✔





44



    Array::init_from_mem(mem);




4,177,488✔





45



    m_composite.init_from_parent();




4,177,488✔





46



    m_ints.detach();




4,177,488✔





47



    m_int_pairs.detach();




4,177,488✔





48



    m_strings.detach();




4,177,488✔





49



    m_refs.detach();




4,177,488✔





50



}




4,177,488✔





51












52



void ArrayMixed::add(Mixed value)










53



{




50,604✔





54



    if (value.is_null()) {





50,604✔





55



        m_composite.add(0);




54✔





56



        return;




54✔





57



    }




54✔





58



    m_composite.add(store(value));




50,550✔





59



}




50,550✔





60












61












62



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










63



{




421,776✔





64



    auto old_type = get_type(ndx);




421,776✔





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,776✔





72












73



    if (value.is_null()) {





421,776✔





74



        set_null(ndx);




1,878✔





75



    }




1,878✔





76



    else {




419,898✔





77



        erase_linked_payload(ndx, destroy_collection);




419,898✔





78



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




419,898✔





79



    }




419,898✔





80












81



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





421,776✔





82



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





163,116✔





83



            Array keys(Array::get_alloc());




144,906✔





84



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




144,906✔





85



            keys.init_from_ref(ref);




144,906✔





86



            if (ndx < keys.size())





144,906✔





87



                keys.set(ndx, 0);




144,858✔





88



        }




144,906✔





89



    }




163,116✔





90



}




421,776✔





91












92



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










93



{




1,019,580✔





94



    if (value.is_null()) {





1,019,580✔





95



        m_composite.insert(ndx, 0);




172,146✔





96



    }




172,146✔





97



    else {




847,434✔





98



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




847,434✔





99



    }




847,434✔





100



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





1,019,580✔





101



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





1,019,130✔





102



            Array keys(Array::get_alloc());




169,269✔





103



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




169,269✔





104



            keys.init_from_ref(ref);




169,269✔





105



            keys.insert(ndx, 0);




169,269✔





106



        }




169,269✔





107



    }




1,019,130✔





108



}




1,019,580✔





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,726,890✔





121



    int64_t val = m_composite.get(ndx);




4,726,890✔





122












123



    if (val) {





4,726,890✔





124



        int64_t int_val = val >> s_data_shift;




4,534,812✔





125



        size_t payload_ndx = size_t(int_val);




4,534,812✔





126



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




4,534,812✔





127



        switch (type) {




4,534,812✔





128



            case type_Int: {





552,531✔





129



                if (val & s_payload_idx_mask) {





552,531✔





130



                    ensure_int_array();




4,560✔





131



                    return Mixed(m_ints.get(payload_ndx));




4,560✔





132



                }




4,560✔





133



                return Mixed(int_val);




547,971✔





134



            }




552,531✔





135



            case type_Bool:





20,064✔





136



                return Mixed(int_val != 0);




20,064✔





137



            case type_Float:





27,402✔





138



                ensure_int_array();




27,402✔





139



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




27,402✔





140



            case type_Double:





59,691✔





141



                ensure_int_array();




59,691✔





142



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




59,691✔





143



            case type_String: {





558,402✔





144



                ensure_string_array();




558,402✔





145



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





558,402✔





146



                return Mixed(m_strings.get(payload_ndx));




558,402✔





147



            }




552,531✔





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,531✔





154



            case type_Timestamp: {





18,174✔





155



                ensure_int_pair_array();




18,174✔





156



                payload_ndx <<= 1;




18,174✔





157



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





18,174✔





158



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




18,174✔





159



            }




552,531✔





160



            case type_ObjectId: {





26,838✔





161



                ensure_string_array();




26,838✔





162



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





26,838✔





163



                auto s = m_strings.get(payload_ndx);




26,838✔





164



                ObjectId id;




26,838✔





165



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




26,838✔





166



                return Mixed(id);




26,838✔





167



            }




552,531✔





168



            case type_Decimal: {





51,612✔





169



                ensure_int_pair_array();




51,612✔





170



                Decimal128::Bid128 raw;




51,612✔





171



                payload_ndx <<= 1;




51,612✔





172



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





51,612✔





173



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




51,612✔





174



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




51,612✔





175



                return Mixed(Decimal128(raw));




51,612✔





176



            }




552,531✔





177



            case type_Link:




✔





178



                ensure_int_array();




×







179



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




×







180



            case type_TypedLink: {





1,554,444✔





181



                ensure_int_pair_array();




1,554,444✔





182



                payload_ndx <<= 1;




1,554,444✔





183



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





1,554,444✔





184



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




1,554,444✔





185



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




1,554,444✔





186



                return Mixed(ret);




1,554,444✔





187



            }




552,531✔





188



            case type_UUID: {





29,043✔





189



                ensure_string_array();




29,043✔





190



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





29,043✔





191



                auto s = m_strings.get(payload_ndx);




29,043✔





192



                UUID::UUIDBytes bytes{};




29,043✔





193



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




29,043✔





194



                return Mixed(UUID(bytes));




29,043✔





195



            }




552,531✔





196



            default:





1,617,432✔





197



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





1,617,432✔





198



                    ensure_ref_array();




1,617,432✔





199



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




1,617,432✔





200



                }




1,617,432✔






UNCOV

201



                break;




×







202



        }




4,534,812✔





203



    }




4,534,812✔





204












205



    return {};




192,078✔





206



}




4,726,890✔





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,477✔





231



    erase_linked_payload(ndx, true);




165,477✔





232



    m_composite.erase(ndx);




165,477✔





233



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





165,477✔





234



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





165,459✔





235



            Array keys(Array::get_alloc());




144,393✔





236



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




144,393✔





237



            keys.init_from_ref(ref);




144,393✔





238



            keys.erase(ndx);




144,393✔





239



        }




144,393✔





240



    }




165,459✔





241



}




165,477✔





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,024✔





249



        auto val = get(i++);




50,490✔





250



        dst.add(val);




50,490✔





251



    }




50,490✔





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++) {





50,964✔





259



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




50,436✔





260



            }




50,436✔





261



            keys.truncate(ndx);




528✔





262



        }




528✔





263



    }




534✔





264



    while (i > ndx) {





51,024✔





265



        erase_linked_payload(--i, false);




50,490✔





266



    }




50,490✔





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,115✔





301



    if (ref_type ref = get_as_ref(payload_idx_key)) {





596,115✔





302



        Array keys(Array::get_alloc());




596,040✔





303



        keys.init_from_ref(ref);




596,040✔





304



        return keys.find_first(key);




596,040✔





305



    }




596,040✔





306



    return realm::not_found;




75✔





307



}




596,115✔





308












309



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










310



{




298,689✔





311



    Array keys(Array::get_alloc());




298,689✔





312



    ensure_array_accessor(keys, payload_idx_key);




298,689✔





313



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





352,599✔





314



        keys.add(0);




53,910✔





315



    }




53,910✔





316



    keys.set(ndx, key);




298,689✔





317



}




298,689✔





318












319



int64_t ArrayMixed::get_key(size_t ndx) const










320



{




1,559,427✔





321



    Array keys(Array::get_alloc());




1,559,427✔





322



    if (ref_type ref = get_as_ref(payload_idx_key)) {





1,559,427✔





323



        keys.init_from_ref(ref);




1,558,761✔





324



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





2,148,262,516✔





325



    }




1,558,761✔





326



    return 0;




666✔





327



}




1,559,427✔





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,992,486✔





336



    if (!arr.is_attached()) {





4,992,486✔





337



        ref_type ref = get_as_ref(ndx_in_parent);




2,929,170✔





338



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




2,929,170✔





339



        if (ref) {





2,929,170✔





340



            arr.init_from_ref(ref);




2,590,914✔





341



        }




2,590,914✔





342



        else {




338,256✔





343



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





338,256✔





344



            arr.update_parent();




338,256✔





345



        }




338,256✔





346



    }




2,929,170✔





347



}




4,992,486✔





348












349



void ArrayMixed::ensure_int_array() const










350



{




112,605✔





351



    ensure_array_accessor(m_ints, payload_idx_int);




112,605✔





352



}




112,605✔





353












354



void ArrayMixed::ensure_int_pair_array() const










355



{




1,968,468✔





356



    ensure_array_accessor(m_int_pairs, payload_idx_pair);




1,968,468✔





357



}




1,968,468✔





358












359



void ArrayMixed::ensure_string_array() const










360



{




900,342✔





361



    if (!m_strings.is_attached()) {





900,342✔





362



        ref_type ref = get_as_ref(payload_idx_str);




476,349✔





363



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




476,349✔





364



        if (ref) {





476,349✔





365



            m_strings.init_from_ref(ref);




325,530✔





366



        }




325,530✔





367



        else {




150,819✔





368



            m_strings.create();




150,819✔





369



            m_strings.update_parent();




150,819✔





370



        }




150,819✔





371



    }




476,349✔





372



}




900,342✔





373












374



void ArrayMixed::ensure_ref_array() const










375



{




2,614,569✔





376



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





2,614,569✔





377



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




×







378



    }




×







379



    ensure_array_accessor(m_refs, payload_idx_ref);




2,614,569✔





380



}




2,614,569✔





381












382



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










383



{




203,556✔





384



    if (old_ndx != new_ndx) {





203,556✔





385



        size_t sz = m_composite.size();




203,556✔





386



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





20,043,423✔





387



            int64_t val = m_composite.get(i);




20,043,423✔





388



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





20,043,423✔





389



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





20,043,423✔





390



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




203,556✔





391



                return;




203,556✔





392



            }




203,556✔





393



        }




20,043,423✔





394



    }




203,556✔





395



}




203,556✔





396












397



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










398



{




637,668✔





399



    auto val = m_composite.get(ndx);




637,668✔





400



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




637,668✔





401












402



    if (payload_arr_index) {





637,668✔





403



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










404



        size_t last_ndx = 0;




470,214✔





405



        size_t erase_ndx = size_t(val >> s_data_shift);




470,214✔





406



        // Clean up current value by moving last over










407



        switch (payload_arr_index) {




470,214✔





408



            case payload_idx_int: {





4,482✔





409



                ensure_int_array();




4,482✔





410



                last_ndx = m_ints.size() - 1;




4,482✔





411



                if (erase_ndx != last_ndx) {





4,482✔





412



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




3,258✔





413



                    replace_index(last_ndx, erase_ndx, payload_arr_index);




3,258✔





414



                }




3,258✔





415



                m_ints.erase(last_ndx);




4,482✔





416



                break;




4,482✔





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,555✔





443



                ensure_ref_array();




447,555✔





444



                last_ndx = m_refs.size() - 1;




447,555✔





445



                auto old_ref = m_refs.get(erase_ndx);




447,555✔





446



                if (erase_ndx != last_ndx) {





447,555✔





447



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




191,571✔





448



                    replace_index(last_ndx, erase_ndx, payload_arr_index);




191,571✔





449



                }




191,571✔





450



                m_refs.erase(last_ndx);




447,555✔





451



                if (old_ref && free_linked_arrays)





447,555✔





452



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




145,017✔





453



                break;




447,555✔





454



            }




×







455



            default:




✔





456



                break;




×







457



        }




470,214✔





458



    }




470,214✔





459



}




637,668✔





460












461



int64_t ArrayMixed::store(const Mixed& value)










462



{




1,317,744✔





463



    DataType type = value.get_type();




1,317,744✔





464



    int64_t val;




1,317,744✔





465



    switch (type) {




1,317,744✔





466



        case type_Int: {





159,939✔





467



            int64_t int_val = value.get_int();




159,939✔





468



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





159,939✔





469



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




156,003✔





470



            }




156,003✔





471



            else {




3,936✔





472



                ensure_int_array();




3,936✔





473



                size_t ndx = m_ints.size();




3,936✔





474



                m_ints.add(int_val);




3,936✔





475



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




3,936✔





476



            }




3,936✔





477



            break;




159,939✔





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,154✔





547



            ensure_int_pair_array();




323,154✔





548



            size_t ndx = m_int_pairs.size() / 2;




323,154✔





549



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




323,154✔





550



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




323,154✔





551



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




323,154✔





552



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




323,154✔





553



            break;




323,154✔





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,371✔





565



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





550,371✔





566



            ensure_ref_array();




550,371✔





567



            size_t ndx = m_refs.size();




550,371✔





568



            m_refs.add(value.get_ref());




550,371✔





569



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




550,371✔





570



            break;




550,371✔





571



    }




1,317,744✔





572



    return val + int(type) + 1;




1,317,504✔





573



}




1,317,744✔



















    

  • 

    •