realm / realm-core / thomas.goyne_420

coverage: 90.964% (-0.002%) from 90.966%
thomas.goyne_420

Pull #7796

Evergreen

tgoyne 
Derive upload completion entirely from the state of the history

Rather than tracking a bunch of derived state in-memory, check for upload
completion by checking if there are any unuploaded changesets. This is both
multiprocess-compatible and is more precise than the old checks, which had some
false-negatives.
Pull Request #7796: RCORE-2160 Make upload completion reporting multiprocess-compatible

102120 of 180324 branches covered (56.63%)

112 of 117 new or added lines in 8 files covered. (95.73%)

46 existing lines in 16 files now uncovered.

214645 of 235966 relevant lines covered (90.96%)

5898967.27 hits per line

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

91.94
/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)




373,155✔





26



    , m_composite(a)




373,155✔





27



    , m_ints(a)




373,155✔





28



    , m_int_pairs(a)




373,155✔





29



    , m_strings(a)




373,155✔





30



    , m_refs(a)




373,155✔





31



{




745,569✔





32



    m_composite.set_parent(this, payload_idx_type);




745,569✔





33



}




745,569✔





34












35



void ArrayMixed::create()










36



{




50,856✔





37



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




50,856✔





38



    m_composite.create(type_Normal);




50,856✔





39



    m_composite.update_parent();




50,856✔





40



}




50,856✔





41












42



void ArrayMixed::init_from_mem(MemRef mem) noexcept










43



{




494,586✔





44



    Array::init_from_mem(mem);




494,586✔





45



    m_composite.init_from_parent();




494,586✔





46



    m_ints.detach();




494,586✔





47



    m_int_pairs.detach();




494,586✔





48



    m_strings.detach();




494,586✔





49



    m_refs.detach();




494,586✔





50



}




494,586✔





51












52



void ArrayMixed::add(Mixed value)










53



{




168✔





54



    if (value.is_null()) {





168✔





55



        m_composite.add(0);




54✔





56



        return;




54✔





57



    }




54✔





58



    m_composite.add(store(value));




114✔





59



}




114✔





60












61












62



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










63



{




37,584✔





64



    auto old_type = get_type(ndx);




37,584✔





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);




37,584✔





72












73



    if (value.is_null()) {





37,584✔





74



        set_null(ndx);




1,878✔





75



    }




1,878✔





76



    else {




35,706✔





77



        erase_linked_payload(ndx, destroy_collection);




35,706✔





78



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




35,706✔





79



    }




35,706✔





80












81



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





37,584✔





82



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





19,080✔





83



            Array keys(Array::get_alloc());




1,476✔





84



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




1,476✔





85



            keys.init_from_ref(ref);




1,476✔





86



            if (ndx < keys.size())





1,476✔





87



                keys.set(ndx, 0);




1,428✔





88



        }




1,476✔





89



    }




19,080✔





90



}




37,584✔





91












92



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










93



{




155,100✔





94



    if (value.is_null()) {





155,100✔





95



        m_composite.insert(ndx, 0);




28,104✔





96



    }




28,104✔





97



    else {




126,996✔





98



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




126,996✔





99



    }




126,996✔





100



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





155,100✔





101



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





154,848✔





102



            Array keys(Array::get_alloc());




1,836✔





103



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




1,836✔





104



            keys.init_from_ref(ref);




1,836✔





105



            keys.insert(ndx, 0);




1,836✔





106



        }




1,836✔





107



    }




154,848✔





108



}




155,100✔





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



