← Back to branch summary

~ubuntu-branches/ubuntu/utopic/smplayer/utopic

« back to all changes in this revision

Viewing changes to src/findsubtitles/maia/maiaObject.cpp

  • Committer: Package Import Robot
  • Author(s): Alessio Treglia
  • Date: 2013-10-09 12:02:50 UTC
  • mfrom: (20.2.2 sid)
  • Revision ID: package-import@ubuntu.com-20131009120250-a51t46ffycbmum44
Tags: 0.8.6-2
http://bugs.debian.org/725829
* Team upload.
* Remove doc-base document, faq.html file is no longer
  provided. (Closes: #725829)
* Disable updates checking mechanism.
* Add licensing information on libmaia, split sources stanzas from
  License ones.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/findsubtitles/maia/maiaObject.cpp
 
1
/*
 
2
 * libMaia - maiaObject.cpp
 
3
 * Copyright (c) 2003 Frerich Raabe <raabe@kde.org> and
 
4
 *                    Ian Reinhart Geiser <geiseri@kde.org>
 
5
 * Copyright (c) 2007 Sebastian Wiedenroth <wiedi@frubar.net>
 
6
 *
 
7
 * Redistribution and use in source and binary forms, with or without
 
8
 * modification, are permitted provided that the following conditions
 
9
 * are met:
 
10
 *
 
11
 * 1. Redistributions of source code must retain the above copyright
 
12
 *    notice, this list of conditions and the following disclaimer.
 
13
 * 2. Redistributions in binary form must reproduce the above copyright
 
14
 *    notice, this list of conditions and the following disclaimer in the
 
15
 *    documentation and/or other materials provided with the distribution.
 
16
 *
 
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 
18
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 
19
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 
20
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 
21
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 
22
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 
23
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 
24
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 
25
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 
26
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
27
 */
 
28
 
 
29
#include "maiaObject.h"
 
30
 
 
31
MaiaObject::MaiaObject(QObject* parent) : QObject(parent){
 
32
        QDomImplementation::setInvalidDataPolicy(QDomImplementation::DropInvalidChars);
 
33
}
 
34
 
 
35
QDomElement MaiaObject::toXml(QVariant arg) {
 
36
        
 
37
        //dummy document
 
38
        QDomDocument doc;
 
39
        //value element, we need this in each case
 
40
        QDomElement tagValue = doc.createElement("value");
 
41
 
 
42
        /* qDebug("type: %d (%s)", arg.type(), arg.typeName()); */
 
43
 
 
44
        switch(arg.type()) {
 
45
        case QVariant::String: {
 
46
 
 
47
                QDomElement tagString = doc.createElement("string"); 
 
48
                QDomText textString = doc.createTextNode(arg.toString());
 
49
                
 
50
                tagValue.appendChild(tagString);
 
51
                tagString.appendChild(textString);
 
52
 
 
53
                return tagValue;
 
54
 
 
55
        } case QVariant::Int: {
 
56
 
 
57
                QDomElement tagInt = doc.createElement("int"); 
 
58
                QDomText textInt = doc.createTextNode(QString::number(arg.toInt()));
 
59
                
 
60
                tagValue.appendChild(tagInt);
 
61
                tagInt.appendChild(textInt);
 
62
 
 
63
                return tagValue;
 
64
 
 
65
        } case QVariant::Double: {
 
66
 
 
67
                QDomElement tagDouble = doc.createElement("double"); 
 
68
                QDomText textDouble = doc.createTextNode(QString::number(arg.toDouble()));
 
69
                
 
70
                tagValue.appendChild(tagDouble);
 
71
                tagDouble.appendChild(textDouble);
 
72
 
 
73
                return tagValue;
 
74
 
 
75
        } case QVariant::Bool: {
 
76
        
 
77
                QString textValue = arg.toBool() ? "1" : "0";
 
78
 
 
79
                QDomElement tag = doc.createElement("boolean"); 
 
80
                QDomText text = doc.createTextNode(textValue);
 
81
                
 
82
                tagValue.appendChild(tag);
 
83
                tag.appendChild(text);
 
84
 
 
85
                return tagValue;
 
86
 
 
87
        } case QVariant::ByteArray: {
 
88
 
 
89
                QString textValue = arg.toByteArray().toBase64();
 
90
 
 
91
                QDomElement tag = doc.createElement("base64"); 
 
92
                QDomText text = doc.createTextNode(textValue);
 
93
                
 
94
                tagValue.appendChild(tag);
 
95
                tag.appendChild(text);
 
96
 
 
97
                return tagValue;
 
98
 
 
99
        } case QVariant::DateTime: {
 
100
        
 
101
                QString textValue = arg.toDateTime().toString("yyyyMMddThh:mm:ss");
 
102
 
 
103
                QDomElement tag = doc.createElement("datetime.iso8601"); 
 
104
                QDomText text = doc.createTextNode(textValue);
 
105
                
 
106
                tagValue.appendChild(tag);
 
107
                tag.appendChild(text);
 
108
 
 
109
                return tagValue;
 
110
 
 
111
        } case QVariant::List: {
 
112
 
 
113
                QDomElement tagArray = doc.createElement("array");
 
114
                QDomElement tagData = doc.createElement("data");
 
115
                tagArray.appendChild(tagData);
 
116
                tagValue.appendChild(tagArray);
 
117
 
 
118
                const QList<QVariant> args = arg.toList();
 
119
                for(int i = 0; i < args.size(); ++i) {
 
120
                        tagData.appendChild(toXml(args.at(i)));
 
121
                }
 
122
        
 
123
                return tagValue;
 
124
 
 
125
        } case QVariant::Map: {
 
126
 
 
127
                QDomElement tagStruct = doc.createElement("struct");
 
128
                QDomElement member;
 
129
                QDomElement name;
 
130
 
 
131
                tagValue.appendChild(tagStruct);
 
132
 
 
133
                QMap<QString, QVariant> map = arg.toMap();
 
134
                QMapIterator<QString, QVariant> i(map);
 
135
                while(i.hasNext()) {
 
136
                        i.next();
 
137
 
 
138
                        member = doc.createElement("member");
 
139
                        name = doc.createElement("name");
 
140
 
 
141
                        // (key) -> name -> member -> struct
 
142
                        tagStruct.appendChild(member);
 
143
                        member.appendChild(name);
 
144
                        name.appendChild(doc.createTextNode(i.key()));
 
145
 
 
146
                        // add variables by recursion
 
147
                        member.appendChild(toXml(i.value()));
 
148
                }
 
149
 
 
150
                return tagValue;
 
151
 
 
152
        } default:
 
153
                qDebug() << "Failed to marshal unknown variant type: " << arg.type() << endl;
 
154
        }
 
155
        return QDomElement(); //QString::null;
 
156
}
 
157
 
 
158
QVariant MaiaObject::fromXml(const QDomElement &elem) {
 
159
        if(elem.tagName().toLower() != "value") {
 
160
                return QVariant();
 
161
        }
 
162
        
 
163
        // If no type is indicated, the type is string.
 
164
        if(!elem.firstChild().isElement()) {
 
165
                return QVariant(elem.text());
 
166
        }
 
167
        
 
168
        const QDomElement typeElement = elem.firstChild().toElement();  
 
169
        const QString typeName = typeElement.tagName().toLower();
 
170
 
 
171
        if(typeName == "string")
 
172
                return QVariant(typeElement.text());
 
173
        else if(typeName == "i4" || typeName == "int")
 
174
                return QVariant(typeElement.text().toInt());
 
175
        else if(typeName == "double")
 
176
                return QVariant(typeElement.text().toDouble());
 
177
        else if (typeName == "boolean") {
 
178
                if(typeElement.text().toLower() == "true" || typeElement.text() == "1")
 
179
                        return QVariant(true);
 
180
                else
 
181
                        return QVariant(false);
 
182
        } else if(typeName == "base64")
 
183
                return QVariant(QByteArray::fromBase64( typeElement.text().toLatin1()));
 
184
        else if(typeName == "datetime" || typeName == "datetime.iso8601")
 
185
                return QVariant(QDateTime::fromString(typeElement.text(), "yyyyMMddThh:mm:ss"));
 
186
        else if(typeName == "nil") // Non-standard extension: http://ontosys.com/xml-rpc/extensions.php
 
187
                return QVariant();
 
188
        else if ( typeName == "array" ) {
 
189
                QList<QVariant> values;
 
190
                QDomNode valueNode = typeElement.firstChild().firstChild();
 
191
                while(!valueNode.isNull()) {
 
192
                        values << fromXml(valueNode.toElement());
 
193
                        valueNode = valueNode.nextSibling();
 
194
                }
 
195
                return QVariant(values);
 
196
        }
 
197
        else if ( typeName == "struct" ) {
 
198
                QMap<QString, QVariant> map;
 
199
                QDomNode memberNode = typeElement.firstChild();
 
200
                while(!memberNode.isNull())     {
 
201
                        const QString key = memberNode.toElement().elementsByTagName("name").item(0).toElement().text();
 
202
                        const QVariant data = fromXml(memberNode.toElement().elementsByTagName("value").item(0).toElement());
 
203
                        map[key] = data;
 
204
                        memberNode = memberNode.nextSibling();
 
205
                }
 
206
                return QVariant(map);
 
207
        } else {
 
208
                qDebug() << "Cannot demarshal unknown type " << typeElement.tagName().toLower();
 
209
        }
 
210
        return QVariant();
 
211
}
 
212
 
 
213
 
 
214
QString MaiaObject::prepareCall(QString method, QList<QVariant> args) {
 
215
        
 
216
 
 
217
        QDomDocument doc;
 
218
 
 
219
        QDomProcessingInstruction header = doc.createProcessingInstruction( "xml", QString("version=\"1.0\" encoding=\"UTF-8\"" ));
 
220
        doc.appendChild(header);
 
221
        
 
222
        QDomElement methodCall = doc.createElement("methodCall");
 
223
        QDomElement methodName = doc.createElement("methodName");
 
224
        QDomElement params = doc.createElement("params");
 
225
        QDomElement param;
 
226
 
 
227
        doc.appendChild(methodCall);
 
228
        methodCall.appendChild(methodName);
 
229
        methodName.appendChild(doc.createTextNode(method));
 
230
 
 
231
        methodCall.appendChild(params);
 
232
 
 
233
        for(int i = 0; i < args.size(); ++i) {
 
234
                param = doc.createElement("param");
 
235
                param.appendChild(toXml(args.at(i)));
 
236
                params.appendChild(param);
 
237
        }
 
238
 
 
239
        return doc.toString();
 
240
}
 
241
 
 
242
QString MaiaObject::prepareResponse(QVariant arg) {
 
243
 
 
244
        QDomDocument doc;
 
245
 
 
246
        QDomProcessingInstruction header = doc.createProcessingInstruction( "xml", QString("version=\"1.0\" encoding=\"UTF-8\"" )); 
 
247
        doc.appendChild(header);
 
248
        
 
249
        QDomElement methodResponse = doc.createElement("methodResponse");
 
250
        QDomElement params = doc.createElement("params");
 
251
        QDomElement param;
 
252
 
 
253
        doc.appendChild(methodResponse);
 
254
 
 
255
        methodResponse.appendChild(params);
 
256
 
 
257
        if(!arg.isNull()) {
 
258
                param = doc.createElement("param");
 
259
                param.appendChild(toXml(arg));
 
260
                params.appendChild(param);
 
261
        }
 
262
        return doc.toString();
 
263
}
 
264
 
 
265
void MaiaObject::parseResponse(QString response, QNetworkReply* reply) {
 
266
        QDomDocument doc;
 
267
        QVariant arg;
 
268
        QString errorMsg;
 
269
        int errorLine;
 
270
        int errorColumn;
 
271
        if(!doc.setContent(response, &errorMsg, &errorLine, &errorColumn)) {
 
272
                emit fault(-32700, QString("parse error: response not well formed at line %1: %2").arg(errorLine).arg(errorMsg), reply);
 
273
                delete this;
 
274
                return;
 
275
        }
 
276
        if(doc.documentElement().firstChild().toElement().tagName().toLower() == "params") {
 
277
                QDomNode paramNode = doc.documentElement().firstChild().firstChild();
 
278
                if(!paramNode.isNull()) {
 
279
                        arg = fromXml( paramNode.firstChild().toElement() );
 
280
                }
 
281
                emit aresponse(arg, reply);
 
282
        } else if(doc.documentElement().firstChild().toElement().tagName().toLower() == "fault") {
 
283
                const QVariant errorVariant = fromXml(doc.documentElement().firstChild().firstChild().toElement());
 
284
                emit fault(errorVariant.toMap() [ "faultCode" ].toInt(),
 
285
                           errorVariant.toMap() [ "faultString" ].toString(),
 
286
                           reply);
 
287
        } else {
 
288
                emit fault(-32600,
 
289
                           "parse error: invalid xml-rpc. not conforming to spec.",
 
290
                           reply);
 
291
        }
 
292
        delete this;
 
293
        return;
 
294
}
 
295
 
 
296
#include "moc_maiaObject.cpp"