1 #include "JSONNode.h"
2
3 #ifdef JSON_ITERATORS
4 #ifdef JSON_REF_COUNT
5 #define JSON_ASSERT_UNIQUE(x) JSON_ASSERT(internal -> refcount == 1, json_string(JSON_TEXT(x)) + JSON_TEXT(" in non single reference"))
6 #else
7 #define JSON_ASSERT_UNIQUE(x) (void)0
8 #endif
9
10 #ifdef JSON_MUTEX_CALLBACKS
11 #define JSON_MUTEX_COPY2 ,internal -> mylock
12 #else
13 #define JSON_MUTEX_COPY2
14 #endif
15
find(const json_string & name_t)16 JSONNode::json_iterator JSONNode::find(const json_string & name_t) json_nothrow {
17 JSON_CHECK_INTERNAL();
18 JSON_ASSERT(type() == JSON_NODE, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("find"));
19 makeUniqueInternal();
20 if (JSONNode ** res = internal -> at(name_t)){
21 return ptr_to_json_iterator(res);
22 }
23 return end();
24 }
25
26 #ifdef JSON_CASE_INSENSITIVE_FUNCTIONS
find_nocase(const json_string & name_t)27 JSONNode::json_iterator JSONNode::find_nocase(const json_string & name_t) json_nothrow {
28 JSON_CHECK_INTERNAL();
29 JSON_ASSERT(type() == JSON_NODE, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("find_nocase"));
30 makeUniqueInternal();
31 if (JSONNode ** res = internal -> at_nocase(name_t)){
32 return ptr_to_json_iterator(res);
33 }
34 return end();
35 }
36 #endif
37
erase(json_iterator pos)38 JSONNode::json_iterator JSONNode::erase(json_iterator pos) json_nothrow {
39 JSON_CHECK_INTERNAL();
40 JSON_ASSERT(type() == JSON_NODE || type() == JSON_ARRAY, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("erase"));
41 JSON_ASSERT_UNIQUE("erase 1");
42 JSON_ASSERT_SAFE(pos < end(), JSON_TEXT("erase out of range"), return end(););
43 JSON_ASSERT_SAFE(pos >= begin(), JSON_TEXT("erase out of range"), return begin(););
44 deleteJSONNode(*(json_iterator_ptr(pos)));
45 internal -> CHILDREN -> erase(json_iterator_ptr(pos));
46 return (empty()) ? end() : pos;
47 }
48
erase(json_iterator _start,const json_iterator & _end)49 JSONNode::json_iterator JSONNode::erase(json_iterator _start, const json_iterator & _end) json_nothrow {
50 if (_start == _end) return _start;
51 JSON_CHECK_INTERNAL();
52 JSON_ASSERT(type() == JSON_NODE || type() == JSON_ARRAY, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("erase"));
53 JSON_ASSERT_UNIQUE("erase 3");
54 JSON_ASSERT_SAFE(_start <= end(), JSON_TEXT("erase out of lo range"), return end(););
55 JSON_ASSERT_SAFE(_end <= end(), JSON_TEXT("erase out of hi range"), return end(););
56 JSON_ASSERT_SAFE(_start >= begin(), JSON_TEXT("erase out of lo range"), return begin(););
57 JSON_ASSERT_SAFE(_end >= begin(), JSON_TEXT("erase out of hi range"), return begin(););
58 for (JSONNode ** pos = json_iterator_ptr(_start); pos < json_iterator_ptr(_end); ++pos){
59 deleteJSONNode(*pos);
60 }
61
62 internal -> CHILDREN -> erase(json_iterator_ptr(_start), (json_index_t)(json_iterator_ptr(_end) - json_iterator_ptr(_start)));
63 return (empty()) ? end() : _start;
64 }
65
66 #ifdef JSON_LIBRARY
insert(json_iterator pos,JSONNode * x)67 JSONNode::json_iterator JSONNode::insert(json_iterator pos, JSONNode * x) json_nothrow {
68 #else
69 JSONNode::json_iterator JSONNode::insert(json_iterator pos, const JSONNode & x) json_nothrow {
70 #endif
71 JSON_CHECK_INTERNAL();
72 JSON_ASSERT(type() == JSON_NODE || type() == JSON_ARRAY, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("insert"));
73 JSON_ASSERT_UNIQUE("insert 1");
74 if (json_iterator_ptr(pos) >= internal -> CHILDREN -> end()){
75 internal -> push_back(x);
76 return end() - 1;
77 }
78 JSON_ASSERT_SAFE(pos >= begin(), JSON_TEXT("insert out of lo range"), return begin(););
79 #ifdef JSON_LIBRARY
80 internal -> CHILDREN -> insert(json_iterator_ptr(pos), x);
81 #else
82 internal -> CHILDREN -> insert(json_iterator_ptr(pos), newJSONNode(x));
83 #endif
84 return pos;
85 }
86
87 JSONNode::json_iterator JSONNode::insertFFF(json_iterator pos, JSONNode ** const _start, JSONNode ** const _end) json_nothrow {
88 JSON_CHECK_INTERNAL();
89 JSON_ASSERT(type() == JSON_NODE || type() == JSON_ARRAY, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("insertFFF"));
90 JSON_ASSERT_UNIQUE("insertFFF");
91 JSON_ASSERT_SAFE(pos <= end(), JSON_TEXT("insert out of high range"), return end(););
92 JSON_ASSERT_SAFE(pos >= begin(), JSON_TEXT("insert out of low range"), return begin(););
93 const json_index_t num = (json_index_t)(_end - _start);
94 json_auto<JSONNode *> mem(num);
95 JSONNode ** runner = mem.ptr;
96 for (JSONNode ** po = _start; po < _end; ++po){
97 *runner++ = newJSONNode(*(*po) JSON_MUTEX_COPY2);
98 }
99 internal -> CHILDREN -> insert(json_iterator_ptr(pos), mem.ptr, num);
100 return pos;
101 }
102
103 #ifndef JSON_LIBRARY
104 JSONNode::const_iterator JSONNode::find(const json_string & name_t) const json_nothrow {
105 JSON_CHECK_INTERNAL();
106 JSON_ASSERT(type() == JSON_NODE, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("find"));
107 if (JSONNode ** res = internal -> at(name_t)){
108 return JSONNode::const_iterator(res);
109 }
110 return JSONNode::const_iterator(internal -> end());
111 }
112
113 #ifdef JSON_CASE_INSENSITIVE_FUNCTIONS
114 JSONNode::const_iterator JSONNode::find_nocase(const json_string & name_t) const json_nothrow {
115 JSON_CHECK_INTERNAL();
116 JSON_ASSERT(type() == JSON_NODE, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("find_nocase"));
117 if (JSONNode ** res = internal -> at_nocase(name_t)){
118 return JSONNode::const_iterator(res);
119 }
120 return JSONNode::const_iterator(internal -> end());
121 }
122 #endif
123
124 JSONNode::reverse_iterator JSONNode::erase(reverse_iterator pos) json_nothrow {
125 JSON_CHECK_INTERNAL();
126 JSON_ASSERT(type() == JSON_NODE || type() == JSON_ARRAY, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("erase"));
127 JSON_ASSERT_UNIQUE("erase 2");
128 JSON_ASSERT_SAFE(pos < rend(), JSON_TEXT("erase out of range"), return rend(););
129 JSON_ASSERT_SAFE(pos >= rbegin(), JSON_TEXT("erase out of range"), return rbegin(););
130 deleteJSONNode(*(pos.it));
131 internal -> CHILDREN -> erase(pos.it);
132 return (empty()) ? rend() : pos + 1;
133 }
134
135 JSONNode::reverse_iterator JSONNode::erase(reverse_iterator _start, const reverse_iterator & _end) json_nothrow {
136 if (_start == _end) return _start;
137 JSON_CHECK_INTERNAL();
138 JSON_ASSERT(type() == JSON_NODE || type() == JSON_ARRAY, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("erase"));
139 JSON_ASSERT_UNIQUE("erase 4");
140 JSON_ASSERT_SAFE(_start <= rend(), JSON_TEXT("erase out of lo range"), return rend(););
141 JSON_ASSERT_SAFE(_end <= rend(), JSON_TEXT("erase out of hi range"), return rend(););
142 JSON_ASSERT_SAFE(_start >= rbegin(), JSON_TEXT("erase out of lo range"), return rbegin(););
143 JSON_ASSERT_SAFE(_end >= rbegin(), JSON_TEXT("erase out of hi range"), return rbegin(););
144 for (JSONNode ** pos = _start.it; pos > _end.it; --pos){
145 deleteJSONNode(*pos);
146 }
147 const json_index_t num = (json_index_t)(_start.it - _end.it);
148 internal -> CHILDREN -> erase(_end.it + 1, num, _start.it);
149 return (empty()) ? rend() : _start + num;
150 }
151
152 JSONNode::reverse_iterator JSONNode::insert(reverse_iterator pos, const JSONNode & x) json_nothrow {
153 JSON_CHECK_INTERNAL();
154 JSON_ASSERT(type() == JSON_NODE || type() == JSON_ARRAY, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("insert"));
155 JSON_ASSERT_UNIQUE("insert 1");
156 if (pos.it < internal -> CHILDREN -> begin()){
157 internal -> push_front(x);
158 return rend() - 1;
159 }
160 JSON_ASSERT_SAFE(pos >= rbegin(), JSON_TEXT("insert out of range"), return rbegin(););
161 internal -> CHILDREN -> insert(++pos.it, newJSONNode(x), true);
162 return pos;
163 }
164
165 JSONNode::reverse_iterator JSONNode::insertRFF(reverse_iterator pos, JSONNode ** const _start, JSONNode ** const _end) json_nothrow {
166 JSON_CHECK_INTERNAL();
167 JSON_ASSERT(type() == JSON_NODE || type() == JSON_ARRAY, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("insertRFF"));
168 JSON_ASSERT_UNIQUE("insert RFF");
169 JSON_ASSERT_SAFE(pos <= rend(), JSON_TEXT("insert out of range"), return rend(););
170 JSON_ASSERT_SAFE(pos >= rbegin(), JSON_TEXT("insert out of range"), return rbegin(););
171 const json_index_t num = (json_index_t)(_end - _start);
172 json_auto<JSONNode *> mem(num);
173 JSONNode ** runner = mem.ptr + num;
174 for (JSONNode ** po = _start; po < _end; ++po){ //fill it backwards
175 *(--runner) = newJSONNode(*(*po) JSON_MUTEX_COPY2);
176 }
177 internal -> CHILDREN -> insert(++pos.it, mem.ptr, num);
178 return pos - num + 1;
179 }
180
181 JSONNode::iterator JSONNode::insertFRR(json_iterator pos, JSONNode ** const _start, JSONNode ** const _end) json_nothrow {
182 JSON_CHECK_INTERNAL();
183 JSON_ASSERT(type() == JSON_NODE || type() == JSON_ARRAY, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("insertFRR"));
184 JSON_ASSERT_UNIQUE("insert FRR");
185 JSON_ASSERT_SAFE(pos <= end(), JSON_TEXT("insert out of range"), return end(););
186 JSON_ASSERT_SAFE(pos >= begin(), JSON_TEXT("insert out of range"), return begin(););
187 const json_index_t num = (json_index_t)(_start - _end);
188 json_auto<JSONNode *> mem(num);
189 JSONNode ** runner = mem.ptr;
190 for (JSONNode ** po = _start; po > _end; --po){
191 *runner++ = newJSONNode(*(*po) JSON_MUTEX_COPY2);
192 }
193 internal -> CHILDREN -> insert(pos.it, mem.ptr, num);
194 return pos;
195 }
196
197 JSONNode::reverse_iterator JSONNode::insertRRR(reverse_iterator pos, JSONNode ** const _start, JSONNode ** const _end) json_nothrow {
198 JSON_CHECK_INTERNAL();
199 JSON_ASSERT(type() == JSON_NODE || type() == JSON_ARRAY, json_global(ERROR_NON_ITERATABLE) + JSON_TEXT("insertRRR"));
200 JSON_ASSERT_UNIQUE("insert RRR");
201 JSON_ASSERT_SAFE(pos <= rend(), JSON_TEXT("insert out of range"), return rend(););
202 JSON_ASSERT_SAFE(pos >= rbegin(), JSON_TEXT("insert out of range"), return rbegin(););
203 const json_index_t num = (json_index_t)(_start - _end);
204 json_auto<JSONNode *> mem(num);
205 JSONNode ** runner = mem.ptr;
206 for (JSONNode ** po = _start; po > _end; --po){
207 *runner++ = newJSONNode(*(*po) JSON_MUTEX_COPY2);
208 }
209 internal -> CHILDREN -> insert(++pos.it, mem.ptr, num);
210 return pos - num + 1;
211 }
212 #endif
213
214 #endif
215