• Home
  • Features
  • Pricing
  • Docs
  • Announcements
  • Sign In

realm / realm-core / 1707

25 Sep 2023 06:02PM CUT coverage: 91.192% (-0.006%) from 91.198%
1707

push

Evergreen

web-flow
Fixed double delete in CAPITimer and add documentation for platform networking CAPI integration (#6994)

* Fixed double delete in CAPITimer and added individual functions for handling callbacks.
* Added realm_sync_socket_write_complete() fcn and other updates from review
* Don't call handler functions more than once, esp for timers; updated documentation
* Updated some comments
* Updated changelog after release

95848 of 175718 branches covered (0.0%)

20 of 33 new or added lines in 2 files covered. (60.61%)

65 existing lines in 13 files now uncovered.

232403 of 254849 relevant lines covered (91.19%)

6713313.75 hits per line

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

98.72
/src/realm/array_blobs_big.cpp
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 <algorithm>
20

21
#include <realm/array_blobs_big.hpp>
22
#include <realm/column_integer.hpp>
23

24

25
using namespace realm;
26

27
BinaryData ArrayBigBlobs::get_at(size_t ndx, size_t& pos) const noexcept
28
{
315,300✔
29
    ref_type ref = get_as_ref(ndx);
315,300✔
30
    if (ref == 0)
315,300✔
31
        return {}; // realm::null();
59,754✔
32

124,029✔
33
    ArrayBlob blob(m_alloc);
255,546✔
34
    blob.init_from_ref(ref);
255,546✔
35

124,029✔
36
    return blob.get_at(pos);
255,546✔
37
}
255,546✔
38

39

40
void ArrayBigBlobs::add(BinaryData value, bool add_zero_term)
41
{
105,306✔
42
    REALM_ASSERT_7(value.size(), ==, 0, ||, value.data(), !=, 0);
105,306✔
43

52,311✔
44
    if (value.is_null()) {
105,306✔
45
        Array::add(0); // Throws
51,750✔
46
    }
51,750✔
47
    else {
53,556✔
48
        ArrayBlob new_blob(m_alloc);
53,556✔
49
        new_blob.create();                                                      // Throws
53,556✔
50
        ref_type ref = new_blob.add(value.data(), value.size(), add_zero_term); // Throws
53,556✔
51
        Array::add(from_ref(ref));                                              // Throws
53,556✔
52
    }
53,556✔
53
}
105,306✔
54

55

56
void ArrayBigBlobs::set(size_t ndx, BinaryData value, bool add_zero_term)
57
{
5,453,067✔
58
    REALM_ASSERT_3(ndx, <, size());
5,453,067✔
59
    REALM_ASSERT_7(value.size(), ==, 0, ||, value.data(), !=, 0);
5,453,067✔
60

2,720,787✔
61
    ref_type ref = get_as_ref(ndx);
5,453,067✔
62

2,720,787✔
63
    if (ref == 0 && value.is_null()) {
5,453,067✔
64
        return;
1,662✔
65
    }
1,662✔
66
    else if (ref == 0 && value.data() != nullptr) {
5,451,405✔
67
        ArrayBlob new_blob(m_alloc);
1,400,133✔
68
        new_blob.create();                                             // Throws
1,400,133✔
69
        ref = new_blob.add(value.data(), value.size(), add_zero_term); // Throws
1,400,133✔
70
        Array::set_as_ref(ndx, ref);
1,400,133✔
71
        return;
1,400,133✔
72
    }
1,400,133✔
73
    else if (ref != 0 && value.data() != nullptr) {
4,051,272✔
74
        char* header = m_alloc.translate(ref);
4,038,762✔
75
        if (Array::get_context_flag_from_header(header)) {
4,038,762✔
76
            Array arr(m_alloc);
6✔
77
            arr.init_from_mem(MemRef(header, ref, m_alloc));
6✔
78
            arr.set_parent(this, ndx);
6✔
79
            ref_type new_ref =
6✔
80
                arr.blob_replace(0, arr.blob_size(), value.data(), value.size(), add_zero_term); // Throws
6✔
81
            if (new_ref != ref) {
6✔
UNCOV
82
                Array::set_as_ref(ndx, new_ref);
×
UNCOV
83
            }
×
84
        }
6✔
85
        else {
4,038,756✔
86
            ArrayBlob blob(m_alloc);
4,038,756✔
87
            blob.init_from_mem(MemRef(header, ref, m_alloc));
4,038,756✔
88
            blob.set_parent(this, ndx);
4,038,756✔
89
            ref_type new_ref = blob.replace(0, blob.blob_size(), value.data(), value.size(), add_zero_term); // Throws
4,038,756✔
90
            if (new_ref != ref) {
4,038,756✔
91
                Array::set_as_ref(ndx, new_ref);
3,670,650✔
92
            }
3,670,650✔
93
        }
4,038,756✔
94
        return;
4,038,762✔
95
    }
4,038,762✔
96
    else if (ref != 0 && value.is_null()) {
12,510✔
97
        Array::destroy_deep(ref, get_alloc());
7,944✔
98
        Array::set(ndx, 0);
7,944✔
99
        return;
7,944✔
100
    }
7,944✔
101
    REALM_ASSERT(false);
4,566✔
102
}
4,566✔
103

104

105
void ArrayBigBlobs::insert(size_t ndx, BinaryData value, bool add_zero_term)
106
{
2,329,779✔
107
    REALM_ASSERT_3(ndx, <=, size());
2,329,779✔
108
    REALM_ASSERT_7(value.size(), ==, 0, ||, value.data(), !=, 0);
2,329,779✔
109

1,155,999✔
110
    if (value.is_null()) {
2,329,779✔
111
        Array::insert(ndx, 0); // Throws
1,408,314✔
112
    }
1,408,314✔
113
    else {
921,465✔
114
        ArrayBlob new_blob(m_alloc);
921,465✔
115
        new_blob.create();                                                      // Throws
921,465✔
116
        ref_type ref = new_blob.add(value.data(), value.size(), add_zero_term); // Throws
921,465✔
117

453,351✔
118
        Array::insert(ndx, int64_t(ref)); // Throws
921,465✔
119
    }
921,465✔
120
}
2,329,779✔
121

122

123
size_t ArrayBigBlobs::count(BinaryData value, bool is_string, size_t begin, size_t end) const noexcept
124
{
12✔
125
    size_t num_matches = 0;
12✔
126

6✔
127
    size_t begin_2 = begin;
12✔
128
    for (;;) {
48✔
129
        size_t ndx = find_first(value, is_string, begin_2, end);
48✔
130
        if (ndx == not_found)
48✔
131
            break;
12✔
132
        ++num_matches;
36✔
133
        begin_2 = ndx + 1;
36✔
134
    }
36✔
135

6✔
136
    return num_matches;
12✔
137
}
12✔
138

139

140
size_t ArrayBigBlobs::find_first(BinaryData value, bool is_string, size_t begin, size_t end) const noexcept
141
{
254,679✔
142
    if (end == npos)
254,679✔
143
        end = m_size;
108✔
144
    REALM_ASSERT_11(begin, <=, m_size, &&, end, <=, m_size, &&, begin, <=, end);
254,679✔
145

127,071✔
146
    // When strings are stored as blobs, they are always zero-terminated
127,071✔
147
    // but the value we get as input might not be.
127,071✔
148
    size_t value_size = value.size();
254,679✔
149
    size_t full_size = is_string ? value_size + 1 : value_size;
254,652✔
150

127,071✔
151
    if (value.is_null()) {
254,679✔
152
        for (size_t i = begin; i != end; ++i) {
66,684✔
153
            ref_type ref = get_as_ref(i);
66,678✔
154
            if (ref == 0)
66,678✔
155
                return i;
66,630✔
156
        }
66,678✔
157
    }
66,636✔
158
    else {
188,043✔
159
        for (size_t i = begin; i != end; ++i) {
2,529,474✔
160
            ref_type ref = get_as_ref(i);
2,515,053✔
161
            if (ref) {
2,515,053✔
162
                const char* blob_header = get_alloc().translate(ref);
2,451,441✔
163
                size_t sz = get_size_from_header(blob_header);
2,451,441✔
164
                if (sz == full_size) {
2,451,441✔
165
                    const char* blob_value = ArrayBlob::get(blob_header, 0);
971,586✔
166
                    if (std::equal(blob_value, blob_value + value_size, value.data()))
971,586✔
167
                        return i;
173,622✔
168
                }
971,586✔
169
            }
2,451,441✔
170
        }
2,515,053✔
171
    }
188,043✔
172

127,071✔
173
    return not_found;
134,337✔
174
}
254,679✔
175

176

177
void ArrayBigBlobs::find_all(IntegerColumn& result, BinaryData value, bool is_string, size_t add_offset, size_t begin,
178
                             size_t end)
179
{
12✔
180
    size_t begin_2 = begin;
12✔
181
    for (;;) {
48✔
182
        size_t ndx = find_first(value, is_string, begin_2, end);
48✔
183
        if (ndx == not_found)
48✔
184
            break;
12✔
185
        result.add(add_offset + ndx); // Throws
36✔
186
        begin_2 = ndx + 1;
36✔
187
    }
36✔
188
}
12✔
189

190

191

192
void ArrayBigBlobs::verify() const
193
{
17,808✔
194
#ifdef REALM_DEBUG
17,808✔
195
    REALM_ASSERT(has_refs());
17,808✔
196
    for (size_t i = 0; i < size(); ++i) {
66,492✔
197
        ref_type blob_ref = Array::get_as_ref(i);
48,684✔
198
        // 0 is used to indicate realm::null()
23,871✔
199
        if (blob_ref != 0) {
48,684✔
200
            ArrayBlob blob(m_alloc);
47,130✔
201
            blob.init_from_ref(blob_ref);
47,130✔
202
            blob.verify();
47,130✔
203
        }
47,130✔
204
    }
48,684✔
205
#endif
17,808✔
206
}
17,808✔
207

STATUS · Troubleshooting · Open an Issue · Sales · Support · CAREERS · ENTERPRISE · START FREE · SCHEDULE DEMO
ANNOUNCEMENTS · TWITTER · TOS & SLA · Supported CI Services · What's a CI service? · Automated Testing

© 2025 Coveralls, Inc