dbus-cxx logo
dbus_signal.h
Go to the documentation of this file.
1 
2 // -*- c++ -*-
3 /* Do not edit! -- generated file */
4 
5 /***************************************************************************
6  * Copyright (C) 2009,2010 by Rick L. Vinyard, Jr. *
7  * rvinyard@cs.nmsu.edu *
8  * *
9  * This file is part of the dbus-cxx library. *
10  * *
11  * The dbus-cxx library is free software; you can redistribute it and/or *
12  * modify it under the terms of the GNU General Public License *
13  * version 3 as published by the Free Software Foundation. *
14  * *
15  * The dbus-cxx library is distributed in the hope that it will be *
16  * useful, but WITHOUT ANY WARRANTY; without even the implied warranty *
17  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
18  * General Public License for more details. *
19  * *
20  * You should have received a copy of the GNU General Public License *
21  * along with this software. If not see <http://www.gnu.org/licenses/>. *
22  ***************************************************************************/
23 #include <sstream>
24 #include <dbus-cxx/forward_decls.h>
25 #include <dbus-cxx/utility.h>
26 #include <dbus-cxx/signal_base.h>
27 #include <dbus-cxx/headerlog.h>
28 
29 #ifndef DBUSCXX_DBUS_SIGNAL_H_
30 #define DBUSCXX_DBUS_SIGNAL_H_
31 
32 namespace DBus {
33 
49 template <class T_return, class T_arg1 = nil,class T_arg2 = nil,class T_arg3 = nil,class T_arg4 = nil,class T_arg5 = nil,class T_arg6 = nil,class T_arg7 = nil>
50 class signal
51  : public sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>, public signal_base
52 {
53 public:
54 
55  //template <class T_accumulator>
56  //class accumulated
57  //: public sigc::signal7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7, T_accumulator>, public signal_base
58  //{
59  //public:
60  // typedef DBusCxxPointer<accumulated> pointer;
61  //
62  // accumulated(const std::string& interface, const std::string& name):
63  // signal_base(interface, name)
64  // {
65  // m_internal_callback_connection =
66  // this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
67  //
68  // m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
69  // }
70 
71  // accumulated(const std::string& path, const std::string& interface, const std::string& name):
72  // signal_base(path, interface, name)
73  // {
74  // m_internal_callback_connection =
75  // this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
76  //
77  // m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
78  // }
79 
80  // accumulated(const std::string& interface, const std::string& name, const accumulated& src):
81  // sigc::signal7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7, T_accumulator>(src),
82  // signal_base(interface, name)
83  // {}
84 
85  // accumulated(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src):
86  // sigc::signal7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7, T_accumulator>(src),
87  // signal_base(path, interface, name)
88  // {}
89 
90  // static pointer create(const std::string& interface, const std::string& name)
91  // {
92  // return pointer( new accumulated(interface, name) );
93  // }
94 
95  // static pointer create(const std::string& path, const std::string& interface, const std::string& name)
96  // {
97  // return pointer( new accumulated(path, interface, name) );
98  // }
99 
100  // static pointer create(const std::string& interface, const std::string& name, const accumulated& src)
101  // {
102  // return pointer( new accumulated(interface, name, src) );
103  // }
104 
105  // static pointer create(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src)
106  // {
107  // return pointer( new accumulated(path, interface, name, src) );
108  // }
109 
110  // virtual signal_base::pointer clone()
111  // {
112  // return signal_base::pointer( new accumulated(*this) );
113  // }
114 
115  //protected:
116 
117  // sigc::connection m_internal_callback_connection;
118 
119  // virtual HandlerResult on_dbus_incoming( SignalMessage::const_pointer msg )
120  // {
121  // // T_return _retval;
122  // //
123  // T_arg1 _val_1;
124  // T_arg2 _val_2;
125  // T_arg3 _val_3;
126  // T_arg4 _val_4;
127  // T_arg5 _val_5;
128  // T_arg6 _val_6;
129  // T_arg7 _val_7;
130 
131  // m_internal_callback_connection.block();
132 
133  // try {
134  // Message::iterator i = msg->begin();
135  // i >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5 >> _val_6 >> _val_7;
136  // this->emit(_val_1,_val_2,_val_3,_val_4,_val_5,_val_6,_val_7);
137  // }
138  // catch ( ErrorInvalidTypecast& e ) {
139  // m_internal_callback_connection.unblock();
140  // return NOT_HANDLED;
141  // }
142 
143  // m_internal_callback_connection.unblock();
144 
145  // return HANDLED;
146  // }
147 
148 
149  // T_return internal_callback(T_arg1 arg1,T_arg2 arg2,T_arg3 arg3,T_arg4 arg4,T_arg5 arg5,T_arg6 arg6,T_arg7 arg7)
150  // {
151 
152  // }
153 
154  //};
155 
156  typedef DBusCxxPointer<signal> pointer;
157 
158  signal(const std::string& interface, const std::string& name):
159  signal_base(interface, name)
160  {
162  this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
163  }
164 
165  signal(const std::string& path, const std::string& interface, const std::string& name):
166  signal_base(path, interface, name)
167  {
169  this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
170  }
171 
172  signal(const std::string& interface, const std::string& name, const signal& src) :
173  sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(src),
174  signal_base(interface, name)
175  { }
176 
177  signal(const std::string& path, const std::string& interface, const std::string& name, const signal& src) :
178  sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(src),
179  signal_base(path, interface, name)
180  { }
181 
182  static pointer create(const std::string& interface, const std::string& name)
183  {
184  return pointer( new signal(interface, name) );
185  }
186 
187  static pointer create(const std::string& path, const std::string& interface, const std::string& name)
188  {
189  return pointer( new signal(path, interface, name) );
190  }
191 
192  static pointer create(const std::string& interface, const std::string& name, const signal& src)
193  {
194  return pointer( new signal(interface, name, src) );
195  }
196 
197  static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal& src)
198  {
199  return pointer( new signal(path, interface, name, src) );
200  }
201 
203  {
204  return signal_base::pointer( new signal(*this) );
205  }
206 
208  virtual std::string introspect(int space_depth=0) const
209  {
210  std::ostringstream sout;
211  std::string spaces;
212  for (int i=0; i < space_depth; i++ ) spaces += " ";
213  sout << spaces << "<signal name=\"" << name() << "\">\n";
214 
215  T_arg1 arg1;
216  sout << spaces << " <arg name=\"" << m_arg_names[1-1] << "\" type=\"" << signature(arg1) << "\"/>\n";
217  T_arg2 arg2;
218  sout << spaces << " <arg name=\"" << m_arg_names[2-1] << "\" type=\"" << signature(arg2) << "\"/>\n";
219  T_arg3 arg3;
220  sout << spaces << " <arg name=\"" << m_arg_names[3-1] << "\" type=\"" << signature(arg3) << "\"/>\n";
221  T_arg4 arg4;
222  sout << spaces << " <arg name=\"" << m_arg_names[4-1] << "\" type=\"" << signature(arg4) << "\"/>\n";
223  T_arg5 arg5;
224  sout << spaces << " <arg name=\"" << m_arg_names[5-1] << "\" type=\"" << signature(arg5) << "\"/>\n";
225  T_arg6 arg6;
226  sout << spaces << " <arg name=\"" << m_arg_names[6-1] << "\" type=\"" << signature(arg6) << "\"/>\n";
227  T_arg7 arg7;
228  sout << spaces << " <arg name=\"" << m_arg_names[7-1] << "\" type=\"" << signature(arg7) << "\"/>\n";
229  sout << spaces << "</signal>\n";
230  return sout.str();
231  }
232 
233  virtual std::string arg_name(size_t i) {
234  if ( i < 7 ) return m_arg_names[i];
235  return std::string();
236  }
237 
238  virtual void set_arg_name(size_t i, const std::string& name) {
239  if ( i < 7 ) m_arg_names[i] = name;
240  }
241 
242  protected:
243 
244  friend class Interface;
245 
246  std::string m_arg_names[7];
247 
249 
250  T_return internal_callback(T_arg1 arg1,T_arg2 arg2,T_arg3 arg3,T_arg4 arg4,T_arg5 arg5,T_arg6 arg6,T_arg7 arg7)
251  {
252  // DBUS_CXX_DEBUG( "signal::internal_callback: " << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7 );
254  if ( not m_destination.empty() ) __msg->set_destination(m_destination);
255  *__msg << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7;
256  bool result = this->handle_dbus_outgoing(__msg);
257  DBUSCXX_DEBUG_STDSTR( "dbus.signal", "signal::internal_callback: result=" << result );
258  }
259 
260 };
261 
262 
263 
279 template <class T_return>
280 class signal <T_return, nil,nil,nil,nil,nil,nil,nil>
281  : public sigc::signal<T_return>, public signal_base
282 {
283 public:
284 
285  //template <class T_accumulator>
286  //class accumulated
287  //: public sigc::signal0<T_return, T_accumulator>, public signal_base
288  //{
289  //public:
290  // typedef DBusCxxPointer<accumulated> pointer;
291  //
292  // accumulated(const std::string& interface, const std::string& name):
293  // signal_base(interface, name)
294  // {
295  // m_internal_callback_connection =
296  // this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
297  //
298  // m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
299  // }
300 
301  // accumulated(const std::string& path, const std::string& interface, const std::string& name):
302  // signal_base(path, interface, name)
303  // {
304  // m_internal_callback_connection =
305  // this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
306  //
307  // m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
308  // }
309 
310  // accumulated(const std::string& interface, const std::string& name, const accumulated& src):
311  // sigc::signal0<T_return, T_accumulator>(src),
312  // signal_base(interface, name)
313  // {}
314 
315  // accumulated(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src):
316  // sigc::signal0<T_return, T_accumulator>(src),
317  // signal_base(path, interface, name)
318  // {}
319 
320  // static pointer create(const std::string& interface, const std::string& name)
321  // {
322  // return pointer( new accumulated(interface, name) );
323  // }
324 
325  // static pointer create(const std::string& path, const std::string& interface, const std::string& name)
326  // {
327  // return pointer( new accumulated(path, interface, name) );
328  // }
329 
330  // static pointer create(const std::string& interface, const std::string& name, const accumulated& src)
331  // {
332  // return pointer( new accumulated(interface, name, src) );
333  // }
334 
335  // static pointer create(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src)
336  // {
337  // return pointer( new accumulated(path, interface, name, src) );
338  // }
339 
340  // virtual signal_base::pointer clone()
341  // {
342  // return signal_base::pointer( new accumulated(*this) );
343  // }
344 
345  //protected:
346 
347  // sigc::connection m_internal_callback_connection;
348 
349  // virtual HandlerResult on_dbus_incoming( SignalMessage::const_pointer msg )
350  // {
351  // // T_return _retval;
352  // //
353 
354  // m_internal_callback_connection.block();
355 
356  // try {
357  // Message::iterator i = msg->begin();
358  // i ;
359  // this->emit();
360  // }
361  // catch ( ErrorInvalidTypecast& e ) {
362  // m_internal_callback_connection.unblock();
363  // return NOT_HANDLED;
364  // }
365 
366  // m_internal_callback_connection.unblock();
367 
368  // return HANDLED;
369  // }
370 
371 
372  // T_return internal_callback()
373  // {
374 
375  // }
376 
377  //};
378 
379  typedef DBusCxxPointer<signal> pointer;
380 
381  signal(const std::string& interface, const std::string& name):
382  signal_base(interface, name)
383  {
385  this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
386  }
387 
388  signal(const std::string& path, const std::string& interface, const std::string& name):
389  signal_base(path, interface, name)
390  {
392  this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
393  }
394 
395  signal(const std::string& interface, const std::string& name, const signal& src) :
396  sigc::signal<T_return>(src),
397  signal_base(interface, name)
398  { }
399 
400  signal(const std::string& path, const std::string& interface, const std::string& name, const signal& src) :
401  sigc::signal<T_return>(src),
402  signal_base(path, interface, name)
403  { }
404 
405  static pointer create(const std::string& interface, const std::string& name)
406  {
407  return pointer( new signal(interface, name) );
408  }
409 
410  static pointer create(const std::string& path, const std::string& interface, const std::string& name)
411  {
412  return pointer( new signal(path, interface, name) );
413  }
414 
415  static pointer create(const std::string& interface, const std::string& name, const signal& src)
416  {
417  return pointer( new signal(interface, name, src) );
418  }
419 
420  static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal& src)
421  {
422  return pointer( new signal(path, interface, name, src) );
423  }
424 
426  {
427  return signal_base::pointer( new signal(*this) );
428  }
429 
431  virtual std::string introspect(int space_depth=0) const
432  {
433  std::ostringstream sout;
434  std::string spaces;
435  for (int i=0; i < space_depth; i++ ) spaces += " ";
436  sout << spaces << "<signal name=\"" << name() << "\">\n";
437 
438  sout << spaces << "</signal>\n";
439  return sout.str();
440  }
441 
442  virtual std::string arg_name(size_t i) {
443  if ( i < 0 ) return m_arg_names[i];
444  return std::string();
445  }
446 
447  virtual void set_arg_name(size_t i, const std::string& name) {
448  if ( i < 0 ) m_arg_names[i] = name;
449  }
450 
451  protected:
452 
453  friend class Interface;
454 
455  std::string m_arg_names[0];
456 
458 
459  T_return internal_callback()
460  {
461  // DBUS_CXX_DEBUG( "signal::internal_callback: " );
463  if ( not m_destination.empty() ) __msg->set_destination(m_destination);
464 
465  bool result = this->handle_dbus_outgoing(__msg);
466  DBUSCXX_DEBUG_STDSTR( "dbus.signal", "signal::internal_callback: result=" << result );
467  }
468 
469 };
470 
471 
487 template <class T_return, class T_arg1>
488 class signal <T_return, T_arg1, nil,nil,nil,nil,nil,nil>
489  : public sigc::signal<T_return, T_arg1>, public signal_base
490 {
491 public:
492 
493  //template <class T_accumulator>
494  //class accumulated
495  //: public sigc::signal1<T_return, T_arg1, T_accumulator>, public signal_base
496  //{
497  //public:
498  // typedef DBusCxxPointer<accumulated> pointer;
499  //
500  // accumulated(const std::string& interface, const std::string& name):
501  // signal_base(interface, name)
502  // {
503  // m_internal_callback_connection =
504  // this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
505  //
506  // m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
507  // }
508 
509  // accumulated(const std::string& path, const std::string& interface, const std::string& name):
510  // signal_base(path, interface, name)
511  // {
512  // m_internal_callback_connection =
513  // this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
514  //
515  // m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
516  // }
517 
518  // accumulated(const std::string& interface, const std::string& name, const accumulated& src):
519  // sigc::signal1<T_return, T_arg1, T_accumulator>(src),
520  // signal_base(interface, name)
521  // {}
522 
523  // accumulated(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src):
524  // sigc::signal1<T_return, T_arg1, T_accumulator>(src),
525  // signal_base(path, interface, name)
526  // {}
527 
528  // static pointer create(const std::string& interface, const std::string& name)
529  // {
530  // return pointer( new accumulated(interface, name) );
531  // }
532 
533  // static pointer create(const std::string& path, const std::string& interface, const std::string& name)
534  // {
535  // return pointer( new accumulated(path, interface, name) );
536  // }
537 
538  // static pointer create(const std::string& interface, const std::string& name, const accumulated& src)
539  // {
540  // return pointer( new accumulated(interface, name, src) );
541  // }
542 
543  // static pointer create(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src)
544  // {
545  // return pointer( new accumulated(path, interface, name, src) );
546  // }
547 
548  // virtual signal_base::pointer clone()
549  // {
550  // return signal_base::pointer( new accumulated(*this) );
551  // }
552 
553  //protected:
554 
555  // sigc::connection m_internal_callback_connection;
556 
557  // virtual HandlerResult on_dbus_incoming( SignalMessage::const_pointer msg )
558  // {
559  // // T_return _retval;
560  // //
561  // T_arg1 _val_1;
562 
563  // m_internal_callback_connection.block();
564 
565  // try {
566  // Message::iterator i = msg->begin();
567  // i >> _val_1;
568  // this->emit(_val_1);
569  // }
570  // catch ( ErrorInvalidTypecast& e ) {
571  // m_internal_callback_connection.unblock();
572  // return NOT_HANDLED;
573  // }
574 
575  // m_internal_callback_connection.unblock();
576 
577  // return HANDLED;
578  // }
579 
580 
581  // T_return internal_callback(T_arg1 arg1)
582  // {
583 
584  // }
585 
586  //};
587 
588  typedef DBusCxxPointer<signal> pointer;
589 
590  signal(const std::string& interface, const std::string& name):
591  signal_base(interface, name)
592  {
594  this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
595  }
596 
597  signal(const std::string& path, const std::string& interface, const std::string& name):
598  signal_base(path, interface, name)
599  {
601  this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
602  }
603 
604  signal(const std::string& interface, const std::string& name, const signal& src) :
605  sigc::signal<T_return, T_arg1>(src),
606  signal_base(interface, name)
607  { }
608 
609  signal(const std::string& path, const std::string& interface, const std::string& name, const signal& src) :
610  sigc::signal<T_return, T_arg1>(src),
611  signal_base(path, interface, name)
612  { }
613 
614  static pointer create(const std::string& interface, const std::string& name)
615  {
616  return pointer( new signal(interface, name) );
617  }
618 
619  static pointer create(const std::string& path, const std::string& interface, const std::string& name)
620  {
621  return pointer( new signal(path, interface, name) );
622  }
623 
624  static pointer create(const std::string& interface, const std::string& name, const signal& src)
625  {
626  return pointer( new signal(interface, name, src) );
627  }
628 
629  static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal& src)
630  {
631  return pointer( new signal(path, interface, name, src) );
632  }
633 
635  {
636  return signal_base::pointer( new signal(*this) );
637  }
638 
640  virtual std::string introspect(int space_depth=0) const
641  {
642  std::ostringstream sout;
643  std::string spaces;
644  for (int i=0; i < space_depth; i++ ) spaces += " ";
645  sout << spaces << "<signal name=\"" << name() << "\">\n";
646 
647  T_arg1 arg1;
648  sout << spaces << " <arg name=\"" << m_arg_names[1-1] << "\" type=\"" << signature(arg1) << "\"/>\n";
649  sout << spaces << "</signal>\n";
650  return sout.str();
651  }
652 
653  virtual std::string arg_name(size_t i) {
654  if ( i < 1 ) return m_arg_names[i];
655  return std::string();
656  }
657 
658  virtual void set_arg_name(size_t i, const std::string& name) {
659  if ( i < 1 ) m_arg_names[i] = name;
660  }
661 
662  protected:
663 
664  friend class Interface;
665 
666  std::string m_arg_names[1];
667 
669 
670  T_return internal_callback(T_arg1 arg1)
671  {
672  // DBUS_CXX_DEBUG( "signal::internal_callback: " << arg1 );
674  if ( not m_destination.empty() ) __msg->set_destination(m_destination);
675  *__msg << arg1;
676  bool result = this->handle_dbus_outgoing(__msg);
677  DBUSCXX_DEBUG_STDSTR( "dbus.signal", "signal::internal_callback: result=" << result );
678  }
679 
680 };
681 
682 
698 template <class T_return, class T_arg1,class T_arg2>
699 class signal <T_return, T_arg1,T_arg2, nil,nil,nil,nil,nil>
700  : public sigc::signal<T_return, T_arg1,T_arg2>, public signal_base
701 {
702 public:
703 
704  //template <class T_accumulator>
705  //class accumulated
706  //: public sigc::signal2<T_return, T_arg1,T_arg2, T_accumulator>, public signal_base
707  //{
708  //public:
709  // typedef DBusCxxPointer<accumulated> pointer;
710  //
711  // accumulated(const std::string& interface, const std::string& name):
712  // signal_base(interface, name)
713  // {
714  // m_internal_callback_connection =
715  // this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
716  //
717  // m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
718  // }
719 
720  // accumulated(const std::string& path, const std::string& interface, const std::string& name):
721  // signal_base(path, interface, name)
722  // {
723  // m_internal_callback_connection =
724  // this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
725  //
726  // m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
727  // }
728 
729  // accumulated(const std::string& interface, const std::string& name, const accumulated& src):
730  // sigc::signal2<T_return, T_arg1,T_arg2, T_accumulator>(src),
731  // signal_base(interface, name)
732  // {}
733 
734  // accumulated(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src):
735  // sigc::signal2<T_return, T_arg1,T_arg2, T_accumulator>(src),
736  // signal_base(path, interface, name)
737  // {}
738 
739  // static pointer create(const std::string& interface, const std::string& name)
740  // {
741  // return pointer( new accumulated(interface, name) );
742  // }
743 
744  // static pointer create(const std::string& path, const std::string& interface, const std::string& name)
745  // {
746  // return pointer( new accumulated(path, interface, name) );
747  // }
748 
749  // static pointer create(const std::string& interface, const std::string& name, const accumulated& src)
750  // {
751  // return pointer( new accumulated(interface, name, src) );
752  // }
753 
754  // static pointer create(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src)
755  // {
756  // return pointer( new accumulated(path, interface, name, src) );
757  // }
758 
759  // virtual signal_base::pointer clone()
760  // {
761  // return signal_base::pointer( new accumulated(*this) );
762  // }
763 
764  //protected:
765 
766  // sigc::connection m_internal_callback_connection;
767 
768  // virtual HandlerResult on_dbus_incoming( SignalMessage::const_pointer msg )
769  // {
770  // // T_return _retval;
771  // //
772  // T_arg1 _val_1;
773  // T_arg2 _val_2;
774 
775  // m_internal_callback_connection.block();
776 
777  // try {
778  // Message::iterator i = msg->begin();
779  // i >> _val_1 >> _val_2;
780  // this->emit(_val_1,_val_2);
781  // }
782  // catch ( ErrorInvalidTypecast& e ) {
783  // m_internal_callback_connection.unblock();
784  // return NOT_HANDLED;
785  // }
786 
787  // m_internal_callback_connection.unblock();
788 
789  // return HANDLED;
790  // }
791 
792 
793  // T_return internal_callback(T_arg1 arg1,T_arg2 arg2)
794  // {
795 
796  // }
797 
798  //};
799 
800  typedef DBusCxxPointer<signal> pointer;
801 
802  signal(const std::string& interface, const std::string& name):
803  signal_base(interface, name)
804  {
806  this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
807  }
808 
809  signal(const std::string& path, const std::string& interface, const std::string& name):
810  signal_base(path, interface, name)
811  {
813  this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
814  }
815 
816  signal(const std::string& interface, const std::string& name, const signal& src) :
817  sigc::signal<T_return, T_arg1,T_arg2>(src),
818  signal_base(interface, name)
819  { }
820 
821  signal(const std::string& path, const std::string& interface, const std::string& name, const signal& src) :
822  sigc::signal<T_return, T_arg1,T_arg2>(src),
823  signal_base(path, interface, name)
824  { }
825 
826  static pointer create(const std::string& interface, const std::string& name)
827  {
828  return pointer( new signal(interface, name) );
829  }
830 
831  static pointer create(const std::string& path, const std::string& interface, const std::string& name)
832  {
833  return pointer( new signal(path, interface, name) );
834  }
835 
836  static pointer create(const std::string& interface, const std::string& name, const signal& src)
837  {
838  return pointer( new signal(interface, name, src) );
839  }
840 
841  static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal& src)
842  {
843  return pointer( new signal(path, interface, name, src) );
844  }
845 
847  {
848  return signal_base::pointer( new signal(*this) );
849  }
850 
852  virtual std::string introspect(int space_depth=0) const
853  {
854  std::ostringstream sout;
855  std::string spaces;
856  for (int i=0; i < space_depth; i++ ) spaces += " ";
857  sout << spaces << "<signal name=\"" << name() << "\">\n";
858 
859  T_arg1 arg1;
860  sout << spaces << " <arg name=\"" << m_arg_names[1-1] << "\" type=\"" << signature(arg1) << "\"/>\n";
861  T_arg2 arg2;
862  sout << spaces << " <arg name=\"" << m_arg_names[2-1] << "\" type=\"" << signature(arg2) << "\"/>\n";
863  sout << spaces << "</signal>\n";
864  return sout.str();
865  }
866 
867  virtual std::string arg_name(size_t i) {
868  if ( i < 2 ) return m_arg_names[i];
869  return std::string();
870  }
871 
872  virtual void set_arg_name(size_t i, const std::string& name) {
873  if ( i < 2 ) m_arg_names[i] = name;
874  }
875 
876  protected:
877 
878  friend class Interface;
879 
880  std::string m_arg_names[2];
881 
883 
884  T_return internal_callback(T_arg1 arg1,T_arg2 arg2)
885  {
886  // DBUS_CXX_DEBUG( "signal::internal_callback: " << arg1 << arg2 );
888  if ( not m_destination.empty() ) __msg->set_destination(m_destination);
889  *__msg << arg1 << arg2;
890  bool result = this->handle_dbus_outgoing(__msg);
891  DBUSCXX_DEBUG_STDSTR( "dbus.signal", "signal::internal_callback: result=" << result );
892  }
893 
894 };
895 
896 
912 template <class T_return, class T_arg1,class T_arg2,class T_arg3>
913 class signal <T_return, T_arg1,T_arg2,T_arg3, nil,nil,nil,nil>
914  : public sigc::signal<T_return, T_arg1,T_arg2,T_arg3>, public signal_base
915 {
916 public:
917 
918  //template <class T_accumulator>
919  //class accumulated
920  //: public sigc::signal3<T_return, T_arg1,T_arg2,T_arg3, T_accumulator>, public signal_base
921  //{
922  //public:
923  // typedef DBusCxxPointer<accumulated> pointer;
924  //
925  // accumulated(const std::string& interface, const std::string& name):
926  // signal_base(interface, name)
927  // {
928  // m_internal_callback_connection =
929  // this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
930  //
931  // m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
932  // }
933 
934  // accumulated(const std::string& path, const std::string& interface, const std::string& name):
935  // signal_base(path, interface, name)
936  // {
937  // m_internal_callback_connection =
938  // this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
939  //
940  // m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
941  // }
942 
943  // accumulated(const std::string& interface, const std::string& name, const accumulated& src):
944  // sigc::signal3<T_return, T_arg1,T_arg2,T_arg3, T_accumulator>(src),
945  // signal_base(interface, name)
946  // {}
947 
948  // accumulated(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src):
949  // sigc::signal3<T_return, T_arg1,T_arg2,T_arg3, T_accumulator>(src),
950  // signal_base(path, interface, name)
951  // {}
952 
953  // static pointer create(const std::string& interface, const std::string& name)
954  // {
955  // return pointer( new accumulated(interface, name) );
956  // }
957 
958  // static pointer create(const std::string& path, const std::string& interface, const std::string& name)
959  // {
960  // return pointer( new accumulated(path, interface, name) );
961  // }
962 
963  // static pointer create(const std::string& interface, const std::string& name, const accumulated& src)
964  // {
965  // return pointer( new accumulated(interface, name, src) );
966  // }
967 
968  // static pointer create(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src)
969  // {
970  // return pointer( new accumulated(path, interface, name, src) );
971  // }
972 
973  // virtual signal_base::pointer clone()
974  // {
975  // return signal_base::pointer( new accumulated(*this) );
976  // }
977 
978  //protected:
979 
980  // sigc::connection m_internal_callback_connection;
981 
982  // virtual HandlerResult on_dbus_incoming( SignalMessage::const_pointer msg )
983  // {
984  // // T_return _retval;
985  // //
986  // T_arg1 _val_1;
987  // T_arg2 _val_2;
988  // T_arg3 _val_3;
989 
990  // m_internal_callback_connection.block();
991 
992  // try {
993  // Message::iterator i = msg->begin();
994  // i >> _val_1 >> _val_2 >> _val_3;
995  // this->emit(_val_1,_val_2,_val_3);
996  // }
997  // catch ( ErrorInvalidTypecast& e ) {
998  // m_internal_callback_connection.unblock();
999  // return NOT_HANDLED;
1000  // }
1001 
1002  // m_internal_callback_connection.unblock();
1003 
1004  // return HANDLED;
1005  // }
1006 
1007 
1008  // T_return internal_callback(T_arg1 arg1,T_arg2 arg2,T_arg3 arg3)
1009  // {
1010 
1011  // }
1012 
1013  //};
1014 
1015  typedef DBusCxxPointer<signal> pointer;
1016 
1017  signal(const std::string& interface, const std::string& name):
1018  signal_base(interface, name)
1019  {
1021  this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
1022  }
1023 
1024  signal(const std::string& path, const std::string& interface, const std::string& name):
1025  signal_base(path, interface, name)
1026  {
1028  this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
1029  }
1030 
1031  signal(const std::string& interface, const std::string& name, const signal& src) :
1032  sigc::signal<T_return, T_arg1,T_arg2,T_arg3>(src),
1033  signal_base(interface, name)
1034  { }
1035 
1036  signal(const std::string& path, const std::string& interface, const std::string& name, const signal& src) :
1037  sigc::signal<T_return, T_arg1,T_arg2,T_arg3>(src),
1038  signal_base(path, interface, name)
1039  { }
1040 
1041  static pointer create(const std::string& interface, const std::string& name)
1042  {
1043  return pointer( new signal(interface, name) );
1044  }
1045 
1046  static pointer create(const std::string& path, const std::string& interface, const std::string& name)
1047  {
1048  return pointer( new signal(path, interface, name) );
1049  }
1050 
1051  static pointer create(const std::string& interface, const std::string& name, const signal& src)
1052  {
1053  return pointer( new signal(interface, name, src) );
1054  }
1055 
1056  static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal& src)
1057  {
1058  return pointer( new signal(path, interface, name, src) );
1059  }
1060 
1062  {
1063  return signal_base::pointer( new signal(*this) );
1064  }
1065 
1067  virtual std::string introspect(int space_depth=0) const
1068  {
1069  std::ostringstream sout;
1070  std::string spaces;
1071  for (int i=0; i < space_depth; i++ ) spaces += " ";
1072  sout << spaces << "<signal name=\"" << name() << "\">\n";
1073 
1074  T_arg1 arg1;
1075  sout << spaces << " <arg name=\"" << m_arg_names[1-1] << "\" type=\"" << signature(arg1) << "\"/>\n";
1076  T_arg2 arg2;
1077  sout << spaces << " <arg name=\"" << m_arg_names[2-1] << "\" type=\"" << signature(arg2) << "\"/>\n";
1078  T_arg3 arg3;
1079  sout << spaces << " <arg name=\"" << m_arg_names[3-1] << "\" type=\"" << signature(arg3) << "\"/>\n";
1080  sout << spaces << "</signal>\n";
1081  return sout.str();
1082  }
1083 
1084  virtual std::string arg_name(size_t i) {
1085  if ( i < 3 ) return m_arg_names[i];
1086  return std::string();
1087  }
1088 
1089  virtual void set_arg_name(size_t i, const std::string& name) {
1090  if ( i < 3 ) m_arg_names[i] = name;
1091  }
1092 
1093  protected:
1094 
1095  friend class Interface;
1096 
1097  std::string m_arg_names[3];
1098 
1100 
1101  T_return internal_callback(T_arg1 arg1,T_arg2 arg2,T_arg3 arg3)
1102  {
1103  // DBUS_CXX_DEBUG( "signal::internal_callback: " << arg1 << arg2 << arg3 );
1105  if ( not m_destination.empty() ) __msg->set_destination(m_destination);
1106  *__msg << arg1 << arg2 << arg3;
1107  bool result = this->handle_dbus_outgoing(__msg);
1108  DBUSCXX_DEBUG_STDSTR( "dbus.signal", "signal::internal_callback: result=" << result );
1109  }
1110 
1111 };
1112 
1113 
1129 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
1130 class signal <T_return, T_arg1,T_arg2,T_arg3,T_arg4, nil,nil,nil>
1131  : public sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4>, public signal_base
1132 {
1133 public:
1134 
1135  //template <class T_accumulator>
1136  //class accumulated
1137  //: public sigc::signal4<T_return, T_arg1,T_arg2,T_arg3,T_arg4, T_accumulator>, public signal_base
1138  //{
1139  //public:
1140  // typedef DBusCxxPointer<accumulated> pointer;
1141  //
1142  // accumulated(const std::string& interface, const std::string& name):
1143  // signal_base(interface, name)
1144  // {
1145  // m_internal_callback_connection =
1146  // this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
1147  //
1148  // m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
1149  // }
1150 
1151  // accumulated(const std::string& path, const std::string& interface, const std::string& name):
1152  // signal_base(path, interface, name)
1153  // {
1154  // m_internal_callback_connection =
1155  // this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
1156  //
1157  // m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
1158  // }
1159 
1160  // accumulated(const std::string& interface, const std::string& name, const accumulated& src):
1161  // sigc::signal4<T_return, T_arg1,T_arg2,T_arg3,T_arg4, T_accumulator>(src),
1162  // signal_base(interface, name)
1163  // {}
1164 
1165  // accumulated(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src):
1166  // sigc::signal4<T_return, T_arg1,T_arg2,T_arg3,T_arg4, T_accumulator>(src),
1167  // signal_base(path, interface, name)
1168  // {}
1169 
1170  // static pointer create(const std::string& interface, const std::string& name)
1171  // {
1172  // return pointer( new accumulated(interface, name) );
1173  // }
1174 
1175  // static pointer create(const std::string& path, const std::string& interface, const std::string& name)
1176  // {
1177  // return pointer( new accumulated(path, interface, name) );
1178  // }
1179 
1180  // static pointer create(const std::string& interface, const std::string& name, const accumulated& src)
1181  // {
1182  // return pointer( new accumulated(interface, name, src) );
1183  // }
1184 
1185  // static pointer create(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src)
1186  // {
1187  // return pointer( new accumulated(path, interface, name, src) );
1188  // }
1189 
1190  // virtual signal_base::pointer clone()
1191  // {
1192  // return signal_base::pointer( new accumulated(*this) );
1193  // }
1194 
1195  //protected:
1196 
1197  // sigc::connection m_internal_callback_connection;
1198 
1199  // virtual HandlerResult on_dbus_incoming( SignalMessage::const_pointer msg )
1200  // {
1201  // // T_return _retval;
1202  // //
1203  // T_arg1 _val_1;
1204  // T_arg2 _val_2;
1205  // T_arg3 _val_3;
1206  // T_arg4 _val_4;
1207 
1208  // m_internal_callback_connection.block();
1209 
1210  // try {
1211  // Message::iterator i = msg->begin();
1212  // i >> _val_1 >> _val_2 >> _val_3 >> _val_4;
1213  // this->emit(_val_1,_val_2,_val_3,_val_4);
1214  // }
1215  // catch ( ErrorInvalidTypecast& e ) {
1216  // m_internal_callback_connection.unblock();
1217  // return NOT_HANDLED;
1218  // }
1219 
1220  // m_internal_callback_connection.unblock();
1221 
1222  // return HANDLED;
1223  // }
1224 
1225 
1226  // T_return internal_callback(T_arg1 arg1,T_arg2 arg2,T_arg3 arg3,T_arg4 arg4)
1227  // {
1228 
1229  // }
1230 
1231  //};
1232 
1233  typedef DBusCxxPointer<signal> pointer;
1234 
1235  signal(const std::string& interface, const std::string& name):
1236  signal_base(interface, name)
1237  {
1239  this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
1240  }
1241 
1242  signal(const std::string& path, const std::string& interface, const std::string& name):
1243  signal_base(path, interface, name)
1244  {
1246  this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
1247  }
1248 
1249  signal(const std::string& interface, const std::string& name, const signal& src) :
1250  sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4>(src),
1251  signal_base(interface, name)
1252  { }
1253 
1254  signal(const std::string& path, const std::string& interface, const std::string& name, const signal& src) :
1255  sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4>(src),
1256  signal_base(path, interface, name)
1257  { }
1258 
1259  static pointer create(const std::string& interface, const std::string& name)
1260  {
1261  return pointer( new signal(interface, name) );
1262  }
1263 
1264  static pointer create(const std::string& path, const std::string& interface, const std::string& name)
1265  {
1266  return pointer( new signal(path, interface, name) );
1267  }
1268 
1269  static pointer create(const std::string& interface, const std::string& name, const signal& src)
1270  {
1271  return pointer( new signal(interface, name, src) );
1272  }
1273 
1274  static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal& src)
1275  {
1276  return pointer( new signal(path, interface, name, src) );
1277  }
1278 
1280  {
1281  return signal_base::pointer( new signal(*this) );
1282  }
1283 
1285  virtual std::string introspect(int space_depth=0) const
1286  {
1287  std::ostringstream sout;
1288  std::string spaces;
1289  for (int i=0; i < space_depth; i++ ) spaces += " ";
1290  sout << spaces << "<signal name=\"" << name() << "\">\n";
1291 
1292  T_arg1 arg1;
1293  sout << spaces << " <arg name=\"" << m_arg_names[1-1] << "\" type=\"" << signature(arg1) << "\"/>\n";
1294  T_arg2 arg2;
1295  sout << spaces << " <arg name=\"" << m_arg_names[2-1] << "\" type=\"" << signature(arg2) << "\"/>\n";
1296  T_arg3 arg3;
1297  sout << spaces << " <arg name=\"" << m_arg_names[3-1] << "\" type=\"" << signature(arg3) << "\"/>\n";
1298  T_arg4 arg4;
1299  sout << spaces << " <arg name=\"" << m_arg_names[4-1] << "\" type=\"" << signature(arg4) << "\"/>\n";
1300  sout << spaces << "</signal>\n";
1301  return sout.str();
1302  }
1303 
1304  virtual std::string arg_name(size_t i) {
1305  if ( i < 4 ) return m_arg_names[i];
1306  return std::string();
1307  }
1308 
1309  virtual void set_arg_name(size_t i, const std::string& name) {
1310  if ( i < 4 ) m_arg_names[i] = name;
1311  }
1312 
1313  protected:
1314 
1315  friend class Interface;
1316 
1317  std::string m_arg_names[4];
1318 
1320 
1321  T_return internal_callback(T_arg1 arg1,T_arg2 arg2,T_arg3 arg3,T_arg4 arg4)
1322  {
1323  // DBUS_CXX_DEBUG( "signal::internal_callback: " << arg1 << arg2 << arg3 << arg4 );
1325  if ( not m_destination.empty() ) __msg->set_destination(m_destination);
1326  *__msg << arg1 << arg2 << arg3 << arg4;
1327  bool result = this->handle_dbus_outgoing(__msg);
1328  DBUSCXX_DEBUG_STDSTR( "dbus.signal", "signal::internal_callback: result=" << result );
1329  }
1330 
1331 };
1332 
1333 
1349 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
1350 class signal <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, nil,nil>
1351  : public sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>, public signal_base
1352 {
1353 public:
1354 
1355  //template <class T_accumulator>
1356  //class accumulated
1357  //: public sigc::signal5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, T_accumulator>, public signal_base
1358  //{
1359  //public:
1360  // typedef DBusCxxPointer<accumulated> pointer;
1361  //
1362  // accumulated(const std::string& interface, const std::string& name):
1363  // signal_base(interface, name)
1364  // {
1365  // m_internal_callback_connection =
1366  // this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
1367  //
1368  // m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
1369  // }
1370 
1371  // accumulated(const std::string& path, const std::string& interface, const std::string& name):
1372  // signal_base(path, interface, name)
1373  // {
1374  // m_internal_callback_connection =
1375  // this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
1376  //
1377  // m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
1378  // }
1379 
1380  // accumulated(const std::string& interface, const std::string& name, const accumulated& src):
1381  // sigc::signal5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, T_accumulator>(src),
1382  // signal_base(interface, name)
1383  // {}
1384 
1385  // accumulated(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src):
1386  // sigc::signal5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, T_accumulator>(src),
1387  // signal_base(path, interface, name)
1388  // {}
1389 
1390  // static pointer create(const std::string& interface, const std::string& name)
1391  // {
1392  // return pointer( new accumulated(interface, name) );
1393  // }
1394 
1395  // static pointer create(const std::string& path, const std::string& interface, const std::string& name)
1396  // {
1397  // return pointer( new accumulated(path, interface, name) );
1398  // }
1399 
1400  // static pointer create(const std::string& interface, const std::string& name, const accumulated& src)
1401  // {
1402  // return pointer( new accumulated(interface, name, src) );
1403  // }
1404 
1405  // static pointer create(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src)
1406  // {
1407  // return pointer( new accumulated(path, interface, name, src) );
1408  // }
1409 
1410  // virtual signal_base::pointer clone()
1411  // {
1412  // return signal_base::pointer( new accumulated(*this) );
1413  // }
1414 
1415  //protected:
1416 
1417  // sigc::connection m_internal_callback_connection;
1418 
1419  // virtual HandlerResult on_dbus_incoming( SignalMessage::const_pointer msg )
1420  // {
1421  // // T_return _retval;
1422  // //
1423  // T_arg1 _val_1;
1424  // T_arg2 _val_2;
1425  // T_arg3 _val_3;
1426  // T_arg4 _val_4;
1427  // T_arg5 _val_5;
1428 
1429  // m_internal_callback_connection.block();
1430 
1431  // try {
1432  // Message::iterator i = msg->begin();
1433  // i >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5;
1434  // this->emit(_val_1,_val_2,_val_3,_val_4,_val_5);
1435  // }
1436  // catch ( ErrorInvalidTypecast& e ) {
1437  // m_internal_callback_connection.unblock();
1438  // return NOT_HANDLED;
1439  // }
1440 
1441  // m_internal_callback_connection.unblock();
1442 
1443  // return HANDLED;
1444  // }
1445 
1446 
1447  // T_return internal_callback(T_arg1 arg1,T_arg2 arg2,T_arg3 arg3,T_arg4 arg4,T_arg5 arg5)
1448  // {
1449 
1450  // }
1451 
1452  //};
1453 
1454  typedef DBusCxxPointer<signal> pointer;
1455 
1456  signal(const std::string& interface, const std::string& name):
1457  signal_base(interface, name)
1458  {
1460  this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
1461  }
1462 
1463  signal(const std::string& path, const std::string& interface, const std::string& name):
1464  signal_base(path, interface, name)
1465  {
1467  this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
1468  }
1469 
1470  signal(const std::string& interface, const std::string& name, const signal& src) :
1471  sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(src),
1472  signal_base(interface, name)
1473  { }
1474 
1475  signal(const std::string& path, const std::string& interface, const std::string& name, const signal& src) :
1476  sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(src),
1477  signal_base(path, interface, name)
1478  { }
1479 
1480  static pointer create(const std::string& interface, const std::string& name)
1481  {
1482  return pointer( new signal(interface, name) );
1483  }
1484 
1485  static pointer create(const std::string& path, const std::string& interface, const std::string& name)
1486  {
1487  return pointer( new signal(path, interface, name) );
1488  }
1489 
1490  static pointer create(const std::string& interface, const std::string& name, const signal& src)
1491  {
1492  return pointer( new signal(interface, name, src) );
1493  }
1494 
1495  static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal& src)
1496  {
1497  return pointer( new signal(path, interface, name, src) );
1498  }
1499 
1501  {
1502  return signal_base::pointer( new signal(*this) );
1503  }
1504 
1506  virtual std::string introspect(int space_depth=0) const
1507  {
1508  std::ostringstream sout;
1509  std::string spaces;
1510  for (int i=0; i < space_depth; i++ ) spaces += " ";
1511  sout << spaces << "<signal name=\"" << name() << "\">\n";
1512 
1513  T_arg1 arg1;
1514  sout << spaces << " <arg name=\"" << m_arg_names[1-1] << "\" type=\"" << signature(arg1) << "\"/>\n";
1515  T_arg2 arg2;
1516  sout << spaces << " <arg name=\"" << m_arg_names[2-1] << "\" type=\"" << signature(arg2) << "\"/>\n";
1517  T_arg3 arg3;
1518  sout << spaces << " <arg name=\"" << m_arg_names[3-1] << "\" type=\"" << signature(arg3) << "\"/>\n";
1519  T_arg4 arg4;
1520  sout << spaces << " <arg name=\"" << m_arg_names[4-1] << "\" type=\"" << signature(arg4) << "\"/>\n";
1521  T_arg5 arg5;
1522  sout << spaces << " <arg name=\"" << m_arg_names[5-1] << "\" type=\"" << signature(arg5) << "\"/>\n";
1523  sout << spaces << "</signal>\n";
1524  return sout.str();
1525  }
1526 
1527  virtual std::string arg_name(size_t i) {
1528  if ( i < 5 ) return m_arg_names[i];
1529  return std::string();
1530  }
1531 
1532  virtual void set_arg_name(size_t i, const std::string& name) {
1533  if ( i < 5 ) m_arg_names[i] = name;
1534  }
1535 
1536  protected:
1537 
1538  friend class Interface;
1539 
1540  std::string m_arg_names[5];
1541 
1543 
1544  T_return internal_callback(T_arg1 arg1,T_arg2 arg2,T_arg3 arg3,T_arg4 arg4,T_arg5 arg5)
1545  {
1546  // DBUS_CXX_DEBUG( "signal::internal_callback: " << arg1 << arg2 << arg3 << arg4 << arg5 );
1548  if ( not m_destination.empty() ) __msg->set_destination(m_destination);
1549  *__msg << arg1 << arg2 << arg3 << arg4 << arg5;
1550  bool result = this->handle_dbus_outgoing(__msg);
1551  DBUSCXX_DEBUG_STDSTR( "dbus.signal", "signal::internal_callback: result=" << result );
1552  }
1553 
1554 };
1555 
1556 
1572 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
1573 class signal <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, nil>
1574  : public sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>, public signal_base
1575 {
1576 public:
1577 
1578  //template <class T_accumulator>
1579  //class accumulated
1580  //: public sigc::signal6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, T_accumulator>, public signal_base
1581  //{
1582  //public:
1583  // typedef DBusCxxPointer<accumulated> pointer;
1584  //
1585  // accumulated(const std::string& interface, const std::string& name):
1586  // signal_base(interface, name)
1587  // {
1588  // m_internal_callback_connection =
1589  // this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
1590  //
1591  // m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
1592  // }
1593 
1594  // accumulated(const std::string& path, const std::string& interface, const std::string& name):
1595  // signal_base(path, interface, name)
1596  // {
1597  // m_internal_callback_connection =
1598  // this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
1599  //
1600  // m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
1601  // }
1602 
1603  // accumulated(const std::string& interface, const std::string& name, const accumulated& src):
1604  // sigc::signal6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, T_accumulator>(src),
1605  // signal_base(interface, name)
1606  // {}
1607 
1608  // accumulated(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src):
1609  // sigc::signal6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, T_accumulator>(src),
1610  // signal_base(path, interface, name)
1611  // {}
1612 
1613  // static pointer create(const std::string& interface, const std::string& name)
1614  // {
1615  // return pointer( new accumulated(interface, name) );
1616  // }
1617 
1618  // static pointer create(const std::string& path, const std::string& interface, const std::string& name)
1619  // {
1620  // return pointer( new accumulated(path, interface, name) );
1621  // }
1622 
1623  // static pointer create(const std::string& interface, const std::string& name, const accumulated& src)
1624  // {
1625  // return pointer( new accumulated(interface, name, src) );
1626  // }
1627 
1628  // static pointer create(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src)
1629  // {
1630  // return pointer( new accumulated(path, interface, name, src) );
1631  // }
1632 
1633  // virtual signal_base::pointer clone()
1634  // {
1635  // return signal_base::pointer( new accumulated(*this) );
1636  // }
1637 
1638  //protected:
1639 
1640  // sigc::connection m_internal_callback_connection;
1641 
1642  // virtual HandlerResult on_dbus_incoming( SignalMessage::const_pointer msg )
1643  // {
1644  // // T_return _retval;
1645  // //
1646  // T_arg1 _val_1;
1647  // T_arg2 _val_2;
1648  // T_arg3 _val_3;
1649  // T_arg4 _val_4;
1650  // T_arg5 _val_5;
1651  // T_arg6 _val_6;
1652 
1653  // m_internal_callback_connection.block();
1654 
1655  // try {
1656  // Message::iterator i = msg->begin();
1657  // i >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5 >> _val_6;
1658  // this->emit(_val_1,_val_2,_val_3,_val_4,_val_5,_val_6);
1659  // }
1660  // catch ( ErrorInvalidTypecast& e ) {
1661  // m_internal_callback_connection.unblock();
1662  // return NOT_HANDLED;
1663  // }
1664 
1665  // m_internal_callback_connection.unblock();
1666 
1667  // return HANDLED;
1668  // }
1669 
1670 
1671  // T_return internal_callback(T_arg1 arg1,T_arg2 arg2,T_arg3 arg3,T_arg4 arg4,T_arg5 arg5,T_arg6 arg6)
1672  // {
1673 
1674  // }
1675 
1676  //};
1677 
1678  typedef DBusCxxPointer<signal> pointer;
1679 
1680  signal(const std::string& interface, const std::string& name):
1681  signal_base(interface, name)
1682  {
1684  this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
1685  }
1686 
1687  signal(const std::string& path, const std::string& interface, const std::string& name):
1688  signal_base(path, interface, name)
1689  {
1691  this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
1692  }
1693 
1694  signal(const std::string& interface, const std::string& name, const signal& src) :
1695  sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(src),
1696  signal_base(interface, name)
1697  { }
1698 
1699  signal(const std::string& path, const std::string& interface, const std::string& name, const signal& src) :
1700  sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(src),
1701  signal_base(path, interface, name)
1702  { }
1703 
1704  static pointer create(const std::string& interface, const std::string& name)
1705  {
1706  return pointer( new signal(interface, name) );
1707  }
1708 
1709  static pointer create(const std::string& path, const std::string& interface, const std::string& name)
1710  {
1711  return pointer( new signal(path, interface, name) );
1712  }
1713 
1714  static pointer create(const std::string& interface, const std::string& name, const signal& src)
1715  {
1716  return pointer( new signal(interface, name, src) );
1717  }
1718 
1719  static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal& src)
1720  {
1721  return pointer( new signal(path, interface, name, src) );
1722  }
1723 
1725  {
1726  return signal_base::pointer( new signal(*this) );
1727  }
1728 
1730  virtual std::string introspect(int space_depth=0) const
1731  {
1732  std::ostringstream sout;
1733  std::string spaces;
1734  for (int i=0; i < space_depth; i++ ) spaces += " ";
1735  sout << spaces << "<signal name=\"" << name() << "\">\n";
1736 
1737  T_arg1 arg1;
1738  sout << spaces << " <arg name=\"" << m_arg_names[1-1] << "\" type=\"" << signature(arg1) << "\"/>\n";
1739  T_arg2 arg2;
1740  sout << spaces << " <arg name=\"" << m_arg_names[2-1] << "\" type=\"" << signature(arg2) << "\"/>\n";
1741  T_arg3 arg3;
1742  sout << spaces << " <arg name=\"" << m_arg_names[3-1] << "\" type=\"" << signature(arg3) << "\"/>\n";
1743  T_arg4 arg4;
1744  sout << spaces << " <arg name=\"" << m_arg_names[4-1] << "\" type=\"" << signature(arg4) << "\"/>\n";
1745  T_arg5 arg5;
1746  sout << spaces << " <arg name=\"" << m_arg_names[5-1] << "\" type=\"" << signature(arg5) << "\"/>\n";
1747  T_arg6 arg6;
1748  sout << spaces << " <arg name=\"" << m_arg_names[6-1] << "\" type=\"" << signature(arg6) << "\"/>\n";
1749  sout << spaces << "</signal>\n";
1750  return sout.str();
1751  }
1752 
1753  virtual std::string arg_name(size_t i) {
1754  if ( i < 6 ) return m_arg_names[i];
1755  return std::string();
1756  }
1757 
1758  virtual void set_arg_name(size_t i, const std::string& name) {
1759  if ( i < 6 ) m_arg_names[i] = name;
1760  }
1761 
1762  protected:
1763 
1764  friend class Interface;
1765 
1766  std::string m_arg_names[6];
1767 
1769 
1770  T_return internal_callback(T_arg1 arg1,T_arg2 arg2,T_arg3 arg3,T_arg4 arg4,T_arg5 arg5,T_arg6 arg6)
1771  {
1772  // DBUS_CXX_DEBUG( "signal::internal_callback: " << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 );
1774  if ( not m_destination.empty() ) __msg->set_destination(m_destination);
1775  *__msg << arg1 << arg2 << arg3 << arg4 << arg5 << arg6;
1776  bool result = this->handle_dbus_outgoing(__msg);
1777  DBUSCXX_DEBUG_STDSTR( "dbus.signal", "signal::internal_callback: result=" << result );
1778  }
1779 
1780 };
1781 
1782 
1783 
1784 } /* namespace DBus */
1785 
1786 #endif /* _DBUS_CXX_SIGNAL_H_ */
DBusCxxPointer< signal > pointer
Definition: dbus_signal.h:1678
virtual std::string arg_name(size_t i)
Definition: dbus_signal.h:653
static pointer create(const std::string &path, const std::string &interface, const std::string &name, const signal &src)
Definition: dbus_signal.h:1056
static pointer create(const std::string &interface, const std::string &name, const signal &src)
Definition: dbus_signal.h:1269
Path m_path
Definition: signal_base.h:111
Subclass of the numbered sigc::signal templates.
Definition: dbus_signal.h:50
virtual void set_arg_name(size_t i, const std::string &name)
Definition: dbus_signal.h:658
static pointer create(const std::string &interface, const std::string &name, const signal &src)
Definition: dbus_signal.h:624
virtual std::string arg_name(size_t i)
Definition: dbus_signal.h:1304
signal(const std::string &interface, const std::string &name)
Definition: dbus_signal.h:802
signal(const std::string &path, const std::string &interface, const std::string &name)
Definition: dbus_signal.h:1687
T_return internal_callback(T_arg1 arg1, T_arg2 arg2, T_arg3 arg3, T_arg4 arg4)
Definition: dbus_signal.h:1321
sigc::nil nil
Definition: types.h:36
T_return internal_callback(T_arg1 arg1, T_arg2 arg2, T_arg3 arg3)
Definition: dbus_signal.h:1101
static pointer create(const std::string &interface, const std::string &name, const signal &src)
Definition: dbus_signal.h:192
virtual std::string arg_name(size_t i)
Definition: dbus_signal.h:1527
signal(const std::string &interface, const std::string &name, const signal &src)
Definition: dbus_signal.h:1031
const std::string & name() const
Definition: signal_base.cpp:99
Definition: accumulators.h:24
static pointer create(const std::string &path, const std::string &interface, const std::string &name)
Definition: dbus_signal.h:831
virtual std::string introspect(int space_depth=0) const
Returns a DBus XML description of this interface.
Definition: dbus_signal.h:1506
DBusCxxPointer< signal > pointer
Definition: dbus_signal.h:588
#define DBUSCXX_DEBUG_STDSTR(logger, message)
Definition: headerlog.h:38
virtual signal_base::pointer clone()
Definition: dbus_signal.h:1061
virtual void set_arg_name(size_t i, const std::string &name)
Definition: dbus_signal.h:1309
signal(const std::string &interface, const std::string &name, const signal &src)
Definition: dbus_signal.h:1694
sigc::connection m_internal_callback_connection
Definition: dbus_signal.h:457
DBusCxxPointer< SignalMessage > pointer
Definition: signalmessage.h:54
virtual void set_arg_name(size_t i, const std::string &name)
Definition: dbus_signal.h:1532
virtual signal_base::pointer clone()
Definition: dbus_signal.h:634
std::string m_destination
Definition: signal_base.h:117
bool handle_dbus_outgoing(Message::const_pointer)
Definition: signal_base.cpp:129
sigc::connection m_internal_callback_connection
Definition: dbus_signal.h:668
virtual std::string introspect(int space_depth=0) const
Returns a DBus XML description of this interface.
Definition: dbus_signal.h:640
virtual void set_arg_name(size_t i, const std::string &name)
Definition: dbus_signal.h:238
std::string m_interface
Definition: signal_base.h:113
signal(const std::string &interface, const std::string &name, const signal &src)
Definition: dbus_signal.h:172
signal(const std::string &path, const std::string &interface, const std::string &name)
Definition: dbus_signal.h:1463
signal(const std::string &interface, const std::string &name, const signal &src)
Definition: dbus_signal.h:816
DBusCxxPointer< signal_base > pointer
Definition: signal_base.h:64
signal(const std::string &path, const std::string &interface, const std::string &name, const signal &src)
Definition: dbus_signal.h:1475
T_return internal_callback(T_arg1 arg1, T_arg2 arg2, T_arg3 arg3, T_arg4 arg4, T_arg5 arg5, T_arg6 arg6)
Definition: dbus_signal.h:1770
signal(const std::string &path, const std::string &interface, const std::string &name, const signal &src)
Definition: dbus_signal.h:400
virtual signal_base::pointer clone()
Definition: dbus_signal.h:202
sigc::connection m_internal_callback_connection
Definition: dbus_signal.h:1319
virtual std::string arg_name(size_t i)
Definition: dbus_signal.h:1753
signal(const std::string &path, const std::string &interface, const std::string &name)
Definition: dbus_signal.h:1242
virtual std::string introspect(int space_depth=0) const
Returns a DBus XML description of this interface.
Definition: dbus_signal.h:1067
static pointer create(const std::string &path, const std::string &interface, const std::string &name)
Definition: dbus_signal.h:619
T_return internal_callback(T_arg1 arg1, T_arg2 arg2)
Definition: dbus_signal.h:884
signal(const std::string &interface, const std::string &name)
Definition: dbus_signal.h:1680
static pointer create(const std::string &path, const std::string &interface, const std::string &name)
Definition: dbus_signal.h:1709
T_return internal_callback(T_arg1 arg1, T_arg2 arg2, T_arg3 arg3, T_arg4 arg4, T_arg5 arg5)
Definition: dbus_signal.h:1544
signal(const std::string &path, const std::string &interface, const std::string &name, const signal &src)
Definition: dbus_signal.h:821
sigc::connection m_internal_callback_connection
Definition: dbus_signal.h:1542
T_return internal_callback()
Definition: dbus_signal.h:459
static pointer create(DBusMessage *cobj=NULL, CreateMethod m=CREATE_ALIAS)
Definition: signalmessage.cpp:64
static pointer create(const std::string &path, const std::string &interface, const std::string &name)
Definition: dbus_signal.h:1485
static pointer create(const std::string &interface, const std::string &name)
Definition: dbus_signal.h:182
static pointer create(const std::string &interface, const std::string &name, const signal &src)
Definition: dbus_signal.h:1490
signal(const std::string &path, const std::string &interface, const std::string &name)
Definition: dbus_signal.h:809
static pointer create(const std::string &path, const std::string &interface, const std::string &name, const signal &src)
Definition: dbus_signal.h:1719
signal(const std::string &interface, const std::string &name, const signal &src)
Definition: dbus_signal.h:1470
static pointer create(const std::string &path, const std::string &interface, const std::string &name, const signal &src)
Definition: dbus_signal.h:841
sigc::connection m_internal_callback_connection
Definition: dbus_signal.h:248
DBusCxxPointer< signal > pointer
Definition: dbus_signal.h:379
static pointer create(const std::string &path, const std::string &interface, const std::string &name, const signal &src)
Definition: dbus_signal.h:1274
virtual std::string arg_name(size_t i)
Definition: dbus_signal.h:442
signal(const std::string &path, const std::string &interface, const std::string &name)
Definition: dbus_signal.h:1024
virtual void set_arg_name(size_t i, const std::string &name)
Definition: dbus_signal.h:872
virtual std::string arg_name(size_t i)
Definition: dbus_signal.h:1084
virtual std::string arg_name(size_t i)
Definition: dbus_signal.h:867
virtual void set_arg_name(size_t i, const std::string &name)
Definition: dbus_signal.h:1089
virtual signal_base::pointer clone()
Definition: dbus_signal.h:1500
static pointer create(const std::string &interface, const std::string &name)
Definition: dbus_signal.h:614
virtual signal_base::pointer clone()
Definition: dbus_signal.h:425
DBusCxxPointer< signal > pointer
Definition: dbus_signal.h:800
virtual std::string introspect(int space_depth=0) const
Returns a DBus XML description of this interface.
Definition: dbus_signal.h:1730
signal(const std::string &interface, const std::string &name)
Definition: dbus_signal.h:1235
signal(const std::string &path, const std::string &interface, const std::string &name, const signal &src)
Definition: dbus_signal.h:1036
DBusCxxPointer< signal > pointer
Definition: dbus_signal.h:1454
std::string m_arg_names[7]
Definition: dbus_signal.h:246
virtual void set_arg_name(size_t i, const std::string &name)
Definition: dbus_signal.h:447
static pointer create(const std::string &interface, const std::string &name)
Definition: dbus_signal.h:1704
std::string m_name
Definition: signal_base.h:115
signal(const std::string &path, const std::string &interface, const std::string &name, const signal &src)
Definition: dbus_signal.h:1254
Definition: signal_base.h:48
signal(const std::string &interface, const std::string &name)
Definition: dbus_signal.h:158
signal(const std::string &interface, const std::string &name, const signal &src)
Definition: dbus_signal.h:1249
static pointer create(const std::string &path, const std::string &interface, const std::string &name)
Definition: dbus_signal.h:1264
signal(const std::string &path, const std::string &interface, const std::string &name, const signal &src)
Definition: dbus_signal.h:1699
signal(const std::string &interface, const std::string &name)
Definition: dbus_signal.h:1017
DBusCxxPointer< signal > pointer
Definition: dbus_signal.h:1015
virtual std::string introspect(int space_depth=0) const
Returns a DBus XML description of this interface.
Definition: dbus_signal.h:208
static pointer create(const std::string &path, const std::string &interface, const std::string &name, const signal &src)
Definition: dbus_signal.h:1495
signal(const std::string &interface, const std::string &name, const signal &src)
Definition: dbus_signal.h:604
virtual std::string introspect(int space_depth=0) const
Returns a DBus XML description of this interface.
Definition: dbus_signal.h:431
signal(const std::string &interface, const std::string &name, const signal &src)
Definition: dbus_signal.h:395
Definition: interface.h:46
virtual void set_arg_name(size_t i, const std::string &name)
Definition: dbus_signal.h:1758
static pointer create(const std::string &path, const std::string &interface, const std::string &name, const signal &src)
Definition: dbus_signal.h:197
sigc::connection m_internal_callback_connection
Definition: dbus_signal.h:1099
virtual std::string introspect(int space_depth=0) const
Returns a DBus XML description of this interface.
Definition: dbus_signal.h:1285
signal(const std::string &path, const std::string &interface, const std::string &name, const signal &src)
Definition: dbus_signal.h:609
virtual signal_base::pointer clone()
Definition: dbus_signal.h:1279
std::string signature(uint8_t &)
Definition: signature.h:94
signal(const std::string &path, const std::string &interface, const std::string &name)
Definition: dbus_signal.h:388
static pointer create(const std::string &path, const std::string &interface, const std::string &name)
Definition: dbus_signal.h:1046
static pointer create(const std::string &interface, const std::string &name, const signal &src)
Definition: dbus_signal.h:1714
virtual signal_base::pointer clone()
Definition: dbus_signal.h:846
static pointer create(const std::string &interface, const std::string &name)
Definition: dbus_signal.h:826
static pointer create(const std::string &path, const std::string &interface, const std::string &name)
Definition: dbus_signal.h:410
static pointer create(const std::string &path, const std::string &interface, const std::string &name)
Definition: dbus_signal.h:187
static pointer create(const std::string &path, const std::string &interface, const std::string &name, const signal &src)
Definition: dbus_signal.h:629
signal(const std::string &path, const std::string &interface, const std::string &name)
Definition: dbus_signal.h:597
T_return internal_callback(T_arg1 arg1, T_arg2 arg2, T_arg3 arg3, T_arg4 arg4, T_arg5 arg5, T_arg6 arg6, T_arg7 arg7)
Definition: dbus_signal.h:250
static pointer create(const std::string &interface, const std::string &name)
Definition: dbus_signal.h:1041
virtual signal_base::pointer clone()
Definition: dbus_signal.h:1724
static pointer create(const std::string &interface, const std::string &name, const signal &src)
Definition: dbus_signal.h:836
const std::string & interface() const
Definition: signal_base.cpp:89
virtual std::string introspect(int space_depth=0) const
Returns a DBus XML description of this interface.
Definition: dbus_signal.h:852
static pointer create(const std::string &interface, const std::string &name, const signal &src)
Definition: dbus_signal.h:415
signal(const std::string &interface, const std::string &name)
Definition: dbus_signal.h:590
const Path & path() const
Definition: signal_base.cpp:109
static pointer create(const std::string &interface, const std::string &name)
Definition: dbus_signal.h:1480
signal(const std::string &interface, const std::string &name)
Definition: dbus_signal.h:381
DBusCxxPointer< signal > pointer
Definition: dbus_signal.h:1233
signal(const std::string &path, const std::string &interface, const std::string &name)
Definition: dbus_signal.h:165
signal(const std::string &interface, const std::string &name)
Definition: dbus_signal.h:1456
static pointer create(const std::string &interface, const std::string &name, const signal &src)
Definition: dbus_signal.h:1051
T_return internal_callback(T_arg1 arg1)
Definition: dbus_signal.h:670
DBusCxxPointer< signal > pointer
Definition: dbus_signal.h:156
sigc::connection m_internal_callback_connection
Definition: dbus_signal.h:882
static pointer create(const std::string &interface, const std::string &name)
Definition: dbus_signal.h:405
static pointer create(const std::string &path, const std::string &interface, const std::string &name, const signal &src)
Definition: dbus_signal.h:420
static pointer create(const std::string &interface, const std::string &name)
Definition: dbus_signal.h:1259
sigc::connection m_internal_callback_connection
Definition: dbus_signal.h:1768
virtual std::string arg_name(size_t i)
Definition: dbus_signal.h:233
signal(const std::string &path, const std::string &interface, const std::string &name, const signal &src)
Definition: dbus_signal.h:177

Generated on Sun Mar 19 2017 14:54:27 for dbus-cxx by doxygen 1.8.8