{




1,820,565✔





121



    int64_t val = m_composite.get(ndx);




1,820,565✔





122












123



    if (val) {





1,820,565✔





124



        int64_t int_val = val >> s_data_shift;




1,773,069✔





125



        size_t payload_ndx = size_t(int_val);




1,773,069✔





126



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




1,773,069✔





127



        switch (type) {




1,773,069✔





128



            case type_Int: {





312,642✔





129



                if (val & s_payload_idx_mask) {





312,642✔





130



                    ensure_int_array();




4,890✔





131



                    return Mixed(m_ints.get(payload_ndx));




4,890✔





132



                }




4,890✔





133



                return Mixed(int_val);




307,752✔





134



            }




312,642✔





135



            case type_Bool:





20,082✔





136



                return Mixed(int_val != 0);




20,082✔





137



            case type_Float:





27,378✔





138



                ensure_int_array();




27,378✔





139



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




27,378✔





140



            case type_Double:





59,643✔





141



                ensure_int_array();




59,643✔





142



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




59,643✔





143



            case type_String: {





126,450✔





144



                ensure_string_array();




126,450✔





145



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





126,450✔





146



                return Mixed(m_strings.get(payload_ndx));




126,450✔





147



            }




312,642✔





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



            }




312,642✔





154



            case type_Timestamp: {





18,159✔





155



                ensure_int_pair_array();




18,159✔





156



                payload_ndx <<= 1;




18,159✔





157



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





18,159✔





158



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




18,159✔





159



            }




312,642✔





160



            case type_ObjectId: {





26,856✔





161



                ensure_string_array();




26,856✔





162



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





26,856✔





163



                auto s = m_strings.get(payload_ndx);




26,856✔





164



                ObjectId id;




26,856✔





165



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




26,856✔





166



                return Mixed(id);




26,856✔





167



            }




312,642✔





168



            case type_Decimal: {





51,600✔





169



                ensure_int_pair_array();




51,600✔





170



                Decimal128::Bid128 raw;




51,600✔





171



                payload_ndx <<= 1;




51,600✔





172



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





51,600✔





173



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




51,600✔





174



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




51,600✔





175



                return Mixed(Decimal128(raw));




51,600✔





176



            }




312,642✔





177



            case type_Link:




✔





178



                ensure_int_array();




×







179



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




×







180



            case type_TypedLink: {





978,408✔





181



                ensure_int_pair_array();




978,408✔





182



                payload_ndx <<= 1;




978,408✔





183



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





978,408✔





184



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




978,408✔





185



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




978,408✔





186



                return Mixed(ret);




978,408✔





187



            }




312,642✔





188



            case type_UUID: {





29,049✔





189



                ensure_string_array();




29,049✔





190



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





29,049✔





191



                auto s = m_strings.get(payload_ndx);




29,049✔





192



                UUID::UUIDBytes bytes{};




29,049✔





193



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




29,049✔





194



                return Mixed(UUID(bytes));




29,049✔





195



            }




312,642✔





196



            default:





102,792✔





197



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





102,792✔





198



                    ensure_ref_array();




102,792✔





199



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




102,792✔





200



                }




102,792✔





201



                break;




×







202



        }




1,773,069✔





203



    }




1,773,069✔





204












205



    return {};




47,496✔





206



}




1,820,565✔





207












208



void ArrayMixed::clear()










209



{




666✔





210



    m_composite.clear();




666✔





211



    m_ints.destroy();




666✔





212



    m_int_pairs.destroy();




666✔





213



    m_strings.destroy();




666✔





214



    m_refs.destroy_deep();




666✔





215



    Array::set(payload_idx_int, 0);




666✔





216



    Array::set(payload_idx_pair, 0);




666✔





217



    Array::set(payload_idx_str, 0);




666✔





218



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





666✔





219



        Array::set(payload_idx_ref, 0);




666✔





220



    }




666✔





221



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





666✔





222



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





666✔





223



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




6✔





224



            Array::set(payload_idx_key, 0);




6✔





225



        }




6✔





226



    }




666✔





227



}




666✔





228












229



void ArrayMixed::erase(size_t ndx)










230



{




21,564✔





231



    erase_linked_payload(ndx, true);




21,564✔





232



    m_composite.erase(ndx);




21,564✔





233



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





21,564✔





234



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





21,552✔





235



            Array keys(Array::get_alloc());




402✔





236



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




402✔





237



            keys.init_from_ref(ref);




402✔





238



            keys.erase(ndx);




402✔





239



        }




402✔





240



    }




21,552✔





241



}




21,564✔





242












243



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










244



