realm/realm-core | Build 2449 | src/realm/array_mixed.cpp | Coveralls

25

    : Array(a)

372,642✔

26

    , m_composite(a)

372,642✔

27

    , m_ints(a)

372,642✔

28

    , m_int_pairs(a)

372,642✔

29

    , m_strings(a)

372,642✔

30

    , m_refs(a)

372,642✔

31

745,800✔

32

    m_composite.set_parent(this, payload_idx_type);

745,800✔

33

745,800✔

36

51,006✔

37

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

51,006✔

38

    m_composite.create(type_Normal);

51,006✔

39

    m_composite.update_parent();

51,006✔

40

51,006✔

43

495,123✔

44

    Array::init_from_mem(mem);

495,123✔

45

    m_composite.init_from_parent();

495,123✔

46

    m_ints.detach();

495,123✔

47

    m_int_pairs.detach();

495,123✔

48

    m_strings.detach();

495,123✔

49

    m_refs.detach();

495,123✔

50

495,123✔

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✔

63

37,764✔

64

    auto old_type = get_type(ndx);

37,764✔

71

    bool destroy_collection = !value.is_type(old_type);

37,764✔

73

    if (value.is_null()) {

37,764✔

74

        set_null(ndx);

1,878✔

75

1,878✔

76

    else {

35,886✔

77

        erase_linked_payload(ndx, destroy_collection);

35,886✔

78

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

35,886✔

79

35,886✔

81

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

37,764✔

82

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

19,116✔

83

            Array keys(Array::get_alloc());

1,494✔

84

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

1,494✔

85

            keys.init_from_ref(ref);

1,494✔

86

            if (ndx < keys.size())

1,494✔

87

                keys.set(ndx, 0);

1,446✔

88

1,494✔

89

19,116✔

90

37,764✔

93

155,454✔

94

    if (value.is_null()) {

155,454✔

95

        m_composite.insert(ndx, 0);

28,140✔

96

28,140✔

97

    else {

127,314✔

98

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

127,314✔

99

127,314✔

100

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

155,454✔

101

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

155,202✔

102

            Array keys(Array::get_alloc());

1,872✔

103

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

1,872✔

104

            keys.init_from_ref(ref);

1,872✔

105

            keys.insert(ndx, 0);

1,872✔

106

1,872✔

107

155,202✔

108

155,454✔

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✔

120

1,821,534✔

121

    int64_t val = m_composite.get(ndx);

1,821,534✔

123

    if (val) {

1,821,534✔

124

        int64_t int_val = val >> s_data_shift;

1,773,978✔

125

        size_t payload_ndx = size_t(int_val);

1,773,978✔

126

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

1,773,978✔

127

        switch (type) {

1,773,978✔

128

            case type_Int: {

312,654✔

129

                if (val & s_payload_idx_mask) {

312,654✔

130

                    ensure_int_array();

4,728✔

131

                    return Mixed(m_ints.get(payload_ndx));

4,728✔

132

4,728✔

133

                return Mixed(int_val);

307,926✔

134

312,654✔

135

            case type_Bool:

20,076✔

136

                return Mixed(int_val != 0);

20,076✔

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

141

                ensure_int_array();

59,667✔

142

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

59,667✔

143

            case type_String: {

126,456✔

144

                ensure_string_array();

126,456✔

145

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

126,456✔

146

                return Mixed(m_strings.get(payload_ndx));

126,456✔

147

312,654✔

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

154

            case type_Timestamp: {

18,186✔

155

                ensure_int_pair_array();

18,186✔

156

                payload_ndx <<= 1;

18,186✔

157

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

18,186✔

158

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

18,186✔

159

312,654✔

160

            case type_ObjectId: {

26,853✔

161

                ensure_string_array();

26,853✔

162

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

26,853✔

163

                auto s = m_strings.get(payload_ndx);

26,853✔

164

                ObjectId id;

26,853✔

165

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

26,853✔

166

                return Mixed(id);

26,853✔

167

312,654✔

168

            case type_Decimal: {

51,621✔

169

                ensure_int_pair_array();

51,621✔

170

                Decimal128::Bid128 raw;

51,621✔

171

                payload_ndx <<= 1;

51,621✔

172

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

51,621✔

173

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

51,621✔

174

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

51,621✔

175

                return Mixed(Decimal128(raw));

51,621✔

176

312,654✔

180

            case type_TypedLink: {

978,348✔

181

                ensure_int_pair_array();

978,348✔

182

                payload_ndx <<= 1;

978,348✔

183

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

978,348✔

184

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

978,348✔

185

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

978,348✔

186

                return Mixed(ret);

978,348✔

187

312,654✔

188

            case type_UUID: {

29,025✔

189

                ensure_string_array();

29,025✔

190

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

29,025✔

191

                auto s = m_strings.get(payload_ndx);

29,025✔

192

                UUID::UUIDBytes bytes{};

29,025✔

193

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

29,025✔

194

                return Mixed(UUID(bytes));

29,025✔

195

312,654✔

196

            default:

103,683✔

197

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

103,683✔

198

                    ensure_ref_array();

103,683✔

199

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

103,683✔

200

103,683✔

202

1,773,978✔

203

1,773,978✔

205

    return {};

47,556✔

206

1,821,534✔

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✔

230

21,537✔

231

    erase_linked_payload(ndx, true);

21,537✔

232

    m_composite.erase(ndx);

21,537✔

233

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

21,537✔

234

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

21,525✔

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

241

21,537✔

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✔

262

6✔

263

    while (i > ndx) {

60✔

264

        erase_linked_payload(--i, false);

54✔

265

54✔

266

    m_composite.truncate(ndx);

6✔

267

6✔

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✔

286

4,884✔

287

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

4,884✔

288

        Array keys(Array::get_alloc());

3,420✔

289

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

3,420✔

290

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

3,420✔

291

        keys.update_parent();

3,420✔

293

        return false;

3,420✔

294

3,420✔

295

    return true;

1,464✔

296

4,884✔

299

68,031✔

300

    if (ref_type ref = get_as_ref(payload_idx_key)) {

68,031✔

301

        Array keys(Array::get_alloc());

68,007✔

302

        keys.init_from_ref(ref);

68,007✔

303

        return keys.find_first(key);

68,007✔

304

68,007✔

305

    return realm::not_found;

24✔

306

68,031✔

309

8,262✔

310

    Array keys(Array::get_alloc());

8,262✔

311

    ensure_array_accessor(keys, payload_idx_key);

8,262✔

312

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

11,160✔

313

        keys.add(0);

2,898✔

314

2,898✔

315

    keys.set(ndx, key);

8,262✔

316

8,262✔

319

48,030✔

320

    Array keys(Array::get_alloc());

48,030✔

321

    if (ref_type ref = get_as_ref(payload_idx_key)) {

48,030✔

322

        keys.init_from_ref(ref);

48,030✔

323

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

48,030✔

324

48,030✔

326

48,030✔

329

14,904✔

331

14,904✔

334

1,362,354✔

335

    if (!arr.is_attached()) {

1,362,354✔

336

        ref_type ref = get_as_ref(ndx_in_parent);

264,438✔

337

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

264,438✔

338

        if (ref) {

264,438✔

339

            arr.init_from_ref(ref);

238,860✔

340

238,860✔

341

        else {

25,578✔

342

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

25,578✔

343

            arr.update_parent();

25,578✔

344

25,578✔

345

264,438✔

346

1,362,354✔

349

112,890✔

350

    ensure_array_accessor(m_ints, payload_idx_int);

112,890✔

351

112,890✔

354

1,104,381✔

355

    ensure_array_accessor(m_int_pairs, payload_idx_pair);

1,104,381✔

356

1,104,381✔

359

252,393✔

360

    if (!m_strings.is_attached()) {

252,393✔

361

        ref_type ref = get_as_ref(payload_idx_str);

80,373✔

362

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

80,373✔

363

        if (ref) {

80,373✔

364

            m_strings.init_from_ref(ref);

61,542✔

365

61,542✔

366

        else {

18,831✔

367

            m_strings.create();

18,831✔

368

            m_strings.update_parent();

18,831✔

369

18,831✔

370

80,373✔

371

252,393✔

374

136,821✔

375

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

136,821✔

378

    ensure_array_accessor(m_refs, payload_idx_ref);

136,821✔

379

136,821✔

382

13,071✔

383

    if (old_ndx != new_ndx) {

13,071✔

384

        size_t sz = m_composite.size();

13,071✔

385

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

752,793✔

386

            int64_t val = m_composite.get(i);

752,793✔

387

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

752,793✔

388

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

752,793✔

389

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

13,071✔

390

                return;

13,071✔

391

13,071✔

392

752,793✔

393

13,071✔

394

13,071✔

397

59,331✔

398

    auto val = m_composite.get(ndx);

59,331✔

399

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

59,331✔

401

    if (payload_arr_index) {

59,331✔

403

        size_t last_ndx = 0;

35,880✔

404

        size_t erase_ndx = size_t(val >> s_data_shift);

35,880✔

406

        switch (payload_arr_index) {

35,880✔

407

            case payload_idx_int: {

4,566✔

408

                ensure_int_array();

4,566✔

409

                last_ndx = m_ints.size() - 1;

4,566✔

410

                if (erase_ndx != last_ndx) {

4,566✔

411

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

3,345✔

412

                    replace_index(last_ndx, erase_ndx, payload_arr_index);

3,345✔

413

3,345✔

414

                m_ints.erase(last_ndx);

4,566✔

415

                break;

4,566✔

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✔

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✔

441

            case payload_idx_ref: {

13,158✔

442

                ensure_ref_array();

13,158✔

443

                last_ndx = m_refs.size() - 1;

13,158✔

444

                auto old_ref = m_refs.get(erase_ndx);

13,158✔

445

                if (erase_ndx != last_ndx) {

13,158✔

446

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

1,008✔

447

                    replace_index(last_ndx, erase_ndx, payload_arr_index);

1,008✔

448

1,008✔

449

                m_refs.erase(last_ndx);

13,158✔

450

                if (old_ref && free_linked_arrays)

13,158✔

451

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

1,020✔

452

                break;

13,158✔

456

35,880✔

457

35,880✔

458

59,331✔

461

163,314✔

462

    DataType type = value.get_type();

163,314✔

463

    int64_t val;

163,314✔

464

    switch (type) {

163,314✔

465

        case type_Int: {

39,870✔

466

            int64_t int_val = value.get_int();

39,870✔

467

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

39,870✔

468

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

35,853✔

469

35,853✔

470

            else {

4,017✔

471

                ensure_int_array();

4,017✔

472

                size_t ndx = m_ints.size();

4,017✔

473

                m_ints.add(int_val);

4,017✔

474

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

4,017✔

475

4,017✔

476

            break;

39,870✔

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✔

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✔

495

        case type_String: {

30,168✔

496

            ensure_string_array();

30,168✔

497

            size_t ndx = m_strings.size();

30,168✔

498

            m_strings.add(value.get_string());

30,168✔

499

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

30,168✔

500

            break;

30,168✔

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✔

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✔

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✔

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✔

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✔

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✔

563

        default:

19,980✔

564

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

19,980✔

565

            ensure_ref_array();

19,980✔

566

            size_t ndx = m_refs.size();

19,980✔

567

            m_refs.add(value.get_ref());

19,980✔

568

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

19,980✔

569

            break;

19,980✔

570

163,314✔

571

    return val + int(type) + 1;

163,314✔

572

163,314✔

realm / realm-core / 2449

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

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)	372,642✔
26	, m_composite(a)	372,642✔
27	, m_ints(a)	372,642✔
28	, m_int_pairs(a)	372,642✔
29	, m_strings(a)	372,642✔
30	, m_refs(a)	372,642✔
31	{	745,800✔
32	m_composite.set_parent(this, payload_idx_type);	745,800✔
33	}	745,800✔
34
35	void ArrayMixed::create()
36	{	51,006✔
37	Array::create(type_HasRefs, false, payload_idx_size);	51,006✔
38	m_composite.create(type_Normal);	51,006✔
39	m_composite.update_parent();	51,006✔
40	}	51,006✔
41
42	void ArrayMixed::init_from_mem(MemRef mem) noexcept
43	{	495,123✔
44	Array::init_from_mem(mem);	495,123✔
45	m_composite.init_from_parent();	495,123✔
46	m_ints.detach();	495,123✔
47	m_int_pairs.detach();	495,123✔
48	m_strings.detach();	495,123✔
49	m_refs.detach();	495,123✔
50	}	495,123✔
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,764✔
64	auto old_type = get_type(ndx);	37,764✔
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,764✔
72
73	if (value.is_null()) {	37,764✔
74	set_null(ndx);	1,878✔
75	}	1,878✔
76	else {	35,886✔
77	erase_linked_payload(ndx, destroy_collection);	35,886✔
78	m_composite.set(ndx, store(value));	35,886✔
79	}	35,886✔
80
81	if (destroy_collection && Array::size() > payload_idx_key) {	37,764✔
82	if (auto ref = Array::get_as_ref(payload_idx_key)) {	19,116✔
83	Array keys(Array::get_alloc());	1,494✔
84	keys.set_parent(const_cast<ArrayMixed*>(this), payload_idx_key);	1,494✔
85	keys.init_from_ref(ref);	1,494✔
86	if (ndx < keys.size())	1,494✔
87	keys.set(ndx, 0);	1,446✔
88	}	1,494✔
89	}	19,116✔
90	}	37,764✔
91
92	void ArrayMixed::insert(size_t ndx, Mixed value)
93	{	155,454✔
94	if (value.is_null()) {	155,454✔
95	m_composite.insert(ndx, 0);	28,140✔
96	}	28,140✔
97	else {	127,314✔
98	m_composite.insert(ndx, store(value));	127,314✔
99	}	127,314✔
100	if (Array::size() > payload_idx_key) {	155,454✔
101	if (auto ref = Array::get_as_ref(payload_idx_key)) {	155,202✔
102	Array keys(Array::get_alloc());	1,872✔
103	keys.set_parent(const_cast<ArrayMixed*>(this), payload_idx_key);	1,872✔
104	keys.init_from_ref(ref);	1,872✔
105	keys.insert(ndx, 0);	1,872✔
106	}	1,872✔
107	}	155,202✔
108	}	155,454✔
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,821,534✔
121	int64_t val = m_composite.get(ndx);	1,821,534✔
122
123	if (val) {	1,821,534✔
124	int64_t int_val = val >> s_data_shift;	1,773,978✔
125	size_t payload_ndx = size_t(int_val);	1,773,978✔
126	DataType type = DataType((val & s_data_type_mask) - 1);	1,773,978✔
127	switch (type) {	1,773,978✔
128	case type_Int: {	312,654✔
129	if (val & s_payload_idx_mask) {	312,654✔
130	ensure_int_array();	4,728✔
131	return Mixed(m_ints.get(payload_ndx));	4,728✔
132	}	4,728✔
133	return Mixed(int_val);	307,926✔
134	}	312,654✔
135	case type_Bool:	20,076✔
136	return Mixed(int_val != 0);	20,076✔
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,667✔
141	ensure_int_array();	59,667✔
142	return Mixed(type_punning<double>(m_ints.get(payload_ndx)));	59,667✔
143	case type_String: {	126,456✔
144	ensure_string_array();	126,456✔
145	REALM_ASSERT(size_t(int_val) < m_strings.size());	126,456✔
146	return Mixed(m_strings.get(payload_ndx));	126,456✔
147	}	312,654✔
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,654✔
154	case type_Timestamp: {	18,186✔
155	ensure_int_pair_array();	18,186✔
156	payload_ndx <<= 1;	18,186✔
157	REALM_ASSERT(payload_ndx + 1 < m_int_pairs.size());	18,186✔
158	return Mixed(Timestamp(m_int_pairs.get(payload_ndx), int32_t(m_int_pairs.get(payload_ndx + 1))));	18,186✔
159	}	312,654✔
160	case type_ObjectId: {	26,853✔
161	ensure_string_array();	26,853✔
162	REALM_ASSERT(size_t(int_val) < m_strings.size());	26,853✔
163	auto s = m_strings.get(payload_ndx);	26,853✔
164	ObjectId id;	26,853✔
165	memcpy(&id, s.data(), sizeof(ObjectId));	26,853✔
166	return Mixed(id);	26,853✔
167	}	312,654✔
168	case type_Decimal: {	51,621✔
169	ensure_int_pair_array();	51,621✔
170	Decimal128::Bid128 raw;	51,621✔
171	payload_ndx <<= 1;	51,621✔
172	REALM_ASSERT(payload_ndx + 1 < m_int_pairs.size());	51,621✔
173	raw.w[0] = m_int_pairs.get(payload_ndx);	51,621✔
174	raw.w[1] = m_int_pairs.get(payload_ndx + 1);	51,621✔
175	return Mixed(Decimal128(raw));	51,621✔
176	}	312,654✔
177	case type_Link:	✔
178	ensure_int_array();	×
179	return Mixed(ObjKey(m_ints.get(payload_ndx)));	×
180	case type_TypedLink: {	978,348✔
181	ensure_int_pair_array();	978,348✔
182	payload_ndx <<= 1;	978,348✔
183	REALM_ASSERT(payload_ndx + 1 < m_int_pairs.size());	978,348✔
184	ObjLink ret{TableKey(uint32_t(m_int_pairs.get(payload_ndx))),	978,348✔
185	ObjKey(m_int_pairs.get(payload_ndx + 1))};	978,348✔
186	return Mixed(ret);	978,348✔
187	}	312,654✔
188	case type_UUID: {	29,025✔
189	ensure_string_array();	29,025✔
190	REALM_ASSERT(size_t(int_val) < m_strings.size());	29,025✔
191	auto s = m_strings.get(payload_ndx);	29,025✔
192	UUID::UUIDBytes bytes{};	29,025✔
193	std::copy_n(s.data(), bytes.size(), bytes.begin());	29,025✔
194	return Mixed(UUID(bytes));	29,025✔
195	}	312,654✔
196	default:	103,683✔
197	if (size_t((val & s_payload_idx_mask) >> s_payload_idx_shift) == payload_idx_ref) {	103,683✔
198	ensure_ref_array();	103,683✔
199	return Mixed(m_refs.get(payload_ndx), CollectionType(int(type)));	103,683✔
200	}	103,683✔
201	break;	×
202	}	1,773,978✔
203	}	1,773,978✔
204
205	return {};	47,556✔
206	}	1,821,534✔
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	{	21,537✔
231	erase_linked_payload(ndx, true);	21,537✔
232	m_composite.erase(ndx);	21,537✔
233	if (Array::size() > payload_idx_key) {	21,537✔
234	if (auto ref = Array::get_as_ref(payload_idx_key)) {	21,525✔
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,525✔
241	}	21,537✔
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,884✔
287	if (Array::size() < payload_idx_key + 1 \|\| Array::get(payload_idx_key) == 0) {	4,884✔
288	Array keys(Array::get_alloc());	3,420✔
289	keys.set_parent(const_cast<ArrayMixed*>(this), payload_idx_key);	3,420✔
290	keys.create(type_Normal, false, size(), 0);	3,420✔
291	keys.update_parent();	3,420✔
292
293	return false;	3,420✔
294	}	3,420✔
295	return true;	1,464✔
296	}	4,884✔
297
298	size_t ArrayMixed::find_key(int64_t key) const noexcept
299	{	68,031✔
300	if (ref_type ref = get_as_ref(payload_idx_key)) {	68,031✔
301	Array keys(Array::get_alloc());	68,007✔
302	keys.init_from_ref(ref);	68,007✔
303	return keys.find_first(key);	68,007✔
304	}	68,007✔
305	return realm::not_found;	24✔
306	}	68,031✔
307
308	void ArrayMixed::set_key(size_t ndx, int64_t key)
309	{	8,262✔
310	Array keys(Array::get_alloc());	8,262✔
311	ensure_array_accessor(keys, payload_idx_key);	8,262✔
312	while (keys.size() <= ndx) {	11,160✔
313	keys.add(0);	2,898✔
314	}	2,898✔
315	keys.set(ndx, key);	8,262✔
316	}	8,262✔
317
318	int64_t ArrayMixed::get_key(size_t ndx) const
319	{	48,030✔
320	Array keys(Array::get_alloc());	48,030✔
321	if (ref_type ref = get_as_ref(payload_idx_key)) {	48,030✔
322	keys.init_from_ref(ref);	48,030✔
323	return (ndx < keys.size()) ? keys.get(ndx) : 0;	48,030✔
324	}	48,030✔
325	return 0;	×
326	}	48,030✔
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,362,354✔
335	if (!arr.is_attached()) {	1,362,354✔
336	ref_type ref = get_as_ref(ndx_in_parent);	264,438✔
337	arr.set_parent(const_cast<ArrayMixed*>(this), ndx_in_parent);	264,438✔
338	if (ref) {	264,438✔
339	arr.init_from_ref(ref);	238,860✔
340	}	238,860✔
341	else {	25,578✔
342	arr.create(ndx_in_parent == payload_idx_ref ? type_HasRefs : type_Normal);	25,578✔
343	arr.update_parent();	25,578✔
344	}	25,578✔
345	}	264,438✔
346	}	1,362,354✔
347
348	void ArrayMixed::ensure_int_array() const
349	{	112,890✔
350	ensure_array_accessor(m_ints, payload_idx_int);	112,890✔
351	}	112,890✔
352
353	void ArrayMixed::ensure_int_pair_array() const
354	{	1,104,381✔
355	ensure_array_accessor(m_int_pairs, payload_idx_pair);	1,104,381✔
356	}	1,104,381✔
357
358	void ArrayMixed::ensure_string_array() const
359	{	252,393✔
360	if (!m_strings.is_attached()) {	252,393✔
361	ref_type ref = get_as_ref(payload_idx_str);	80,373✔
362	m_strings.set_parent(const_cast<ArrayMixed*>(this), payload_idx_str);	80,373✔
363	if (ref) {	80,373✔
364	m_strings.init_from_ref(ref);	61,542✔
365	}	61,542✔
366	else {	18,831✔
367	m_strings.create();	18,831✔
368	m_strings.update_parent();	18,831✔
369	}	18,831✔
370	}	80,373✔
371	}	252,393✔
372
373	void ArrayMixed::ensure_ref_array() const
374	{	136,821✔
375	while (Array::size() < payload_idx_ref + 1) {	136,821✔
376	const_cast<ArrayMixed*>(this)->Array::add(0);	×
377	}	×
378	ensure_array_accessor(m_refs, payload_idx_ref);	136,821✔
379	}	136,821✔
380
381	void ArrayMixed::replace_index(size_t old_ndx, size_t new_ndx, size_t payload_arr_index)
382	{	13,071✔
383	if (old_ndx != new_ndx) {	13,071✔
384	size_t sz = m_composite.size();	13,071✔
385	for (size_t i = 0; i != sz; i++) {	752,793✔
386	int64_t val = m_composite.get(i);	752,793✔
387	if (size_t((val & s_payload_idx_mask) >> s_payload_idx_shift) == payload_arr_index &&	752,793✔
388	(val >> s_data_shift) == int64_t(old_ndx)) {	752,793✔
389	m_composite.set(i, int64_t(new_ndx << s_data_shift) \| (val & 0xff));	13,071✔
390	return;	13,071✔
391	}	13,071✔
392	}	752,793✔
393	}	13,071✔
394	}	13,071✔
395
396	void ArrayMixed::erase_linked_payload(size_t ndx, bool free_linked_arrays)
397	{	59,331✔
398	auto val = m_composite.get(ndx);	59,331✔
399	auto payload_arr_index = size_t((val & s_payload_idx_mask) >> s_payload_idx_shift);	59,331✔
400
401	if (payload_arr_index) {	59,331✔
402	// A value is stored in one of the payload arrays
403	size_t last_ndx = 0;	35,880✔
404	size_t erase_ndx = size_t(val >> s_data_shift);	35,880✔
405	// Clean up current value by moving last over
406	switch (payload_arr_index) {	35,880✔
407	case payload_idx_int: {	4,566✔
408	ensure_int_array();	4,566✔
409	last_ndx = m_ints.size() - 1;	4,566✔
410	if (erase_ndx != last_ndx) {	4,566✔
411	m_ints.set(erase_ndx, m_ints.get(last_ndx));	3,345✔
412	replace_index(last_ndx, erase_ndx, payload_arr_index);	3,345✔
413	}	3,345✔
414	m_ints.erase(last_ndx);	4,566✔
415	break;	4,566✔
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,158✔
442	ensure_ref_array();	13,158✔
443	last_ndx = m_refs.size() - 1;	13,158✔
444	auto old_ref = m_refs.get(erase_ndx);	13,158✔
445	if (erase_ndx != last_ndx) {	13,158✔
446	m_refs.set(erase_ndx, m_refs.get(last_ndx));	1,008✔
447	replace_index(last_ndx, erase_ndx, payload_arr_index);	1,008✔
448	}	1,008✔
449	m_refs.erase(last_ndx);	13,158✔
450	if (old_ref && free_linked_arrays)	13,158✔
451	Array::destroy_deep(old_ref, m_composite.get_alloc());	1,020✔
452	break;	13,158✔
453	}	×
454	default:	✔
455	break;	×
456	}	35,880✔
457	}	35,880✔
458	}	59,331✔
459
460	int64_t ArrayMixed::store(const Mixed& value)
461	{	163,314✔
462	DataType type = value.get_type();	163,314✔
463	int64_t val;	163,314✔
464	switch (type) {	163,314✔
465	case type_Int: {	39,870✔
466	int64_t int_val = value.get_int();	39,870✔
467	if (std::numeric_limits<int32_t>::min() <= int_val && int_val <= std::numeric_limits<int32_t>::max()) {	39,870✔
468	val = (static_cast<uint64_t>(int_val) << s_data_shift);	35,853✔
469	}	35,853✔
470	else {	4,017✔
471	ensure_int_array();	4,017✔
472	size_t ndx = m_ints.size();	4,017✔
473	m_ints.add(int_val);	4,017✔
474	val = int64_t(ndx << s_data_shift) \| (payload_idx_int << s_payload_idx_shift);	4,017✔
475	}	4,017✔
476	break;	39,870✔
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,168✔
496	ensure_string_array();	30,168✔
497	size_t ndx = m_strings.size();	30,168✔
498	m_strings.add(value.get_string());	30,168✔
499	val = int64_t(ndx << s_data_shift) \| (payload_idx_str << s_payload_idx_shift);	30,168✔
500	break;	30,168✔
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,980✔
564	REALM_ASSERT(type == type_List \|\| type == type_Dictionary);	19,980✔
565	ensure_ref_array();	19,980✔
566	size_t ndx = m_refs.size();	19,980✔
567	m_refs.add(value.get_ref());	19,980✔
568	val = int64_t(ndx << s_data_shift) \| (payload_idx_ref << s_payload_idx_shift);	19,980✔
569	break;	19,980✔
570	}	163,314✔
571	return val + int(type) + 1;	163,314✔
572	}	163,314✔

realm / realm-core / 2449

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

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