← Back to branch summary

~ubuntu-branches/ubuntu/trusty/syncevolution/trusty-proposed

« back to all changes in this revision

Viewing changes to src/gdbus/gdbus-cxx-bridge.h

  • Committer: Bazaar Package Importer
  • Author(s): Tino Keitel
  • Date: 2011-07-20 16:02:02 UTC
  • mfrom: (3.1.7 experimental)
  • Revision ID: james.westby@ubuntu.com-20110720160202-e8uf7ogw4vh0q0f3
Tags: 1.1.99.5a-1
* New upstream version 1.1.99.5a, first release candiate for 1.2
* Added python-openssl dependency, the HTTP server needs it for HTTPS support
* Added versioned dependency on libsynthesis0 to get required features
* Fixed .orig.tar.gz generation in get-orig-source target
* Added myself to Uploaders:, thanks to David for sponsoring
* Use updated upstream tag for source package generation
* Removed 0001-Replace-with-in-call-to-PKG_CHECK_MODULES.patch, fixed upstream
* Renamed NEWS.Debian to NEWS so that it is actually used
* Updated NEWS for 1.1.99.5a

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gdbus/gdbus-cxx-bridge.h
63
63
#include <map>
64
64
#include <vector>
65
65
 
66
 
#include <boost/bind.hpp>
67
 
#include <boost/intrusive_ptr.hpp>
68
 
#include <boost/shared_ptr.hpp>
69
 
#include <boost/variant.hpp>
70
 
#include <boost/variant/get.hpp>
71
 
 
72
66
namespace boost {
73
67
    void intrusive_ptr_add_ref(DBusConnection *con) { dbus_connection_ref(con); }
74
68
    void intrusive_ptr_release(DBusConnection *con) { dbus_connection_unref(con); }
78
72
    void intrusive_ptr_release(DBusPendingCall *call) {dbus_pending_call_unref (call); }
79
73
}
80
74
 
 
75
#include <boost/bind.hpp>
 
76
#include <boost/intrusive_ptr.hpp>
 
77
#include <boost/shared_ptr.hpp>
 
78
#include <boost/variant.hpp>
 
79
#include <boost/variant/get.hpp>
 
