Drizzled Public API Documentation

json_valueiterator.inl
1 /* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
2  *
3  * JSON Library, originally from http://jsoncpp.sourceforge.net/
4  *
5  * Copyright (C) 2011 Stewart Smith
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions are
10  * met:
11  *
12  * * Redistributions of source code must retain the above copyright
13  * notice, this list of conditions and the following disclaimer.
14  *
15  * * Redistributions in binary form must reproduce the above
16  * copyright notice, this list of conditions and the following disclaimer
17  * in the documentation and/or other materials provided with the
18  * distribution.
19  *
20  * * The names of its contributors may not be used to endorse or
21  * promote products derived from this software without specific prior
22  * written permission.
23  *
24  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
25  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
26  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
27  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
28  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
29  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
30  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
31  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
32  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
33  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
34  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35  *
36  */
37 
38 #pragma once
39 // included by json_value.cpp
40 // everything is within Json namespace
41 
42 
43 // //////////////////////////////////////////////////////////////////
44 // //////////////////////////////////////////////////////////////////
45 // //////////////////////////////////////////////////////////////////
46 // class ValueIteratorBase
47 // //////////////////////////////////////////////////////////////////
48 // //////////////////////////////////////////////////////////////////
49 // //////////////////////////////////////////////////////////////////
50 
51 ValueIteratorBase::ValueIteratorBase()
52 #ifndef JSON_VALUE_USE_INTERNAL_MAP
53  : current_()
54  , isNull_( true )
55 {
56 }
57 #else
58  : isArray_( true )
59  , isNull_( true )
60 {
61  iterator_.array_ = ValueInternalArray::IteratorState();
62 }
63 #endif
64 
65 
66 #ifndef JSON_VALUE_USE_INTERNAL_MAP
67 ValueIteratorBase::ValueIteratorBase( const Value::ObjectValues::iterator &current )
68  : current_( current )
69  , isNull_( false )
70 {
71 }
72 #else
73 ValueIteratorBase::ValueIteratorBase( const ValueInternalArray::IteratorState &state )
74  : isArray_( true )
75 {
76  iterator_.array_ = state;
77 }
78 
79 
80 ValueIteratorBase::ValueIteratorBase( const ValueInternalMap::IteratorState &state )
81  : isArray_( false )
82 {
83  iterator_.map_ = state;
84 }
85 #endif
86 
87 Value &
88 ValueIteratorBase::deref() const
89 {
90 #ifndef JSON_VALUE_USE_INTERNAL_MAP
91  return current_->second;
92 #else
93  if ( isArray_ )
94  return ValueInternalArray::dereference( iterator_.array_ );
95  return ValueInternalMap::value( iterator_.map_ );
96 #endif
97 }
98 
99 
100 void
101 ValueIteratorBase::increment()
102 {
103 #ifndef JSON_VALUE_USE_INTERNAL_MAP
104  ++current_;
105 #else
106  if ( isArray_ )
107  ValueInternalArray::increment( iterator_.array_ );
108  ValueInternalMap::increment( iterator_.map_ );
109 #endif
110 }
111 
112 
113 void
114 ValueIteratorBase::decrement()
115 {
116 #ifndef JSON_VALUE_USE_INTERNAL_MAP
117  --current_;
118 #else
119  if ( isArray_ )
120  ValueInternalArray::decrement( iterator_.array_ );
121  ValueInternalMap::decrement( iterator_.map_ );
122 #endif
123 }
124 
125 
126 ValueIteratorBase::difference_type
127 ValueIteratorBase::computeDistance( const SelfType &other ) const
128 {
129 #ifndef JSON_VALUE_USE_INTERNAL_MAP
130 # ifdef JSON_USE_CPPTL_SMALLMAP
131  return current_ - other.current_;
132 # else
133  // Iterator for null value are initialized using the default
134  // constructor, which initialize current_ to the default
135  // std::map::iterator. As begin() and end() are two instance
136  // of the default std::map::iterator, they can not be compared.
137  // To allow this, we handle this comparison specifically.
138  if ( isNull_ && other.isNull_ )
139  {
140  return 0;
141  }
142 
143 
144  // Usage of std::distance is not portable (does not compile with Sun Studio 12 RogueWave STL,
145  // which is the one used by default).
146  // Using a portable hand-made version for non random iterator instead:
147  // return difference_type( std::distance( current_, other.current_ ) );
148  difference_type myDistance = 0;
149  for ( Value::ObjectValues::iterator it = current_; it != other.current_; ++it )
150  {
151  ++myDistance;
152  }
153  return myDistance;
154 # endif
155 #else
156  if ( isArray_ )
157  return ValueInternalArray::distance( iterator_.array_, other.iterator_.array_ );
158  return ValueInternalMap::distance( iterator_.map_, other.iterator_.map_ );
159 #endif
160 }
161 
162 
163 bool
164 ValueIteratorBase::isEqual( const SelfType &other ) const
165 {
166 #ifndef JSON_VALUE_USE_INTERNAL_MAP
167  if ( isNull_ )
168  {
169  return other.isNull_;
170  }
171  return current_ == other.current_;
172 #else
173  if ( isArray_ )
174  return ValueInternalArray::equals( iterator_.array_, other.iterator_.array_ );
175  return ValueInternalMap::equals( iterator_.map_, other.iterator_.map_ );
176 #endif
177 }
178 
179 
180 void
181 ValueIteratorBase::copy( const SelfType &other )
182 {
183 #ifndef JSON_VALUE_USE_INTERNAL_MAP
184  current_ = other.current_;
185 #else
186  if ( isArray_ )
187  iterator_.array_ = other.iterator_.array_;
188  iterator_.map_ = other.iterator_.map_;
189 #endif
190 }
191 
192 
193 Value
195 {
196 #ifndef JSON_VALUE_USE_INTERNAL_MAP
197  const Value::CZString czstring = (*current_).first;
198  if ( czstring.c_str() )
199  {
200  if ( czstring.isStaticString() )
201  return Value( StaticString( czstring.c_str() ) );
202  return Value( czstring.c_str() );
203  }
204  return Value( czstring.index() );
205 #else
206  if ( isArray_ )
207  return Value( ValueInternalArray::indexOf( iterator_.array_ ) );
208  bool isStatic;
209  const char *memberName = ValueInternalMap::key( iterator_.map_, isStatic );
210  if ( isStatic )
211  return Value( StaticString( memberName ) );
212  return Value( memberName );
213 #endif
214 }
215 
216 
217 UInt
219 {
220 #ifndef JSON_VALUE_USE_INTERNAL_MAP
221  const Value::CZString czstring = (*current_).first;
222  if ( !czstring.c_str() )
223  return czstring.index();
224  return Value::UInt( -1 );
225 #else
226  if ( isArray_ )
227  return Value::UInt( ValueInternalArray::indexOf( iterator_.array_ ) );
228  return Value::UInt( -1 );
229 #endif
230 }
231 
232 
233 const char *
235 {
236 #ifndef JSON_VALUE_USE_INTERNAL_MAP
237  const char *name = (*current_).first.c_str();
238  return name ? name : "";
239 #else
240  if ( !isArray_ )
241  return ValueInternalMap::key( iterator_.map_ );
242  return "";
243 #endif
244 }
245 
246 
247 // //////////////////////////////////////////////////////////////////
248 // //////////////////////////////////////////////////////////////////
249 // //////////////////////////////////////////////////////////////////
250 // class ValueConstIterator
251 // //////////////////////////////////////////////////////////////////
252 // //////////////////////////////////////////////////////////////////
253 // //////////////////////////////////////////////////////////////////
254 
255 ValueConstIterator::ValueConstIterator()
256 {
257 }
258 
259 
260 #ifndef JSON_VALUE_USE_INTERNAL_MAP
261 ValueConstIterator::ValueConstIterator( const Value::ObjectValues::iterator &current )
262  : ValueIteratorBase( current )
263 {
264 }
265 #else
266 ValueConstIterator::ValueConstIterator( const ValueInternalArray::IteratorState &state )
267  : ValueIteratorBase( state )
268 {
269 }
270 
271 ValueConstIterator::ValueConstIterator( const ValueInternalMap::IteratorState &state )
272  : ValueIteratorBase( state )
273 {
274 }
275 #endif
276 
277 ValueConstIterator &
278 ValueConstIterator::operator =( const ValueIteratorBase &other )
279 {
280  copy( other );
281  return *this;
282 }
283 
284 
285 // //////////////////////////////////////////////////////////////////
286 // //////////////////////////////////////////////////////////////////
287 // //////////////////////////////////////////////////////////////////
288 // class ValueIterator
289 // //////////////////////////////////////////////////////////////////
290 // //////////////////////////////////////////////////////////////////
291 // //////////////////////////////////////////////////////////////////
292 
293 ValueIterator::ValueIterator()
294 {
295 }
296 
297 
298 #ifndef JSON_VALUE_USE_INTERNAL_MAP
299 ValueIterator::ValueIterator( const Value::ObjectValues::iterator &current )
300  : ValueIteratorBase( current )
301 {
302 }
303 #else
304 ValueIterator::ValueIterator( const ValueInternalArray::IteratorState &state )
305  : ValueIteratorBase( state )
306 {
307 }
308 
309 ValueIterator::ValueIterator( const ValueInternalMap::IteratorState &state )
310  : ValueIteratorBase( state )
311 {
312 }
313 #endif
314 
315 ValueIterator::ValueIterator( const ValueConstIterator &other )
316  : ValueIteratorBase( other )
317 {
318 }
319 
320 ValueIterator::ValueIterator( const ValueIterator &other )
321  : ValueIteratorBase( other )
322 {
323 }
324 
325 ValueIterator &
326 ValueIterator::operator =( const SelfType &other )
327 {
328  copy( other );
329  return *this;
330 }
const char * memberName() const
Return the member name of the referenced Value. "" if it is not an objectValue.
Definition: json_value.cpp:235
Value key() const
Return either the index or the member name of the referenced value as a Value.
Definition: json_value.cpp:195
UInt index() const
Return the index of the referenced Value. -1 if it is not an arrayValue.
Definition: json_value.cpp:219