Jamoma API  0.6.0.a19
JSONIterators.cpp
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 
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
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 
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 
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
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