80
 
 
81
namespace GDBusCXX {
 
82
 
81
83
class DBusConnectionPtr : public boost::intrusive_ptr<DBusConnection>
82
84
{
83
85
 public:
183
185
 
184
186
/**
185
187
 * Append a varying number of parameters as result to the
186
 
 * message. Types can be anything that has a dbus_traits, including
 
188
 * message, using AppendRetvals(msg) << res1 << res2 << ...;
 
189
 *
 
190
 * Types can be anything that has a dbus_traits, including
187
191
 * types which are normally recognized as input parameters in D-Bus
188
192
 * method calls.
189
193
 */
190
 
template <class A1, class A2, class A3, class A4, class A5,
191
 
    class A6, class A7, class A8, class A9, class A10>
192
 
void append_retvals(DBusMessagePtr &msg,
193
 
                    A1 a1,
194
 
                    A2 a2,
195
 
                    A3 a3,
196
 
                    A4 a4,
197
 
                    A5 a5,
198
 
                    A6 a6,
199
 
                    A7 a7,
200
 
                    A8 a8,
201
 
                    A9 a9,
202
 
                    A10 a10)
203
 
{
204
 
    DBusMessageIter iter;
205
 
    dbus_message_iter_init_append(msg.get(), &iter);
206
 
    dbus_traits<A1>::append_retval(iter, a1);
207
 
    dbus_traits<A2>::append_retval(iter, a2);
208
 
    dbus_traits<A3>::append_retval(iter, a3);
209
 
    dbus_traits<A4>::append_retval(iter, a4);
210
 
    dbus_traits<A5>::append_retval(iter, a5);
211
 
    dbus_traits<A6>::append_retval(iter, a6);
212
 
    dbus_traits<A7>::append_retval(iter, a7);
213
 
    dbus_traits<A8>::append_retval(iter, a8);
214
 
    dbus_traits<A9>::append_retval(iter, a9);
215
 
    dbus_traits<A10>::append_retval(iter, a10);
216
 
}
217
 
 
218
 
template <class A1, class A2, class A3, class A4, class A5,
219
 
    class A6, class A7, class A8, class A9>
220
 
void append_retvals(DBusMessagePtr &msg,
221
 
                    A1 a1,
222
 
                    A2 a2,
223
 
                    A3 a3,
224
 
                    A4 a4,
225
 
                    A5 a5,
226
 
                    A6 a6,
227
 
                    A7 a7,
228
 
                    A8 a8,
229
 
                    A9 a9)
230
 
{
231
 
    DBusMessageIter iter;
232
 
    dbus_message_iter_init_append(msg.get(), &iter);
233
 
    dbus_traits<A1>::append_retval(iter, a1);
234
 
    dbus_traits<A2>::append_retval(iter, a2);
235
 
    dbus_traits<A3>::append_retval(iter, a3);
236
 
    dbus_traits<A4>::append_retval(iter, a4);
237
 
    dbus_traits<A5>::append_retval(iter, a5);
238
 
    dbus_traits<A6>::append_retval(iter, a6);
239
 
    dbus_traits<A7>::append_retval(iter, a7);
240
 
    dbus_traits<A8>::append_retval(iter, a8);
241
 
    dbus_traits<A9>::append_retval(iter, a9);
242
 
}
243
 
 
244
 
template <class A1, class A2, class A3, class A4, class A5,
245
 
    class A6, class A7, class A8>
246
 
void append_retvals(DBusMessagePtr &msg,
247
 
                    A1 a1,
248
 
                    A2 a2,
249
 
                    A3 a3,
250
 
                    A4 a4,
251
 
                    A5 a5,
252
 
                    A6 a6,
253
 
                    A7 a7,
254
 
                    A8 a8)
255
 
{
256
 
    DBusMessageIter iter;
257
 
    dbus_message_iter_init_append(msg.get(), &iter);
258
 
    dbus_traits<A1>::append_retval(iter, a1);
259
 
    dbus_traits<A2>::append_retval(iter, a2);
260
 
    dbus_traits<A3>::append_retval(iter, a3);
261
 
    dbus_traits<A4>::append_retval(iter, a4);
262
 
    dbus_traits<A5>::append_retval(iter, a5);
263
 
    dbus_traits<A6>::append_retval(iter, a6);
264
 
    dbus_traits<A7>::append_retval(iter, a7);
265
 
    dbus_traits<A8>::append_retval(iter, a8);
266
 
}
267
 
 
268
 
template <class A1, class A2, class A3, class A4, class A5,
269
 
    class A6, class A7>
270
 
void append_retvals(DBusMessagePtr &msg,
271
 
                    A1 a1,
272
 
                    A2 a2,
273
 
                    A3 a3,
274
 
                    A4 a4,
275
 
                    A5 a5,
276
 
                    A6 a6,
277
 
                    A7 a7)
278
 
{
279
 
    DBusMessageIter iter;
280
 
    dbus_message_iter_init_append(msg.get(), &iter);
281
 
    dbus_traits<A1>::append_retval(iter, a1);
282
 
    dbus_traits<A2>::append_retval(iter, a2);
283
 
    dbus_traits<A3>::append_retval(iter, a3);
284
 
    dbus_traits<A4>::append_retval(iter, a4);
285
 
    dbus_traits<A5>::append_retval(iter, a5);
286
 
    dbus_traits<A6>::append_retval(iter, a6);
287
 
    dbus_traits<A7>::append_retval(iter, a7);
288
 
}
289
 
 
290
 
template <class A1, class A2, class A3, class A4, class A5,
291
 
    class A6>
292
 
void append_retvals(DBusMessagePtr &msg,
293
 
                    A1 a1,
294
 
                    A2 a2,
295
 
                    A3 a3,
296
 
                    A4 a4,
297
 
                    A5 a5,
298
 
                    A6 a6)
299
 
{
300
 
    DBusMessageIter iter;
301
 
    dbus_message_iter_init_append(msg.get(), &iter);
302
 
    dbus_traits<A1>::append_retval(iter, a1);
303
 
    dbus_traits<A2>::append_retval(iter, a2);
304
 
    dbus_traits<A3>::append_retval(iter, a3);
305
 
    dbus_traits<A4>::append_retval(iter, a4);
306
 
    dbus_traits<A5>::append_retval(iter, a5);
307
 
    dbus_traits<A6>::append_retval(iter, a6);
308
 
}
309
 
 
310
 
template <class A1, class A2, class A3, class A4, class A5>
311
 
void append_retvals(DBusMessagePtr &msg,
312
 
                    A1 a1,
313
 
                    A2 a2,
314
 
                    A3 a3,
315
 
                    A4 a4,
316
 
                    A5 a5)
317
 
{
318
 
    DBusMessageIter iter;
319
 
    dbus_message_iter_init_append(msg.get(), &iter);
320
 
    dbus_traits<A1>::append_retval(iter, a1);
321
 
    dbus_traits<A2>::append_retval(iter, a2);
322
 
    dbus_traits<A3>::append_retval(iter, a3);
323
 
    dbus_traits<A4>::append_retval(iter, a4);
324
 
    dbus_traits<A5>::append_retval(iter, a5);
325
 
}
326
 
 
327
 
template <class A1, class A2, class A3, class A4>
328
 
void append_retvals(DBusMessagePtr &msg,
329
 
                    A1 a1,
330
 
                    A2 a2,
331
 
                    A3 a3,
332
 
                    A4 a4)
333
 
{
334
 
    DBusMessageIter iter;
335
 
    dbus_message_iter_init_append(msg.get(), &iter);
336
 
    dbus_traits<A1>::append_retval(iter, a1);
337
 
    dbus_traits<A2>::append_retval(iter, a2);
338
 
    dbus_traits<A3>::append_retval(iter, a3);
339
 
    dbus_traits<A4>::append_retval(iter, a4);
340
 
}
341
 
 
342
 
template <class A1, class A2, class A3>
343
 
void append_retvals(DBusMessagePtr &msg,
344
 
                    A1 a1,
345
 
                    A2 a2,
346
 
                    A3 a3)
347
 
{
348
 
    DBusMessageIter iter;
349
 
    dbus_message_iter_init_append(msg.get(), &iter);
350
 
    dbus_traits<A1>::append_retval(iter, a1);
351
 
    dbus_traits<A2>::append_retval(iter, a2);
352
 
    dbus_traits<A3>::append_retval(iter, a3);
353
 
}
354
 
 
355
 
template <class A1, class A2>
356
 
void append_retvals(DBusMessagePtr &msg,
357
 
                    A1 a1,
358
 
                    A2 a2)
359
 
{
360
 
    DBusMessageIter iter;
361
 
    dbus_message_iter_init_append(msg.get(), &iter);
362
 
    dbus_traits<A1>::append_retval(iter, a1);
363
 
    dbus_traits<A2>::append_retval(iter, a2);
364
 
}
365
 
 
366
 
template <class A1>
367
 
void append_retvals(DBusMessagePtr &msg,
368
 
                    A1 a1)
369
 
{
370
 
    DBusMessageIter iter;
371
 
    dbus_message_iter_init_append(msg.get(), &iter);
372
 
    dbus_traits<A1>::append_retval(iter, a1);
373
 
}
 
194
class AppendRetvals {
 
195
    DBusMessageIter m_iter;
 
196
 
 
197
 public:
 
198
    AppendRetvals(DBusMessagePtr &msg) {
 
199
        dbus_message_iter_init_append(msg.get(), &m_iter);
 
200
    }
 
201
 
 
202
    template<class A> AppendRetvals & operator << (const A &a) {
 
203
        dbus_traits<A>::append(m_iter, a);
 
204
        return *this;
 
205
    }
 
206
};
 
207
 
 
208
/**
 
209
 * Append a varying number of method parameters as result to the reply
 
210
 * message, using AppendArgs(msg) << Set<A1>(res1) << Set<A2>(res2) << ...;
 
211
 */
 
212
struct AppendArgs {
 
213
    DBusMessageIter m_iter;
 
214
 
 
215
    AppendArgs(DBusMessage *msg) {
 
216
        dbus_message_iter_init_append(msg, &m_iter);
 
217
    }
 
218
 
 
219
    /** syntactic sugar: redirect << into Set instance */
 
220
    template<class A> AppendArgs & operator << (const A &a) {
 
221
        return a.set(*this);
 
222
    }
 
223
 
 
224
    /**
 
225
     * Always append argument, including those types which
 
226
     * would be recognized by << as parameters and thus get
 
227
     * skipped.
 
228
     */
 
229
    template<class A> AppendArgs & operator + (const A &a) {
 
230
        dbus_traits<A>::append(m_iter, a);
 
231
        return *this;
 
232
    }
 
233
};
 
234
 
 
235
/** default: skip it, not a result of the method */
 
236
template<class A> struct Set
 
237
{
 
238
    Set(A &a) {}
 
239
    AppendArgs &set(AppendArgs &context) const {
 
240
        return context;
 
241
    }
 
242
};
 
243
 
 
244
/** same for const reference */
 
245
template<class A> struct Set <const A &>
 
246
{
 
247
    Set(A &a) {}
 
248
    AppendArgs &set(AppendArgs &context) const {
 
249
        return context;
 
250
    }
 
251
};
 
252
 
 
253
/** specialization for reference: marshal result */
 
254
template<class A> struct Set <A &>
 
255
{
 
256
    A &m_a;
 
257
    Set(A &a) : m_a(a) {}
 
258
    AppendArgs &set(AppendArgs &context) const {
 
259
        dbus_traits<A>::append(context.m_iter, m_a);
 
260
        return context;
 
261
    }
 
262
};
 
263
 
 
264
/**
 
265
 * Extract values from a message, using ExtractArgs(conn, msg) >> Get<A1>(val1) >> Get<A2>(val2) >> ...;
 
266
 *
 
267
 * This complements AppendArgs: it skips over those method arguments
 
268
 * which are results of the method. Which values are skipped and
 
269
 * which are marshalled depends on the specialization of Get and thus
 
270
 * ultimately on the prototype of the method.
 
271
 */
 
272
struct ExtractArgs {
 
273
    DBusConnection *m_conn;
 
274
    DBusMessage *m_msg;
 
275
    DBusMessageIter m_iter;
 
276
 
 
277
 public:
 
278
    ExtractArgs(DBusConnection *conn, DBusMessage *msg) {
 
279
        m_conn = conn;
 
280
        m_msg = msg;
 
281
        dbus_message_iter_init(msg, &m_iter);
 
282
    }
 
283
 
 
284
    /** syntactic sugar: redirect >> into Get instance */
 
285
    template<class A> ExtractArgs & operator >> (const A &a) {
 
286
        return a.get(*this);
 
287
    }
 
288
};
 
289
 
 
290
/** default: extract data from message */
 
291
template<class A> struct Get
 
292
{
 
293
    A &m_a;
 
294
    Get(A &a) : m_a(a) {}
 
295
    ExtractArgs &get(ExtractArgs &context) const {
 
296
        dbus_traits<A>::get(context.m_conn, context.m_msg, context.m_iter, m_a);
 
297
        return context;
 
298
    }
 
299
};
 
300
 
 
301
/** same for const reference */
 
302
template<class A> struct Get <const A &>
 
303
{
 
304
    A &m_a;
 
305
    Get(A &a) : m_a(a) {}
 
306
    ExtractArgs &get(ExtractArgs &context) const {
 
307
        dbus_traits<A>::get(context.m_conn, context.m_msg, context.m_iter, m_a);
 
308
        return context;
 
309
    }
 
310
};
 
311
 
 
312
/** specialization for reference: skip it, not an input parameter */
 
313
template<class A> struct Get <A &>
 
314
{
 
315
    Get(A &a) {}
 
316
    ExtractArgs &get(ExtractArgs &context) const {
 
317
        return context;
 
318
    }
 
319
};
374
320
 
375
321
/**
376
322
 * interface expected by EmitSignal
443
389
        if (!msg) {
444
390
            throw std::runtime_error("dbus_message_new_signal() failed");
445
391
        }
446
 
        append_retvals(msg, a1);
 
392
        AppendRetvals(msg) << a1;
447
393
 
448
394
        if (!dbus_connection_send(m_object.getConnection(), msg.get(), NULL)) {
449
395
            throw std::runtime_error("dbus_connection_send failed");
483
429
        if (!msg) {
484
430
            throw std::runtime_error("dbus_message_new_signal() failed");
485
431
        }
486
 
        append_retvals(msg, a1, a2);
 
432
        AppendRetvals(msg) << a1 << a2;
487
433
 
488
434
        if (!dbus_connection_send(m_object.getConnection(), msg.get(), NULL)) {
489
435
            throw std::runtime_error("dbus_connection_send failed");
524
470
        if (!msg) {
525
471
            throw std::runtime_error("dbus_message_new_signal() failed");
526
472
        }
527
 
        append_retvals(msg, a1, a2, a3);
 
473
        AppendRetvals(msg) << a1 << a2 << a3;
528
474
        if (!dbus_connection_send(m_object.getConnection(), msg.get(), NULL)) {
529
475
            throw std::runtime_error("dbus_connection_send failed");
530
476
        }
565
511
        if (!msg) {
566
512
            throw std::runtime_error("dbus_message_new_signal() failed");
567
513
        }
568
 
        append_retvals(msg, a1, a2, a3, a4);
 
514
        AppendRetvals(msg) << a1 << a2 << a3 << a4;
569
515
        if (!dbus_connection_send(m_object.getConnection(), msg.get(), NULL)) {
570
516
            throw std::runtime_error("dbus_connection_send failed");
571
517
        }
607
553
        if (!msg) {
608
554
            throw std::runtime_error("dbus_message_new_signal() failed");
609
555
        }
610
 
        append_retvals(msg, a1, a2, a3, a4, a5);
 
556
        AppendRetvals(msg) << a1 << a2 << a3 << a4 << a5;
611
557
        if (!dbus_connection_send(m_object.getConnection(), msg.get(), NULL)) {
612
558
            throw std::runtime_error("dbus_connection_send failed");
613
559
        }
650
596
        if (!msg) {
651
597
            throw std::runtime_error("dbus_message_new_signal() failed");
652
598
        }
653
 
        append_retvals(msg, a1, a2, a3, a4, a5, a6);
 
599
        AppendRetvals(msg) << a1 << a2 << a3 << a4 << a5 << a6;
654
600
        if (!dbus_connection_send(m_object.getConnection(), msg.get(), NULL)) {
655
601
            throw std::runtime_error("dbus_connection_send failed");
656
602
        }
865
811
    }
866
812
 
867
813
    /**
868
 
     * copy value from return value into D-Bus iterator,
869
 
     * empty here because plain types are no return values
 
814
     * copy value into D-Bus iterator
870
815
     */
871
816
    static void append(DBusMessageIter &iter, arg_type value)
872
817
    {
873
 
        // nothing to do
874
 
    }
875
 
 
876
 
    /**
877
 
     * utility function to be used by derived classes which
878
 
     * need to copy a variable of this underlying type
879
 
     */
880
 
    static void append_retval(DBusMessageIter &iter, arg_type value)
881
 
    {
882
818
        if (!dbus_message_iter_append_basic(&iter, dbus, &value)) {
883
819
            throw std::runtime_error("out of memory");
884
820
        }
967
903
        value = dbus_value;
968
904
    }    
969
905
 
970
 
    static void append(DBusMessageIter &iter, bool value) {}
971
 
 
972
 
    static void append_retval(DBusMessageIter &iter, bool value)
 
906
    static void append(DBusMessageIter &iter, bool value)
973
907
    {
974
908
        dbus_bool_t dbus_value = value;
975
909
        if (!dbus_message_iter_append_basic(&iter, dbus, &dbus_value)) {
1000
934
        value = str;
1001
935
    }
1002
936
 
1003
 
    static void append(DBusMessageIter &iter, const std::string &value) {}
1004
 
 
1005
 
    static void append_retval(DBusMessageIter &iter, const std::string &value)
 
937
    static void append(DBusMessageIter &iter, const std::string &value)
1006
938
    {
1007
939
        const char *str = value.c_str();
1008
940
        if (!dbus_message_iter_append_basic(&iter, dbus, &str)) {
1033
965
        value = str;
1034
966
    }
1035
967
 
1036
 
    static void append(DBusMessageIter &iter, const DBusObject_t &value) {}
1037
 
 
1038
 
    static void append_retval(DBusMessageIter &iter, const DBusObject_t &value)
 
968
    static void append(DBusMessageIter &iter, const DBusObject_t &value)
1039
969
    {
1040
970
        const char *str = value.c_str();
1041
971
        if (!dbus_message_iter_append_basic(&iter, dbus, &str)) {
1067
997
        value = peer;
1068
998
    }
1069
999
 
1070
 
    static void append(DBusMessageIter &iter, const DBusObject_t &value) {}
1071
 
 
1072
1000
    typedef Caller_t host_type;
1073
1001
    typedef const Caller_t &arg_type;
1074
1002
};
1116
1044
        dbus_message_iter_next(&iter);
1117
1045
    }
1118
1046
 
1119
 
    static void append(DBusMessageIter &iter, arg_type array) {}
1120
 
 
1121
 
    static void append_retval(DBusMessageIter &iter, arg_type array)
 
1047
    static void append(DBusMessageIter &iter, arg_type array)
1122
1048
    {
1123
1049
        DBusMessageIter sub;
1124
1050
        if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, getContainedType().c_str(), &sub) ||
1176
1102
        dbus_message_iter_next(&iter);
1177
1103
    }
1178
1104
 
1179
 
    static void append(DBusMessageIter &iter, arg_type dict) {}
1180
 
 
1181
 
    static void append_retval(DBusMessageIter &iter, arg_type dict)
 
1105
    static void append(DBusMessageIter &iter, arg_type dict)
1182
1106
    {
1183
1107
        DBusMessageIter sub;
1184
1108
        if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, getContainedType().c_str(), &sub)) {
1192
1116
            if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_DICT_ENTRY, NULL, &entry)) {
1193
1117
                throw std::runtime_error("out of memory");
1194
1118
            }
