source: sources/src/rpcXmlValue.cc @ 1439:b23bfdd8a935

Revision 1439:b23bfdd8a935, 8.9 KB checked in by niam, 2 years ago (diff)

change contact info
Line 
1/***************************************************************************
2 *            rpcXmlValue.cc
3 *
4 *  Wed Apr 09 2008
5 *  Copyright  2008  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/rpcXmlValue.h>
33#include <libdodo/types.h>
34#include <libdodo/dataFormatXmlNode.h>
35#include <libdodo/toolsString.h>
36#include <libdodo/rpcValue.h>
37
38using namespace dodo::rpc::xml;
39
40const char value::trimSymbols[] = {
41    ' ',
42    '\r'
43};
44
45//-------------------------------------------------------------------
46
47dodo::rpc::value
48value::xmlToValue(dodo::data::format::xml::node &node)
49{
50    dodoMap<dodo::string, dodoArray<dodo::data::format::xml::node>, dodoMapStringCompare>::iterator i = node.nodeChildren.begin();
51    if (i == node.nodeChildren.end())
52        return rpc::value();
53
54    rpc::value val;
55
56    if (tools::string::iequal(i->first, "int") || tools::string::iequal(i->first, "i4")) {
57        val.valueDataType = dodo::rpc::value::DATA_NUMERIC;
58
59        dodoArray<dodo::data::format::xml::node> &arr0 = i->second;
60        if (arr0.size() > 0)
61            val.numericValue = tools::string::stringToI(tools::string::trim(arr0[0].nodeValue, trimSymbols, 2));
62        else
63            val.numericValue = 0;
64    } else {
65        if (tools::string::iequal(i->first, "boolean")) {
66            val.valueDataType = dodo::rpc::value::DATA_BOOLEAN;
67
68            dodoArray<dodo::data::format::xml::node> &arr0 = i->second;
69            if (arr0.size() > 0)
70                val.booleanValue = tools::string::stringToI(tools::string::trim(arr0[0].nodeValue, trimSymbols, 2)) == 1 ? true : false;
71            else
72                val.booleanValue = false;
73        } else {
74            if (tools::string::iequal(i->first, "string") || tools::string::iequal(i->first, "base64") || tools::string::iequal(i->first, "dateTime.iso8601")) {
75                val.valueDataType = dodo::rpc::value::DATA_STRING;
76                val.stringValue = new dodo::string;
77
78                dodoArray<dodo::data::format::xml::node> &arr0 = i->second;
79                if (arr0.size() > 0)
80                    *val.stringValue = tools::string::trim(arr0[0].nodeValue, trimSymbols, 2);
81            } else {
82                if (tools::string::iequal(i->first, "double")) {
83                    val.valueDataType = dodo::rpc::value::DATA_NUMERIC;
84
85                    dodoArray<dodo::data::format::xml::node> &arr0 = i->second;
86                    if (arr0.size() > 0)
87                        val.numericValue = tools::string::stringToD(tools::string::trim(arr0[0].nodeValue, trimSymbols, 2));
88                    else
89                        val.numericValue = 0;
90                } else {
91                    if (tools::string::iequal(i->first, "struct")) {
92                        val.valueDataType = dodo::rpc::value::DATA_STRUCT;
93                        val.structValue = new dodoMap<dodo::string, rpc::value, dodoMapStringCompare>;
94
95                        dodoArray<dodo::data::format::xml::node> &arr0 = i->second;
96                        if (arr0.size() == 0)
97                            return val;
98
99                        dodoArray<dodo::data::format::xml::node> &nodeArray = arr0[0].nodeChildren["member"];
100
101                        dodoArray<dodo::data::format::xml::node>::iterator o = nodeArray.begin(), p = nodeArray.end();
102                        for (; o != p; ++o) {
103                            dodoArray<dodo::data::format::xml::node> &arr1 = o->nodeChildren["name"];
104                            dodoArray<dodo::data::format::xml::node> &arr2 = o->nodeChildren["value"];
105                            if (arr1.size() > 0 && arr2.size() > 0)
106                                val.structValue->insert(std::make_pair(tools::string::trim(arr1[0].nodeValue, trimSymbols, 2), xmlToValue(arr2[0])));
107                        }
108                    } else {
109                        if (tools::string::iequal(i->first, "array")) {
110                            val.valueDataType = dodo::rpc::value::DATA_ARRAY;
111                            val.arrayValue = new dodoArray<rpc::value>;
112
113                            dodoArray<dodo::data::format::xml::node> &arr0 = i->second;
114                            if (arr0.size() == 0)
115                                return val;
116
117                            dodoArray<dodo::data::format::xml::node> &arr1 = arr0[0].nodeChildren["data"];
118                            if (arr1.size() == 0)
119                                return val;
120
121                            dodoArray<dodo::data::format::xml::node> &nodeArray = arr1[0].nodeChildren["value"];
122
123                            dodoArray<dodo::data::format::xml::node>::iterator o = nodeArray.begin(), p = nodeArray.end();
124                            for (; o != p; ++o)
125                                val.arrayValue->push_back(xmlToValue(*o));
126                        }
127                    }
128                }
129            }
130        }
131    }
132
133    return val;
134}
135
136//-------------------------------------------------------------------
137
138dodo::data::format::xml::node
139value::valueToXml(const rpc::value &data)
140{
141    dodoArray<dodo::data::format::xml::node> nodeArr;
142
143    dodo::data::format::xml::node node;
144    node.name = "value";
145
146    dodo::data::format::xml::node subNode;
147
148    switch (data.valueDataType) {
149        case dodo::rpc::value::DATA_STRING:
150
151            subNode.name = "string";
152            subNode.nodeValue = *data.stringValue;
153
154            nodeArr.assign(1, subNode);
155            node.nodeChildren.insert(std::make_pair(subNode.name, nodeArr));
156
157            break;
158
159        case dodo::rpc::value::DATA_BOOLEAN:
160
161            subNode.name = "boolean";
162            subNode.nodeValue = data.booleanValue ? "1" : "0";
163
164            nodeArr.assign(1, subNode);
165            node.nodeChildren.insert(std::make_pair(subNode.name, nodeArr));
166
167            break;
168
169        case dodo::rpc::value::DATA_NUMERIC:
170
171            subNode.name = "double";
172            subNode.nodeValue = tools::string::dToString(data.numericValue);
173
174            nodeArr.assign(1, subNode);
175            node.nodeChildren.insert(std::make_pair(subNode.name, nodeArr));
176
177            break;
178
179        case dodo::rpc::value::DATA_ARRAY:
180        {
181            subNode.name = "array";
182
183            dodo::data::format::xml::node dataNode;
184            dataNode.name = "data";
185
186            dodoArray<rpc::value>::const_iterator i = data.arrayValue->begin(), j = data.arrayValue->end();
187            for (; i != j; ++i)
188                nodeArr.push_back(valueToXml(*i));
189            dataNode.nodeChildren.insert(std::make_pair("value", nodeArr));
190
191            nodeArr.assign(1, dataNode);
192            subNode.nodeChildren.insert(std::make_pair(dataNode.name, nodeArr));
193
194            nodeArr.assign(1, subNode);
195            node.nodeChildren.insert(std::make_pair(subNode.name, nodeArr));
196
197            break;
198        }
199
200        case dodo::rpc::value::DATA_STRUCT:
201        {
202            subNode.name = "struct";
203
204            dodo::data::format::xml::node memberNode, memberNameNode, memberValueNode;
205            memberNode.name = "member";
206            memberNameNode.name = "name";
207            memberValueNode.name = "value";
208
209            dodoArray<dodo::data::format::xml::node> subNodeArr;
210
211            dodoMap<dodo::string, rpc::value, dodoMapStringCompare>::const_iterator
212            i = data.structValue->begin(),
213            j = data.structValue->end();
214            for (; i != j; ++i) {
215                memberNode.nodeChildren.clear();
216                memberValueNode.nodeChildren.clear();
217
218                memberNameNode.nodeValue = i->first;
219                nodeArr.assign(1, memberNameNode);
220                memberNode.nodeChildren.insert(std::make_pair(memberNameNode.name, nodeArr));
221
222                nodeArr.assign(1, valueToXml(i->second));
223                memberNode.nodeChildren.insert(std::make_pair(memberValueNode.name, nodeArr));
224
225                subNodeArr.push_back(memberNode);
226            }
227            subNode.nodeChildren.insert(std::make_pair(memberNode.name, subNodeArr));
228
229            nodeArr.assign(1, subNode);
230            node.nodeChildren.insert(std::make_pair(subNode.name, nodeArr));
231
232            break;
233        }
234    }
235
236    return node;
237}
238
239//-------------------------------------------------------------------
Note: See TracBrowser for help on using the repository browser.