← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/strigi/oneiric

« back to all changes in this revision

Viewing changes to src/daemon/dbus/dbuscpp/dbusmessagewriter.cpp

  • Committer: Package Import Robot
  • Author(s): Fathi Boudra
  • Date: 2011-09-20 08:50:25 UTC
  • mto: (1.1.20 upstream) (5.1.6 sid)
  • mto: This revision was merged to the branch mainline in revision 44.
  • Revision ID: package-import@ubuntu.com-20110920085025-wszfu6x8rshrjq0e
Import upstream version 0.7.6

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/daemon/dbus/dbuscpp/dbusmessagewriter.cpp
1
 
/* This file is part of Strigi Desktop Search
2
 
 *
3
 
 * Copyright (C) 2006 Jos van den Oever <jos@vandenoever.info>
4
 
 *
5
 
 * This library is free software; you can redistribute it and/or
6
 
 * modify it under the terms of the GNU Library General Public
7
 
 * License as published by the Free Software Foundation; either
8
 
 * version 2 of the License, or (at your option) any later version.
9
 
 *
10
 
 * This library is distributed in the hope that it will be useful,
11
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
 
 * Library General Public License for more details.
14
 
 *
15
 
 * You should have received a copy of the GNU Library General Public License
16
 
 * along with this library; see the file COPYING.LIB.  If not, write to
17
 
 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18
 
 * Boston, MA 02110-1301, USA.
19
 
 */
20
 
#include "dbusmessagewriter.h"
21
 
#include <dbus/dbus.h>
22
 
using namespace std;
23
 
 
24
 
DBusMessageWriter::DBusMessageWriter(DBusConnection* c, DBusMessage* msg)
25
 
        :conn(c), reply(dbus_message_new_method_return(msg)), reply_to(msg), error(0) {
26
 
    dbus_message_iter_init_append(reply, &it);
27
 
}
28
 
DBusMessageWriter::DBusMessageWriter(DBusConnection* c, const char* object,
29
 
        const char* interface, const char* function)
30
 
        :conn(c), reply(dbus_message_new_signal(object, interface, function)),
31
 
         reply_to(0), error(0) {
32
 
    dbus_message_iter_init_append(reply, &it);
33
 
}
34
 
DBusMessageWriter::~DBusMessageWriter() {
35
 
    if (reply) {
36
 
        DBusMessage* msg = (error) ?error :reply;
37
 
        dbus_uint32_t serial = 0;
38
 
        dbus_connection_send(conn, msg, &serial);
39
 
        dbus_connection_flush(conn);
40
 
        dbus_message_unref(reply);
41
 
        if (error) {
42
 
            dbus_message_unref(error);
43
 
        }
44
 
    }
45
 
}
46
 
void
47
 
DBusMessageWriter::setError(const std::string &e) {
48
 
    // allow for only one error
49
 
    if (error == 0) {
50
 
        // if this is an error in a reply, use the reply in the constructor
51
 
        if (reply_to) {
52
 
            error = dbus_message_new_error(reply_to,
53
 
                "org.freedesktop.DBus.Error.Failed", e.c_str());
54
 
        } else {
55
 
            error = dbus_message_new(DBUS_MESSAGE_TYPE_ERROR);
56
 
            dbus_message_set_error_name(error,
57
 
                "org.freedesktop.DBus.Error.Failed");
58
 
        }
59
 
    }
60
 
}
61
 
DBusMessageWriter&
62
 
operator<<(DBusMessageWriter& w, bool b) {
63
 
    dbus_bool_t db = b;
64
 
    dbus_message_iter_append_basic(&w.it, DBUS_TYPE_BOOLEAN, &db);
65
 
    return w;
66
 
}
67
 
DBusMessageWriter&
68
 
operator<<(DBusMessageWriter& w, int32_t i) {
69
 
    dbus_message_iter_append_basic(&w.it, DBUS_TYPE_INT32, &i);
70
 
    return w;
71
 
}
72
 
DBusMessageWriter&
73
 
operator<<(DBusMessageWriter& w, uint32_t i) {
74
 
    dbus_message_iter_append_basic(&w.it, DBUS_TYPE_UINT32, &i);
75
 
    return w;
76
 
}
77
 
DBusMessageWriter&
78
 