1195
 
            dbus_traits<K>::append_retval(entry, it->first);
1196
 
            dbus_traits<V>::append_retval(entry, it->second);
 
1119
            dbus_traits<K>::append(entry, it->first);
 
1120
            dbus_traits<V>::append(entry, it->second);
1197
1121
            if (!dbus_message_iter_close_container(&sub, &entry)) {
1198
1122
                throw std::runtime_error("out of memory");
1199
1123
            }
1240
1164
        dbus_message_iter_next(&iter);
1241
1165
    }
1242
1166
 
1243
 
    static void append(DBusMessageIter &iter, arg_type array) {}
1244
 
 
1245
 
    static void append_retval(DBusMessageIter &iter, arg_type array)
 
1167
    static void append(DBusMessageIter &iter, arg_type array)
1246
1168
    {
1247
1169
        DBusMessageIter sub;
1248
1170
        if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, getContainedType().c_str(), &sub)) {
1252
1174
        for(typename host_type::const_iterator it = array.begin();
1253
1175
            it != array.end();
1254
1176
            ++it) {
1255
 
            dbus_traits<V>::append_retval(sub, *it);
 
1177
            dbus_traits<V>::append(sub, *it);
1256
1178
        }
1257
1179
        if (!dbus_message_iter_close_container(&iter, &sub)) {
1258
1180
            throw std::runtime_error("out of memory");
1291
1213
        value = val;
1292
1214
    }
1293
1215
 
1294
 
    static void append(DBusMessageIter &iter, const boost::variant <V>  &value) {
1295
 
    }
1296
 
 
1297
 
    //append_retval not implemented
1298
 
    //static void append_retval(DBusMessageIter &iter, arg_type array)
1299
 
    //{
1300
 
    //}
1301
 
 
1302
1216
    typedef boost::variant<V> host_type;
1303
1217
    typedef const boost::variant<V> &arg_type;
1304
1218
};
1340
1254
        }
1341
1255
    }
1342
1256
 
1343
 
    static void append(DBusMessageIter &iter, const boost::variant <V1, V2>  &value) {
1344
 
    }
1345
 
 
1346
1257
    typedef boost::variant<V1, V2> host_type;
1347
1258
    typedef const boost::variant<V1, V2> &arg_type;
1348
1259
};
1364
1275
        dbus_traits<V>::get(conn, msg, iter, val.*m);
1365
1276
    }
1366
1277
 
1367
 
    static void append_retval(DBusMessageIter &iter, const K &val)
 
1278
    static void append(DBusMessageIter &iter, const K &val)
1368
1279
    {
1369
 
        dbus_traits<V>::append_retval(iter, val.*m);
 
1280
        dbus_traits<V>::append(iter, val.*m);
1370
1281
    }
1371
1282
};
1372
1283
 
1389
1300
        M::get(conn, msg, iter, val);
1390
1301
    }
1391
1302
 
1392
 
    static void append_retval(DBusMessageIter &iter, const K &val)
 
1303
    static void append(DBusMessageIter &iter, const K &val)
1393
1304
    {
1394
 
        dbus_traits<V>::append_retval(iter, val.*m);
1395
 
        M::append_retval(iter, val);
 
1305
        dbus_traits<V>::append(iter, val.*m);
 
1306
        M::append(iter, val);
1396
1307
    }
1397
1308
};
1398
1309
 
1434
1345
        dbus_message_iter_next(&iter);
1435
1346
    }
1436
1347
 
1437
 
    static void append(DBusMessageIter &iter, arg_type val) {}
1438
 
 
1439
 
    static void append_retval(DBusMessageIter &iter, arg_type val)
 
1348
    static void append(DBusMessageIter &iter, arg_type val)
1440
1349
    {
1441
1350
        DBusMessageIter sub;
1442
1351
        if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_STRUCT, NULL, &sub)) {
1443
1352
            throw std::runtime_error("out of memory");
1444
1353
        }
1445
 
        M::append_retval(sub, val);
 
1354
        M::append(sub, val);
1446
1355
        if (!dbus_message_iter_close_container(&iter, &sub)) {
1447
1356
            throw std::runtime_error("out of memory");
1448
1357
        }
1459
1368
 
1460
1369
/**
1461
1370
 * special case writeable reference parameter:
1462
 
 * must be a return value, so provide our own
1463
 
 * get() and pack() where get() doesn't do
1464
 
 * anything and pack() really encodes the value
 
1371
 * must be a return value
1465
1372
 *
1466
1373
 * Example: std::string &retval
1467
1374
 */
1468
1375
template<class C> struct dbus_traits<C &> : public dbus_traits<C>
1469
1376
{
1470
 
    /**
1471
 
     * skip when extracting input arguments
1472
 
     */
1473
 
    static void get(DBusConnection *conn, DBusMessage *msg,
1474
 
                    DBusMessageIter &iter, C &value) {}
1475
1377
    static std::string getSignature() { return ""; }
1476
 
 
1477
 
    /**
1478
 
     * use utility function provided by underlying trait
1479
 
     */
1480
 
    static void append(DBusMessageIter &iter, const C &value)
1481
 
    {
1482
 
        dbus_traits<C>::append_retval(iter, value);
1483
 
    }
1484
1378
    static std::string getReply() { return dbus_traits<C>::getType(); }
1485
1379
};
1486
1380
 
1688
1582
    }
1689
1583
 
1690
1584
    static std::string getSignature() { return ""; }
1691
 
    static void append(DBusMessageIter &iter) {}
1692
1585
};
1693
1586
 
1694
1587
template <typename A1>
1708
1601
        if (!reply) {
1709
1602
            throw std::runtime_error("no DBusMessage");
1710
1603
        }
1711
 
        append_retvals(reply, a1);
 
1604
        AppendRetvals(reply) << a1;
1712
1605
        if (!dbus_connection_send(m_conn.get(), reply.get(), NULL)) {
1713
1606
            throw std::runtime_error("dbus_connection_send failed");
1714
1607
        }
1737
1630
        if (!reply) {
1738
1631
            throw std::runtime_error("no DBusMessage");
1739
1632
        }
1740
 
        append_retvals(reply, a1, a2);
 
1633
        AppendRetvals(reply) << a1 << a2;
1741
1634
        if (!dbus_connection_send(m_conn.get(), reply.get(), NULL)) {
1742
1635
            throw std::runtime_error("dbus_connection_send failed");
1743
1636
        }
1770
1663
        if (!reply) {
1771
1664
            throw std::runtime_error("no DBusMessage");
1772
1665
        }
1773
 
        append_retvals(reply, a1, a2, a3);
 
1666
        AppendRetvals(reply) << a1 << a2 << a3;
