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

659,955✔

    m_composite.set_parent(this, payload_idx_type);

659,955✔

33

659,955✔

36

45,408✔

37

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

45,408✔

38

    m_composite.create(type_Normal);

45,408✔

39

    m_composite.update_parent();

45,408✔

40

45,408✔

43

428,706✔

44

    Array::init_from_mem(mem);

428,706✔

45

    m_composite.init_from_parent();

428,706✔

46

    m_ints.detach();

428,706✔

47

    m_int_pairs.detach();

428,706✔

48

    m_strings.detach();

428,706✔

49

    m_refs.detach();

428,706✔

50

428,706✔

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

28,926✔

64

    auto old_type = get_type(ndx);

28,926✔

65

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

14,457✔

66

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

14,457✔

67

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

14,457✔

68

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

14,457✔

69

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

14,457✔

70

    // destroyed as well as the possible key.

14,457✔

71

    bool destroy_collection = !value.is_type(old_type);

28,926✔

72

14,457✔

73

    if (value.is_null()) {

28,926✔

74

        set_null(ndx);

1,866✔

75

1,866✔

76

    else {

27,060✔

77

        erase_linked_payload(ndx, destroy_collection);

27,060✔

78

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

27,060✔

79

27,060✔

80

14,457✔

81

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

28,926✔

82

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

14,814✔

83

            Array keys(Array::get_alloc());

936✔

84

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

936✔

85

            keys.init_from_ref(ref);

936✔

86

            if (ndx < keys.size())

936✔

87

                keys.set(ndx, 0);

888✔

88

936✔

89

14,814✔

90

28,926✔

93

144,642✔

94

    if (value.is_null()) {

144,642✔

95

        m_composite.insert(ndx, 0);

22,032✔

96

22,032✔

97

    else {

122,610✔

98

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

122,610✔

99

122,610✔

100

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

144,642✔

101

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

144,390✔

102

            Array keys(Array::get_alloc());

1,398✔

103

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

1,398✔

104

            keys.init_from_ref(ref);

1,398✔

105

            keys.insert(ndx, 0);

1,398✔

106

1,398✔

107

144,390✔

108

144,642✔

111

1,866✔

112

    auto val = m_composite.get(ndx);

1,866✔

113

    if (val) {

1,866✔

114

        erase_linked_payload(ndx, true);

1,842✔

115

        m_composite.set(ndx, 0);

1,842✔

116

1,842✔

117

1,866✔

120

1,663,677✔

121

    int64_t val = m_composite.get(ndx);

1,663,677✔

122

832,755✔

123

    if (val) {

1,663,677✔

124

        int64_t int_val = val >> s_data_shift;

1,623,492✔

125

        size_t payload_ndx = size_t(int_val);

1,623,492✔

126

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

1,623,492✔

127

        switch (type) {

1,623,492✔

128

            case type_Int: {

283,812✔

129

                if (val & s_payload_idx_mask) {

283,812✔

130

                    ensure_int_array();

4,740✔

131

                    return Mixed(m_ints.get(payload_ndx));

4,740✔

132

4,740✔

133

                return Mixed(int_val);

279,072✔

134

279,072✔

135

            case type_Bool:

144,705✔

136

                return Mixed(int_val != 0);

10,821✔

137

            case type_Float:

152,493✔

138

                ensure_int_array();

27,366✔

139

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

27,366✔

140

            case type_Double:

157,368✔

141

                ensure_int_array();

36,096✔

142

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

36,096✔

143

            case type_String: {

197,517✔

144

                ensure_string_array();

116,805✔

145

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

116,805✔

146

                return Mixed(m_strings.get(payload_ndx));

116,805✔

147

279,072✔

148

            case type_Binary: {

148,980✔

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

279,072✔

154

            case type_Timestamp: {

144,384✔

155

                ensure_int_pair_array();

10,215✔

156

                payload_ndx <<= 1;

10,215✔

157

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

10,215✔

158

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

10,215✔

159

279,072✔

160

            case type_ObjectId: {

148,848✔

161

                ensure_string_array();

18,909✔

162

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

18,909✔

163

                auto s = m_strings.get(payload_ndx);

18,909✔

164

                ObjectId id;

18,909✔

165

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

18,909✔

166

                return Mixed(id);

18,909✔

167

279,072✔

168

            case type_Decimal: {

153,135✔

169

                ensure_int_pair_array();

28,059✔

170

                Decimal128::Bid128 raw;

28,059✔

171

                payload_ndx <<= 1;

28,059✔

172

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

28,059✔

173

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

28,059✔

174

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

28,059✔

175

                return Mixed(Decimal128(raw));

28,059✔

176

279,072✔

177

            case type_Link:

139,299✔

180

            case type_TypedLink: {

970,110✔

181

                ensure_int_pair_array();

970,110✔

182

                payload_ndx <<= 1;

970,110✔

183

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

970,110✔

184

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

970,110✔

185

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

970,110✔

186

                return Mixed(ret);

970,110✔

187

279,072✔

188

            case type_UUID: {

150,111✔

189

                ensure_string_array();

21,231✔

190

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

21,231✔

191

                auto s = m_strings.get(payload_ndx);

21,231✔

192

                UUID::UUIDBytes bytes{};

21,231✔

193

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

21,231✔

194

                return Mixed(UUID(bytes));

21,231✔

195

279,072✔

196

            default:

179,571✔

197

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

80,544✔

198

                    ensure_ref_array();

80,544✔

199

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

80,544✔

200

80,544✔

202

1,623,492✔

203

1,623,492✔

204

20,769✔

205

    return {};

40,185✔

206

40,185✔

209

420✔

210

    m_composite.clear();

420✔

211

    m_ints.destroy();

420✔

212

    m_int_pairs.destroy();

420✔

213

    m_strings.destroy();

420✔

214

    m_refs.destroy_deep();

420✔

215

    Array::set(payload_idx_int, 0);

420✔

216

    Array::set(payload_idx_pair, 0);

420✔

217

    Array::set(payload_idx_str, 0);

420✔

218

    Array::set(payload_idx_ref, 0);

420✔

219

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

420✔

220

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

420✔

221

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

6✔

222

            Array::set(payload_idx_key, 0);

6✔

223

6✔

224

420✔

225

420✔

228

20,625✔

229

    erase_linked_payload(ndx, true);

20,625✔

230

    m_composite.erase(ndx);

20,625✔

231

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

20,625✔

232

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

20,613✔

233

            Array keys(Array::get_alloc());

204✔

234

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

204✔

235

            keys.init_from_ref(ref);

204✔

236

            keys.erase(ndx);

204✔

237

204✔

238

20,613✔

239

20,625✔

242

6✔

243

    auto sz = size();

6✔

244

    size_t i = ndx;

6✔

245

    while (i < sz) {

60✔

246

        auto val = get(i++);

54✔

247

        dst.add(val);

54✔

248

54✔

249

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

6✔

250

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

6✔

260

6✔

261

    while (i > ndx) {

60✔

262

        erase_linked_payload(--i, false);

54✔

263

54✔

264

    m_composite.truncate(ndx);

6✔

265

6✔

268

51,840✔

269

    if (value.is_null()) {

51,840✔

270

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

462✔

271

462✔

272

    DataType type = value.get_type();

51,378✔

273

    if (end == realm::npos)

51,378✔

274

        end = size();

6✔

275

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

130,566✔

276

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

130,266✔

277

            return i;

51,078✔

278

51,078✔

279

130,266✔

280

    return realm::npos;

25,803✔

281

51,378✔

284

3,690✔

285

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

3,690✔

286

        Array keys(Array::get_alloc());

2,508✔

287

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

2,508✔

288

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

2,508✔

289

        keys.update_parent();

2,508✔

290

1,254✔

291

        return false;

2,508✔

292

2,508✔

293

    return true;

1,182✔

294

1,182✔

297

57,510✔

298

    if (ref_type ref = get_as_ref(payload_idx_key)) {

57,510✔

299

        Array keys(Array::get_alloc());

57,486✔

300

        keys.init_from_ref(ref);

57,486✔

301

        return keys.find_first(key);

57,486✔

302

57,486✔

303

    return realm::not_found;

24✔

304

24✔

307

5,604✔

308

    Array keys(Array::get_alloc());

5,604✔

309

    ensure_array_accessor(keys, payload_idx_key);

5,604✔

310

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

7,320✔

311

        keys.add(0);

1,716✔

312

1,716✔

313

    keys.set(ndx, key);

5,604✔

314

5,604✔

317

32,178✔

318

    Array keys(Array::get_alloc());

32,178✔

319

    if (ref_type ref = get_as_ref(payload_idx_key)) {

32,178✔

320

        keys.init_from_ref(ref);

32,178✔

321

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

32,178✔

322

32,178✔

327

13,914✔

328

    // TODO: Implement

6,957✔

329

13,914✔

332

1,260,279✔

333

    if (!arr.is_attached()) {

1,260,279✔

334

        ref_type ref = get_as_ref(ndx_in_parent);

230,532✔

335

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

230,532✔

336

        if (ref) {

230,532✔

337

            arr.init_from_ref(ref);

208,374✔

338

208,374✔

339

        else {

22,158✔

340

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

20,127✔

341

            arr.update_parent();

22,158✔

342

22,158✔

343

230,532✔

344

1,260,279✔

347

88,923✔

348

    ensure_array_accessor(m_ints, payload_idx_int);

88,923✔

349

88,923✔

352

1,063,638✔

353

    ensure_array_accessor(m_int_pairs, payload_idx_pair);

1,063,638✔

354

1,063,638✔

357

225,300✔

358

    if (!m_strings.is_attached()) {

225,300✔

359

        ref_type ref = get_as_ref(payload_idx_str);

75,966✔

360

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

75,966✔

361

        if (ref) {

75,966✔

362

            m_strings.init_from_ref(ref);

57,774✔

363

57,774✔

364

        else {

18,192✔

365

            m_strings.create();

18,192✔

366

            m_strings.update_parent();

18,192✔

367

18,192✔

368

75,966✔

369

225,300✔

372

102,138✔

373

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

102,138✔

376

    ensure_array_accessor(m_refs, payload_idx_ref);

102,138✔

377

102,138✔

380

12,666✔

381

    if (old_ndx != new_ndx) {

12,666✔

382

        size_t sz = m_composite.size();

12,666✔

383

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

744,069✔

384

            int64_t val = m_composite.get(i);

744,069✔

385

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

744,069✔

386

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

644,439✔

387

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

12,666✔

388

                return;

12,666✔

389

12,666✔

390

744,069✔

391

12,666✔

392

12,666✔

395

49,578✔

396

    auto val = m_composite.get(ndx);

49,578✔

397

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

49,578✔

398

24,717✔

399

    if (payload_arr_index) {

49,578✔

400

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

15,522✔

401

        size_t last_ndx = 0;

31,038✔

402

        size_t erase_ndx = size_t(val >> s_data_shift);

31,038✔

403

        // Clean up current value by moving last over

15,522✔

404

        switch (payload_arr_index) {

31,038✔

405

            case payload_idx_int: {

4,572✔

406

                ensure_int_array();

4,572✔

407

                last_ndx = m_ints.size() - 1;

4,572✔

408

                if (erase_ndx != last_ndx) {

4,572✔

409

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

3,336✔

410

                    replace_index(last_ndx, erase_ndx, payload_arr_index);

3,336✔

411

3,336✔

412

                m_ints.erase(last_ndx);

4,572✔

413

                break;

4,572✔

415

            case payload_idx_str: {

5,976✔

416

                ensure_string_array();

5,976✔

417

                last_ndx = m_strings.size() - 1;

5,976✔

418

                if (erase_ndx != last_ndx) {

5,976✔

419

                    StringData tmp = m_strings.get(last_ndx);

3,336✔

420

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

3,336✔

421

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

3,336✔

422

                    replace_index(last_ndx, erase_ndx, payload_arr_index);

3,336✔

423

3,336✔

424

                m_strings.erase(last_ndx);

5,976✔

425

                break;

5,976✔

427

            case payload_idx_pair: {

12,060✔

428

                ensure_int_pair_array();

12,060✔

429

                last_ndx = m_int_pairs.size() - 2;

12,060✔

430

                erase_ndx <<= 1;

12,060✔

431

                if (erase_ndx != last_ndx) {

12,060✔

432

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

5,382✔

433

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

5,382✔

434

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

5,382✔

435

5,382✔

436

                m_int_pairs.truncate(last_ndx);

12,060✔

437

                break;

12,060✔

439

            case payload_idx_ref: {

8,430✔

440

                ensure_ref_array();

8,430✔

441

                last_ndx = m_refs.size() - 1;

8,430✔

442

                auto old_ref = m_refs.get(erase_ndx);

8,430✔

443

                if (erase_ndx != last_ndx) {

8,430✔

444

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

612✔

445

                    replace_index(last_ndx, erase_ndx, payload_arr_index);

612✔

446

612✔

447

                m_refs.erase(last_ndx);

8,430✔

448

                if (old_ref && free_linked_arrays)

8,430✔

449

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

582✔

450

                break;

8,430✔

454

31,038✔

455

31,038✔

456

49,578✔

459

149,781✔

460

    DataType type = value.get_type();

149,781✔

461

    int64_t val;

149,781✔

462

    switch (type) {

149,781✔

463

        case type_Int: {

36,270✔

464

            int64_t int_val = value.get_int();

36,270✔

465

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

36,270✔

466

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

32,355✔

467

32,355✔

468

            else {

3,915✔

469

                ensure_int_array();

3,915✔

470

                size_t ndx = m_ints.size();

3,915✔

471

                m_ints.add(int_val);

3,915✔

472

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

3,915✔

473

3,915✔

474

            break;

36,270✔

476

        case type_Bool:

2,532✔

477

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

2,532✔

478

            break;

2,532✔

479

        case type_Float: {

6,006✔

480

            ensure_int_array();

6,006✔

481

            size_t ndx = m_ints.size();

6,006✔

482

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

6,006✔

483

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

6,006✔

484

            break;

6,006✔

486

        case type_Double: {

6,228✔

487

            ensure_int_array();

6,228✔

488

            size_t ndx = m_ints.size();

6,228✔

489

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

6,228✔

490

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

6,228✔

491

            break;

6,228✔

493

        case type_String: {

29,196✔

494

            ensure_string_array();

29,196✔

495

            size_t ndx = m_strings.size();

29,196✔

496

            m_strings.add(value.get_string());

29,196✔

497

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

29,196✔

498

            break;

29,196✔

500

        case type_Binary: {

5,052✔

501

            ensure_string_array();

5,052✔

502

            size_t ndx = m_strings.size();

5,052✔

503

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

5,052✔

504

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

5,052✔

505

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

5,052✔

506

            break;

5,052✔

508

        case type_Timestamp: {

3,228✔

509

            ensure_int_pair_array();

3,228✔

510

            size_t ndx = m_int_pairs.size() / 2;

3,228✔

511

            auto t = value.get_timestamp();

3,228✔

512

            m_int_pairs.add(t.get_seconds());

3,228✔

513

            m_int_pairs.add(t.get_nanoseconds());

3,228✔

514

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

3,228✔

515

            break;

3,228✔

517

        case type_ObjectId: {

3,384✔

518

            ensure_string_array();

3,384✔

519

            size_t ndx = m_strings.size();

3,384✔

520

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

3,384✔

521

            char buffer[sizeof(ObjectId)];

3,384✔

522

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

3,384✔

523

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

3,384✔

524

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

3,384✔

525

            break;

3,384✔

527

        case type_Decimal: {

5,238✔

528

            ensure_int_pair_array();

5,238✔

529

            size_t ndx = m_int_pairs.size() / 2;

5,238✔

530

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

5,238✔

531

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

5,238✔

532

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

5,238✔

533

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

5,238✔

534

            break;

5,238✔

543

        case type_TypedLink: {

34,734✔

544

            ensure_int_pair_array();

34,734✔

545

            size_t ndx = m_int_pairs.size() / 2;

34,734✔

546

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

34,734✔

547

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

34,734✔

548

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

34,734✔

549

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

34,734✔

550

            break;

34,734✔

552

        case type_UUID: {

4,752✔

553

            ensure_string_array();

4,752✔

554

            size_t ndx = m_strings.size();

4,752✔

555

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

4,752✔

556

            const auto uuid_bytes = id.to_bytes();

4,752✔

557

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

4,752✔

558

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

4,752✔

559

            break;

4,752✔

561

        default:

13,164✔

562

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

13,164✔

563

            ensure_ref_array();

13,164✔

564

            size_t ndx = m_refs.size();

13,164✔

565

            m_refs.add(value.get_ref());

13,164✔

566

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

13,164✔

567

            break;

13,164✔

568

149,784✔

569

    return val + int(type) + 1;

149,784✔

570

149,784✔

realm / realm-core / 2214

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)
26	, m_composite(a)
27	, m_ints(a)
28	, m_int_pairs(a)
29	, m_strings(a)
30	, m_refs(a)
31	{	659,955✔
32	m_composite.set_parent(this, payload_idx_type);	659,955✔
33	}	659,955✔
34
35	void ArrayMixed::create()
36	{	45,408✔
37	Array::create(type_HasRefs, false, payload_idx_size);	45,408✔
38	m_composite.create(type_Normal);	45,408✔
39	m_composite.update_parent();	45,408✔
40	}	45,408✔
41
42	void ArrayMixed::init_from_mem(MemRef mem) noexcept
43	{	428,706✔
44	Array::init_from_mem(mem);	428,706✔
45	m_composite.init_from_parent();	428,706✔
46	m_ints.detach();	428,706✔
47	m_int_pairs.detach();	428,706✔
48	m_strings.detach();	428,706✔
49	m_refs.detach();	428,706✔
50	}	428,706✔
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	{	28,926✔
64	auto old_type = get_type(ndx);	28,926✔
65	// If we replace a collections ref value with one of the	14,457✔
66	// same type, then it is just an update of of the	14,457✔
67	// ref stored in the parent. If the new type is a different	14,457✔
68	// type then it means that we are overwriting a collection	14,457✔
69	// with some other value and hence the collection must be	14,457✔
70	// destroyed as well as the possible key.	14,457✔
71	bool destroy_collection = !value.is_type(old_type);	28,926✔
72		14,457✔
73	if (value.is_null()) {	28,926✔
74	set_null(ndx);	1,866✔
75	}	1,866✔
76	else {	27,060✔
77	erase_linked_payload(ndx, destroy_collection);	27,060✔
78	m_composite.set(ndx, store(value));	27,060✔
79	}	27,060✔
80		14,457✔
81	if (destroy_collection && Array::size() > payload_idx_key) {	28,926✔
82	if (auto ref = Array::get_as_ref(payload_idx_key)) {	14,814✔
83	Array keys(Array::get_alloc());	936✔
84	keys.set_parent(const_cast<ArrayMixed*>(this), payload_idx_key);	936✔
85	keys.init_from_ref(ref);	936✔
86	if (ndx < keys.size())	936✔
87	keys.set(ndx, 0);	888✔
88	}	936✔
89	}	14,814✔
90	}	28,926✔
91
92	void ArrayMixed::insert(size_t ndx, Mixed value)
93	{	144,642✔
94	if (value.is_null()) {	144,642✔
95	m_composite.insert(ndx, 0);	22,032✔
96	}	22,032✔
97	else {	122,610✔
98	m_composite.insert(ndx, store(value));	122,610✔
99	}	122,610✔
100	if (Array::size() > payload_idx_key) {	144,642✔
101	if (auto ref = Array::get_as_ref(payload_idx_key)) {	144,390✔
102	Array keys(Array::get_alloc());	1,398✔
103	keys.set_parent(const_cast<ArrayMixed*>(this), payload_idx_key);	1,398✔
104	keys.init_from_ref(ref);	1,398✔
105	keys.insert(ndx, 0);	1,398✔
106	}	1,398✔
107	}	144,390✔
108	}	144,642✔
109
110	void ArrayMixed::set_null(size_t ndx)
111	{	1,866✔
112	auto val = m_composite.get(ndx);	1,866✔
113	if (val) {	1,866✔
114	erase_linked_payload(ndx, true);	1,842✔
115	m_composite.set(ndx, 0);	1,842✔
116	}	1,842✔
117	}	1,866✔
118
119	Mixed ArrayMixed::get(size_t ndx) const
120	{	1,663,677✔
121	int64_t val = m_composite.get(ndx);	1,663,677✔
122		832,755✔
123	if (val) {	1,663,677✔
124	int64_t int_val = val >> s_data_shift;	1,623,492✔
125	size_t payload_ndx = size_t(int_val);	1,623,492✔
126	DataType type = DataType((val & s_data_type_mask) - 1);	1,623,492✔
127	switch (type) {	1,623,492✔
128	case type_Int: {	283,812✔
129	if (val & s_payload_idx_mask) {	283,812✔
130	ensure_int_array();	4,740✔
131	return Mixed(m_ints.get(payload_ndx));	4,740✔
132	}	4,740✔
133	return Mixed(int_val);	279,072✔
134	}	279,072✔
135	case type_Bool:	144,705✔
136	return Mixed(int_val != 0);	10,821✔
137	case type_Float:	152,493✔
138	ensure_int_array();	27,366✔
139	return Mixed(type_punning<float>(m_ints.get(payload_ndx)));	27,366✔
140	case type_Double:	157,368✔
141	ensure_int_array();	36,096✔
142	return Mixed(type_punning<double>(m_ints.get(payload_ndx)));	36,096✔
143	case type_String: {	197,517✔
144	ensure_string_array();	116,805✔
145	REALM_ASSERT(size_t(int_val) < m_strings.size());	116,805✔
146	return Mixed(m_strings.get(payload_ndx));	116,805✔
147	}	279,072✔
148	case type_Binary: {	148,980✔
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	}	279,072✔
154	case type_Timestamp: {	144,384✔
155	ensure_int_pair_array();	10,215✔
156	payload_ndx <<= 1;	10,215✔
157	REALM_ASSERT(payload_ndx + 1 < m_int_pairs.size());	10,215✔
158	return Mixed(Timestamp(m_int_pairs.get(payload_ndx), int32_t(m_int_pairs.get(payload_ndx + 1))));	10,215✔
159	}	279,072✔
160	case type_ObjectId: {	148,848✔
161	ensure_string_array();	18,909✔
162	REALM_ASSERT(size_t(int_val) < m_strings.size());	18,909✔
163	auto s = m_strings.get(payload_ndx);	18,909✔
164	ObjectId id;	18,909✔
165	memcpy(&id, s.data(), sizeof(ObjectId));	18,909✔
166	return Mixed(id);	18,909✔
167	}	279,072✔
168	case type_Decimal: {	153,135✔
169	ensure_int_pair_array();	28,059✔
170	Decimal128::Bid128 raw;	28,059✔
171	payload_ndx <<= 1;	28,059✔
172	REALM_ASSERT(payload_ndx + 1 < m_int_pairs.size());	28,059✔
173	raw.w[0] = m_int_pairs.get(payload_ndx);	28,059✔
174	raw.w[1] = m_int_pairs.get(payload_ndx + 1);	28,059✔
175	return Mixed(Decimal128(raw));	28,059✔
176	}	279,072✔
177	case type_Link:	139,299✔
178	ensure_int_array();	×
179	return Mixed(ObjKey(m_ints.get(payload_ndx)));	×
180	case type_TypedLink: {	970,110✔
181	ensure_int_pair_array();	970,110✔
182	payload_ndx <<= 1;	970,110✔
183	REALM_ASSERT(payload_ndx + 1 < m_int_pairs.size());	970,110✔
184	ObjLink ret{TableKey(uint32_t(m_int_pairs.get(payload_ndx))),	970,110✔
185	ObjKey(m_int_pairs.get(payload_ndx + 1))};	970,110✔
186	return Mixed(ret);	970,110✔
187	}	279,072✔
188	case type_UUID: {	150,111✔
189	ensure_string_array();	21,231✔
190	REALM_ASSERT(size_t(int_val) < m_strings.size());	21,231✔
191	auto s = m_strings.get(payload_ndx);	21,231✔
192	UUID::UUIDBytes bytes{};	21,231✔
193	std::copy_n(s.data(), bytes.size(), bytes.begin());	21,231✔
194	return Mixed(UUID(bytes));	21,231✔
195	}	279,072✔
196	default:	179,571✔
197	if (size_t((val & s_payload_idx_mask) >> s_payload_idx_shift) == payload_idx_ref) {	80,544✔
198	ensure_ref_array();	80,544✔
199	return Mixed(m_refs.get(payload_ndx), CollectionType(int(type)));	80,544✔
200	}	80,544✔
201	break;	×
202	}	1,623,492✔
203	}	1,623,492✔
204		20,769✔
205	return {};	40,185✔
206	}	40,185✔
207
208	void ArrayMixed::clear()
209	{	420✔
210	m_composite.clear();	420✔
211	m_ints.destroy();	420✔
212	m_int_pairs.destroy();	420✔
213	m_strings.destroy();	420✔
214	m_refs.destroy_deep();	420✔
215	Array::set(payload_idx_int, 0);	420✔
216	Array::set(payload_idx_pair, 0);	420✔
217	Array::set(payload_idx_str, 0);	420✔
218	Array::set(payload_idx_ref, 0);	420✔
219	if (Array::size() > payload_idx_key) {	420✔
220	if (auto ref = Array::get_as_ref(payload_idx_key)) {	420✔
221	Array::destroy(ref, m_composite.get_alloc());	6✔
222	Array::set(payload_idx_key, 0);	6✔
223	}	6✔
224	}	420✔
225	}	420✔
226
227	void ArrayMixed::erase(size_t ndx)
228	{	20,625✔
229	erase_linked_payload(ndx, true);	20,625✔
230	m_composite.erase(ndx);	20,625✔
231	if (Array::size() > payload_idx_key) {	20,625✔
232	if (auto ref = Array::get_as_ref(payload_idx_key)) {	20,613✔
233	Array keys(Array::get_alloc());	204✔
234	keys.set_parent(const_cast<ArrayMixed*>(this), payload_idx_key);	204✔
235	keys.init_from_ref(ref);	204✔
236	keys.erase(ndx);	204✔
237	}	204✔
238	}	20,613✔
239	}	20,625✔
240
241	void ArrayMixed::move(ArrayMixed& dst, size_t ndx)
242	{	6✔
243	auto sz = size();	6✔
244	size_t i = ndx;	6✔
245	while (i < sz) {	60✔
246	auto val = get(i++);	54✔
247	dst.add(val);	54✔
248	}	54✔
249	if (Array::size() > payload_idx_key) {	6✔
250	if (auto ref = Array::get_as_ref(payload_idx_key)) {	6✔
251	dst.ensure_keys();	×
252	Array keys(Array::get_alloc());	×
253	keys.set_parent(const_cast<ArrayMixed*>(this), payload_idx_key);	×
UNCOV 254	keys.init_from_ref(ref);	×
UNCOV 255	for (size_t j = 0, i = ndx; i < sz; i++, j++) {	×
UNCOV 256	dst.set_key(j, keys.get(i));	×
UNCOV 257	}	×
UNCOV 258	keys.truncate(ndx);	×
UNCOV 259	}	×
260	}	6✔
261	while (i > ndx) {	60✔
262	erase_linked_payload(--i, false);	54✔
263	}	54✔
264	m_composite.truncate(ndx);	6✔
265	}	6✔
266
267	size_t ArrayMixed::find_first(Mixed value, size_t begin, size_t end) const noexcept
268	{	51,840✔
269	if (value.is_null()) {	51,840✔
270	return m_composite.find_first(0, begin, end);	462✔
271	}	462✔
272	DataType type = value.get_type();	51,378✔
273	if (end == realm::npos)	51,378✔
274	end = size();	6✔
275	for (size_t i = begin; i < end; i++) {	130,566✔
276	if (Mixed::data_types_are_comparable(this->get_type(i), type) && get(i) == value) {	130,266✔
277	return i;	51,078✔
278	}	51,078✔
279	}	130,266✔
280	return realm::npos;	25,803✔
281	}	51,378✔
282
283	bool ArrayMixed::ensure_keys()
284	{	3,690✔
285	if (Array::size() < payload_idx_key + 1 \|\| Array::get(payload_idx_key) == 0) {	3,690✔
286	Array keys(Array::get_alloc());	2,508✔
287	keys.set_parent(const_cast<ArrayMixed*>(this), payload_idx_key);	2,508✔
288	keys.create(type_Normal, false, size(), 0);	2,508✔
289	keys.update_parent();	2,508✔
290		1,254✔
291	return false;	2,508✔
292	}	2,508✔
293	return true;	1,182✔
294	}	1,182✔
295
296	size_t ArrayMixed::find_key(int64_t key) const noexcept
297	{	57,510✔
298	if (ref_type ref = get_as_ref(payload_idx_key)) {	57,510✔
299	Array keys(Array::get_alloc());	57,486✔
300	keys.init_from_ref(ref);	57,486✔
301	return keys.find_first(key);	57,486✔
302	}	57,486✔
303	return realm::not_found;	24✔
304	}	24✔
305
306	void ArrayMixed::set_key(size_t ndx, int64_t key)
307	{	5,604✔
308	Array keys(Array::get_alloc());	5,604✔
309	ensure_array_accessor(keys, payload_idx_key);	5,604✔
310	while (keys.size() <= ndx) {	7,320✔
311	keys.add(0);	1,716✔
312	}	1,716✔
313	keys.set(ndx, key);	5,604✔
314	}	5,604✔
315
316	int64_t ArrayMixed::get_key(size_t ndx) const
317	{	32,178✔
318	Array keys(Array::get_alloc());	32,178✔
319	if (ref_type ref = get_as_ref(payload_idx_key)) {	32,178✔
320	keys.init_from_ref(ref);	32,178✔
321	return (ndx < keys.size()) ? keys.get(ndx) : 0;	32,178✔
322	}	32,178✔
UNCOV 323	return 0;	×
UNCOV 324	}	×
325
326	void ArrayMixed::verify() const
327	{	13,914✔
328	// TODO: Implement	6,957✔
329	}	13,914✔
330
331	void ArrayMixed::ensure_array_accessor(Array& arr, size_t ndx_in_parent) const
332	{	1,260,279✔
333	if (!arr.is_attached()) {	1,260,279✔
334	ref_type ref = get_as_ref(ndx_in_parent);	230,532✔
335	arr.set_parent(const_cast<ArrayMixed*>(this), ndx_in_parent);	230,532✔
336	if (ref) {	230,532✔
337	arr.init_from_ref(ref);	208,374✔
338	}	208,374✔
339	else {	22,158✔
340	arr.create(ndx_in_parent == payload_idx_ref ? type_HasRefs : type_Normal);	20,127✔
341	arr.update_parent();	22,158✔
342	}	22,158✔
343	}	230,532✔
344	}	1,260,279✔
345
346	void ArrayMixed::ensure_int_array() const
347	{	88,923✔
348	ensure_array_accessor(m_ints, payload_idx_int);	88,923✔
349	}	88,923✔
350
351	void ArrayMixed::ensure_int_pair_array() const
352	{	1,063,638✔
353	ensure_array_accessor(m_int_pairs, payload_idx_pair);	1,063,638✔
354	}	1,063,638✔
355
356	void ArrayMixed::ensure_string_array() const
357	{	225,300✔
358	if (!m_strings.is_attached()) {	225,300✔
359	ref_type ref = get_as_ref(payload_idx_str);	75,966✔
360	m_strings.set_parent(const_cast<ArrayMixed*>(this), payload_idx_str);	75,966✔
361	if (ref) {	75,966✔
362	m_strings.init_from_ref(ref);	57,774✔
363	}	57,774✔
364	else {	18,192✔
365	m_strings.create();	18,192✔
366	m_strings.update_parent();	18,192✔
367	}	18,192✔
368	}	75,966✔
369	}	225,300✔
370
371	void ArrayMixed::ensure_ref_array() const
372	{	102,138✔
373	while (Array::size() < payload_idx_ref + 1) {	102,138✔
UNCOV 374	const_cast<ArrayMixed*>(this)->Array::add(0);	×
UNCOV 375	}	×
376	ensure_array_accessor(m_refs, payload_idx_ref);	102,138✔
377	}	102,138✔
378
379	void ArrayMixed::replace_index(size_t old_ndx, size_t new_ndx, size_t payload_arr_index)
380	{	12,666✔
381	if (old_ndx != new_ndx) {	12,666✔
382	size_t sz = m_composite.size();	12,666✔
383	for (size_t i = 0; i != sz; i++) {	744,069✔
384	int64_t val = m_composite.get(i);	744,069✔
385	if (size_t((val & s_payload_idx_mask) >> s_payload_idx_shift) == payload_arr_index &&	744,069✔
386	(val >> s_data_shift) == int64_t(old_ndx)) {	644,439✔
387	m_composite.set(i, int64_t(new_ndx << s_data_shift) \| (val & 0xff));	12,666✔
388	return;	12,666✔
389	}	12,666✔
390	}	744,069✔
391	}	12,666✔
392	}	12,666✔
393
394	void ArrayMixed::erase_linked_payload(size_t ndx, bool free_linked_arrays)
395	{	49,578✔
396	auto val = m_composite.get(ndx);	49,578✔
397	auto payload_arr_index = size_t((val & s_payload_idx_mask) >> s_payload_idx_shift);	49,578✔
398		24,717✔
399	if (payload_arr_index) {	49,578✔
400	// A value is stored in one of the payload arrays	15,522✔
401	size_t last_ndx = 0;	31,038✔
402	size_t erase_ndx = size_t(val >> s_data_shift);	31,038✔
403	// Clean up current value by moving last over	15,522✔
404	switch (payload_arr_index) {	31,038✔
405	case payload_idx_int: {	4,572✔
406	ensure_int_array();	4,572✔
407	last_ndx = m_ints.size() - 1;	4,572✔
408	if (erase_ndx != last_ndx) {	4,572✔
409	m_ints.set(erase_ndx, m_ints.get(last_ndx));	3,336✔
410	replace_index(last_ndx, erase_ndx, payload_arr_index);	3,336✔
411	}	3,336✔
412	m_ints.erase(last_ndx);	4,572✔
413	break;	4,572✔
UNCOV 414	}	×
415	case payload_idx_str: {	5,976✔
416	ensure_string_array();	5,976✔
417	last_ndx = m_strings.size() - 1;	5,976✔
418	if (erase_ndx != last_ndx) {	5,976✔
419	StringData tmp = m_strings.get(last_ndx);	3,336✔
420	std::string tmp_val(tmp.data(), tmp.size());	3,336✔
421	m_strings.set(erase_ndx, StringData(tmp_val));	3,336✔
422	replace_index(last_ndx, erase_ndx, payload_arr_index);	3,336✔
423	}	3,336✔
424	m_strings.erase(last_ndx);	5,976✔
425	break;	5,976✔
UNCOV 426	}	×
427	case payload_idx_pair: {	12,060✔
428	ensure_int_pair_array();	12,060✔
429	last_ndx = m_int_pairs.size() - 2;	12,060✔
430	erase_ndx <<= 1;	12,060✔
431	if (erase_ndx != last_ndx) {	12,060✔
432	m_int_pairs.set(erase_ndx, m_int_pairs.get(last_ndx));	5,382✔
433	m_int_pairs.set(erase_ndx + 1, m_int_pairs.get(last_ndx + 1));	5,382✔
434	replace_index(last_ndx >> 1, erase_ndx >> 1, payload_arr_index);	5,382✔
435	}	5,382✔
436	m_int_pairs.truncate(last_ndx);	12,060✔
437	break;	12,060✔
UNCOV 438	}	×
439	case payload_idx_ref: {	8,430✔
440	ensure_ref_array();	8,430✔
441	last_ndx = m_refs.size() - 1;	8,430✔
442	auto old_ref = m_refs.get(erase_ndx);	8,430✔
443	if (erase_ndx != last_ndx) {	8,430✔
444	m_refs.set(erase_ndx, m_refs.get(last_ndx));	612✔
445	replace_index(last_ndx, erase_ndx, payload_arr_index);	612✔
446	}	612✔
447	m_refs.erase(last_ndx);	8,430✔
448	if (old_ref && free_linked_arrays)	8,430✔
449	Array::destroy_deep(old_ref, m_composite.get_alloc());	582✔
450	break;	8,430✔
UNCOV 451	}	×
UNCOV 452	default:	✔
UNCOV 453	break;	×
454	}	31,038✔
455	}	31,038✔
456	}	49,578✔
457
458	int64_t ArrayMixed::store(const Mixed& value)
459	{	149,781✔
460	DataType type = value.get_type();	149,781✔
461	int64_t val;	149,781✔
462	switch (type) {	149,781✔
463	case type_Int: {	36,270✔
464	int64_t int_val = value.get_int();	36,270✔
465	if (std::numeric_limits<int32_t>::min() <= int_val && int_val <= std::numeric_limits<int32_t>::max()) {	36,270✔
466	val = (static_cast<uint64_t>(int_val) << s_data_shift);	32,355✔
467	}	32,355✔
468	else {	3,915✔
469	ensure_int_array();	3,915✔
470	size_t ndx = m_ints.size();	3,915✔
471	m_ints.add(int_val);	3,915✔
472	val = int64_t(ndx << s_data_shift) \| (payload_idx_int << s_payload_idx_shift);	3,915✔
473	}	3,915✔
474	break;	36,270✔
UNCOV 475	}	×
476	case type_Bool:	2,532✔
477	val = (value.get_bool() << s_data_shift);	2,532✔
478	break;	2,532✔
479	case type_Float: {	6,006✔
480	ensure_int_array();	6,006✔
481	size_t ndx = m_ints.size();	6,006✔
482	m_ints.add(type_punning<int64_t>(value.get_float()));	6,006✔
483	val = int64_t(ndx << s_data_shift) \| (payload_idx_int << s_payload_idx_shift);	6,006✔
484	break;	6,006✔
UNCOV 485	}	×
486	case type_Double: {	6,228✔
487	ensure_int_array();	6,228✔
488	size_t ndx = m_ints.size();	6,228✔
489	m_ints.add(type_punning<int64_t>(value.get_double()));	6,228✔
490	val = int64_t(ndx << s_data_shift) \| (payload_idx_int << s_payload_idx_shift);	6,228✔
491	break;	6,228✔
UNCOV 492	}	×
493	case type_String: {	29,196✔
494	ensure_string_array();	29,196✔
495	size_t ndx = m_strings.size();	29,196✔
496	m_strings.add(value.get_string());	29,196✔
497	val = int64_t(ndx << s_data_shift) \| (payload_idx_str << s_payload_idx_shift);	29,196✔
498	break;	29,196✔
UNCOV 499	}	×
500	case type_Binary: {	5,052✔
501	ensure_string_array();	5,052✔
502	size_t ndx = m_strings.size();	5,052✔
503	auto bin = value.get<Binary>();	5,052✔
504	m_strings.add(StringData(bin.data(), bin.size()));	5,052✔
505	val = int64_t(ndx << s_data_shift) \| (payload_idx_str << s_payload_idx_shift);	5,052✔
506	break;	5,052✔
507	}	×
508	case type_Timestamp: {	3,228✔
509	ensure_int_pair_array();	3,228✔
510	size_t ndx = m_int_pairs.size() / 2;	3,228✔
511	auto t = value.get_timestamp();	3,228✔
512	m_int_pairs.add(t.get_seconds());	3,228✔
513	m_int_pairs.add(t.get_nanoseconds());	3,228✔
514	val = int64_t(ndx << s_data_shift) \| (payload_idx_pair << s_payload_idx_shift);	3,228✔
515	break;	3,228✔
UNCOV 516	}	×
517	case type_ObjectId: {	3,384✔
518	ensure_string_array();	3,384✔
519	size_t ndx = m_strings.size();	3,384✔
520	auto id = value.get<ObjectId>();	3,384✔
521	char buffer[sizeof(ObjectId)];	3,384✔
522	memcpy(buffer, &id, sizeof(ObjectId));	3,384✔
523	m_strings.add(StringData(buffer, sizeof(ObjectId)));	3,384✔
524	val = int64_t(ndx << s_data_shift) \| (payload_idx_str << s_payload_idx_shift);	3,384✔
525	break;	3,384✔
526	}	×
527	case type_Decimal: {	5,238✔
528	ensure_int_pair_array();	5,238✔
529	size_t ndx = m_int_pairs.size() / 2;	5,238✔
530	auto t = value.get<Decimal128>();	5,238✔
531	m_int_pairs.add(t.raw()->w[0]);	5,238✔
532	m_int_pairs.add(t.raw()->w[1]);	5,238✔
533	val = int64_t(ndx << s_data_shift) \| (payload_idx_pair << s_payload_idx_shift);	5,238✔
534	break;	5,238✔
UNCOV 535	}	×
UNCOV 536	case type_Link: {	✔
UNCOV 537	ensure_int_array();	×
UNCOV 538	size_t ndx = m_ints.size();	×
UNCOV 539	m_ints.add(value.get<ObjKey>().value);	×
UNCOV 540	val = int64_t(ndx << s_data_shift) \| (payload_idx_int << s_payload_idx_shift);	×
UNCOV 541	break;	×
542	}	×
543	case type_TypedLink: {	34,734✔
544	ensure_int_pair_array();	34,734✔
545	size_t ndx = m_int_pairs.size() / 2;	34,734✔
546	auto t = value.get<ObjLink>();	34,734✔
547	m_int_pairs.add(int64_t(t.get_table_key().value));	34,734✔
548	m_int_pairs.add(t.get_obj_key().value);	34,734✔
549	val = int64_t(ndx << s_data_shift) \| (payload_idx_pair << s_payload_idx_shift);	34,734✔
550	break;	34,734✔
551	}	×
552	case type_UUID: {	4,752✔
553	ensure_string_array();	4,752✔
554	size_t ndx = m_strings.size();	4,752✔
555	auto id = value.get<UUID>();	4,752✔
556	const auto uuid_bytes = id.to_bytes();	4,752✔
557	m_strings.add(StringData(reinterpret_cast<const char*>(uuid_bytes.data()), uuid_bytes.size()));	4,752✔
558	val = int64_t(ndx << s_data_shift) \| (payload_idx_str << s_payload_idx_shift);	4,752✔
559	break;	4,752✔
UNCOV 560	}	×
561	default:	13,164✔
562	REALM_ASSERT(type == type_List \|\| type == type_Dictionary);	13,164✔
563	ensure_ref_array();	13,164✔
564	size_t ndx = m_refs.size();	13,164✔
565	m_refs.add(value.get_ref());	13,164✔
566	val = int64_t(ndx << s_data_shift) \| (payload_idx_ref << s_payload_idx_shift);	13,164✔
567	break;	13,164✔
568	}	149,784✔
569	return val + int(type) + 1;	149,784✔
570	}	149,784✔

realm / realm-core / 2214

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