realm / realm-core / thomas.goyne_439

coverage: 91.316% (+0.3%) from 90.974%
thomas.goyne_439

push

Evergreen

web-flow 
[RCORE-2146] CAPI Remove `is_fatal` flag flip (#7751)

104592 of 183414 branches covered (57.03%)

0 of 1 new or added line in 1 file covered. (0.0%)

11 existing lines in 5 files now uncovered.

218041 of 238776 relevant lines covered (91.32%)

5606911.04 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,868,363✔





26



    , m_composite(a)




2,868,363✔





27



    , m_ints(a)




2,868,363✔





28



    , m_int_pairs(a)




2,868,363✔





29



    , m_strings(a)




2,868,363✔





30



    , m_refs(a)




2,868,363✔





31



{




5,737,719✔





32



    m_composite.set_parent(this, payload_idx_type);




5,737,719✔





33



}




5,737,719✔





34












35



void ArrayMixed::create()










36



{




363,600✔





37



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




363,600✔





38



    m_composite.create(type_Normal);




363,600✔





39



    m_composite.update_parent();




363,600✔





40



}




363,600✔





41












42



void ArrayMixed::init_from_mem(MemRef mem) noexcept










43



{




4,179,288✔





44



    Array::init_from_mem(mem);




4,179,288✔





45



    m_composite.init_from_parent();




4,179,288✔





46



    m_ints.detach();




4,179,288✔





47



    m_int_pairs.detach();




4,179,288✔





48



    m_strings.detach();




4,179,288✔





49



    m_refs.detach();




4,179,288✔





50



}




4,179,288✔





51












52



void ArrayMixed::add(Mixed value)










53



{




50,073✔





54



    if (value.is_null()) {





50,073✔





55



        m_composite.add(0);




54✔





56



        return;




54✔





57



    }




54✔





58



    m_composite.add(store(value));




50,019✔





59



}




50,019✔





60












61












62



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










63



{




421,782✔





64



    auto old_type = get_type(ndx);




421,782✔





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





72












73



    if (value.is_null()) {





421,782✔





74



        set_null(ndx);




1,878✔





75



    }




1,878✔





76



    else {




419,904✔





77



        erase_linked_payload(ndx, destroy_collection);




419,904✔





78



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




419,904✔





79



    }




419,904✔





80












81



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





421,782✔





82



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





163,116✔





83



            Array keys(Array::get_alloc());




144,918✔





84



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




144,918✔





85



            keys.init_from_ref(ref);




144,918✔





86



            if (ndx < keys.size())





144,918✔





87



                keys.set(ndx, 0);




144,867✔





88



        }




144,918✔





89



    }




163,116✔





90



}




421,782✔





91












92



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










93



{




1,019,532✔





94



    if (value.is_null()) {





1,019,532✔





95



        m_composite.insert(ndx, 0);




172,146✔





96



    }




172,146✔





97



    else {




847,386✔





98



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




847,386✔





99



    }




847,386✔





100



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





1,019,532✔





101



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





1,019,244✔





102



            Array keys(Array::get_alloc());




169,290✔





103



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




169,290✔





104



            keys.init_from_ref(ref);




169,290✔





105



            keys.insert(ndx, 0);




169,290✔





106



        }




169,290✔





107



    }




1,019,244✔





108



}




1,019,532✔





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





121



    int64_t val = m_composite.get(ndx);




4,727,079✔





122