1774
1667
        if (!dbus_connection_send(m_conn.get(), reply.get(), NULL)) {
1775
1668
            throw std::runtime_error("dbus_connection_send failed");
1776
1669
        }
1803
1696
        if (!reply) {
1804
1697
            throw std::runtime_error("no DBusMessage");
1805
1698
        }
1806
 
        append_retvals(reply, a1, a2, a3, a4);
 
1699
        AppendRetvals(reply) << a1 << a2 << a3 << a4;
1807
1700
        if (!dbus_connection_send(m_conn.get(), reply.get(), NULL)) {
1808
1701
            throw std::runtime_error("dbus_connection_send failed");
1809
1702
        }
1836
1729
        if (!reply) {
1837
1730
            throw std::runtime_error("no DBusMessage");
1838
1731
        }
1839
 
        append_retvals(reply, a1, a2, a3, a4, a5);
 
1732
        AppendRetvals(reply) << a1 << a2 << a3 << a4 << a5;
1840
1733
        if (!dbus_connection_send(m_conn.get(), reply.get(), NULL)) {
1841
1734
            throw std::runtime_error("dbus_connection_send failed");
1842
1735
        }
1870
1763
        if (!reply) {
1871
1764
            throw std::runtime_error("no DBusMessage");
1872
1765
        }
1873
 
        append_retvals(reply, a1, a2, a3, a4, a5, a6);
 
1766
        AppendRetvals(reply) << a1 << a2 << a3 << a4 << a5 << a6;
1874
1767
        if (!dbus_connection_send(m_conn.get(), reply.get(), NULL)) {
1875
1768
            throw std::runtime_error("dbus_connection_send failed");
1876
1769
        }
1904
1797
        if (!reply) {
1905
1798
            throw std::runtime_error("no DBusMessage");
1906
1799
        }
1907
 
        append_retvals(reply, a1, a2, a3, a4, a5, a6, a7);
 
1800
        AppendRetvals(reply) << a1 << a2 << a3 << a4 << a5 << a6 << a7;
1908
1801
        if (!dbus_connection_send(m_conn.get(), reply.get(), NULL)) {
1909
1802
            throw std::runtime_error("dbus_connection_send failed");
1910
1803
        }
1938
1831
        if (!reply) {
1939
1832
            throw std::runtime_error("no DBusMessage");
1940
1833
        }
1941
 
        append_retvals(reply, a1, a2, a3, a4, a5, a6, a7, a8);
 
1834
        AppendRetvals(reply) << a1 << a2 << a3 << a4 << a5 << a6 << a7 << a8;
1942
1835
        if (!dbus_connection_send(m_conn.get(), reply.get(), NULL)) {
1943
1836
            throw std::runtime_error("dbus_connection_send failed");
1944
1837
        }
1972
1865
        if (!reply) {
1973
1866
            throw std::runtime_error("no DBusMessage");
1974
1867
        }