{




6✔





245



    auto sz = size();




6✔





246



    size_t i = ndx;




6✔





247



    while (i < sz) {





60✔





248



        auto val = get(i++);




54✔





249



        dst.add(val);




54✔





250



    }




54✔





251



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





6✔





252



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





6✔





253



            dst.ensure_keys();




×







254



            Array keys(Array::get_alloc());




×







255



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




×







256



            keys.init_from_ref(ref);




×







257



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





×







258



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




×







259



            }




×







260



            keys.truncate(ndx);




×







261



        }




×







262



    }




6✔





263



    while (i > ndx) {





60✔





264



        erase_linked_payload(--i, false);




54✔





265



    }




54✔





266



    m_composite.truncate(ndx);




6✔





267



}




6✔





268












269



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










270



{




67,464✔





271



    if (value.is_null()) {





67,464✔





272



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




468✔





273



    }




468✔





274



    DataType type = value.get_type();




66,996✔





275



    if (end == realm::npos)





66,996✔





276



        end = size();




6✔





277



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





633,534✔





278



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





630,780✔





279



            return i;




64,242✔





280



        }




64,242✔





281



    }




630,780✔





282



    return realm::npos;




2,754✔





283



}




66,996✔





284












285



bool ArrayMixed::ensure_keys()










286



{




4,848✔





287



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





4,848✔





288



        Array keys(Array::get_alloc());




3,402✔





289



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




3,402✔





290



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




3,402✔





291



        keys.update_parent();




3,402✔





292












293



        return false;




3,402✔





294



    }




3,402✔





295



    return true;




1,446✔





296



}




4,848✔





297












298



size_t ArrayMixed::find_key(int64_t key) const noexcept










299



{




67,566✔





300



    if (ref_type ref = get_as_ref(payload_idx_key)) {





67,566✔





301



        Array keys(Array::get_alloc());




67,542✔





302



        keys.init_from_ref(ref);




67,542✔





303



        return keys.find_first(key);




67,542✔





304



    }




67,542✔





305



    return realm::not_found;




24✔





306



}




67,566✔





307












308



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










309



{




8,190✔





310



    Array keys(Array::get_alloc());




8,190✔





311



    ensure_array_accessor(keys, payload_idx_key);




8,190✔





312



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





11,070✔





313



        keys.add(0);




2,880✔





314



    }




2,880✔





315



    keys.set(ndx, key);




8,190✔





316



}




8,190✔





317












318



int64_t ArrayMixed::get_key(size_t ndx) const










319



{




47,508✔





320



    Array keys(Array::get_alloc());




47,508✔





321



    if (ref_type ref = get_as_ref(payload_idx_key)) {





47,508✔





322



        keys.init_from_ref(ref);




47,508✔





323



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





47,508✔





324



    }




47,508✔






UNCOV

325



    return 0;




×







326



}




47,508✔





327












328



void ArrayMixed::verify() const










329



{




14,904✔





330



    // TODO: Implement










331



}




14,904✔





332












333



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










334



{




1,361,328✔





335



    if (!arr.is_attached()) {





1,361,328✔





336



        ref_type ref = get_as_ref(ndx_in_parent);




263,838✔





337



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




263,838✔





338



        if (ref) {





263,838✔





339



            arr.init_from_ref(ref);




238,314✔





340



        }




238,314✔





341



        else {




25,524✔





342



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





25,524✔





343



            arr.update_parent();




25,524✔





344



        }




25,524✔





345



    }




263,838✔





346



}




1,361,328✔





347












348



void ArrayMixed::ensure_int_array() const










349



{




113,181✔





350



    ensure_array_accessor(m_ints, payload_idx_int);




113,181✔





351



}




113,181✔





352












353



void ArrayMixed::ensure_int_pair_array() const










354



{




1,104,393✔





355



    ensure_array_accessor(m_int_pairs, payload_idx_pair);




1,104,393✔





356



}




1,104,393✔





357












358



void ArrayMixed::ensure_string_array() const










359



