source: sources/src/dataFormatJsonNode.cc @ 1464:3f6711617be1

Revision 1464:3f6711617be1, 12.0 KB checked in by niam, 22 months ago (diff)

{issue #58[resolved]} support for non-c++ exceptions
Line 
1/***************************************************************************
2 *            dataFormatJsonNode.cc
3 *
4 *  Mon Oct 20 2007
5 *  Copyright  2007  Dmytro Milinevskyy
6 *  milinevskyy@gmail.com
7 ****************************************************************************/
8
9/*
10 *  This program is free software; you can redistribute it and/or modify
11 *  it under the terms of the GNU Lesser General Public License version 2.1 as published by
12 *  the Free Software Foundation;
13 *
14 *  This program is distributed in the hope that it will be useful,
15 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
16 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 *  GNU Library General Public License for more details.
18 *
19 *  You should have received a copy of the GNU Lesser General Public License
20 *  along with this program; if not, write to the Free Software
21 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22 */
23
24/**
25 * vim indentation settings
26 * set tabstop=4
27 * set shiftwidth=4
28 */
29
30#include <libdodo/directives.h>
31
32#include <libdodo/dataFormatJsonNode.h>
33#include <libdodo/types.h>
34#include <libdodo/toolsString.h>
35#include <libdodo/dataFormatJsonNodeEx.h>
36
37using namespace dodo::data::format::json;
38
39node::node() : valueDataType(DATA_NULL)
40{
41}
42
43//-------------------------------------------------------------------
44
45node::node(const dodo::string &value) : stringValue(new dodo::string(value)),
46                                      valueDataType(DATA_STRING)
47{
48}
49
50//-------------------------------------------------------------------
51
52node::node(long value) : numericValue(value),
53                         valueDataType(DATA_NUMERIC)
54{
55}
56
57//-------------------------------------------------------------------
58
59node::node(bool value) : booleanValue(value),
60                         valueDataType(DATA_BOOLEAN)
61{
62}
63
64//-------------------------------------------------------------------
65
66node::node(const dodoArray<node> &value) : arrayValue(new dodoArray<node>(value)),
67                                           valueDataType(DATA_ARRAY)
68{
69}
70
71//-------------------------------------------------------------------
72
73node::node(const dodoMap<dodo::string, node, dodoMapStringCompare> &value) : objectValue(new dodoMap<dodo::string, node, dodoMapStringCompare>(value)),
74                                                                           valueDataType(DATA_OBJECT)
75{
76}
77
78//-------------------------------------------------------------------
79
80node::node(const node &n) : valueDataType(n.valueDataType)
81{
82    switch (valueDataType) {
83        case DATA_STRING:
84            stringValue = new dodo::string(*n.stringValue);
85            break;
86
87        case DATA_OBJECT:
88            objectValue = new dodoMap<dodo::string, node, dodoMapStringCompare>(*n.objectValue);
89            break;
90
91        case DATA_ARRAY:
92            arrayValue = new dodoArray<node>(*n.arrayValue);
93            break;
94
95        case DATA_NUMERIC:
96            numericValue = n.numericValue;
97            break;
98
99        case DATA_BOOLEAN:
100            booleanValue = n.booleanValue;
101            break;
102    }
103}
104
105//-------------------------------------------------------------------
106
107node::~node()
108{
109    switch (valueDataType) {
110        case DATA_STRING:
111            delete stringValue;
112            break;
113
114        case DATA_OBJECT:
115            delete objectValue;
116            break;
117
118        case DATA_ARRAY:
119            delete arrayValue;
120            break;
121    }
122}
123
124//-------------------------------------------------------------------
125
126void
127node::setString(const dodo::string &value)
128{
129    if (valueDataType != DATA_STRING) {
130        switch (valueDataType) {
131            case DATA_OBJECT:
132                delete objectValue;
133                break;
134
135            case DATA_ARRAY:
136                delete arrayValue;
137                break;
138        }
139
140        valueDataType = DATA_STRING;
141        stringValue = new dodo::string(value);
142    } else
143        *stringValue = value;
144}
145
146//-------------------------------------------------------------------
147
148void
149node::setBoolean(bool value)
150{
151    if (valueDataType != DATA_BOOLEAN) {
152        switch (valueDataType) {
153            case DATA_STRING:
154                delete stringValue;
155                break;
156
157            case DATA_OBJECT:
158                delete objectValue;
159                break;
160
161            case DATA_ARRAY:
162                delete arrayValue;
163                break;
164        }
165
166        valueDataType = DATA_BOOLEAN;
167    }
168
169    booleanValue = value;
170}
171
172//-------------------------------------------------------------------
173
174void
175node::setNumeric(long value)
176{
177    if (valueDataType != DATA_NUMERIC) {
178        switch (valueDataType) {
179            case DATA_STRING:
180                delete stringValue;
181                break;
182
183            case DATA_OBJECT:
184                delete objectValue;
185                break;
186
187            case DATA_ARRAY:
188                delete arrayValue;
189                break;
190        }
191
192        valueDataType = DATA_NUMERIC;
193    }
194
195    numericValue = value;
196}
197
198//-------------------------------------------------------------------
199
200void
201node::setNull()
202{
203    if (valueDataType != DATA_NULL) {
204        switch (valueDataType) {
205            case DATA_STRING:
206                delete stringValue;
207                break;
208
209            case DATA_OBJECT:
210                delete objectValue;
211                break;
212
213            case DATA_ARRAY:
214                delete arrayValue;
215                break;
216        }
217
218        valueDataType = DATA_NULL;
219    }
220}
221
222//-------------------------------------------------------------------
223
224void
225node::addArrayElement(const node &value)
226{
227    if (valueDataType != DATA_ARRAY) {
228        switch (valueDataType) {
229            case DATA_STRING:
230                delete stringValue;
231                break;
232
233            case DATA_OBJECT:
234                delete objectValue;
235                break;
236
237            case DATA_ARRAY:
238                delete arrayValue;
239                break;
240        }
241
242        valueDataType = DATA_ARRAY;
243        arrayValue = new dodoArray<node>;
244    }
245
246    arrayValue->push_back(value);
247}
248
249//-------------------------------------------------------------------
250
251void
252node::addObjectMember(const dodo::string &name,
253                      const node       &value)
254{
255    if (valueDataType != DATA_OBJECT) {
256        switch (valueDataType) {
257            case DATA_STRING:
258                delete stringValue;
259                break;
260
261            case DATA_ARRAY:
262                delete arrayValue;
263                break;
264        }
265
266        valueDataType = DATA_OBJECT;
267        objectValue = new dodoMap<dodo::string, node, dodoMapStringCompare>;
268    }
269
270    objectValue->insert(std::make_pair(name, value));
271}
272
273//-------------------------------------------------------------------
274
275void
276node::setArray(const dodoArray<node> &value)
277{
278    if (valueDataType != DATA_ARRAY) {
279        switch (valueDataType) {
280            case DATA_STRING:
281                delete stringValue;
282                break;
283
284            case DATA_OBJECT:
285                delete objectValue;
286                break;
287        }
288
289        valueDataType = DATA_ARRAY;
290        arrayValue = new dodoArray<node>(value);
291    } else
292        *arrayValue = value;
293}
294
295//-------------------------------------------------------------------
296
297void
298node::setObject(const dodoMap<dodo::string, node, dodoMapStringCompare> &value)
299{
300    if (valueDataType != DATA_OBJECT) {
301        switch (valueDataType) {
302            case DATA_STRING:
303                delete stringValue;
304                break;
305
306            case DATA_ARRAY:
307                delete arrayValue;
308                break;
309        }
310
311        valueDataType = DATA_OBJECT;
312        objectValue = new dodoMap<dodo::string, node, dodoMapStringCompare>(value);
313    } else
314        *objectValue = value;
315}
316
317//-------------------------------------------------------------------
318
319node
320node::operator[](const dodo::string &key) const
321{
322    if (valueDataType != DATA_OBJECT)
323        dodo_throw exception::basic(exception::MODULE_DATAFORMATJSONNODE, NODEEX_BROPERATORSTRING, exception::ERRNO_LIBDODO, NODEEX_WRONGTYPEREQUESTED, DATAFORMATJSONNODEEX_WRONGTYPEREQUESTED_STR, __LINE__, __FILE__);
324
325    return (*objectValue)[key];
326}
327
328//-------------------------------------------------------------------
329
330node
331node::operator[](unsigned long key) const
332{
333    if (valueDataType != DATA_ARRAY)
334        dodo_throw exception::basic(exception::MODULE_DATAFORMATJSONNODE, NODEEX_BROPERATORNUMERIC, exception::ERRNO_LIBDODO, NODEEX_WRONGTYPEREQUESTED, DATAFORMATJSONNODEEX_WRONGTYPEREQUESTED_STR, __LINE__, __FILE__);
335
336    if (key >= (arrayValue)->size())
337        dodo_throw exception::basic(exception::MODULE_DATAFORMATJSONNODE, NODEEX_BROPERATORNUMERIC, exception::ERRNO_LIBDODO, NODEEX_ARRAYOUTOFRANGE, DATAFORMATJSONNODEEX_ARRAYOUTOFRANGE_STR, __LINE__, __FILE__);
338
339    return (*arrayValue)[key];
340}
341
342//-------------------------------------------------------------------
343
344short
345node::type() const
346{
347    return valueDataType;
348}
349
350//-------------------------------------------------------------------
351
352dodo::string
353node::string() const
354{
355    if (valueDataType != DATA_STRING)
356        dodo_throw exception::basic(exception::MODULE_DATAFORMATJSONNODE, NODEEX_GETSTRING, exception::ERRNO_LIBDODO, NODEEX_WRONGTYPEREQUESTED, DATAFORMATJSONNODEEX_WRONGTYPEREQUESTED_STR, __LINE__, __FILE__);
357
358    return *stringValue;
359}
360
361//-------------------------------------------------------------------
362
363bool
364node::boolean() const
365{
366    if (valueDataType != DATA_BOOLEAN)
367        dodo_throw exception::basic(exception::MODULE_DATAFORMATJSONNODE, NODEEX_GETBOOLEAN, exception::ERRNO_LIBDODO, NODEEX_WRONGTYPEREQUESTED, DATAFORMATJSONNODEEX_WRONGTYPEREQUESTED_STR, __LINE__, __FILE__);
368
369    return booleanValue;
370}
371
372//-------------------------------------------------------------------
373
374long
375node::numeric() const
376{
377    if (valueDataType != DATA_NUMERIC)
378        dodo_throw exception::basic(exception::MODULE_DATAFORMATJSONNODE, NODEEX_GETNUMERIC, exception::ERRNO_LIBDODO, NODEEX_WRONGTYPEREQUESTED, DATAFORMATJSONNODEEX_WRONGTYPEREQUESTED_STR, __LINE__, __FILE__);
379
380    return numericValue;
381}
382
383//-------------------------------------------------------------------
384
385dodoArray<node>
386node::array() const
387{
388    if (valueDataType != DATA_ARRAY)
389        dodo_throw exception::basic(exception::MODULE_DATAFORMATJSONNODE, NODEEX_GETARRAY, exception::ERRNO_LIBDODO, NODEEX_WRONGTYPEREQUESTED, DATAFORMATJSONNODEEX_WRONGTYPEREQUESTED_STR, __LINE__, __FILE__);
390
391    return *arrayValue;
392}
393
394//-------------------------------------------------------------------
395
396dodoMap<dodo::string, node, dodo::dodoMapStringCompare>
397node::object() const
398{
399    if (valueDataType != DATA_OBJECT)
400        dodo_throw exception::basic(exception::MODULE_DATAFORMATJSONNODE, NODEEX_GETOBJECT, exception::ERRNO_LIBDODO, NODEEX_WRONGTYPEREQUESTED, DATAFORMATJSONNODEEX_WRONGTYPEREQUESTED_STR, __LINE__, __FILE__);
401
402    return *objectValue;
403}
404
405//-------------------------------------------------------------------
406
407bool
408node::isNull() const
409{
410    return (valueDataType == DATA_NULL);
411}
412
413//-------------------------------------------------------------------
414
415node &
416node::operator=(const node &n)
417{
418    switch (valueDataType) {
419        case DATA_STRING:
420            delete stringValue;
421            break;
422
423        case DATA_OBJECT:
424            delete objectValue;
425            break;
426
427        case DATA_ARRAY:
428            delete arrayValue;
429            break;
430    }
431
432    valueDataType = n.valueDataType;
433    switch (valueDataType) {
434        case DATA_STRING:
435            stringValue = new dodo::string(*n.stringValue);
436            break;
437
438        case DATA_OBJECT:
439            objectValue = new dodoMap<dodo::string, node, dodoMapStringCompare>(*n.objectValue);
440            break;
441
442        case DATA_ARRAY:
443            arrayValue = new dodoArray<node>(*n.arrayValue);
444            break;
445
446        case DATA_NUMERIC:
447            numericValue = n.numericValue;
448            break;
449
450        case DATA_BOOLEAN:
451            booleanValue = n.booleanValue;
452            break;
453    }
454
455    return *this;
456}
457
458//-------------------------------------------------------------------
459
Note: See TracBrowser for help on using the repository browser.