1975
 
        append_retvals(reply, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 
1868
        AppendRetvals(reply) << a1 << a2 << a3 << a4 << a5 << a6 << a7 << a8 << a9;
1976
1869
        if (!dbus_connection_send(m_conn.get(), reply.get(), NULL)) {
1977
1870
            throw std::runtime_error("dbus_connection_send failed");
1978
1871
        }
2006
1899
        if (!reply) {
2007
1900
            throw std::runtime_error("no DBusMessage");
2008
1901
        }
2009
 
        append_retvals(reply, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
 
1902
        AppendRetvals(reply) << a1 << a2 << a3 << a4 << a5 << a6 << a7 << a8 << a9 << a10;
2010
1903
        if (!dbus_connection_send(m_conn.get(), reply.get(), NULL)) {
2011
1904
            throw std::runtime_error("dbus_connection_send failed");
2012
1905
        }
2045
1938
    {
2046
1939
        value.reset(new DBusR(conn, msg));
2047
1940
    }
2048
 
 
2049
 
    static void append(DBusMessageIter &iter, const host_type &value) {}
2050
 
    static void append_retval(DBusMessageIter &iter, const host_type &value) {}
2051
1941
};
2052
1942
 
2053
1943
template <>
2161
2051
            // even though the trait would not normally do that
2162
2052
            // because it is a plain type => call utility function
2163
2053
            // directly.
2164
 
            dbus_traits<R>::append_retval(iter, r);
 
2054
            dbus_traits<R>::append(iter, r);
2165
2055
            dbus_traits<A1>::append(iter, a1);
2166
2056
            dbus_traits<A2>::append(iter, a2);
2167
2057
            return reply;
2248
2138
            typename dbus_traits<A9>::host_type a9;
2249
2139
            typename dbus_traits<A10>::host_type a10;
2250
2140
 
2251
 
            DBusMessageIter iter;
2252
 
            dbus_message_iter_init(msg, &iter);
2253
 
            dbus_traits<A1>::get(conn, msg, iter, a1);
2254
 
            dbus_traits<A2>::get(conn, msg, iter, a2);
2255
 
            dbus_traits<A3>::get(conn, msg, iter, a3);
2256
 
            dbus_traits<A4>::get(conn, msg, iter, a4);
2257
 
            dbus_traits<A5>::get(conn, msg, iter, a5);
2258
 
            dbus_traits<A6>::get(conn, msg, iter, a6);
2259
 
            dbus_traits<A7>::get(conn, msg, iter, a7);
2260
 
            dbus_traits<A8>::get(conn, msg, iter, a8);
2261
 
            dbus_traits<A9>::get(conn, msg, iter, a9);
2262
 
            dbus_traits<A10>::get(conn, msg, iter, a10);
 
2141
            ExtractArgs(conn, msg) >> Get<A1>(a1) >> Get<A2>(a2) >> Get<A3>(a3) >> Get<A4>(a4) >> Get<A5>(a5) >> Get<A6>(a6) >> Get<A7>(a7) >> Get<A8>(a8) >> Get<A9>(a9) >> Get<A10>(a10);
2263
2142
 
2264
2143
            (*static_cast<M *>(data))(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
2265
2144
 
2270
2149
            DBusMessage *reply = dbus_message_new_method_return(msg);
2271
2150
            if (!reply)
2272
2151
                return NULL;
2273
 
            dbus_message_iter_init_append(reply, &iter);
2274
 
            dbus_traits<A1>::append(iter, a1);
2275
 
            dbus_traits<A2>::append(iter, a2);
2276
 
            dbus_traits<A3>::append(iter, a3);
2277
 
            dbus_traits<A4>::append(iter, a4);
2278
 
            dbus_traits<A5>::append(iter, a5);
2279
 
            dbus_traits<A6>::append(iter, a6);
2280
 
            dbus_traits<A7>::append(iter, a7);
2281
 
            dbus_traits<A8>::append(iter, a8);
2282
 
            dbus_traits<A9>::append(iter, a9);
2283
 
            dbus_traits<A10>::append(iter, a10);
 
2152
 
 
2153
            AppendArgs(reply) << Set<A1>(a1) << Set<A2>(a2) << Set<A3>(a3) << Set<A4>(a4) << Set<A5>(a5) << Set<A6>(a6) << Set<A7>(a7) << Set<A8>(a8) << Set<A9>(a9) << Set<A10>(a10);
 
2154
 
2284
2155
            return reply;
2285
2156
        } catch (...) {
2286
2157
            return handleException(msg);
2362
2233
            typename dbus_traits<A8>::host_type a8;
2363
2234
            typename dbus_traits<A9>::host_type a9;
2364
2235
 
2365
 
            DBusMessageIter iter;
2366
 
            dbus_message_iter_init(msg, &iter);
2367
 
            dbus_traits<A1>::get(conn, msg, iter, a1);
2368
 
            dbus_traits<A2>::get(conn, msg, iter, a2);
2369
 
            dbus_traits<A3>::get(conn, msg, iter, a3);
2370
 
            dbus_traits<A4>::get(conn, msg, iter, a4);
2371
 
            dbus_traits<A5>::get(conn, msg, iter, a5);
2372
 
            dbus_traits<A6>::get(conn, msg, iter, a6);
2373
 
            dbus_traits<A7>::get(conn, msg, iter, a7);
2374
 
            dbus_traits<A8>::get(conn, msg, iter, a8);
2375
 
            dbus_traits<A9>::get(conn, msg, iter, a9);
 
2236
            ExtractArgs(conn, msg) >> Get<A1>(a1) >> Get<A2>(a2) >> Get<A3>(a3) >> Get<A4>(a4) >> Get<A5>(a5) >> Get<A6>(a6) >> Get<A7>(a7) >> Get<A8>(a8) >> Get<A9>(a9);
2376
2237
 
2377
2238
            r = (*static_cast<M *>(data))(a1, a2, a3, a4, a5, a6, a7, a8, a9);
2378
2239
 
2383
2244
            DBusMessage *reply = dbus_message_new_method_return(msg);
2384
2245
            if (!reply)
2385
2246
                return NULL;
2386
 
            dbus_message_iter_init_append(reply, &iter);
2387
 
            dbus_traits<R>::append_retval(iter, r);
2388
 
            dbus_traits<A1>::append(iter, a1);
2389
 
            dbus_traits<A2>::append(iter, a2);
2390
 
            dbus_traits<A3>::append(iter, a3);
2391
 
            dbus_traits<A4>::append(iter, a4);
2392
 
            dbus_traits<A5>::append(iter, a5);
2393
 
            dbus_traits<A6>::append(iter, a6);
2394
 
            dbus_traits<A7>::append(iter, a7);
2395
 
            dbus_traits<A8>::append(iter, a8);
2396
 
            dbus_traits<A9>::append(iter, a9);
 
2247
 
 
2248
            AppendArgs(reply) + r << Set<A1>(a1) << Set<A2>(a2) << Set<A3>(a3) << Set<A4>(a4) << Set<A5>(a5) << Set<A6>(a6) << Set<A7>(a7) << Set<A8>(a8) << Set<A9>(a9);
 
2249
 
2397
2250
            return reply;
2398
2251
        } catch (...) {
2399
2252
            return handleException(msg);
2470
2323
            typename dbus_traits<A8>::host_type a8;
2471
2324
            typename dbus_traits<A9>::host_type a9;
2472
2325
 
2473
 
            DBusMessageIter iter;
2474
 
            dbus_message_iter_init(msg, &iter);
2475
 
            dbus_traits<A1>::get(conn, msg, iter, a1);
2476
 
            dbus_traits<A2>::get(conn, msg, iter, a2);
2477
 
            dbus_traits<A3>::get(conn, msg, iter, a3);
2478
 
            dbus_traits<A4>::get(conn, msg, iter, a4);
2479
 
            dbus_traits<A5>::get(conn, msg, iter, a5);
2480
 
            dbus_traits<A6>::get(conn, msg, iter, a6);
2481
 
            dbus_traits<A7>::get(conn, msg, iter, a7);
2482
 
            dbus_traits<A8>::get(conn, msg, iter, a8);
2483
 
            dbus_traits<A9>::get(conn, msg, iter, a9);
 
2326
            ExtractArgs(conn, msg) >> Get<A1>(a1) >> Get<A2>(a2) >> Get<A3>(a3) >> Get<A4>(a4) >> Get<A5>(a5) >> Get<A6>(a6) >> Get<A7>(a7) >> Get<A8>(a8) >> Get<A9>(a9);
2484
2327
 
2485
2328
            (*static_cast<M *>(data))(a1, a2, a3, a4, a5, a6, a7, a8, a9);
2486
2329
 
2491
2334
            DBusMessage *reply = dbus_message_new_method_return(msg);
2492
2335
            if (!reply)
2493
2336
                return NULL;
2494
 
            dbus_message_iter_init_append(reply, &iter);
2495
 
            dbus_traits<A1>::append(iter, a1);
2496
 
            dbus_traits<A2>::append(iter, a2);
2497
 
            dbus_traits<A3>::append(iter, a3);
2498
 
            dbus_traits<A4>::append(iter, a4);
2499
 
            dbus_traits<A5>::append(iter, a5);
2500
 
            dbus_traits<A6>::append(iter, a6);
2501
 
            dbus_traits<A7>::append(iter, a7);
2502
 
            dbus_traits<A8>::append(iter, a8);
2503
 
            dbus_traits<A9>::append(iter, a9);
 
2337
 
 
2338
            AppendArgs(reply) << Set<A1>(a1) << Set<A2>(a2) << Set<A3>(a3) << Set<A4>(a4) << Set<A5>(a5) << Set<A6>(a6) << Set<A7>(a7) << Set<A8>(a8) << Set<A9>(a9);
 
2339
 
2504
2340
            return reply;
2505
2341
        } catch (...) {
2506
2342
            return handleException(msg);
2577
2413
            typename dbus_traits<A7>::host_type a7;
2578
2414
            typename dbus_traits<A8>::host_type a8;
2579
2415
 
2580
 
            DBusMessageIter iter;
2581
 
            dbus_message_iter_init(msg, &iter);
2582
 
            dbus_traits<A1>::get(conn, msg, iter, a1);
2583
 
            dbus_traits<A2>::get(conn, msg, iter, a2);
2584
 
            dbus_traits<A3>::get(conn, msg, iter, a3);
2585
 
            dbus_traits<A4>::get(conn, msg, iter, a4);
2586
 
            dbus_traits<A5>::get(conn, msg, iter, a5);
2587
 
            dbus_traits<A6>::get(conn, msg, iter, a6);
2588
 
            dbus_traits<A7>::get(conn, msg, iter, a7);
2589
 
            dbus_traits<A8>::get(conn, msg, iter, a8);
 
2416
            ExtractArgs(conn, msg) >> Get<A1>(a1) >> Get<A2>(a2) >> Get<A3>(a3) >> Get<A4>(a4) >> Get<A5>(a5) >> Get<A6>(a6) >> Get<A7>(a7) >> Get<A8>(a8);
2590
2417
 
2591
2418
            r = (*static_cast<M *>(data))(a1, a2, a3, a4, a5, a6, a7, a8);
2592
2419
 
2597
2424
            DBusMessage *reply = dbus_message_new_method_return(msg);
2598
2425
            if (!reply)
2599
2426
                return NULL;
2600
 
            dbus_message_iter_init_append(reply, &iter);
2601
 
            dbus_traits<R>::append_retval(iter, r);
2602
 
            dbus_traits<A1>::append(iter, a1);
2603
 
            dbus_traits<A2>::append(iter, a2);
2604
 
            dbus_traits<A3>::append(iter, a3);
2605
 
            dbus_traits<A4>::append(iter, a4);
2606
 
            dbus_traits<A5>::append(iter, a5);
2607
 
            dbus_traits<A6>::append(iter, a6);
2608
 
            dbus_traits<A7>::append(iter, a7);
2609
 
            dbus_traits<A8>::append(iter, a8);
 
2427
 
 
2428
            AppendArgs(reply) + r << Set<A1>(a1) << Set<A2>(a2) << Set<A3>(a3) << Set<A4>(a4) << Set<A5>(a5) << Set<A6>(a6) << Set<A7>(a7) << Set<A8>(a8);
 
2429
 
2610
2430
            return reply;
2611
2431
        } catch (...) {
2612
2432
            return handleException(msg);
2680
2500
            typename dbus_traits<A7>::host_type a7;
2681
2501
            typename dbus_traits<A8>::host_type a8;
2682
2502
 
2683
 
            DBusMessageIter iter;
2684
 
            dbus_message_iter_init(msg, &iter);
2685
 
            dbus_traits<A1>::get(conn, msg, iter, a1);
2686
 
            dbus_traits<A2>::get(conn, msg, iter, a2);
2687
 
            dbus_traits<A3>::get(conn, msg, iter, a3);
2688
 
            dbus_traits<A4>::get(conn, msg, iter, a4);
2689
 
            dbus_traits<A5>::get(conn, msg, iter, a5);
2690
 
            dbus_traits<A6>::get(conn, msg, iter, a6);
2691
 
            dbus_traits<A7>::get(conn, msg, iter, a7);
2692
 
            dbus_traits<A8>::get(conn, msg, iter, a8);
 
2503
            ExtractArgs(conn, msg) >> Get<A1>(a1) >> Get<A2>(a2) >> Get<A3>(a3) >> Get<A4>(a4) >> Get<A5>(a5) >> Get<A6>(a6) >> Get<A7>(a7) >> Get<A8>(a8);
2693
2504
 
2694
2505
            (*static_cast<M *>(data))(a1, a2, a3, a4, a5, a6, a7, a8);
2695
2506
 
2700
2511
            DBusMessage *reply = dbus_message_new_method_return(msg);
2701
2512
            if (!reply)
2702
2513
                return NULL;
2703
 
            dbus_message_iter_init_append(reply, &iter);
2704
 
            dbus_traits<A1>::append(iter, a1);
2705
 
            dbus_traits<A2>::append(iter, a2);
2706
 
            dbus_traits<A3>::append(iter, a3);
2707
 
            dbus_traits<A4>::append(iter, a4);
2708
 
            dbus_traits<A5>::append(iter, a5);
2709
 
            dbus_traits<A6>::append(iter, a6);
2710
 
            dbus_traits<A7>::append(iter, a7);
2711
 
            dbus_traits<A8>::append(iter, a8);
 
2514
 
 
2515
            AppendArgs(reply) << Set<A1>(a1) << Set<A2>(a2) << Set<A3>(a3) << Set<A4>(a4) << Set<A5>(a5) << Set<A6>(a6) << Set<A7>(a7) << Set<A8>(a8);
 
2516
 
2712
2517
            return reply;
2713
2518
        } catch (...) {
2714
2519
            return handleException(msg);
2782
2587
            typename dbus_traits<A6>::host_type a6;
2783
2588
            typename dbus_traits<A7>::host_type a7;
2784
2589
 
2785
 
            DBusMessageIter iter;
2786
 
            dbus_message_iter_init(msg, &iter);
2787
 
            dbus_traits<A1>::get(conn, msg, iter, a1);
2788
 
            dbus_traits<A2>::get(conn, msg, iter, a2);
2789
 
            dbus_traits<A3>::get(conn, msg, iter, a3);
2790
 
            dbus_traits<A4>::get(conn, msg, iter, a4);
2791
 
            dbus_traits<A5>::get(conn, msg, iter, a5);
2792
 
            dbus_traits<A6>::get(conn, msg, iter, a6);
2793
 
            dbus_traits<A7>::get(conn, msg, iter, a7);
 
2590
            ExtractArgs(conn, msg) >> Get<A1>(a1) >> Get<A2>(a2) >> Get<A3>(a3) >> Get<A4>(a4) >> Get<A5>(a5) >> Get<A6>(a6) >> Get<A7>(a7);
2794
2591
 
2795
2592
            r = (*static_cast<M *>(data))(a1, a2, a3, a4, a5, a6, a7);
2796
2593
 
2801
2598
            DBusMessage *reply = dbus_message_new_method_return(msg);
2802
2599
            if (!reply)
2803
2600
                return NULL;
2804
 
            dbus_message_iter_init_append(reply, &iter);
2805
 
            dbus_traits<R>::append_retval(iter, r);
2806
 
            dbus_traits<A1>::append(iter, a1);
2807
 
            dbus_traits<A2>::append(iter, a2);
2808
 
            dbus_traits<A3>::append(iter, a3);
2809
 
            dbus_traits<A4>::append(iter, a4);
2810
 
            dbus_traits<A5>::append(iter, a5);
2811
 
            dbus_traits<A6>::append(iter, a6);
2812
 
            dbus_traits<A7>::append(iter, a7);
 
2601
 
 
2602
            AppendArgs(reply) + r << Set<A1>(a1) << Set<A2>(a2) << Set<A3>(a3) << Set<A4>(a4) << Set<A5>(a5) << Set<A6>(a6) << Set<A7>(a7);
 
2603
 
2813
2604
            return reply;
2814
2605
        } catch (...) {
2815
2606
            return handleException(msg);
2880
2671
            typename dbus_traits<A6>::host_type a6;
2881
2672
            typename dbus_traits<A7>::host_type a7;
2882
2673
 
2883
 
            DBusMessageIter iter;
2884
 
            dbus_message_iter_init(msg, &iter);
2885
 
            dbus_traits<A1>::get(conn, msg, iter, a1);
2886
 
            dbus_traits<A2>::get(conn, msg, iter, a2);
2887
 
            dbus_traits<A3>::get(conn, msg, iter, a3);
2888
 
            dbus_traits<A4>::get(conn, msg, iter, a4);
2889
 
            dbus_traits<A5>::get(conn, msg, iter, a5);
2890
 
            dbus_traits<A6>::get(conn, msg, iter, a6);
2891
 
            dbus_traits<A7>::get(conn, msg, iter, a7);
 
2674
            ExtractArgs(conn, msg) >> Get<A1>(a1) >> Get<A2>(a2) >> Get<A3>(a3) >> Get<A4>(a4) >> Get<A5>(a5) >> Get<A6>(a6) >> Get<A7>(a7);
2892
2675
 
2893
2676
            (*static_cast<M *>(data))(a1, a2, a3, a4, a5, a6, a7);
2894
2677
 
2899
2682
            DBusMessage *reply = dbus_message_new_method_return(msg);
2900
2683
            if (!reply)
2901
2684
                return NULL;
2902
 
            dbus_message_iter_init_append(reply, &iter);
2903
 
            dbus_traits<A1>::append(iter, a1);
2904
 
            dbus_traits<A2>::append(iter, a2);
2905
 
            dbus_traits<A3>::append(iter, a3);
2906
 
            dbus_traits<A4>::append(iter, a4);
2907
 
            dbus_traits<A5>::append(iter, a5);
2908
 
            dbus_traits<A6>::append(iter, a6);
2909
 
            dbus_traits<A7>::append(iter, a7);
 
2685
 
 
2686
            AppendArgs(reply) << Set<A1>(a1) << Set<A2>(a2) << Set<A3>(a3) << Set<A4>(a4) << Set<A5>(a5) << Set<A6>(a6) << Set<A7>(a7);
 
2687
 
2910
2688
            return reply;
2911
2689
        } catch (...) {
2912
2690
            return handleException(msg);
2977
2755
            typename dbus_traits<A5>::host_type a5;
2978
2756
            typename dbus_traits<A6>::host_type a6;
2979
2757
 
2980
 
            DBusMessageIter iter;
2981
 
            dbus_message_iter_init(msg, &iter);
2982
 
            dbus_traits<A1>::get(conn, msg, iter, a1);
2983
 
            dbus_traits<A2>::get(conn, msg, iter, a2);
2984
 
            dbus_traits<A3>::get(conn, msg, iter, a3);
2985
 
            dbus_traits<A4>::get(conn, msg, iter, a4);
2986
 
            dbus_traits<A5>::get(conn, msg, iter, a5);
2987
 
            dbus_traits<A6>::get(conn, msg, iter, a6);
 
2758
            ExtractArgs(conn, msg) >> Get<A1>(a1) >> Get<A2>(a2) >> Get<A3>(a3) >> Get<A4>(a4) >> Get<A5>(a5) >> Get<A6>(a6);
2988
2759
 
2989
2760
            r = (*static_cast<M *>(data))(a1, a2, a3, a4, a5, a6);
2990
2761
 
2995
2766
            DBusMessage *reply = dbus_message_new_method_return(msg);
2996
2767
            if (!reply)
2997
2768
                return NULL;
2998
 
            dbus_message_iter_init_append(reply, &iter);
2999
 
            dbus_traits<R>::append_retval(iter, r);
3000
 
            dbus_traits<A1>::append(iter, a1);
3001
 
            dbus_traits<A2>::append(iter, a2);
3002
 
            dbus_traits<A3>::append(iter, a3);
3003
 
            dbus_traits<A4>::append(iter, a4);
3004
 
            dbus_traits<A5>::append(iter, a5);
3005
 
            dbus_traits<A6>::append(iter, a6);
 
2769
 
 
2770
            AppendArgs(reply) + r << Set<A1>(a1) << Set<A2>(a2) << Set<A3>(a3) << Set<A4>(a4) << Set<A5>(a5) << Set<A6>(a6);
 
2771
 
3006
2772
            return reply;
3007
2773
        } catch (...) {
3008
2774
            return handleException(msg);
3070
2836
            typename dbus_traits<A5>::host_type a5;
3071
2837
            typename dbus_traits<A6>::host_type a6;
3072
2838
 
3073
 
            DBusMessageIter iter;
3074
 
            dbus_message_iter_init(msg, &iter);
3075
 
            dbus_traits<A1>::get(conn, msg, iter, a1);
3076
 
            dbus_traits<A2>::get(conn, msg, iter, a2);
3077
 
            dbus_traits<A3>::get(conn, msg, iter, a3);
3078
 
            dbus_traits<A4>::get(conn, msg, iter, a4);
3079
 
            dbus_traits<A5>::get(conn, msg, iter, a5);
3080
 
            dbus_traits<A6>::get(conn, msg, iter, a6);
 
2839
            ExtractArgs(conn, msg) >> Get<A1>(a1) >> Get<A2>(a2) >> Get<A3>(a3) >> Get<A4>(a4) >> Get<A5>(a5) >> Get<A6>(a6);
3081
2840
 
3082
2841
            (*static_cast<M *>(data))(a1, a2, a3, a4, a5, a6);
3083
2842
 
3088
2847
            DBusMessage *reply = dbus_message_new_method_return(msg);
3089
2848
            if (!reply)
3090
2849
                return NULL;
3091
 
            dbus_message_iter_init_append(reply, &iter);
3092
 
            dbus_traits<A1>::append(iter, a1);
3093
 
            dbus_traits<A2>::append(iter, a2);
3094
 
            dbus_traits<A3>::append(iter, a3);
3095
 
            dbus_traits<A4>::append(iter, a4);
3096
 
            dbus_traits<A5>::append(iter, a5);
3097
 
            dbus_traits<A6>::append(iter, a6);
 
2850
 
 
2851
            AppendArgs(reply) << Set<A1>(a1) << Set<A2>(a2) << Set<A3>(a3) << Set<A4>(a4) << Set<A5>(a5) << Set<A6>(a6);
 
2852
 
3098
2853
            return reply;
3099
2854
        } catch (...) {
3100
2855
            return handleException(msg);
3160
2915
            typename dbus_traits<A4>::host_type a4;
3161
2916
            typename dbus_traits<A5>::host_type a5;
3162
2917
 
3163
 
            DBusMessageIter iter;
3164
 
            dbus_message_iter_init(msg, &iter);
3165
 
            dbus_traits<A1>::get(conn, msg, iter, a1);
3166
 
            dbus_traits<A2>::get(conn, msg, iter, a2);
3167
 
            dbus_traits<A3>::get(conn, msg, iter, a3);
3168
 
            dbus_traits<A4>::get(conn, msg, iter, a4);
3169
 
            dbus_traits<A5>::get(conn, msg, iter, a5);
 
2918
            ExtractArgs(conn, msg) >> Get<A1>(a1) >> Get<A2>(a2) >> Get<A3>(a3) >> Get<A4>(a4) >> Get<A5>(a5);
3170
2919
 
3171
2920
            r = (*static_cast<M *>(data))(a1, a2, a3, a4, a5);
3172
2921
 
3177
2926
            DBusMessage *reply = dbus_message_new_method_return(msg);
3178
2927
            if (!reply)
3179
2928
                return NULL;
3180
 
            dbus_message_iter_init_append(reply, &iter);
3181
 
            dbus_traits<R>::append_retval(iter, r);
3182
 
            dbus_traits<A1>::append(iter, a1);
3183
 
            dbus_traits<A2>::append(iter, a2);
3184
 
            dbus_traits<A3>::append(iter, a3);
3185
 
            dbus_traits<A4>::append(iter, a4);
3186
 
            dbus_traits<A5>::append(iter, a5);
 
2929
 
 
2930
            AppendArgs(reply) + r << Set<A1>(a1) << Set<A2>(a2) << Set<A3>(a3) << Set<A4>(a4) << Set<A5>(a5);
 
2931
 
3187
2932
            return reply;
3188
2933
        } catch (...) {
3189
2934
            return handleException(msg);
3247
2992
            typename dbus_traits<A4>::host_type a4;
3248
2993
            typename dbus_traits<A5>::host_type a5;
3249
2994
 
3250
 
            DBusMessageIter iter;
3251
 
            dbus_message_iter_init(msg, &iter);
3252
 
            dbus_traits<A1>::get(conn, msg, iter, a1);
3253
 
            dbus_traits<A2>::get(conn, msg, iter, a2);
3254
 
            dbus_traits<A3>::get(conn, msg, iter, a3);
3255
 
            dbus_traits<A4>::get(conn, msg, iter, a4);
3256
 
            dbus_traits<A5>::get(conn, msg, iter, a5);
 
2995
            ExtractArgs(conn, msg) >> Get<A1>(a1) >> Get<A2>(a2) >> Get<A3>(a3) >> Get<A4>(a4) >> Get<A5>(a5);
3257
2996
 
3258
2997
            (*static_cast<M *>(data))(a1, a2, a3, a4, a5);
3259
2998
 
3264
3003
            DBusMessage *reply = dbus_message_new_method_return(msg);
3265
3004
            if (!reply)
3266
3005
                return NULL;
3267
 
            dbus_message_iter_init_append(reply, &iter);
3268
 
            dbus_traits<A1>::append(iter, a1);
3269
 
            dbus_traits<A2>::append(iter, a2);
3270
 
            dbus_traits<A3>::append(iter, a3);
3271
 
            dbus_traits<A4>::append(iter, a4);
3272
 
            dbus_traits<A5>::append(iter, a5);
 
3006
 
 
3007
            AppendArgs(reply) << Set<A1>(a1) << Set<A2>(a2) << Set<A3>(a3) << Set<A4>(a4) << Set<A5>(a5);
 
3008
 
3273
3009
            return reply;
3274
3010
        } catch (...) {
3275
3011
            return handleException(msg);
3333
3069
            typename dbus_traits<A3>::host_type a3;
3334
3070
            typename dbus_traits<A4>::host_type a4;
3335
3071
 
3336
 
            DBusMessageIter iter;
3337
 
            dbus_message_iter_init(msg, &iter);
3338
 
            dbus_traits<A1>::get(conn, msg, iter, a1);
3339
 
            dbus_traits<A2>::get(conn, msg, iter, a2);
3340
 
            dbus_traits<A3>::get(conn, msg, iter, a3);
3341
 
            dbus_traits<A4>::get(conn, msg, iter, a4);
 
3072
            ExtractArgs(conn, msg) >> Get<A1>(a1) >> Get<A2>(a2) >> Get<A3>(a3) >> Get<A4>(a4);
3342
3073
 
3343
3074
            r = (*static_cast<M *>(data))(a1, a2, a3, a4);
3344
3075
 
3349
3080
            DBusMessage *reply = dbus_message_new_method_return(msg);
3350
3081
            if (!reply)
3351
3082
                return NULL;
3352
 
            dbus_message_iter_init_append(reply, &iter);
3353
 
            dbus_traits<R>::append_retval(iter, r);
3354
 
            dbus_traits<A1>::append(iter, a1);
3355
 
            dbus_traits<A2>::append(iter, a2);
3356
 
            dbus_traits<A3>::append(iter, a3);
3357
 
            dbus_traits<A4>::append(iter, a4);
 
3083
 
 
3084
            AppendArgs(reply) + r << Set<A1>(a1) << Set<A2>(a2) << Set<A3>(a3) << Set<A4>(a4);
 
3085
 
3358
3086
            return reply;
3359
3087
        } catch (...) {
3360
3088
            return handleException(msg);
3415
3143
            typename dbus_traits<A3>::host_type a3;
3416
3144
            typename dbus_traits<A4>::host_type a4;
3417
3145
 
3418
 
            DBusMessageIter iter;
3419
 
            dbus_message_iter_init(msg, &iter);
3420
 
            dbus_traits<A1>::get(conn, msg, iter, a1);
3421
 
            dbus_traits<A2>::get(conn, msg, iter, a2);
3422
 
            dbus_traits<A3>::get(conn, msg, iter, a3);
3423
 
            dbus_traits<A4>::get(conn, msg, iter, a4);
 
3146
            ExtractArgs(conn, msg) >> Get<A1>(a1) >> Get<A2>(a2) >> Get<A3>(a3) >> Get<A4>(a4);
3424
3147
 
3425
3148
            (*static_cast<M *>(data))(a1, a2, a3, a4);
3426
3149
 
3431
3154
            DBusMessage *reply = dbus_message_new_method_return(msg);
3432
3155
            if (!reply)
3433
3156
                return NULL;
3434
 
            dbus_message_iter_init_append(reply, &iter);
3435
 
            dbus_traits<A1>::append(iter, a1);
3436
 
            dbus_traits<A2>::append(iter, a2);
3437
 
            dbus_traits<A3>::append(iter, a3);
3438
 
            dbus_traits<A4>::append(iter, a4);
 
3157
 
 
3158
            AppendArgs(reply) << Set<A1>(a1) << Set<A2>(a2) << Set<A3>(a3) << Set<A4>(a4);
 
3159
 
3439
3160
            return reply;
3440
3161
        } catch (...) {
3441
3162
            return handleException(msg);
3496
3217
            typename dbus_traits<A2>::host_type a2;
3497
3218
            typename dbus_traits<A3>::host_type a3;
3498
3219
 
3499
 
            DBusMessageIter iter;
3500
 
            dbus_message_iter_init(msg, &iter);
3501
 
            dbus_traits<A1>::get(conn, msg, iter, a1);
3502
 
            dbus_traits<A2>::get(conn, msg, iter, a2);
3503
 
            dbus_traits<A3>::get(conn, msg, iter, a3);
 
3220
            ExtractArgs(conn, msg) >> Get<A1>(a1) >> Get<A2>(a2) >> Get<A3>(a3);
3504
3221
 
3505
3222
            r = (*static_cast<M *>(data))(a1, a2, a3);
3506
3223
 
3511
3228
            DBusMessage *reply = dbus_message_new_method_return(msg);
3512
3229
            if (!reply)
3513
3230
                return NULL;
3514
 
            dbus_message_iter_init_append(reply, &iter);
3515
 
            dbus_traits<R>::append_retval(iter, r);
3516
 
            dbus_traits<A1>::append(iter, a1);
3517
 
            dbus_traits<A2>::append(iter, a2);
3518
 
            dbus_traits<A3>::append(iter, a3);
 
3231
 
 
3232
            AppendArgs(reply) + r << Set<A1>(a1) << Set<A2>(a2) << Set<A3>(a3);
 
3233
 
3519
3234
            return reply;
3520
3235
        } catch (...) {
3521
3236
            return handleException(msg);
3573
3288
            typename dbus_traits<A2>::host_type a2;
3574
3289
            typename dbus_traits<A3>::host_type a3;
3575
3290
 
3576
 
            DBusMessageIter iter;
3577
 
            dbus_message_iter_init(msg, &iter);
3578
 
            dbus_traits<A1>::get(conn, msg, iter, a1);
3579
 
            dbus_traits<A2>::get(conn, msg, iter, a2);
3580
 
            dbus_traits<A3>::get(conn, msg, iter, a3);
 
3291
            ExtractArgs(conn, msg) >> Get<A1>(a1) >> Get<A2>(a2) >> Get<A3>(a3);
3581
3292
 
3582
3293
            (*static_cast<M *>(data))(a1, a2, a3);
3583
3294
 
3588
3299
            DBusMessage *reply = dbus_message_new_method_return(msg);
3589
3300
            if (!reply)
3590
3301
                return NULL;
3591
 
            dbus_message_iter_init_append(reply, &iter);
3592
 
            dbus_traits<A1>::append(iter, a1);
3593
 
            dbus_traits<A2>::append(iter, a2);
3594
 
            dbus_traits<A3>::append(iter, a3);
 
3302
 
 
3303
            AppendArgs(reply) << Set<A1>(a1) << Set<A2>(a2) << Set<A3>(a3);
 
3304
 
3595
3305
            return reply;
3596
3306
        } catch (...) {
3597
3307
            return handleException(msg);
3649
3359
            typename dbus_traits<A1>::host_type a1;
3650
3360
            typename dbus_traits<A2>::host_type a2;
3651
3361
 
3652
 
            DBusMessageIter iter;
3653
 
            dbus_message_iter_init(msg, &iter);
3654
 
            dbus_traits<A1>::get(conn, msg, iter, a1);
3655
 
            dbus_traits<A2>::get(conn, msg, iter, a2);
 
3362
            ExtractArgs(conn, msg) >> Get<A1>(a1) >> Get<A2>(a2);
3656
3363
 
3657
3364
            r = (*static_cast<M *>(data))(a1, a2);
3658
3365
 
3663
3370
            DBusMessage *reply = dbus_message_new_method_return(msg);
3664
3371
            if (!reply)
3665
3372
                return NULL;
3666
 
            dbus_message_iter_init_append(reply, &iter);
3667
 
            dbus_traits<R>::append_retval(iter, r);
3668
 
            dbus_traits<A1>::append(iter, a1);
3669
 
            dbus_traits<A2>::append(iter, a2);
 
3373
 
 
3374
            AppendArgs(reply) + r << Set<A1>(a1) << Set<A2>(a2);
 
3375
 
3670
3376
            return reply;
3671
3377
        } catch (...) {
3672
3378
            return handleException(msg);
3721
3427
            typename dbus_traits<A1>::host_type a1;
3722
3428
            typename dbus_traits<A2>::host_type a2;
3723
3429
 
3724
 
            DBusMessageIter iter;
3725
 
            dbus_message_iter_init(msg, &iter);
3726
 
            dbus_traits<A1>::get(conn, msg, iter, a1);
3727
 
            dbus_traits<A2>::get(conn, msg, iter, a2);
 
3430
            ExtractArgs(conn, msg) >> Get<A1>(a1) >> Get<A2>(a2);
3728
3431
 
3729
3432
            (*static_cast<M *>(data))(a1, a2);
3730
3433
 
3735
3438
            DBusMessage *reply = dbus_message_new_method_return(msg);
3736
3439
            if (!reply)
3737
3440
                return NULL;
3738
 
            dbus_message_iter_init_append(reply, &iter);
3739
 
            dbus_traits<A1>::append(iter, a1);
3740
 
            dbus_traits<A2>::append(iter, a2);
 
3441
 
 
3442
            AppendArgs(reply) << Set<A1>(a1) << Set<A2>(a2);
 
3443
 
3741
3444
            return reply;
3742
3445
        } catch (...) {
3743
3446
            return handleException(msg);
3792
3495
            typename dbus_traits<R>::host_type r;
3793
3496
            typename dbus_traits<A1>::host_type a1;
3794
3497
 
3795
 
            DBusMessageIter iter;
3796
 
            dbus_message_iter_init(msg, &iter);
3797
 
            dbus_traits<A1>::get(conn, msg, iter, a1);
 
3498
            ExtractArgs(conn, msg) >> Get<A1>(a1);
3798
3499
 
3799
3500
            r = (*static_cast<M *>(data))(a1);
3800
3501
 
3805
3506
            DBusMessage *reply = dbus_message_new_method_return(msg);
3806
3507
            if (!reply)
3807
3508
                return NULL;
3808
 
            dbus_message_iter_init_append(reply, &iter);
3809
 
            dbus_traits<R>::append_retval(iter, r);
3810
 
            dbus_traits<A1>::append(iter, a1);
 
3509
 
 
3510
            AppendArgs(reply) + r << Set<A1>(a1);
 
3511
 
3811
3512
            return reply;
3812
3513
        } catch (...) {
3813
3514
            return handleException(msg);
3859
3560
        try {
3860
3561
            typename dbus_traits<A1>::host_type a1;
3861
3562
 
3862
 
            DBusMessageIter iter;
3863
 
            dbus_message_iter_init(msg, &iter);
3864
 
            dbus_traits<A1>::get(conn, msg, iter, a1);
 
3563
            ExtractArgs(conn, msg) >> Get<A1>(a1);
3865
3564
 
3866
3565
            (*static_cast<M *>(data))(a1);
3867
3566
 
3872
3571
            DBusMessage *reply = dbus_message_new_method_return(msg);
3873
3572
            if (!reply)
3874
3573
                return NULL;
3875
 
            dbus_message_iter_init_append(reply, &iter);
3876
 
            dbus_traits<A1>::append(iter, a1);
 
3574
 
 
3575
            AppendArgs(reply) << Set<A1>(a1);
 
3576
 
3877
3577
            return reply;
3878
3578
        } catch (...) {
3879
3579
            return handleException(msg);
3927
3627
            DBusMessage *reply = dbus_message_new_method_return(msg);
3928
3628
            if (!reply)
3929
3629
                return NULL;
3930
 
            DBusMessageIter iter;
3931
 
            dbus_message_iter_init_append(reply, &iter);
3932
 
            dbus_traits<R>::append_retval(iter, r);
 
3630
 
 
3631
            AppendArgs(reply) + r;
 
3632
 
3933
3633
            return reply;
3934
3634
        } catch (...) {
3935
3635
            return handleException(msg);
4120
3820
        if (!msg) {
4121
3821
            throw std::runtime_error("dbus_message_new_method_call() failed");
4122
3822
        }
4123
 
        append_retvals(msg, a1);
 
3823
        AppendRetvals(msg) << a1;
4124
3824
 
4125
3825
        //parameter marshaling (none)
4126
3826
        if (!dbus_connection_send_with_reply(m_conn.get(), msg.get(), &call, -1)) {
4147
3847
        if (!msg) {
4148
3848
            throw std::runtime_error("dbus_message_new_method_call() failed");
4149
3849
        }
4150
 
        append_retvals(msg, a1);
4151
 
        append_retvals(msg, a2);
 
3850
        AppendRetvals(msg) << a1 << a2;
4152
3851
 
4153
3852
        //parameter marshaling (none)
4154
3853
        if (!dbus_connection_send_with_reply(m_conn.get(), msg.get(), &call, -1)) {
4175
3874
        if (!msg) {
4176
3875
            throw std::runtime_error("dbus_message_new_method_call() failed");
4177
3876
        }
4178
 
        append_retvals(msg, a1);
4179
 
        append_retvals(msg, a2);
4180
 
        append_retvals(msg, a3);
 
3877
        AppendRetvals(msg) << a1 << a2 << a3;
4181
3878
 
4182
3879
        //parameter marshaling (none)
4183
3880
        if (!dbus_connection_send_with_reply(m_conn.get(), msg.get(), &call, -1)) {
4249
3946
        std::string error;
4250
3947
        typename dbus_traits<R1>::host_type r;
4251
3948
        if (!errname) {
4252
 
            DBusMessageIter iter;
4253
 
            dbus_message_iter_init(reply.get(), &iter);
4254
 
            dbus_traits<R1>::get(data->m_conn.get(), reply.get(), iter, r);
 
3949
            ExtractArgs(data->m_conn.get(), reply.get()) >> Get<R1>(r);
4255
3950
        } else {
4256
3951
            error = errname;
4257
3952
        }
4294
3989
        typename dbus_traits<R1>::host_type r1;
4295
3990
        typename dbus_traits<R2>::host_type r2;
4296
3991
        if (!errname) {
4297
 
            DBusMessageIter iter;
4298
 
            dbus_message_iter_init(reply.get(), &iter);
4299
 
            dbus_traits<R1>::get(data->m_conn.get(), reply.get(), iter, r1);
4300
 
            dbus_traits<R2>::get(data->m_conn.get(), reply.get(), iter, r2);
 
3992
            ExtractArgs(data->m_conn.get(), reply.get()) >> Get<R1>(r1) >> Get<R2>(r2);
4301
3993
        } else {
4302
3994
            error = errname;
4303
3995
        }
4340
4032
        typename dbus_traits<R2>::host_type r2;
4341
4033
        typename dbus_traits<R3>::host_type r3;
4342
4034
        if (!errname) {
4343
 
            DBusMessageIter iter;
4344
 
            dbus_message_iter_init(reply.get(), &iter);
4345
 
            dbus_traits<R1>::get(data->m_conn.get(), reply.get(), iter, r1);
4346
 
            dbus_traits<R2>::get(data->m_conn.get(), reply.get(), iter, r2);
4347
 
            dbus_traits<R3>::get(data->m_conn.get(), reply.get(), iter, r3);
 
4035
            ExtractArgs(data->m_conn.get(), reply.get()) >> Get<R1>(r1) >> Get<R2>(r2) >> Get<R3>(r3);
4348
4036
        } else {
4349
4037
            error = errname;
4350
4038
        }
4446
4134
        return TRUE;
4447
4135
    }
4448
4136
 
4449
 
    void activate(const Callback_t &callback) { activateInternal(callback, internalCallback); }
 
4137
    void activate(const Callback_t &callback) { SignalWatch< boost::function<void (void)> >::activateInternal(callback, internalCallback); }
4450
4138
};
4451
4139
 
4452
4140
template <typename A1>
4478
4166
        return TRUE;
4479
4167
    }
4480
4168
 
4481
 
    void activate(const Callback_t &callback) { activateInternal(callback, internalCallback); }
 
4169
    void activate(const Callback_t &callback) { SignalWatch< boost::function<void (const A1 &)> >::activateInternal(callback, internalCallback); }
4482
4170
};
4483
4171
 
4484
4172
template <typename A1, typename A2>
4512
4200
        return TRUE;
4513
4201
    }
4514
4202
 
4515
 
    void activate(const Callback_t &callback) { activateInternal(callback, internalCallback); }
 
4203
    void activate(const Callback_t &callback) { SignalWatch< boost::function<void (const A1 &, const A2 &)> >::activateInternal(callback, internalCallback); }
4516
4204
};
4517
4205
 