operator<<(DBusMessageWriter& w, int64_t i) {
79
 
    dbus_message_iter_append_basic(&w.it, DBUS_TYPE_INT64, &i);
80
 
    return w;
81
 
}
82
 
DBusMessageWriter&
83
 
operator<<(DBusMessageWriter& w, double d) {
84
 
    dbus_message_iter_append_basic(&w.it, DBUS_TYPE_DOUBLE, &d);
85
 
    return w;
86
 
}
87
 
DBusMessageWriter&
88
 
operator<<(DBusMessageWriter& w, const std::string& s) {
89
 
    const char* c = s.c_str();
90
 
    dbus_message_iter_append_basic(&w.it, DBUS_TYPE_STRING, &c);
91
 
    return w;
92
 
}
93
 
DBusMessageWriter&
94
 
operator<<(DBusMessageWriter& w, const set<string>& s) {
95
 
    DBusMessageIter sub;
96
 
    dbus_message_iter_open_container(&w.it, DBUS_TYPE_ARRAY,
97
 
        DBUS_TYPE_STRING_AS_STRING, &sub);
98
 
    set<string>::const_iterator i;
99
 
    for (i = s.begin(); i != s.end(); ++i) {
100
 
        const char* c = i->c_str();
101
 
        dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &c);
102
 
    }
103
 
    dbus_message_iter_close_container(&w.it, &sub);
104
 
    return w;
105
 
}
106
 
DBusMessageWriter&
107
 
operator<<(DBusMessageWriter& w, const std::map<std::string, std::string>& m) {
108
 
    DBusMessageIter sub, ssub;
109
 
    dbus_message_iter_open_container(&w.it, DBUS_TYPE_ARRAY, "{ss}", &sub);
110
 
    map<string, string>::const_iterator i;
111
 
    for (i = m.begin(); i != m.end(); ++i) {
112
 
        dbus_message_iter_open_container(&sub, DBUS_TYPE_DICT_ENTRY, 0, &ssub);
113
 
        const char* c = i->first.c_str();
114
 
        dbus_message_iter_append_basic(&ssub, DBUS_TYPE_STRING, &c);
115
 
        c = i->second.c_str();
116
 
        dbus_message_iter_append_basic(&ssub, DBUS_TYPE_STRING, &c);
117
 
        dbus_message_iter_close_container(&sub, &ssub);
118
 
    }
119
 
    dbus_message_iter_close_container(&w.it, &sub);
120
 
    return w;
121
 
}
122
 
DBusMessageWriter&
123
 
operator<<(DBusMessageWriter& w, const std::vector<std::string>& s) {
124
 
    DBusMessageIter sub;
125
 
    dbus_message_iter_open_container(&w.it, DBUS_TYPE_ARRAY,
126
 
        DBUS_TYPE_STRING_AS_STRING, &sub);
127
 
    vector<string>::const_iterator i;
128
 
    for (i = s.begin(); i != s.end(); ++i) {
129
 
        const char* c = i->c_str();
130
 
        dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &c);
131
 
    }
132
 
    dbus_message_iter_close_container(&w.it, &sub);
133
 
    return w;
134
 
}
135
 
DBusMessageWriter&
136
 
operator<<(DBusMessageWriter& w, const std::vector<int32_t>& s) {
137
 
    DBusMessageIter sub;
138
 
    dbus_message_iter_open_container(&w.it, DBUS_TYPE_ARRAY, "i", &sub);
139
 
    vector<int32_t>::const_iterator i;
140
 
    for (i = s.begin(); i != s.end(); ++i) {
141
 
        int32_t v = *i;
142
 
        dbus_message_iter_append_basic(&sub, DBUS_TYPE_INT32, &v);
143
 
    }
144
 
    dbus_message_iter_close_container(&w.it, &sub);
145
 
    return w;
146
 
}
147
 
DBusMessageWriter&
148
 
operator<<(DBusMessageWriter& w, const std::vector<uint32_t>& s) {
149
 
    DBusMessageIter sub;
150
 
    dbus_message_iter_open_container(&w.it, DBUS_TYPE_ARRAY, "u", &sub);
151
 
    vector<uint32_t>::const_iterator i;
152
 
    for (i = s.begin(); i != s.end(); ++i) {
153
 
        uint32_t v = *i;
154
 
        dbus_message_iter_append_basic(&sub, DBUS_TYPE_UINT32, &v);
155
 
    }
156
 
    dbus_message_iter_close_container(&w.it, &sub);
157
 
    return w;
158
 
}
159
 