123



    if (val) {





4,727,079✔





124



        int64_t int_val = val >> s_data_shift;




4,535,154✔





125



        size_t payload_ndx = size_t(int_val);




4,535,154✔





126



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




4,535,154✔





127



        switch (type) {




4,535,154✔





128



            case type_Int: {





552,528✔





129



                if (val & s_payload_idx_mask) {





552,528✔





130



                    ensure_int_array();




4,740✔





131



                    return Mixed(m_ints.get(payload_ndx));




4,740✔





132



                }




4,740✔





133



                return Mixed(int_val);




547,788✔





134



            }




552,528✔





135



            case type_Bool:





20,064✔





136



                return Mixed(int_val != 0);




20,064✔





137



            case type_Float:





27,387✔





138



                ensure_int_array();




27,387✔





139



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




27,387✔





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





144



                ensure_string_array();




558,417✔





145



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





558,417✔





146



                return Mixed(m_strings.get(payload_ndx));




558,417✔





147



            }




552,528✔





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





154



            case type_Timestamp: {





18,177✔





155



                ensure_int_pair_array();




18,177✔





156



                payload_ndx <<= 1;




18,177✔





157



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





18,177✔





158



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




18,177✔





159



            }




552,528✔





160



            case type_ObjectId: {





26,841✔





161



                ensure_string_array();




26,841✔





162



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





26,841✔





163



                auto s = m_strings.get(payload_ndx);




26,841✔





164



                ObjectId id;




26,841✔





165



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




26,841✔





166



                return Mixed(id);




26,841✔





167



            }




552,528✔





168



            case type_Decimal: {





51,606✔





169



                ensure_int_pair_array();




51,606✔





170



                Decimal128::Bid128 raw;




51,606✔





171



                payload_ndx <<= 1;




51,606✔





172



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





51,606✔





173



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




51,606✔





174



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




51,606✔





175



                return Mixed(Decimal128(raw));




51,606✔





176



            }




552,528✔





177



            case type_Link:




✔





178



                ensure_int_array();




×







179



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




×







180



            case type_TypedLink: {





1,554,489✔





181



                ensure_int_pair_array();




1,554,489✔





182



                payload_ndx <<= 1;




1,554,489✔





183



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





1,554,489✔





184



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




1,554,489✔





185



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




1,554,489✔





186



                return Mixed(ret);




1,554,489✔





187



            }




552,528✔





188



            case type_UUID: {





29,058✔





189



                ensure_string_array();




29,058✔





190



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





29,058✔





191



                auto s = m_strings.get(payload_ndx);




29,058✔





192



                UUID::UUIDBytes bytes{};




29,058✔





193



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




29,058✔





194



                return Mixed(UUID(bytes));




29,058✔





195



            }




552,528✔





196



            default:





1,617,435✔





197



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





1,617,435✔





198



                    ensure_ref_array();




1,617,435✔





199



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




1,617,435✔





200



                }




1,617,435✔






UNCOV

201



                break;




×







202



        }




4,535,154✔





203



    }




4,535,154✔





204












205



    return {};




191,925✔





206



}




4,727,079✔





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





231



    erase_linked_payload(ndx, true);




165,495✔





232



    m_composite.erase(ndx);




165,495✔





233



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





165,495✔





234



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





165,483✔





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





241



}




165,495✔





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





50,493✔





249



        auto val = get(i++);




49,959✔





250



        dst.add(val);




49,959✔





251



    }




49,959✔





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





259



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




49,905✔





260



            }




49,905✔





261



            keys.truncate(ndx);




528✔





262



        }




528✔





263



    }




534✔





264



    while (i > ndx) {





50,493✔





265



        erase_linked_payload(--i, false);




49,959✔





266



    }




49,959✔





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





303



        keys.init_from_ref(ref);




596,109✔





304



        return keys.find_first(key);




596,109✔





305



    }




596,109✔





306



    return realm::not_found;




24✔





307



}




596,133✔





308












309



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










310



{




298,167✔





311



    Array keys(Array::get_alloc());




298,167✔





312



    ensure_array_accessor(keys, payload_idx_key);




298,167✔





313



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





351,546✔





314



        keys.add(0);




53,379✔





315



    }




53,379✔





316



    keys.set(ndx, key);




298,167✔





317



}




298,167✔





318












319



int64_t ArrayMixed::get_key(size_t ndx) const










320



{




1,559,937✔





321



    Array keys(Array::get_alloc());




1,559,937✔





322



    if (ref_type ref = get_as_ref(payload_idx_key)) {





1,559,937✔





323



        keys.init_from_ref(ref);




1,559,787✔





324



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





2,148,263,422✔





325



    }




1,559,787✔





326



    return 0;




150✔





327



}




1,559,937✔





328












329



void ArrayMixed::verify() const










330



{




14,904✔





331



    // TODO: Implement










332



}




14,904✔





333












334



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










335



{




4,993,170✔





336



    if (!arr.is_attached()) {





4,993,170✔





337



        ref_type ref = get_as_ref(ndx_in_parent);




2,930,652✔





338



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




2,930,652✔





339



        if (ref) {





2,930,652✔





340



            arr.init_from_ref(ref);




2,592,078✔





341



        }




2,592,078✔





342



        else {




338,574✔





343



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





338,574✔





344



            arr.update_parent();




338,574✔





345



        }




338,574✔





346



    }




2,930,652✔





347



}




4,993,170✔





348












349



void ArrayMixed::ensure_int_array() const










350



{




112,896✔





351



    ensure_array_accessor(m_ints, payload_idx_int);




112,896✔





352



}




112,896✔





353












354



void ArrayMixed::ensure_int_pair_array() const