4518
4206
template <typename A1, typename A2, typename A3>
4548
4236
        return TRUE;
4549
4237
    }
4550
4238
 
4551
 
    void activate(const Callback_t &callback) { activateInternal(callback, internalCallback); }
 
4239
    void activate(const Callback_t &callback) { SignalWatch< boost::function<void (const A1 &, const A2 &, const A3 &)> >::activateInternal(callback, internalCallback); }
4552
4240
};
4553
4241
 
4554
4242
template <typename A1, typename A2, typename A3, typename A4>
4586
4274
        return TRUE;
4587
4275
    }
4588
4276
 
4589
 
    void activate(const Callback_t &callback) { activateInternal(callback, internalCallback); }
 
4277
    void activate(const Callback_t &callback) { SignalWatch< boost::function<void (const A1 &, const A2 &, const A3 &, const A4 &)> >::activateInternal(callback, internalCallback); }
4590
4278
};
4591
4279
 
4592
4280
template <typename A1, typename A2, typename A3, typename A4, typename A5>
4626
4314
        return TRUE;
4627
4315
    }
4628
4316
 
4629
 
    void activate(const Callback_t &callback) { activateInternal(callback, internalCallback); }
 
4317
    void activate(const Callback_t &callback) { SignalWatch< boost::function<void (const A1 &, const A2 &, const A3 &, const A4 &, const A5 &)> >::activateInternal(callback, internalCallback); }
4630
4318
};
4631
4319
 
4632
4320
template <typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
4669
4357
        return TRUE;
4670
4358
    }
4671
4359
 
4672
 
    void activate(const Callback_t &callback) { activateInternal(callback, internalCallback); }
 
4360
    void activate(const Callback_t &callback) { SignalWatch< boost::function<void (const A1 &, const A2 &, const A3 &, const A4 &, const A5 &, const A6 &)> >::activateInternal(callback, internalCallback); }
4673
4361
};
4674
4362
 
 
4363
} // namespace GDBusCXX
 
4364
 
4675
4365
#endif // INCL_BDBUS_CXX_BRIDGE