{




252,381✔





360



    if (!m_strings.is_attached()) {





252,381✔





361



        ref_type ref = get_as_ref(payload_idx_str);




80,334✔





362



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




80,334✔





363



        if (ref) {





80,334✔





364



            m_strings.init_from_ref(ref);




61,530✔





365



        }




61,530✔





366



        else {




18,804✔





367



            m_strings.create();




18,804✔





368



            m_strings.update_parent();




18,804✔





369



        }




18,804✔





370



    }




80,334✔





371



}




252,381✔





372












373



void ArrayMixed::ensure_ref_array() const










374



{




135,567✔





375



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





135,567✔





376



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




×







377



    }




×







378



    ensure_array_accessor(m_refs, payload_idx_ref);




135,567✔





379



}




135,567✔





380












381



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










382



{




13,017✔





383



    if (old_ndx != new_ndx) {





13,017✔





384



        size_t sz = m_composite.size();




13,017✔





385



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





750,270✔





386



            int64_t val = m_composite.get(i);




750,270✔





387



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





750,270✔





388



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





750,270✔





389



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




13,017✔





390



                return;




13,017✔





391



            }




13,017✔





392



        }




750,270✔





393



    }




13,017✔





394



}




13,017✔





395












396



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










397



{




59,175✔





398



    auto val = m_composite.get(ndx);




59,175✔





399



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




59,175✔





400












401



    if (payload_arr_index) {





59,175✔





402



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










403



        size_t last_ndx = 0;




35,817✔





404



        size_t erase_ndx = size_t(val >> s_data_shift);




35,817✔





405



        // Clean up current value by moving last over










406



        switch (payload_arr_index) {




35,817✔





407



            case payload_idx_int: {





4,647✔





408



                ensure_int_array();




4,647✔





409



                last_ndx = m_ints.size() - 1;




4,647✔





410



                if (erase_ndx != last_ndx) {





4,647✔





411



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




3,411✔





412



                    replace_index(last_ndx, erase_ndx, payload_arr_index);




3,411✔





413



                }




3,411✔





414



                m_ints.erase(last_ndx);




4,647✔





415



                break;




4,647✔





416



            }




×







417



            case payload_idx_str: {





6,072✔





418



                ensure_string_array();




6,072✔





419



                last_ndx = m_strings.size() - 1;




6,072✔





420



                if (erase_ndx != last_ndx) {





6,072✔





421



                    StringData tmp = m_strings.get(last_ndx);




3,336✔





422



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




3,336✔





423



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




3,336✔





424



                    replace_index(last_ndx, erase_ndx, payload_arr_index);




3,336✔





425



                }




3,336✔





426



                m_strings.erase(last_ndx);




6,072✔





427



                break;




6,072✔





428



            }




×







429



            case payload_idx_pair: {





12,084✔





430



                ensure_int_pair_array();




12,084✔





431



                last_ndx = m_int_pairs.size() - 2;




12,084✔





432



                erase_ndx <<= 1;




12,084✔





433



                if (erase_ndx != last_ndx) {





12,084✔





434



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




5,382✔





435



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




5,382✔





436



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




5,382✔





437



                }




5,382✔





438



                m_int_pairs.truncate(last_ndx);




12,084✔





439



                break;




12,084✔





440



            }




×







441



            case payload_idx_ref: {





13,011✔





442



                ensure_ref_array();




13,011✔





443



                last_ndx = m_refs.size() - 1;




13,011✔





444



                auto old_ref = m_refs.get(erase_ndx);




13,011✔





445



                if (erase_ndx != last_ndx) {





13,011✔





446



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




888✔





447



                    replace_index(last_ndx, erase_ndx, payload_arr_index);




888✔





448



                }




888✔





449



                m_refs.erase(last_ndx);




13,011✔





450



                if (old_ref && free_linked_arrays)





13,011✔





451



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




1,020✔





452



                break;




13,011✔





453



            }




×







454



            default:




✔





455



                break;




×







456



        }




35,817✔





457



    }




35,817✔





458



}




59,175✔





459












460



int64_t ArrayMixed::store(const Mixed& value)










461