355



{




1,968,555✔





356



    ensure_array_accessor(m_int_pairs, payload_idx_pair);




1,968,555✔





357



}




1,968,555✔





358












359



void ArrayMixed::ensure_string_array() const










360



{




900,369✔





361



    if (!m_strings.is_attached()) {





900,369✔





362



        ref_type ref = get_as_ref(payload_idx_str);




476,373✔





363



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




476,373✔





364



        if (ref) {





476,373✔





365



            m_strings.init_from_ref(ref);




325,542✔





366



        }




325,542✔





367



        else {




150,831✔





368



            m_strings.create();




150,831✔





369



            m_strings.update_parent();




150,831✔





370



        }




150,831✔





371



    }




476,373✔





372



}




900,369✔





373












374



void ArrayMixed::ensure_ref_array() const










375



{




2,614,260✔





376



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





2,614,260✔





377



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




×







378



    }




×







379



    ensure_array_accessor(m_refs, payload_idx_ref);




2,614,260✔





380



}




2,614,260✔





381












382



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










383



{




203,052✔





384



    if (old_ndx != new_ndx) {





203,052✔





385



        size_t sz = m_composite.size();




203,052✔





386



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





20,074,107✔





387



            int64_t val = m_composite.get(i);




20,074,104✔





388



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





20,074,104✔





389



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





20,074,104✔





390



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




203,049✔





391



                return;




203,049✔





392



            }




203,049✔





393



        }




20,074,104✔





394



    }




203,052✔





395



}




203,052✔





396












397



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










398



{




637,206✔





399



    auto val = m_composite.get(ndx);




637,206✔





400



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




637,206✔





401












402



    if (payload_arr_index) {





637,206✔





403



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










404



        size_t last_ndx = 0;




469,806✔





405



        size_t erase_ndx = size_t(val >> s_data_shift);




469,806✔





406



        // Clean up current value by moving last over










407



        switch (payload_arr_index) {




469,806✔





408



            case payload_idx_int: {





4,572✔





409



                ensure_int_array();




4,572✔





410



                last_ndx = m_ints.size() - 1;




4,572✔





411



                if (erase_ndx != last_ndx) {





4,572✔





412



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




3,342✔





413



                    replace_index(last_ndx, erase_ndx, payload_arr_index);




3,342✔





414



                }




3,342✔





415



                m_ints.erase(last_ndx);




4,572✔





416



                break;




4,572✔





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





443



                ensure_ref_array();




447,063✔





444



                last_ndx = m_refs.size() - 1;




447,063✔





445



                auto old_ref = m_refs.get(erase_ndx);




447,063✔





446



                if (erase_ndx != last_ndx) {





447,063✔





447



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




190,980✔





448



                    replace_index(last_ndx, erase_ndx, payload_arr_index);




190,980✔





449



                }




190,980✔





450



                m_refs.erase(last_ndx);




447,063✔





451



                if (old_ref && free_linked_arrays)





447,063✔





452



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




145,020✔





453



                break;




447,063✔





454



            }




×







455



            default:




✔





456



                break;




×







457



        }




469,806✔





458



    }




469,806✔





459



}




637,206✔





460












461



int64_t ArrayMixed::store(const Mixed& value)










462



{




1,317,270✔





463



    DataType type = value.get_type();




1,317,270✔





464



    int64_t val;




1,317,270✔





465



    switch (type) {




1,317,270✔





466



        case type_Int: {





159,915✔





467



            int64_t int_val = value.get_int();




159,915✔





468



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





159,915✔





469



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




155,943✔





470



            }




155,943✔





471



            else {




3,972✔





472



                ensure_int_array();




3,972✔





473



                size_t ndx = m_ints.size();




3,972✔





474



                m_ints.add(int_val);




3,972✔





475



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




3,972✔





476



            }




3,972✔





477



            break;




159,915✔





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





547



            ensure_int_pair_array();




323,163✔





548



            size_t ndx = m_int_pairs.size() / 2;




323,163✔





549



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




323,163✔





550



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




323,163✔





551



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




323,163✔





552



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




323,163✔





553



            break;




323,163✔





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:





549,876✔





565



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





549,876✔





566



            ensure_ref_array();




549,876✔





567



            size_t ndx = m_refs.size();




549,876✔





568



            m_refs.add(value.get_ref());




549,876✔





569



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




549,876✔





570



            break;




549,876✔





571



    }




1,317,270✔





572



    return val + int(type) + 1;




1,317,258✔





573



}




1,317,270✔



















    

  • 

    •