realm/realm-core | Build 0 | src/realm/array_string.cpp | Coveralls

20,255,580✔

    m_arr = new (&m_storage.m_string_short) ArrayStringShort(a, true);

20,255,580✔

29

20,255,580✔

32

364,884✔

33

    static_cast<ArrayStringShort*>(m_arr)->create();

364,884✔

34

364,884✔

37

18,195,918✔

38

    char* header = mem.get_addr();

18,195,918✔

39

9,117,969✔

40

    ArrayParent* parent = m_arr->get_parent();

18,195,918✔

41

    size_t ndx_in_parent = m_arr->get_ndx_in_parent();

18,195,918✔

42

9,117,969✔

43

    bool long_strings = Array::get_hasrefs_from_header(header);

18,195,918✔

44

    if (!long_strings) {

18,195,918✔

45

        // Small strings

6,815,076✔

46

        bool is_small = Array::get_wtype_from_header(header) == Array::wtype_Multiply;

13,550,331✔

47

        if (is_small) {

13,550,331✔

48

            auto arr = new (&m_storage.m_string_short) ArrayStringShort(m_alloc, m_nullable);

7,891,608✔

49

            arr->init_from_mem(mem);

7,891,608✔

50

            m_type = Type::small_strings;

7,891,608✔

51

7,891,608✔

52

        else {

5,658,723✔

53

            auto arr = new (&m_storage.m_enum) Array(m_alloc);

5,658,723✔

54

            arr->init_from_mem(mem);

5,658,723✔

55

            m_string_enum_values = std::make_unique<ArrayString>(m_alloc);

5,658,723✔

56

            ArrayParent* p;

5,658,723✔

57

            REALM_ASSERT(m_spec != nullptr);

5,658,723✔

58

            REALM_ASSERT(m_col_ndx != realm::npos);

5,658,723✔

59

            ref_type r = m_spec->get_enumkeys_ref(m_col_ndx, p);

5,658,723✔

60

            m_string_enum_values->init_from_ref(r);

5,658,723✔

61

            m_string_enum_values->set_parent(p, m_col_ndx);

5,658,723✔

62

            m_type = Type::enum_strings;

5,658,723✔

63

5,658,723✔

64

13,550,331✔

65

    else {

4,645,587✔

66

        bool is_big = Array::get_context_flag_from_header(header);

4,645,587✔

67

        if (!is_big) {

4,645,587✔

68

            auto arr = new (&m_storage.m_string_long) ArraySmallBlobs(m_alloc);

1,207,197✔

69

            arr->init_from_mem(mem);

1,207,197✔

70

            m_type = Type::medium_strings;

1,207,197✔

71

1,207,197✔

72

        else {

3,438,390✔

73

            auto arr = new (&m_storage.m_big_blobs) ArrayBigBlobs(m_alloc, m_nullable);

3,438,390✔

74

            arr->init_from_mem(mem);

3,438,390✔

75

            m_type = Type::big_strings;

3,438,390✔

76

3,438,390✔

77

4,645,587✔

78

    m_arr->set_parent(parent, ndx_in_parent);

18,195,918✔

79

18,195,918✔

82

5,334,222✔

83

    ref_type ref = m_arr->get_ref_from_parent();

5,334,222✔

84

    init_from_ref(ref);

5,334,222✔

85

5,334,222✔

88

366✔

89

    if (m_arr->is_attached()) {

366✔

90

        Array::destroy_deep(m_arr->get_ref(), m_alloc);

360✔

91

        detach();

360✔

92

360✔

93

366✔

96

282,705✔

97

    m_arr->detach();

282,705✔

98

    // Make sure the object is in a state like right after construction

141,567✔

99

    // Next call must be to create()

141,567✔

100

    m_arr = new (&m_storage.m_string_short) ArrayStringShort(m_alloc, true);

282,705✔

101

    m_type = Type::small_strings;

282,705✔

102

282,705✔

105

15,494,007✔

106

    switch (m_type) {

15,494,007✔

107

        case Type::small_strings:

6,893,370✔

108

            return static_cast<ArrayStringShort*>(m_arr)->size();

6,893,370✔

109

        case Type::medium_strings:

425,844✔

110

            return static_cast<ArraySmallBlobs*>(m_arr)->size();

425,844✔

111

        case Type::big_strings:

8,185,950✔

112

            return static_cast<ArrayBigBlobs*>(m_arr)->size();

8,185,950✔

113

        case Type::enum_strings:

282✔

114

            return static_cast<Array*>(m_arr)->size();

282✔

120

160,215✔

121

    switch (upgrade_leaf(value.size())) {

160,215✔

122

        case Type::small_strings:

104,853✔

123

            static_cast<ArrayStringShort*>(m_arr)->add(value);

104,853✔

124

            break;

104,853✔

125

        case Type::medium_strings:

27,561✔

126

            static_cast<ArraySmallBlobs*>(m_arr)->add_string(value);

27,561✔

127

            break;

27,561✔

128

        case Type::big_strings:

27,801✔

129

            static_cast<ArrayBigBlobs*>(m_arr)->add_string(value);

27,801✔

130

            break;

27,801✔

138

160,215✔

139

160,215✔

142

3,814,779✔

143

    switch (upgrade_leaf(value.size())) {

3,814,779✔

144

        case Type::small_strings:

534,942✔

145

            static_cast<ArrayStringShort*>(m_arr)->set(ndx, value);

534,942✔

146

            break;

534,942✔

147

        case Type::medium_strings:

247,260✔

148

            static_cast<ArraySmallBlobs*>(m_arr)->set_string(ndx, value);

247,260✔

149

            break;

247,260✔

150

        case Type::big_strings:

408,864✔

151

            static_cast<ArrayBigBlobs*>(m_arr)->set_string(ndx, value);

408,864✔

152

            break;

408,864✔

153

        case Type::enum_strings: {

2,625,462✔

154

            size_t sz = m_string_enum_values->size();

2,625,462✔

155

            size_t res = m_string_enum_values->find_first(value, 0, sz);

2,625,462✔

156

            if (res == realm::not_found) {

2,625,462✔

157

                m_string_enum_values->add(value);

9,657✔

158

                res = sz;

9,657✔

159

9,657✔

160

            static_cast<Array*>(m_arr)->set(ndx, res);

2,625,462✔

161

            break;

2,625,462✔

163

3,814,779✔

164

3,814,779✔

167

3,358,044✔

168

    switch (upgrade_leaf(value.size())) {

3,358,044✔

169

        case Type::small_strings:

1,021,935✔

170

            static_cast<ArrayStringShort*>(m_arr)->insert(ndx, value);

1,021,935✔

171

            break;

1,021,935✔

172

        case Type::medium_strings:

286,194✔

173

            static_cast<ArraySmallBlobs*>(m_arr)->insert_string(ndx, value);

286,194✔

174

            break;

286,194✔

175

        case Type::big_strings:

738,492✔

176

            static_cast<ArrayBigBlobs*>(m_arr)->insert_string(ndx, value);

738,492✔

177

            break;

738,492✔

178

        case Type::enum_strings: {

1,312,668✔

179

            static_cast<Array*>(m_arr)->insert(ndx, 0);

1,312,668✔

180

            set(ndx, value);

1,312,668✔

181

1,312,668✔

182

3,358,044✔

183

3,358,044✔

186

22,443,714✔

187

    switch (m_type) {

22,443,714✔

188

        case Type::small_strings:

9,214,074✔

189

            return static_cast<ArrayStringShort*>(m_arr)->get(ndx);

9,214,074✔

190

        case Type::medium_strings:

1,374,156✔

191

            return static_cast<ArraySmallBlobs*>(m_arr)->get_string(ndx);

1,374,156✔

192

        case Type::big_strings:

8,823,471✔

193

            return static_cast<ArrayBigBlobs*>(m_arr)->get_string(ndx);

8,823,471✔

194

        case Type::enum_strings: {

3,074,727✔

195

            size_t index = size_t(static_cast<Array*>(m_arr)->get(ndx));

3,074,727✔

196

            return m_string_enum_values->get(index);

3,074,727✔

203

6,648✔

204

    switch (m_type) {

6,648✔

205

        case Type::small_strings:

402✔

206

            return static_cast<ArrayStringShort*>(m_arr)->get(ndx);

402✔

207

        case Type::medium_strings:

3,060✔

208

            return static_cast<ArraySmallBlobs*>(m_arr)->get_string_legacy(ndx);

3,060✔

209

        case Type::big_strings:

3,078✔

210

            return static_cast<ArrayBigBlobs*>(m_arr)->get_string(ndx);

3,078✔

211

        case Type::enum_strings: {

108✔

212

            size_t index = size_t(static_cast<Array*>(m_arr)->get(ndx));

108✔

213

            return m_string_enum_values->get(index);

108✔

220

22,464✔

221

    return Mixed(get(ndx));

22,464✔

222

22,464✔

225

3,876,840✔

226

    switch (m_type) {

3,876,840✔

227

        case Type::small_strings:

694,782✔

228

            return static_cast<ArrayStringShort*>(m_arr)->is_null(ndx);

694,782✔

229

        case Type::medium_strings:

10,425✔

230

            return static_cast<ArraySmallBlobs*>(m_arr)->is_null(ndx);

10,425✔

231

        case Type::big_strings:

3,178,926✔

232

            return static_cast<ArrayBigBlobs*>(m_arr)->is_null(ndx);

3,178,926✔

242

183,117✔

243

    switch (m_type) {

183,117✔

244

        case Type::small_strings:

92,148✔

245

            static_cast<ArrayStringShort*>(m_arr)->erase(ndx);

92,148✔

246

            break;

92,148✔

247

        case Type::medium_strings:

58,905✔

248

            static_cast<ArraySmallBlobs*>(m_arr)->erase(ndx);

58,905✔

249

            break;

58,905✔

250

        case Type::big_strings:

23,745✔

251

            static_cast<ArrayBigBlobs*>(m_arr)->erase(ndx);

23,745✔

252

            break;

23,745✔

253

        case Type::enum_strings:

8,322✔

254

            static_cast<Array*>(m_arr)->erase(ndx);

8,322✔

255

            break;

8,322✔

256

183,117✔

257

183,117✔

260

66✔

261

    size_t sz = size();

66✔

262

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

20,730✔

263

        dst.add(get(i));

20,664✔

264

20,664✔

265

33✔

266

    switch (m_type) {

66✔

270

        case Type::medium_strings:

60✔

271

            static_cast<ArraySmallBlobs*>(m_arr)->truncate(ndx);

60✔

272

            break;

60✔

273

        case Type::big_strings:

6✔

274

            static_cast<ArrayBigBlobs*>(m_arr)->truncate(ndx);

6✔

275

            break;

6✔

280

66✔

281

66✔

284

474✔

285

    switch (m_type) {

474✔

286

        case Type::small_strings:

420✔

287

            static_cast<ArrayStringShort*>(m_arr)->clear();

420✔

288

            break;

420✔

289

        case Type::medium_strings:

6✔

290

            static_cast<ArraySmallBlobs*>(m_arr)->clear();

6✔

291

            break;

6✔

292

        case Type::big_strings:

48✔

293

            static_cast<ArrayBigBlobs*>(m_arr)->clear();

48✔

294

            break;

48✔

298

474✔

299

474✔

302

4,076,163✔

303

    switch (m_type) {

4,076,163✔

304

        case Type::small_strings:

3,120,057✔

305

            return static_cast<ArrayStringShort*>(m_arr)->find_first(value, begin, end);

3,120,057✔

306

        case Type::medium_strings: {

104,910✔

307

            BinaryData as_binary(value.data(), value.size());

104,910✔

308

            return static_cast<ArraySmallBlobs*>(m_arr)->find_first(as_binary, true, begin, end);

104,910✔

311

        case Type::big_strings: {

255,294✔

312

            BinaryData as_binary(value.data(), value.size());

255,294✔

313

            return static_cast<ArrayBigBlobs*>(m_arr)->find_first(as_binary, true, begin, end);

255,294✔

316

        case Type::enum_strings: {

596,223✔

317

            size_t sz = m_string_enum_values->size();

596,223✔

318

            size_t res = m_string_enum_values->find_first(value, 0, sz);

596,223✔

319

            if (res != realm::not_found) {

596,223✔

320

                return static_cast<Array*>(m_arr)->find_first(res, begin, end);

596,223✔

321

596,223✔

332

437,337✔

333

    return arr->get_string(ndx);

437,337✔

334

437,337✔

338

93,690✔

339

    return arr->get(ndx);

93,690✔

340

93,690✔

344

234,912✔

345

    size_t i = 0;

234,912✔

346

    size_t sz = arr->size();

234,912✔

347

    while (0 < sz) {

765,939✔

348

        size_t half = sz / 2;

531,027✔

349

        size_t mid = i + half;

531,027✔

350

        auto probe = get_string(arr, mid);

531,027✔

351

        if (probe < value) {

531,027✔

352

            i = mid + 1;

191,424✔

353

            sz -= half + 1;

191,424✔

354

191,424✔

355

        else {

339,603✔

356

            sz = half;

339,603✔

357

339,603✔

358

531,027✔

359

    return i;

234,912✔

360

234,912✔

364

234,912✔

365

    switch (m_type) {

234,912✔

366

        case Type::small_strings:

58,434✔

367

            return lower_bound_string(static_cast<ArrayStringShort*>(m_arr), value);

58,434✔

368

        case Type::medium_strings:

68,418✔

369

            return lower_bound_string(static_cast<ArraySmallBlobs*>(m_arr), value);

68,418✔

370

        case Type::big_strings:

108,060✔

371

            return lower_bound_string(static_cast<ArrayBigBlobs*>(m_arr), value);

108,060✔

379

7,329,096✔

380

    if (m_type == Type::big_strings)

7,329,096✔

381

        return Type::big_strings;

1,137,432✔

382

3,041,406✔

383

    if (m_type == Type::enum_strings)

6,191,664✔

384

        return Type::enum_strings;

3,938,100✔

385

1,072,380✔

386

    if (m_type == Type::medium_strings) {

2,253,564✔

387

        if (value_size <= medium_string_max_size)

531,765✔

388

            return Type::medium_strings;

531,243✔

389

258✔

390

        // Upgrade root leaf from medium to big strings

258✔

391

        auto string_medium = static_cast<ArraySmallBlobs*>(m_arr);

522✔

392

        ArrayBigBlobs big_blobs(m_alloc, true);

522✔

393

        big_blobs.create(); // Throws

522✔

394

258✔

395

        size_t n = string_medium->size();

522✔

396

        for (size_t i = 0; i < n; i++) {

10,680✔

397

            big_blobs.add_string(string_medium->get_string(i)); // Throws

10,158✔

398

10,158✔

399

        auto parent = string_medium->get_parent();

522✔

400

        auto ndx_in_parent = string_medium->get_ndx_in_parent();

522✔

401

        string_medium->destroy();

522✔

402

258✔

403

        auto arr = new (&m_storage.m_big_blobs) ArrayBigBlobs(m_alloc, true);

522✔

404

        arr->init_from_mem(big_blobs.get_mem());

522✔

405

        arr->set_parent(parent, ndx_in_parent);

522✔

406

        arr->update_parent();

522✔

407

258✔

408

        m_type = Type::big_strings;

522✔

409

        return Type::big_strings;

522✔

410

522✔

411

806,124✔

412

    // m_type == Type::small

806,124✔

413

    if (value_size <= small_string_max_size)

1,721,799✔

414

        return Type::small_strings;

1,661,283✔

415

28,860✔

416

    if (value_size <= medium_string_max_size) {

60,516✔

417

        // Upgrade root leaf from small to medium strings

14,607✔

418

        auto string_short = static_cast<ArrayStringShort*>(m_arr);

29,745✔

419

        ArraySmallBlobs string_long(m_alloc);

29,745✔

420

        string_long.create(); // Throws

29,745✔

421

14,607✔

422

        size_t n = string_short->size();

29,745✔

423

        for (size_t i = 0; i < n; i++) {

64,218✔

424

            string_long.add_string(string_short->get(i)); // Throws

34,473✔

425

34,473✔

426

        auto parent = string_short->get_parent();

29,745✔

427

        auto ndx_in_parent = string_short->get_ndx_in_parent();

29,745✔

428

        string_short->destroy();

29,745✔

429

14,607✔

430

        auto arr = new (&m_storage.m_string_long) ArraySmallBlobs(m_alloc);

29,745✔

431

        arr->init_from_mem(string_long.get_mem());

29,745✔

432

        arr->set_parent(parent, ndx_in_parent);

29,745✔

433

        arr->update_parent();

29,745✔

434

14,607✔

435

        m_type = Type::medium_strings;

29,745✔

436

29,745✔

437

    else {

30,771✔

438

        // Upgrade root leaf from small to big strings

14,253✔

439

        auto string_short = static_cast<ArrayStringShort*>(m_arr);

30,771✔

440

        ArrayBigBlobs big_blobs(m_alloc, true);

30,771✔

441

        big_blobs.create(); // Throws

30,771✔

442

14,253✔

443

        size_t n = string_short->size();

30,771✔

444

        for (size_t i = 0; i < n; i++) {

68,328✔

445

            big_blobs.add_string(string_short->get(i)); // Throws

37,557✔

446

37,557✔

447

        auto parent = string_short->get_parent();

30,771✔

448

        auto ndx_in_parent = string_short->get_ndx_in_parent();

30,771✔

449

        string_short->destroy();

30,771✔

450

14,253✔

451

        auto arr = new (&m_storage.m_big_blobs) ArrayBigBlobs(m_alloc, true);

30,771✔

452

        arr->init_from_mem(big_blobs.get_mem());

30,771✔

453

        arr->set_parent(parent, ndx_in_parent);

30,771✔

454

        arr->update_parent();

30,771✔

455

14,253✔

456

        m_type = Type::big_strings;

30,771✔

457

30,771✔

458

28,860✔

459

    return m_type;

60,516✔

460

60,516✔

463

3,084,780✔

464

#ifdef REALM_DEBUG

3,084,780✔

465

    switch (m_type) {

3,084,780✔

466

        case Type::small_strings:

3,078,282✔

467

            static_cast<ArrayStringShort*>(m_arr)->verify();

3,078,282✔

468

            break;

3,078,282✔

469

        case Type::medium_strings:

1,185✔

470

            static_cast<ArraySmallBlobs*>(m_arr)->verify();

1,185✔

471

            break;

1,185✔

472

        case Type::big_strings:

5,067✔

473

            static_cast<ArrayBigBlobs*>(m_arr)->verify();

5,067✔

474

            break;

5,067✔

475

        case Type::enum_strings:

246✔

476

            static_cast<Array*>(m_arr)->verify();

246✔

477

            break;

246✔

478

3,084,780✔

479

#endif

3,084,780✔

480

3,084,780✔

realm / realm-core / thomas.goyne_121

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

1	/*************************************************************************
2	*
3	* Copyright 2016 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_string.hpp>
20	#include <realm/spec.hpp>
21	#include <realm/mixed.hpp>
22
23	using namespace realm;
24
25	ArrayString::ArrayString(Allocator& a)
26	: m_alloc(a)
27	{	20,255,580✔
28	m_arr = new (&m_storage.m_string_short) ArrayStringShort(a, true);	20,255,580✔
29	}	20,255,580✔
30
31	void ArrayString::create()
32	{	364,884✔
33	static_cast<ArrayStringShort*>(m_arr)->create();	364,884✔
34	}	364,884✔
35
36	void ArrayString::init_from_mem(MemRef mem) noexcept
37	{	18,195,918✔
38	char* header = mem.get_addr();	18,195,918✔
39		9,117,969✔
40	ArrayParent* parent = m_arr->get_parent();	18,195,918✔
41	size_t ndx_in_parent = m_arr->get_ndx_in_parent();	18,195,918✔
42		9,117,969✔
43	bool long_strings = Array::get_hasrefs_from_header(header);	18,195,918✔
44	if (!long_strings) {	18,195,918✔
45	// Small strings	6,815,076✔
46	bool is_small = Array::get_wtype_from_header(header) == Array::wtype_Multiply;	13,550,331✔
47	if (is_small) {	13,550,331✔
48	auto arr = new (&m_storage.m_string_short) ArrayStringShort(m_alloc, m_nullable);	7,891,608✔
49	arr->init_from_mem(mem);	7,891,608✔
50	m_type = Type::small_strings;	7,891,608✔
51	}	7,891,608✔
52	else {	5,658,723✔
53	auto arr = new (&m_storage.m_enum) Array(m_alloc);	5,658,723✔
54	arr->init_from_mem(mem);	5,658,723✔
55	m_string_enum_values = std::make_unique<ArrayString>(m_alloc);	5,658,723✔
56	ArrayParent* p;	5,658,723✔
57	REALM_ASSERT(m_spec != nullptr);	5,658,723✔
58	REALM_ASSERT(m_col_ndx != realm::npos);	5,658,723✔
59	ref_type r = m_spec->get_enumkeys_ref(m_col_ndx, p);	5,658,723✔
60	m_string_enum_values->init_from_ref(r);	5,658,723✔
61	m_string_enum_values->set_parent(p, m_col_ndx);	5,658,723✔
62	m_type = Type::enum_strings;	5,658,723✔
63	}	5,658,723✔
64	}	13,550,331✔
65	else {	4,645,587✔
66	bool is_big = Array::get_context_flag_from_header(header);	4,645,587✔
67	if (!is_big) {	4,645,587✔
68	auto arr = new (&m_storage.m_string_long) ArraySmallBlobs(m_alloc);	1,207,197✔
69	arr->init_from_mem(mem);	1,207,197✔
70	m_type = Type::medium_strings;	1,207,197✔
71	}	1,207,197✔
72	else {	3,438,390✔
73	auto arr = new (&m_storage.m_big_blobs) ArrayBigBlobs(m_alloc, m_nullable);	3,438,390✔
74	arr->init_from_mem(mem);	3,438,390✔
75	m_type = Type::big_strings;	3,438,390✔
76	}	3,438,390✔
77	}	4,645,587✔
78	m_arr->set_parent(parent, ndx_in_parent);	18,195,918✔
79	}	18,195,918✔
80
81	void ArrayString::init_from_parent()
82	{	5,334,222✔
83	ref_type ref = m_arr->get_ref_from_parent();	5,334,222✔
84	init_from_ref(ref);	5,334,222✔
85	}	5,334,222✔
86
87	void ArrayString::destroy() noexcept
88	{	366✔
89	if (m_arr->is_attached()) {	366✔
90	Array::destroy_deep(m_arr->get_ref(), m_alloc);	360✔
91	detach();	360✔
92	}	360✔
93	}	366✔
94
95	void ArrayString::detach() noexcept
96	{	282,705✔
97	m_arr->detach();	282,705✔
98	// Make sure the object is in a state like right after construction	141,567✔
99	// Next call must be to create()	141,567✔
100	m_arr = new (&m_storage.m_string_short) ArrayStringShort(m_alloc, true);	282,705✔
101	m_type = Type::small_strings;	282,705✔
102	}	282,705✔
103
104	size_t ArrayString::size() const
105	{	15,494,007✔
106	switch (m_type) {	15,494,007✔
107	case Type::small_strings:	6,893,370✔
108	return static_cast<ArrayStringShort*>(m_arr)->size();	6,893,370✔
109	case Type::medium_strings:	425,844✔
110	return static_cast<ArraySmallBlobs*>(m_arr)->size();	425,844✔
111	case Type::big_strings:	8,185,950✔
112	return static_cast<ArrayBigBlobs*>(m_arr)->size();	8,185,950✔
113	case Type::enum_strings:	282✔
114	return static_cast<Array*>(m_arr)->size();	282✔
115	}	×
116	return {};	×
117	}	×
118
119	void ArrayString::add(StringData value)
120	{	160,215✔
121	switch (upgrade_leaf(value.size())) {	160,215✔
122	case Type::small_strings:	104,853✔
123	static_cast<ArrayStringShort*>(m_arr)->add(value);	104,853✔
124	break;	104,853✔
125	case Type::medium_strings:	27,561✔
126	static_cast<ArraySmallBlobs*>(m_arr)->add_string(value);	27,561✔
127	break;	27,561✔
128	case Type::big_strings:	27,801✔
129	static_cast<ArrayBigBlobs*>(m_arr)->add_string(value);	27,801✔
130	break;	27,801✔
131	case Type::enum_strings: {	✔
132	auto a = static_cast<Array*>(m_arr);	×
133	size_t ndx = a->size();	×
134	a->add(0);	×
135	set(ndx, value);	×
136	break;	×
137	}	×
138	}	160,215✔
139	}	160,215✔
140
141	void ArrayString::set(size_t ndx, StringData value)
142	{	3,814,779✔
143	switch (upgrade_leaf(value.size())) {	3,814,779✔
144	case Type::small_strings:	534,942✔
145	static_cast<ArrayStringShort*>(m_arr)->set(ndx, value);	534,942✔
146	break;	534,942✔
147	case Type::medium_strings:	247,260✔
148	static_cast<ArraySmallBlobs*>(m_arr)->set_string(ndx, value);	247,260✔
149	break;	247,260✔
150	case Type::big_strings:	408,864✔
151	static_cast<ArrayBigBlobs*>(m_arr)->set_string(ndx, value);	408,864✔
152	break;	408,864✔
153	case Type::enum_strings: {	2,625,462✔
154	size_t sz = m_string_enum_values->size();	2,625,462✔
155	size_t res = m_string_enum_values->find_first(value, 0, sz);	2,625,462✔
156	if (res == realm::not_found) {	2,625,462✔
157	m_string_enum_values->add(value);	9,657✔
158	res = sz;	9,657✔
159	}	9,657✔
160	static_cast<Array*>(m_arr)->set(ndx, res);	2,625,462✔
161	break;	2,625,462✔
162	}	×
163	}	3,814,779✔
164	}	3,814,779✔
165
166	void ArrayString::insert(size_t ndx, StringData value)
167	{	3,358,044✔
168	switch (upgrade_leaf(value.size())) {	3,358,044✔
169	case Type::small_strings:	1,021,935✔
170	static_cast<ArrayStringShort*>(m_arr)->insert(ndx, value);	1,021,935✔
171	break;	1,021,935✔
172	case Type::medium_strings:	286,194✔
173	static_cast<ArraySmallBlobs*>(m_arr)->insert_string(ndx, value);	286,194✔
174	break;	286,194✔
175	case Type::big_strings:	738,492✔
176	static_cast<ArrayBigBlobs*>(m_arr)->insert_string(ndx, value);	738,492✔
177	break;	738,492✔
178	case Type::enum_strings: {	1,312,668✔
179	static_cast<Array*>(m_arr)->insert(ndx, 0);	1,312,668✔
180	set(ndx, value);	1,312,668✔
181	}	1,312,668✔
182	}	3,358,044✔
183	}	3,358,044✔
184
185	StringData ArrayString::get(size_t ndx) const
186	{	22,443,714✔
187	switch (m_type) {	22,443,714✔
188	case Type::small_strings:	9,214,074✔
189	return static_cast<ArrayStringShort*>(m_arr)->get(ndx);	9,214,074✔
190	case Type::medium_strings:	1,374,156✔
191	return static_cast<ArraySmallBlobs*>(m_arr)->get_string(ndx);	1,374,156✔
192	case Type::big_strings:	8,823,471✔
193	return static_cast<ArrayBigBlobs*>(m_arr)->get_string(ndx);	8,823,471✔
194	case Type::enum_strings: {	3,074,727✔
195	size_t index = size_t(static_cast<Array*>(m_arr)->get(ndx));	3,074,727✔
196	return m_string_enum_values->get(index);	3,074,727✔
197	}	×
198	}	×
199	return {};	×
200	}	×
201
202	StringData ArrayString::get_legacy(size_t ndx) const
203	{	6,648✔
204	switch (m_type) {	6,648✔
205	case Type::small_strings:	402✔
206	return static_cast<ArrayStringShort*>(m_arr)->get(ndx);	402✔
207	case Type::medium_strings:	3,060✔
208	return static_cast<ArraySmallBlobs*>(m_arr)->get_string_legacy(ndx);	3,060✔
209	case Type::big_strings:	3,078✔
210	return static_cast<ArrayBigBlobs*>(m_arr)->get_string(ndx);	3,078✔
211	case Type::enum_strings: {	108✔
212	size_t index = size_t(static_cast<Array*>(m_arr)->get(ndx));	108✔
213	return m_string_enum_values->get(index);	108✔
214	}	×
215	}	×
216	return {};	×
217	}	×
218
219	Mixed ArrayString::get_any(size_t ndx) const
220	{	22,464✔
221	return Mixed(get(ndx));	22,464✔
222	}	22,464✔
223
224	bool ArrayString::is_null(size_t ndx) const
225	{	3,876,840✔
226	switch (m_type) {	3,876,840✔
227	case Type::small_strings:	694,782✔
228	return static_cast<ArrayStringShort*>(m_arr)->is_null(ndx);	694,782✔
229	case Type::medium_strings:	10,425✔
230	return static_cast<ArraySmallBlobs*>(m_arr)->is_null(ndx);	10,425✔
231	case Type::big_strings:	3,178,926✔
232	return static_cast<ArrayBigBlobs*>(m_arr)->is_null(ndx);	3,178,926✔
233	case Type::enum_strings: {	✔
234	size_t index = size_t(static_cast<Array*>(m_arr)->get(ndx));	×
235	return m_string_enum_values->is_null(index);	×
236	}	×
237	}	×
238	return {};	×
239	}	×
240
241	void ArrayString::erase(size_t ndx)
242	{	183,117✔
243	switch (m_type) {	183,117✔
244	case Type::small_strings:	92,148✔
245	static_cast<ArrayStringShort*>(m_arr)->erase(ndx);	92,148✔
246	break;	92,148✔
247	case Type::medium_strings:	58,905✔
248	static_cast<ArraySmallBlobs*>(m_arr)->erase(ndx);	58,905✔
249	break;	58,905✔
250	case Type::big_strings:	23,745✔
251	static_cast<ArrayBigBlobs*>(m_arr)->erase(ndx);	23,745✔
252	break;	23,745✔
253	case Type::enum_strings:	8,322✔
254	static_cast<Array*>(m_arr)->erase(ndx);	8,322✔
255	break;	8,322✔
256	}	183,117✔
257	}	183,117✔
258
259	void ArrayString::move(ArrayString& dst, size_t ndx)
260	{	66✔
261	size_t sz = size();	66✔
262	for (size_t i = ndx; i < sz; i++) {	20,730✔
263	dst.add(get(i));	20,664✔
264	}	20,664✔
265		33✔
266	switch (m_type) {	66✔
267	case Type::small_strings:	✔
268	static_cast<ArrayStringShort*>(m_arr)->truncate(ndx);	×
269	break;	×
270	case Type::medium_strings:	60✔
271	static_cast<ArraySmallBlobs*>(m_arr)->truncate(ndx);	60✔
272	break;	60✔
273	case Type::big_strings:	6✔
274	static_cast<ArrayBigBlobs*>(m_arr)->truncate(ndx);	6✔
275	break;	6✔
276	case Type::enum_strings:	✔
277	// this operation will never be called for enumerated columns
278	REALM_UNREACHABLE();
279	break;	×
280	}	66✔
281	}	66✔
282
283	void ArrayString::clear()
284	{	474✔
285	switch (m_type) {	474✔
286	case Type::small_strings:	420✔
287	static_cast<ArrayStringShort*>(m_arr)->clear();	420✔
288	break;	420✔
289	case Type::medium_strings:	6✔
290	static_cast<ArraySmallBlobs*>(m_arr)->clear();	6✔
291	break;	6✔
292	case Type::big_strings:	48✔
293	static_cast<ArrayBigBlobs*>(m_arr)->clear();	48✔
294	break;	48✔
295	case Type::enum_strings:	✔
296	static_cast<Array*>(m_arr)->clear();	×
297	break;	×
298	}	474✔
299	}	474✔
300
301	size_t ArrayString::find_first(StringData value, size_t begin, size_t end) const noexcept
302	{	4,076,163✔
303	switch (m_type) {	4,076,163✔
304	case Type::small_strings:	3,120,057✔
305	return static_cast<ArrayStringShort*>(m_arr)->find_first(value, begin, end);	3,120,057✔
306	case Type::medium_strings: {	104,910✔
307	BinaryData as_binary(value.data(), value.size());	104,910✔
308	return static_cast<ArraySmallBlobs*>(m_arr)->find_first(as_binary, true, begin, end);	104,910✔
309	break;	×
310	}	×
311	case Type::big_strings: {	255,294✔
312	BinaryData as_binary(value.data(), value.size());	255,294✔
313	return static_cast<ArrayBigBlobs*>(m_arr)->find_first(as_binary, true, begin, end);	255,294✔
314	break;	×
315	}	×
316	case Type::enum_strings: {	596,223✔
317	size_t sz = m_string_enum_values->size();	596,223✔
318	size_t res = m_string_enum_values->find_first(value, 0, sz);	596,223✔
319	if (res != realm::not_found) {	596,223✔
320	return static_cast<Array*>(m_arr)->find_first(res, begin, end);	596,223✔
321	}	596,223✔
322	break;	×
323	}	×
324	}	×
325	return not_found;	×
326	}	×
327
328	namespace {
329
330	template <class T>
331	inline StringData get_string(const T* arr, size_t ndx)
332	{	437,337✔
333	return arr->get_string(ndx);	437,337✔
334	}	437,337✔
335
336	template <>
337	inline StringData get_string(const ArrayStringShort* arr, size_t ndx)
338	{	93,690✔
339	return arr->get(ndx);	93,690✔
340	}	93,690✔
341
342	template <class T, class U>
343	size_t lower_bound_string(const T* arr, U value)
344	{	234,912✔
345	size_t i = 0;	234,912✔
346	size_t sz = arr->size();	234,912✔
347	while (0 < sz) {	765,939✔
348	size_t half = sz / 2;	531,027✔
349	size_t mid = i + half;	531,027✔
350	auto probe = get_string(arr, mid);	531,027✔
351	if (probe < value) {	531,027✔
352	i = mid + 1;	191,424✔
353	sz -= half + 1;	191,424✔
354	}	191,424✔
355	else {	339,603✔
356	sz = half;	339,603✔
357	}	339,603✔
358	}	531,027✔
359	return i;	234,912✔
360	}	234,912✔
361	}
362
363	size_t ArrayString::lower_bound(StringData value)
364	{	234,912✔
365	switch (m_type) {	234,912✔
366	case Type::small_strings:	58,434✔
367	return lower_bound_string(static_cast<ArrayStringShort*>(m_arr), value);	58,434✔
368	case Type::medium_strings:	68,418✔
369	return lower_bound_string(static_cast<ArraySmallBlobs*>(m_arr), value);	68,418✔
370	case Type::big_strings:	108,060✔
371	return lower_bound_string(static_cast<ArrayBigBlobs*>(m_arr), value);	108,060✔
372	case Type::enum_strings:	✔
373	break;	×
374	}	×
375	return realm::npos;	×
376	}	×
377
378	ArrayString::Type ArrayString::upgrade_leaf(size_t value_size)
379	{	7,329,096✔
380	if (m_type == Type::big_strings)	7,329,096✔
381	return Type::big_strings;	1,137,432✔
382		3,041,406✔
383	if (m_type == Type::enum_strings)	6,191,664✔
384	return Type::enum_strings;	3,938,100✔
385		1,072,380✔
386	if (m_type == Type::medium_strings) {	2,253,564✔
387	if (value_size <= medium_string_max_size)	531,765✔
388	return Type::medium_strings;	531,243✔
389		258✔
390	// Upgrade root leaf from medium to big strings	258✔
391	auto string_medium = static_cast<ArraySmallBlobs*>(m_arr);	522✔
392	ArrayBigBlobs big_blobs(m_alloc, true);	522✔
393	big_blobs.create(); // Throws	522✔
394		258✔
395	size_t n = string_medium->size();	522✔
396	for (size_t i = 0; i < n; i++) {	10,680✔
397	big_blobs.add_string(string_medium->get_string(i)); // Throws	10,158✔
398	}	10,158✔
399	auto parent = string_medium->get_parent();	522✔
400	auto ndx_in_parent = string_medium->get_ndx_in_parent();	522✔
401	string_medium->destroy();	522✔
402		258✔
403	auto arr = new (&m_storage.m_big_blobs) ArrayBigBlobs(m_alloc, true);	522✔
404	arr->init_from_mem(big_blobs.get_mem());	522✔
405	arr->set_parent(parent, ndx_in_parent);	522✔
406	arr->update_parent();	522✔
407		258✔
408	m_type = Type::big_strings;	522✔
409	return Type::big_strings;	522✔
410	}	522✔
411		806,124✔
412	// m_type == Type::small	806,124✔
413	if (value_size <= small_string_max_size)	1,721,799✔
414	return Type::small_strings;	1,661,283✔
415		28,860✔
416	if (value_size <= medium_string_max_size) {	60,516✔
417	// Upgrade root leaf from small to medium strings	14,607✔
418	auto string_short = static_cast<ArrayStringShort*>(m_arr);	29,745✔
419	ArraySmallBlobs string_long(m_alloc);	29,745✔
420	string_long.create(); // Throws	29,745✔
421		14,607✔
422	size_t n = string_short->size();	29,745✔
423	for (size_t i = 0; i < n; i++) {	64,218✔
424	string_long.add_string(string_short->get(i)); // Throws	34,473✔
425	}	34,473✔
426	auto parent = string_short->get_parent();	29,745✔
427	auto ndx_in_parent = string_short->get_ndx_in_parent();	29,745✔
428	string_short->destroy();	29,745✔
429		14,607✔
430	auto arr = new (&m_storage.m_string_long) ArraySmallBlobs(m_alloc);	29,745✔
431	arr->init_from_mem(string_long.get_mem());	29,745✔
432	arr->set_parent(parent, ndx_in_parent);	29,745✔
433	arr->update_parent();	29,745✔
434		14,607✔
435	m_type = Type::medium_strings;	29,745✔
436	}	29,745✔
437	else {	30,771✔
438	// Upgrade root leaf from small to big strings	14,253✔
439	auto string_short = static_cast<ArrayStringShort*>(m_arr);	30,771✔
440	ArrayBigBlobs big_blobs(m_alloc, true);	30,771✔
441	big_blobs.create(); // Throws	30,771✔
442		14,253✔
443	size_t n = string_short->size();	30,771✔
444	for (size_t i = 0; i < n; i++) {	68,328✔
445	big_blobs.add_string(string_short->get(i)); // Throws	37,557✔
446	}	37,557✔
447	auto parent = string_short->get_parent();	30,771✔
448	auto ndx_in_parent = string_short->get_ndx_in_parent();	30,771✔
449	string_short->destroy();	30,771✔
450		14,253✔
451	auto arr = new (&m_storage.m_big_blobs) ArrayBigBlobs(m_alloc, true);	30,771✔
452	arr->init_from_mem(big_blobs.get_mem());	30,771✔
453	arr->set_parent(parent, ndx_in_parent);	30,771✔
454	arr->update_parent();	30,771✔
455		14,253✔
456	m_type = Type::big_strings;	30,771✔
457	}	30,771✔
458		28,860✔
459	return m_type;	60,516✔
460	}	60,516✔
461
462	void ArrayString::verify() const
463	{	3,084,780✔
464	#ifdef REALM_DEBUG	3,084,780✔
465	switch (m_type) {	3,084,780✔
466	case Type::small_strings:	3,078,282✔
467	static_cast<ArrayStringShort*>(m_arr)->verify();	3,078,282✔
468	break;	3,078,282✔
469	case Type::medium_strings:	1,185✔
470	static_cast<ArraySmallBlobs*>(m_arr)->verify();	1,185✔
471	break;	1,185✔
472	case Type::big_strings:	5,067✔
473	static_cast<ArrayBigBlobs*>(m_arr)->verify();	5,067✔
474	break;	5,067✔
475	case Type::enum_strings:	246✔
476	static_cast<Array*>(m_arr)->verify();	246✔
477	break;	246✔
478	}	3,084,780✔
479	#endif	3,084,780✔
480	}	3,084,780✔

realm / realm-core / thomas.goyne_121

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