{




162,816✔





462



    DataType type = value.get_type();




162,816✔





463



    int64_t val;




162,816✔





464



    switch (type) {




162,816✔





465



        case type_Int: {





39,618✔





466



            int64_t int_val = value.get_int();




39,618✔





467



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





39,618✔





468



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




35,529✔





469



            }




35,529✔





470



            else {




4,089✔





471



                ensure_int_array();




4,089✔





472



                size_t ndx = m_ints.size();




4,089✔





473



                m_ints.add(int_val);




4,089✔





474



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




4,089✔





475



            }




4,089✔





476



            break;




39,618✔





477



        }




×







478



        case type_Bool:





2,832✔





479



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




2,832✔





480



            break;




2,832✔





481



        case type_Float: {





6,006✔





482



            ensure_int_array();




6,006✔





483



            size_t ndx = m_ints.size();




6,006✔





484



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




6,006✔





485



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




6,006✔





486



            break;




6,006✔





487



        }




×







488



        case type_Double: {





6,528✔





489



            ensure_int_array();




6,528✔





490



            size_t ndx = m_ints.size();




6,528✔





491



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




6,528✔





492



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




6,528✔





493



            break;




6,528✔





494



        }




×







495



        case type_String: {





30,138✔





496



            ensure_string_array();




30,138✔





497



            size_t ndx = m_strings.size();




30,138✔





498



            m_strings.add(value.get_string());




30,138✔





499



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




30,138✔





500



            break;




30,138✔





501



        }




×







502



        case type_Binary: {





5,052✔





503



            ensure_string_array();




5,052✔





504



            size_t ndx = m_strings.size();




5,052✔





505



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




5,052✔





506



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




5,052✔





507



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




5,052✔





508



            break;




5,052✔





509



        }




×







510



        case type_Timestamp: {





3,528✔





511



            ensure_int_pair_array();




3,528✔





512



            size_t ndx = m_int_pairs.size() / 2;




3,528✔





513



            auto t = value.get_timestamp();




3,528✔





514



            m_int_pairs.add(t.get_seconds());




3,528✔





515



            m_int_pairs.add(t.get_nanoseconds());




3,528✔





516



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




3,528✔





517



            break;




3,528✔





518



        }




×







519



        case type_ObjectId: {





3,684✔





520



            ensure_string_array();




3,684✔





521



            size_t ndx = m_strings.size();




3,684✔





522



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




3,684✔





523



            char buffer[sizeof(ObjectId)];




3,684✔





524



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




3,684✔





525



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




3,684✔





526



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




3,684✔





527



            break;




3,684✔





528



        }




×







529



        case type_Decimal: {





5,538✔





530



            ensure_int_pair_array();




5,538✔





531



            size_t ndx = m_int_pairs.size() / 2;




5,538✔





532



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




5,538✔





533



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




5,538✔





534



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




5,538✔





535



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




5,538✔





536



            break;




5,538✔





537



        }




×







538



        case type_Link: {




✔





539



            ensure_int_array();




×







540



            size_t ndx = m_ints.size();




×







541



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




×







542



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




×







543



            break;




×







544



        }




×







545



        case type_TypedLink: {





35,076✔





546



            ensure_int_pair_array();




35,076✔





547



            size_t ndx = m_int_pairs.size() / 2;




35,076✔





548



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




35,076✔





549



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




35,076✔





550



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




35,076✔





551



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




35,076✔





552



            break;




35,076✔





553



        }




×







554



        case type_UUID: {





5,052✔





555



            ensure_string_array();




5,052✔





556



            size_t ndx = m_strings.size();




5,052✔





557



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




5,052✔





558



            const auto uuid_bytes = id.to_bytes();




5,052✔





559



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




5,052✔





560



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




5,052✔





561



            break;




5,052✔





562



        }




×







563



        default:





19,764✔





564



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





19,764✔





565



            ensure_ref_array();




19,764✔





566



            size_t ndx = m_refs.size();




19,764✔





567



            m_refs.add(value.get_ref());




19,764✔





568



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




19,764✔





569



            break;




19,764✔





570



    }




162,816✔





571



    return val + int(type) + 1;




162,816✔





572



}




162,816✔



















    

  • 

    •