dbus-cxx logo
method_impl.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 <dbus-cxx/method.h>
24 #include <dbus-cxx/connection.h>
25 #include <dbus-cxx/headerlog.h>
26 
27 #ifndef DBUSCXX_METHOD_IMPL_H
28 #define DBUSCXX_METHOD_IMPL_H
29 
30 namespace DBus {
31 
34  template <>
35  class Method <void, nil,nil,nil,nil,nil,nil,nil>
36  : public MethodBase
37  {
38  public:
39 
40  typedef DBusCxxPointer<Method> pointer;
41 
42  Method(const std::string& name):
43  MethodBase(name)
44  { }
45 
46  virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
47  {
48  DBUSCXX_DEBUG_STDSTR("dbus.Method", "Method<void>::handle_call_message method=" << m_name );
49 
50  if ( not connection or not message ) return NOT_HANDLED;
51 
52 
53 
54 
55 
56  m_slot();
57 
59 
60  if ( message->expects_reply() )
61  {
62  retmsg = message->create_reply();
63  if ( not retmsg ) return NOT_HANDLED;
64  connection << retmsg;
65  }
66 
67  return HANDLED;
68  }
69 
70  void set_method( sigc::slot0<void> slot )
71  { m_slot = slot; }
72 
73  static pointer create(const std::string& name)
74  { return pointer( new Method(name) ); }
75 
77  { return MethodBase::pointer( new Method(this->name()) ); }
78 
80  virtual std::string introspect(int space_depth=0) const
81  {
82  std::ostringstream sout;
83  std::string spaces;
84  for (int i=0; i < space_depth; i++ ) spaces += " ";
85  sout << spaces << "<method name=\"" << name() << "\">\n";
86 
87  sout << spaces << "</method>\n";
88  return sout.str();
89  }
90 
91  virtual std::string arg_name(size_t i) {
92  if ( i < 0+1 ) return m_arg_names[i];
93  return std::string();
94  }
95 
96  virtual void set_arg_name(size_t i, const std::string& name) {
97  if ( i < 0+1 ) m_arg_names[i] = name;
98  }
99 
100  protected:
101 
102  std::string m_arg_names[0+1];
103 
104  sigc::slot0<void> m_slot;
105 
106  };
107 
110  template <class T_arg1>
111  class Method <void, T_arg1, nil,nil,nil,nil,nil,nil>
112  : public MethodBase
113  {
114  public:
115 
116  typedef DBusCxxPointer<Method> pointer;
117 
118  Method(const std::string& name):
119  MethodBase(name)
120  { }
121 
122  virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
123  {
124  DBUSCXX_DEBUG_STDSTR("dbus.Method", "Method<void, T_arg1>::handle_call_message method=" << m_name );
125 
126  if ( not connection or not message ) return NOT_HANDLED;
127 
128 
129  T_arg1 _val_1;
130 
131 
132  try {
133  Message::iterator i = message->begin();
134  i >> _val_1;
135  }
136  catch ( ErrorInvalidTypecast& e ) {
137  return NOT_HANDLED;
138  }
139 
140 
141  m_slot(_val_1);
142 
144 
145  if ( message->expects_reply() )
146  {
147  retmsg = message->create_reply();
148  if ( not retmsg ) return NOT_HANDLED;
149  connection << retmsg;
150  }
151 
152  return HANDLED;
153  }
154 
155  void set_method( sigc::slot1<void, T_arg1> slot )
156  { m_slot = slot; }
157 
158  static pointer create(const std::string& name)
159  { return pointer( new Method(name) ); }
160 
162  { return MethodBase::pointer( new Method(this->name()) ); }
163 
165  virtual std::string introspect(int space_depth=0) const
166  {
167  std::ostringstream sout;
168  std::string spaces;
169  for (int i=0; i < space_depth; i++ ) spaces += " ";
170  sout << spaces << "<method name=\"" << name() << "\">\n";
171 
172  sout << spaces << " <arg name=\"" << m_arg_names[1] << "\" type=\"" << signature<T_arg1>() << "\" direction=\"in\"/>\n";
173  sout << spaces << "</method>\n";
174  return sout.str();
175  }
176 
177  virtual std::string arg_name(size_t i) {
178  if ( i < 1+1 ) return m_arg_names[i];
179  return std::string();
180  }
181 
182  virtual void set_arg_name(size_t i, const std::string& name) {
183  if ( i < 1+1 ) m_arg_names[i] = name;
184  }
185 
186  protected:
187 
188  std::string m_arg_names[1+1];
189 
190  sigc::slot1<void, T_arg1> m_slot;
191 
192  };
193 
196  template <class T_arg1,class T_arg2>
197  class Method <void, T_arg1,T_arg2, nil,nil,nil,nil,nil>
198  : public MethodBase
199  {
200  public:
201 
202  typedef DBusCxxPointer<Method> pointer;
203 
204  Method(const std::string& name):
205  MethodBase(name)
206  { }
207 
208  virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
209  {
210  DBUSCXX_DEBUG_STDSTR("dbus.Method", "Method<void, T_arg1,T_arg2>::handle_call_message method=" << m_name );
211 
212  if ( not connection or not message ) return NOT_HANDLED;
213 
214 
215  T_arg1 _val_1;
216  T_arg2 _val_2;
217 
218 
219  try {
220  Message::iterator i = message->begin();
221  i >> _val_1 >> _val_2;
222  }
223  catch ( ErrorInvalidTypecast& e ) {
224  return NOT_HANDLED;
225  }
226 
227 
228  m_slot(_val_1,_val_2);
229 
231 
232  if ( message->expects_reply() )
233  {
234  retmsg = message->create_reply();
235  if ( not retmsg ) return NOT_HANDLED;
236  connection << retmsg;
237  }
238 
239  return HANDLED;
240  }
241 
242  void set_method( sigc::slot2<void, T_arg1,T_arg2> slot )
243  { m_slot = slot; }
244 
245  static pointer create(const std::string& name)
246  { return pointer( new Method(name) ); }
247 
249  { return MethodBase::pointer( new Method(this->name()) ); }
250 
252  virtual std::string introspect(int space_depth=0) const
253  {
254  std::ostringstream sout;
255  std::string spaces;
256  for (int i=0; i < space_depth; i++ ) spaces += " ";
257  sout << spaces << "<method name=\"" << name() << "\">\n";
258 
259  sout << spaces << " <arg name=\"" << m_arg_names[1] << "\" type=\"" << signature<T_arg1>() << "\" direction=\"in\"/>\n";
260  sout << spaces << " <arg name=\"" << m_arg_names[2] << "\" type=\"" << signature<T_arg2>() << "\" direction=\"in\"/>\n";
261  sout << spaces << "</method>\n";
262  return sout.str();
263  }
264 
265  virtual std::string arg_name(size_t i) {
266  if ( i < 2+1 ) return m_arg_names[i];
267  return std::string();
268  }
269 
270  virtual void set_arg_name(size_t i, const std::string& name) {
271  if ( i < 2+1 ) m_arg_names[i] = name;
272  }
273 
274  protected:
275 
276  std::string m_arg_names[2+1];
277 
278  sigc::slot2<void, T_arg1,T_arg2> m_slot;
279 
280  };
281 
284  template <class T_arg1,class T_arg2,class T_arg3>
285  class Method <void, T_arg1,T_arg2,T_arg3, nil,nil,nil,nil>
286  : public MethodBase
287  {
288  public:
289 
290  typedef DBusCxxPointer<Method> pointer;
291 
292  Method(const std::string& name):
293  MethodBase(name)
294  { }
295 
296  virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
297  {
298  DBUSCXX_DEBUG_STDSTR("dbus.Method", "Method<void, T_arg1,T_arg2,T_arg3>::handle_call_message method=" << m_name );
299 
300  if ( not connection or not message ) return NOT_HANDLED;
301 
302 
303  T_arg1 _val_1;
304  T_arg2 _val_2;
305  T_arg3 _val_3;
306 
307 
308  try {
309  Message::iterator i = message->begin();
310  i >> _val_1 >> _val_2 >> _val_3;
311  }
312  catch ( ErrorInvalidTypecast& e ) {
313  return NOT_HANDLED;
314  }
315 
316 
317  m_slot(_val_1,_val_2,_val_3);
318 
320 
321  if ( message->expects_reply() )
322  {
323  retmsg = message->create_reply();
324  if ( not retmsg ) return NOT_HANDLED;
325  connection << retmsg;
326  }
327 
328  return HANDLED;
329  }
330 
331  void set_method( sigc::slot3<void, T_arg1,T_arg2,T_arg3> slot )
332  { m_slot = slot; }
333 
334  static pointer create(const std::string& name)
335  { return pointer( new Method(name) ); }
336 
338  { return MethodBase::pointer( new Method(this->name()) ); }
339 
341  virtual std::string introspect(int space_depth=0) const
342  {
343  std::ostringstream sout;
344  std::string spaces;
345  for (int i=0; i < space_depth; i++ ) spaces += " ";
346  sout << spaces << "<method name=\"" << name() << "\">\n";
347 
348  sout << spaces << " <arg name=\"" << m_arg_names[1] << "\" type=\"" << signature<T_arg1>() << "\" direction=\"in\"/>\n";
349  sout << spaces << " <arg name=\"" << m_arg_names[2] << "\" type=\"" << signature<T_arg2>() << "\" direction=\"in\"/>\n";
350  sout << spaces << " <arg name=\"" << m_arg_names[3] << "\" type=\"" << signature<T_arg3>() << "\" direction=\"in\"/>\n";
351  sout << spaces << "</method>\n";
352  return sout.str();
353  }
354 
355  virtual std::string arg_name(size_t i) {
356  if ( i < 3+1 ) return m_arg_names[i];
357  return std::string();
358  }
359 
360  virtual void set_arg_name(size_t i, const std::string& name) {
361  if ( i < 3+1 ) m_arg_names[i] = name;
362  }
363 
364  protected:
365 
366  std::string m_arg_names[3+1];
367 
368  sigc::slot3<void, T_arg1,T_arg2,T_arg3> m_slot;
369 
370  };
371 
374  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
375  class Method <void, T_arg1,T_arg2,T_arg3,T_arg4, nil,nil,nil>
376  : public MethodBase
377  {
378  public:
379 
380  typedef DBusCxxPointer<Method> pointer;
381 
382  Method(const std::string& name):
383  MethodBase(name)
384  { }
385 
386  virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
387  {
388  DBUSCXX_DEBUG_STDSTR("dbus.Method", "Method<void, T_arg1,T_arg2,T_arg3,T_arg4>::handle_call_message method=" << m_name );
389 
390  if ( not connection or not message ) return NOT_HANDLED;
391 
392 
393  T_arg1 _val_1;
394  T_arg2 _val_2;
395  T_arg3 _val_3;
396  T_arg4 _val_4;
397 
398 
399  try {
400  Message::iterator i = message->begin();
401  i >> _val_1 >> _val_2 >> _val_3 >> _val_4;
402  }
403  catch ( ErrorInvalidTypecast& e ) {
404  return NOT_HANDLED;
405  }
406 
407 
408  m_slot(_val_1,_val_2,_val_3,_val_4);
409 
411 
412  if ( message->expects_reply() )
413  {
414  retmsg = message->create_reply();
415  if ( not retmsg ) return NOT_HANDLED;
416  connection << retmsg;
417  }
418 
419  return HANDLED;
420  }
421 
422  void set_method( sigc::slot4<void, T_arg1,T_arg2,T_arg3,T_arg4> slot )
423  { m_slot = slot; }
424 
425  static pointer create(const std::string& name)
426  { return pointer( new Method(name) ); }
427 
429  { return MethodBase::pointer( new Method(this->name()) ); }
430 
432  virtual std::string introspect(int space_depth=0) const
433  {
434  std::ostringstream sout;
435  std::string spaces;
436  for (int i=0; i < space_depth; i++ ) spaces += " ";
437  sout << spaces << "<method name=\"" << name() << "\">\n";
438 
439  sout << spaces << " <arg name=\"" << m_arg_names[1] << "\" type=\"" << signature<T_arg1>() << "\" direction=\"in\"/>\n";
440  sout << spaces << " <arg name=\"" << m_arg_names[2] << "\" type=\"" << signature<T_arg2>() << "\" direction=\"in\"/>\n";
441  sout << spaces << " <arg name=\"" << m_arg_names[3] << "\" type=\"" << signature<T_arg3>() << "\" direction=\"in\"/>\n";
442  sout << spaces << " <arg name=\"" << m_arg_names[4] << "\" type=\"" << signature<T_arg4>() << "\" direction=\"in\"/>\n";
443  sout << spaces << "</method>\n";
444  return sout.str();
445  }
446 
447  virtual std::string arg_name(size_t i) {
448  if ( i < 4+1 ) return m_arg_names[i];
449  return std::string();
450  }
451 
452  virtual void set_arg_name(size_t i, const std::string& name) {
453  if ( i < 4+1 ) m_arg_names[i] = name;
454  }
455 
456  protected:
457 
458  std::string m_arg_names[4+1];
459 
460  sigc::slot4<void, T_arg1,T_arg2,T_arg3,T_arg4> m_slot;
461 
462  };
463 
466  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
467  class Method <void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, nil,nil>
468  : public MethodBase
469  {
470  public:
471 
472  typedef DBusCxxPointer<Method> pointer;
473 
474  Method(const std::string& name):
475  MethodBase(name)
476  { }
477 
478  virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
479  {
480  DBUSCXX_DEBUG_STDSTR("dbus.Method", "Method<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::handle_call_message method=" << m_name );
481 
482  if ( not connection or not message ) return NOT_HANDLED;
483 
484 
485  T_arg1 _val_1;
486  T_arg2 _val_2;
487  T_arg3 _val_3;
488  T_arg4 _val_4;
489  T_arg5 _val_5;
490 
491 
492  try {
493  Message::iterator i = message->begin();
494  i >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5;
495  }
496  catch ( ErrorInvalidTypecast& e ) {
497  return NOT_HANDLED;
498  }
499 
500 
501  m_slot(_val_1,_val_2,_val_3,_val_4,_val_5);
502 
504 
505  if ( message->expects_reply() )
506  {
507  retmsg = message->create_reply();
508  if ( not retmsg ) return NOT_HANDLED;
509  connection << retmsg;
510  }
511 
512  return HANDLED;
513  }
514 
515  void set_method( sigc::slot5<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> slot )
516  { m_slot = slot; }
517 
518  static pointer create(const std::string& name)
519  { return pointer( new Method(name) ); }
520 
522  { return MethodBase::pointer( new Method(this->name()) ); }
523 
525  virtual std::string introspect(int space_depth=0) const
526  {
527  std::ostringstream sout;
528  std::string spaces;
529  for (int i=0; i < space_depth; i++ ) spaces += " ";
530  sout << spaces << "<method name=\"" << name() << "\">\n";
531 
532  sout << spaces << " <arg name=\"" << m_arg_names[1] << "\" type=\"" << signature<T_arg1>() << "\" direction=\"in\"/>\n";
533  sout << spaces << " <arg name=\"" << m_arg_names[2] << "\" type=\"" << signature<T_arg2>() << "\" direction=\"in\"/>\n";
534  sout << spaces << " <arg name=\"" << m_arg_names[3] << "\" type=\"" << signature<T_arg3>() << "\" direction=\"in\"/>\n";
535  sout << spaces << " <arg name=\"" << m_arg_names[4] << "\" type=\"" << signature<T_arg4>() << "\" direction=\"in\"/>\n";
536  sout << spaces << " <arg name=\"" << m_arg_names[5] << "\" type=\"" << signature<T_arg5>() << "\" direction=\"in\"/>\n";
537  sout << spaces << "</method>\n";
538  return sout.str();
539  }
540 
541  virtual std::string arg_name(size_t i) {
542  if ( i < 5+1 ) return m_arg_names[i];
543  return std::string();
544  }
545 
546  virtual void set_arg_name(size_t i, const std::string& name) {
547  if ( i < 5+1 ) m_arg_names[i] = name;
548  }
549 
550  protected:
551 
552  std::string m_arg_names[5+1];
553 
554  sigc::slot5<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> m_slot;
555 
556  };
557 
560  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
561  class Method <void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, nil>
562  : public MethodBase
563  {
564  public:
565 
566  typedef DBusCxxPointer<Method> pointer;
567 
568  Method(const std::string& name):
569  MethodBase(name)
570  { }
571 
572  virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
573  {
574  DBUSCXX_DEBUG_STDSTR("dbus.Method", "Method<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::handle_call_message method=" << m_name );
575 
576  if ( not connection or not message ) return NOT_HANDLED;
577 
578 
579  T_arg1 _val_1;
580  T_arg2 _val_2;
581  T_arg3 _val_3;
582  T_arg4 _val_4;
583  T_arg5 _val_5;
584  T_arg6 _val_6;
585 
586 
587  try {
588  Message::iterator i = message->begin();
589  i >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5 >> _val_6;
590  }
591  catch ( ErrorInvalidTypecast& e ) {
592  return NOT_HANDLED;
593  }
594 
595 
596  m_slot(_val_1,_val_2,_val_3,_val_4,_val_5,_val_6);
597 
599 
600  if ( message->expects_reply() )
601  {
602  retmsg = message->create_reply();
603  if ( not retmsg ) return NOT_HANDLED;
604  connection << retmsg;
605  }
606 
607  return HANDLED;
608  }
609 
610  void set_method( sigc::slot6<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> slot )
611  { m_slot = slot; }
612 
613  static pointer create(const std::string& name)
614  { return pointer( new Method(name) ); }
615 
617  { return MethodBase::pointer( new Method(this->name()) ); }
618 
620  virtual std::string introspect(int space_depth=0) const
621  {
622  std::ostringstream sout;
623  std::string spaces;
624  for (int i=0; i < space_depth; i++ ) spaces += " ";
625  sout << spaces << "<method name=\"" << name() << "\">\n";
626 
627  sout << spaces << " <arg name=\"" << m_arg_names[1] << "\" type=\"" << signature<T_arg1>() << "\" direction=\"in\"/>\n";
628  sout << spaces << " <arg name=\"" << m_arg_names[2] << "\" type=\"" << signature<T_arg2>() << "\" direction=\"in\"/>\n";
629  sout << spaces << " <arg name=\"" << m_arg_names[3] << "\" type=\"" << signature<T_arg3>() << "\" direction=\"in\"/>\n";
630  sout << spaces << " <arg name=\"" << m_arg_names[4] << "\" type=\"" << signature<T_arg4>() << "\" direction=\"in\"/>\n";
631  sout << spaces << " <arg name=\"" << m_arg_names[5] << "\" type=\"" << signature<T_arg5>() << "\" direction=\"in\"/>\n";
632  sout << spaces << " <arg name=\"" << m_arg_names[6] << "\" type=\"" << signature<T_arg6>() << "\" direction=\"in\"/>\n";
633  sout << spaces << "</method>\n";
634  return sout.str();
635  }
636 
637  virtual std::string arg_name(size_t i) {
638  if ( i < 6+1 ) return m_arg_names[i];
639  return std::string();
640  }
641 
642  virtual void set_arg_name(size_t i, const std::string& name) {
643  if ( i < 6+1 ) m_arg_names[i] = name;
644  }
645 
646  protected:
647 
648  std::string m_arg_names[6+1];
649 
650  sigc::slot6<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> m_slot;
651 
652  };
653 
654 
655 
656 }
657 
658 #endif
virtual std::string arg_name(size_t i)
Definition: method_impl.h:91
virtual std::string arg_name(size_t i)
Definition: method_impl.h:637
virtual MethodBase::pointer clone()
Definition: method_impl.h:161
virtual HandlerResult handle_call_message(DBusCxxPointer< Connection > connection, CallMessage::const_pointer message)
Definition: method_impl.h:122
void set_method(sigc::slot2< void, T_arg1, T_arg2 > slot)
Definition: method_impl.h:242
DBusCxxPointer< Method > pointer
Definition: method_impl.h:380
virtual void set_arg_name(size_t i, const std::string &name)
Definition: method_impl.h:546
HandlerResult
Definition: enums.h:87
sigc::nil nil
Definition: types.h:36
const std::string & name() const
Definition: methodbase.cpp:42
virtual std::string introspect(int space_depth=0) const
Returns a DBus XML description of this interface.
Definition: method_impl.h:525
Method(const std::string &name)
Definition: method.h:52
std::string m_arg_names[7+1]
Definition: method.h:122
Definition: accumulators.h:24
Method(const std::string &name)
Definition: method_impl.h:118
#define DBUSCXX_DEBUG_STDSTR(logger, message)
Definition: headerlog.h:38
virtual MethodBase::pointer clone()
Definition: method_impl.h:337
virtual std::string arg_name(size_t i)
Definition: method_impl.h:355
DBusCxxPointer< Method > pointer
Definition: method.h:50
static pointer create(const std::string &name)
Definition: method_impl.h:425
static pointer create(const std::string &name)
Definition: method_impl.h:613
virtual void set_arg_name(size_t i, const std::string &name)
Definition: method_impl.h:452
virtual std::string introspect(int space_depth=0) const
Returns a DBus XML description of this interface.
Definition: method_impl.h:80
Definition: enums.h:90
Method(const std::string &name)
Definition: method_impl.h:474
Definition: methodbase.h:39
virtual MethodBase::pointer clone()
Definition: method_impl.h:521
virtual void set_arg_name(size_t i, const std::string &name)
Definition: method_impl.h:96
virtual MethodBase::pointer clone()
Definition: method_impl.h:616
DBusCxxPointer< Method > pointer
Definition: method_impl.h:472
DBusCxxPointer< Method > pointer
Definition: method_impl.h:40
virtual std::string arg_name(size_t i)
Definition: method_impl.h:541
virtual MethodBase::pointer clone()
Definition: method_impl.h:76
void set_method(sigc::slot5< void, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > slot)
Definition: method_impl.h:515
virtual std::string introspect(int space_depth=0) const
Returns a DBus XML description of this interface.
Definition: method_impl.h:620
Method(const std::string &name)
Definition: method_impl.h:42
virtual std::string introspect(int space_depth=0) const
Returns a DBus XML description of this interface.
Definition: method_impl.h:341
Method(const std::string &name)
Definition: method_impl.h:568
DBusCxxPointer< Method > pointer
Definition: method_impl.h:202
static pointer create(const std::string &name)
Definition: method_impl.h:518
static pointer create(const std::string &name)
Definition: method_impl.h:334
DBusCxxPointer< Method > pointer
Definition: method_impl.h:566
virtual HandlerResult handle_call_message(DBusCxxPointer< Connection > connection, CallMessage::const_pointer message)
Definition: method_impl.h:46
Method(const std::string &name)
Definition: method_impl.h:204
DBusCxxPointer< Method > pointer
Definition: method_impl.h:290
virtual HandlerResult handle_call_message(DBusCxxPointer< Connection > connection, CallMessage::const_pointer message)
Definition: method_impl.h:478
virtual std::string arg_name(size_t i)
Definition: method_impl.h:447
Method(const std::string &name)
Definition: method_impl.h:382
static pointer create(const std::string &name)
Definition: method_impl.h:245
DBusCxxPointer< Method > pointer
Definition: method_impl.h:116
std::string m_name
Definition: methodbase.h:76
void set_method(sigc::slot1< void, T_arg1 > slot)
Definition: method_impl.h:155
virtual void set_arg_name(size_t i, const std::string &name)
Definition: method_impl.h:642
virtual void set_arg_name(size_t i, const std::string &name)
Definition: method_impl.h:360
sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > m_slot
Definition: method.h:124
virtual HandlerResult handle_call_message(DBusCxxPointer< Connection > connection, CallMessage::const_pointer message)
Definition: method_impl.h:296
virtual HandlerResult handle_call_message(DBusCxxPointer< Connection > connection, CallMessage::const_pointer message)
Definition: method_impl.h:386
virtual HandlerResult handle_call_message(DBusCxxPointer< Connection > connection, CallMessage::const_pointer message)
Definition: method_impl.h:208
virtual std::string arg_name(size_t i)
Definition: method_impl.h:177
void set_method(sigc::slot3< void, T_arg1, T_arg2, T_arg3 > slot)
Definition: method_impl.h:331
virtual std::string introspect(int space_depth=0) const
Returns a DBus XML description of this interface.
Definition: method_impl.h:165
Method(const std::string &name)
Definition: method_impl.h:292
virtual MethodBase::pointer clone()
Definition: method_impl.h:428
virtual MethodBase::pointer clone()
Definition: method_impl.h:248
static pointer create(const std::string &name)
Definition: method_impl.h:73
virtual std::string introspect(int space_depth=0) const
Returns a DBus XML description of this interface.
Definition: method_impl.h:432
virtual void set_arg_name(size_t i, const std::string &name)
Definition: method_impl.h:270
Extraction iterator allowing values to be retrieved from a message.
Definition: messageiterator.h:37
virtual HandlerResult handle_call_message(DBusCxxPointer< Connection > connection, CallMessage::const_pointer message)
Definition: method_impl.h:572
void set_method(sigc::slot4< void, T_arg1, T_arg2, T_arg3, T_arg4 > slot)
Definition: method_impl.h:422
DBusCxxPointer< const ReturnMessage > const_pointer
Definition: returnmessage.h:54
virtual std::string introspect(int space_depth=0) const
Returns a DBus XML description of this interface.
Definition: method_impl.h:252
Definition: enums.h:89
DBusCxxPointer< MethodBase > pointer
Definition: methodbase.h:49
void set_method(sigc::slot6< void, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > slot)
Definition: method_impl.h:610
DBusCxxPointer< const CallMessage > const_pointer
Definition: callmessage.h:59
void set_method(sigc::slot0< void > slot)
Definition: method_impl.h:70
virtual std::string arg_name(size_t i)
Definition: method_impl.h:265
virtual void set_arg_name(size_t i, const std::string &name)
Definition: method_impl.h:182
static pointer create(const std::string &name)
Definition: method_impl.h:158

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