/** map multimap<int,string> to 'a(is)' **/
160
 
DBusMessageWriter&
161
 
operator<<(DBusMessageWriter& w, const std::multimap<int, std::string>& m) {
162
 
    DBusMessageIter sub, ssub;
163
 
    dbus_message_iter_open_container(&w.it, DBUS_TYPE_ARRAY, "(is)", &sub);
164
 
    multimap<int,string>::const_iterator i;
165
 
    for (i = m.begin(); i != m.end(); ++i) {
166
 
        dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, 0, &ssub);
167
 
        int32_t n = i->first;
168
 
        const char* s = i->second.c_str();
169
 
        dbus_message_iter_append_basic(&ssub, DBUS_TYPE_INT32, &n);
170
 
        dbus_message_iter_append_basic(&ssub, DBUS_TYPE_STRING, &s);
171
 
        dbus_message_iter_close_container(&sub, &ssub);
172
 
    }
173
 
    dbus_message_iter_close_container(&w.it, &sub);
174
 
    return w;
175
 
}
176
 
DBusMessageWriter&
177
 
operator<<(DBusMessageWriter& w, const std::vector<std::pair<bool, std::string> >& s) {
178
 
    DBusMessageIter sub, ssub;
179
 
    dbus_message_iter_open_container(&w.it, DBUS_TYPE_ARRAY, "(bs)", &sub);
180
 
    vector<pair<bool,string> >::const_iterator i;
181
 
    for (i = s.begin(); i != s.end(); ++i) {
182
 
        dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, 0, &ssub);
183
 
        dbus_bool_t n = i->first;
184
 
        const char* s = i->second.c_str();
185
 
        dbus_message_iter_append_basic(&ssub, DBUS_TYPE_BOOLEAN, &n);
186
 
        dbus_message_iter_append_basic(&ssub, DBUS_TYPE_STRING, &s);
187
 
        dbus_message_iter_close_container(&sub, &ssub);
188
 
    }
189
 
    dbus_message_iter_close_container(&w.it, &sub);
190
 
    return w;
191
 
}
192
 
DBusMessageWriter&
193
 
operator<<(DBusMessageWriter& w, const std::vector<std::pair<std::string, dbus_uint32_t> >& s) {
194
 
    DBusMessageIter sub, ssub;
195
 
    dbus_message_iter_open_container(&w.it, DBUS_TYPE_ARRAY, "(su)", &sub);
196
 
    vector<pair<string,dbus_uint32_t> >::const_iterator i;
197
 
    for (i = s.begin(); i != s.end(); ++i) {
198
 
        dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, 0, &ssub);
199
 
        const char* s = i->first.c_str();
200
 
        dbus_uint32_t n = i->second;
201
 
        dbus_message_iter_append_basic(&ssub, DBUS_TYPE_STRING, &s);
202
 
        dbus_message_iter_append_basic(&ssub, DBUS_TYPE_UINT32, &n);
203
 
        dbus_message_iter_close_container(&sub, &ssub);
204
 
    }
205
 
    dbus_message_iter_close_container(&w.it, &sub);
206
 
 
207
 
    return w;
208
 
}
209
 
DBusMessageWriter&
210
 
operator<<(DBusMessageWriter& w, const std::vector<std::vector<std::string> >& v) {
211
 
    DBusMessageIter sub, ssub;
212
 
    dbus_message_iter_open_container(&w.it, DBUS_TYPE_ARRAY, "as", &sub);
213
 
    vector<vector<string> >::const_iterator i;
214
 
    for (i = v.begin(); i != v.end(); ++i) {
215
 
        dbus_message_iter_open_container(&sub, DBUS_TYPE_ARRAY,
216
 
            DBUS_TYPE_STRING_AS_STRING, &ssub);
217
 
        vector<string>::const_iterator j;
218
 
        vector<string>::const_iterator end = (*i).end();
219
 
        for (j = (*i).begin(); j != end; ++j) {
220
 
            const char* c = j->c_str();
221
 
            dbus_message_iter_append_basic(&ssub, DBUS_TYPE_STRING, &c);
222
 
        }
223
 
        dbus_message_iter_close_container(&sub, &ssub);
224
 
    }
225
 
    dbus_message_iter_close_container(&w.it, &sub);
226
 
    return w;
227
 
}