dbus-cxx logo

dbus_signal.h

Go to the documentation of this file.
00001 
00002 // -*- c++ -*-
00003 /* Do not edit! -- generated file */
00004 
00005 #ifndef DBUS_CXX_SIGNAL_H_
00006 #define DBUS_CXX_SIGNAL_H_
00007 
00008 #include <dbus-cxx/signal_base.h>
00009 
00010 namespace DBus {
00011 
00012   class Interface;
00013 
00029 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>
00030 class signal 
00031   : public sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>, public signal_base
00032 {
00033 public:
00034 
00035   //template <class T_accumulator>
00036   //class accumulated
00037   //: public sigc::signal7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7, T_accumulator>, public signal_base
00038   //{
00039   //public:
00040   //  typedef DBusCxxPointer<accumulated> pointer;
00041   //
00042   //  accumulated(const std::string& interface, const std::string& name):
00043   //    signal_base(interface, name)
00044   //  {
00045   //    m_internal_callback_connection =
00046   //      this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
00047   //      
00048   //    m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
00049   //  }
00050 
00051   //  accumulated(const std::string& path, const std::string& interface, const std::string& name):
00052   //    signal_base(path, interface, name)
00053   //  {
00054   //    m_internal_callback_connection =
00055   //      this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
00056   //      
00057   //    m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
00058   //  }
00059 
00060   //  accumulated(const std::string& interface, const std::string& name, const accumulated& src):
00061   //    sigc::signal7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7, T_accumulator>(src),
00062   //    signal_base(interface, name)
00063   //  {}
00064 
00065   //  accumulated(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src):
00066   //    sigc::signal7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7, T_accumulator>(src),
00067   //    signal_base(path, interface, name)
00068   //  {}
00069 
00070   //  static pointer create(const std::string& interface, const std::string& name)
00071   //  {
00072   //    return pointer( new accumulated(interface, name) );
00073   //  }
00074     
00075   //  static pointer create(const std::string& path, const std::string& interface, const std::string& name)
00076   //  {
00077   //    return pointer( new accumulated(path, interface, name) );
00078   //  }
00079     
00080   //  static pointer create(const std::string& interface, const std::string& name, const accumulated& src)
00081   //  {
00082   //    return pointer( new accumulated(interface, name, src) );
00083   //  }
00084     
00085   //  static pointer create(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src)
00086   //  {
00087   //    return pointer( new accumulated(path, interface, name, src) );
00088   //  }
00089     
00090   //  virtual signal_base::pointer clone()
00091   //  {
00092   //    return signal_base::pointer( new accumulated(*this) );
00093   //  }
00094 
00095   //protected:
00096 
00097   //  sigc::connection m_internal_callback_connection;
00098 
00099   //  virtual HandlerResult on_dbus_incoming( SignalMessage::const_pointer msg )
00100   //  {
00101   //    // T_return _retval;
00102   //      //    
00103   //    T_arg1 _val_1;
00104   //    T_arg2 _val_2;
00105   //    T_arg3 _val_3;
00106   //    T_arg4 _val_4;
00107   //    T_arg5 _val_5;
00108   //    T_arg6 _val_6;
00109   //    T_arg7 _val_7;
00110 
00111   //    m_internal_callback_connection.block();
00112     
00113   //    try {
00114   //      Message::iterator i = msg->begin();
00115   //      i  >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5 >> _val_6 >> _val_7;
00116   //      this->emit(_val_1,_val_2,_val_3,_val_4,_val_5,_val_6,_val_7);
00117   //    }
00118   //    catch ( ErrorInvalidTypecast& e ) {
00119   //      m_internal_callback_connection.unblock();
00120   //      return NOT_HANDLED;
00121   //    }
00122     
00123   //    m_internal_callback_connection.unblock();
00124 
00125   //    return HANDLED;
00126   //  }
00127 
00128 
00129   //  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)
00130   //  {
00131     
00132   //  }
00133 
00134   //};
00135 
00136   typedef DBusCxxPointer<signal> pointer;
00137   
00138   signal(const std::string& interface, const std::string& name):
00139     signal_base(interface, name)
00140   {
00141     m_internal_callback_connection =
00142       this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
00143   }
00144   
00145   signal(const std::string& path, const std::string& interface, const std::string& name):
00146     signal_base(path, interface, name)
00147   {
00148     m_internal_callback_connection =
00149       this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
00150   }
00151   
00152   signal(const std::string& interface, const std::string& name, const signal& src) :
00153     sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(src),
00154     signal_base(interface, name)
00155   { }
00156 
00157   signal(const std::string& path, const std::string& interface, const std::string& name, const signal& src) :
00158     sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(src),
00159     signal_base(path, interface, name)
00160   { }
00161 
00162   static pointer create(const std::string& interface, const std::string& name)
00163   {
00164     return pointer( new signal(interface, name) );
00165   }
00166 
00167   static pointer create(const std::string& path, const std::string& interface, const std::string& name)
00168   {
00169     return pointer( new signal(path, interface, name) );
00170   }
00171 
00172   static pointer create(const std::string& interface, const std::string& name, const signal& src)
00173   {
00174     return pointer( new signal(interface, name, src) );
00175   }
00176 
00177   static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal& src)
00178   {
00179     return pointer( new signal(path, interface, name, src) );
00180   }
00181 
00182   virtual signal_base::pointer clone()
00183   {
00184     return signal_base::pointer( new signal(*this) );
00185   }
00186 
00187   protected:
00188 
00189   friend class Interface;
00190 
00191   sigc::connection m_internal_callback_connection;
00192 
00193   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)
00194   {
00195     DBUS_CXX_DEBUG( "signal::internal_callback: "  << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7 );
00196     SignalMessage::pointer msg = SignalMessage::create(m_path, m_interface, m_name);
00197     if ( not m_destination.empty() ) msg->set_destination(m_destination);
00198     msg  << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7;
00199     bool result = this->handle_dbus_outgoing(msg);
00200     DBUS_CXX_DEBUG( "signal::internal_callback: result=" << result );
00201   }
00202 
00203 };
00204 
00205 
00206 
00222 template <class T_return>
00223 class signal <T_return, nil,nil,nil,nil,nil,nil,nil>
00224   : public sigc::signal<T_return>, public signal_base
00225 {
00226 public:
00227 
00228   //template <class T_accumulator>
00229   //class accumulated
00230   //: public sigc::signal0<T_return, T_accumulator>, public signal_base
00231   //{
00232   //public:
00233   //  typedef DBusCxxPointer<accumulated> pointer;
00234   //
00235   //  accumulated(const std::string& interface, const std::string& name):
00236   //    signal_base(interface, name)
00237   //  {
00238   //    m_internal_callback_connection =
00239   //      this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
00240   //      
00241   //    m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
00242   //  }
00243 
00244   //  accumulated(const std::string& path, const std::string& interface, const std::string& name):
00245   //    signal_base(path, interface, name)
00246   //  {
00247   //    m_internal_callback_connection =
00248   //      this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
00249   //      
00250   //    m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
00251   //  }
00252 
00253   //  accumulated(const std::string& interface, const std::string& name, const accumulated& src):
00254   //    sigc::signal0<T_return, T_accumulator>(src),
00255   //    signal_base(interface, name)
00256   //  {}
00257 
00258   //  accumulated(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src):
00259   //    sigc::signal0<T_return, T_accumulator>(src),
00260   //    signal_base(path, interface, name)
00261   //  {}
00262 
00263   //  static pointer create(const std::string& interface, const std::string& name)
00264   //  {
00265   //    return pointer( new accumulated(interface, name) );
00266   //  }
00267     
00268   //  static pointer create(const std::string& path, const std::string& interface, const std::string& name)
00269   //  {
00270   //    return pointer( new accumulated(path, interface, name) );
00271   //  }
00272     
00273   //  static pointer create(const std::string& interface, const std::string& name, const accumulated& src)
00274   //  {
00275   //    return pointer( new accumulated(interface, name, src) );
00276   //  }
00277     
00278   //  static pointer create(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src)
00279   //  {
00280   //    return pointer( new accumulated(path, interface, name, src) );
00281   //  }
00282     
00283   //  virtual signal_base::pointer clone()
00284   //  {
00285   //    return signal_base::pointer( new accumulated(*this) );
00286   //  }
00287 
00288   //protected:
00289 
00290   //  sigc::connection m_internal_callback_connection;
00291 
00292   //  virtual HandlerResult on_dbus_incoming( SignalMessage::const_pointer msg )
00293   //  {
00294   //    // T_return _retval;
00295   //      //    
00296 
00297   //    m_internal_callback_connection.block();
00298     
00299   //    try {
00300   //      Message::iterator i = msg->begin();
00301   //      i ;
00302   //      this->emit();
00303   //    }
00304   //    catch ( ErrorInvalidTypecast& e ) {
00305   //      m_internal_callback_connection.unblock();
00306   //      return NOT_HANDLED;
00307   //    }
00308     
00309   //    m_internal_callback_connection.unblock();
00310 
00311   //    return HANDLED;
00312   //  }
00313 
00314 
00315   //  T_return internal_callback()
00316   //  {
00317     
00318   //  }
00319 
00320   //};
00321 
00322   typedef DBusCxxPointer<signal> pointer;
00323   
00324   signal(const std::string& interface, const std::string& name):
00325     signal_base(interface, name)
00326   {
00327     m_internal_callback_connection =
00328       this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
00329   }
00330   
00331   signal(const std::string& path, const std::string& interface, const std::string& name):
00332     signal_base(path, interface, name)
00333   {
00334     m_internal_callback_connection =
00335       this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
00336   }
00337   
00338   signal(const std::string& interface, const std::string& name, const signal& src) :
00339     sigc::signal<T_return>(src),
00340     signal_base(interface, name)
00341   { }
00342 
00343   signal(const std::string& path, const std::string& interface, const std::string& name, const signal& src) :
00344     sigc::signal<T_return>(src),
00345     signal_base(path, interface, name)
00346   { }
00347 
00348   static pointer create(const std::string& interface, const std::string& name)
00349   {
00350     return pointer( new signal(interface, name) );
00351   }
00352 
00353   static pointer create(const std::string& path, const std::string& interface, const std::string& name)
00354   {
00355     return pointer( new signal(path, interface, name) );
00356   }
00357 
00358   static pointer create(const std::string& interface, const std::string& name, const signal& src)
00359   {
00360     return pointer( new signal(interface, name, src) );
00361   }
00362 
00363   static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal& src)
00364   {
00365     return pointer( new signal(path, interface, name, src) );
00366   }
00367 
00368   virtual signal_base::pointer clone()
00369   {
00370     return signal_base::pointer( new signal(*this) );
00371   }
00372 
00373   protected:
00374 
00375   friend class Interface;
00376 
00377   sigc::connection m_internal_callback_connection;
00378 
00379   T_return internal_callback()
00380   {
00381     DBUS_CXX_DEBUG( "signal::internal_callback: "  );
00382     SignalMessage::pointer msg = SignalMessage::create(m_path, m_interface, m_name);
00383     if ( not m_destination.empty() ) msg->set_destination(m_destination);
00384     
00385     bool result = this->handle_dbus_outgoing(msg);
00386     DBUS_CXX_DEBUG( "signal::internal_callback: result=" << result );
00387   }
00388 
00389 };
00390 
00391 
00407 template <class T_return, class T_arg1>
00408 class signal <T_return, T_arg1, nil,nil,nil,nil,nil,nil>
00409   : public sigc::signal<T_return, T_arg1>, public signal_base
00410 {
00411 public:
00412 
00413   //template <class T_accumulator>
00414   //class accumulated
00415   //: public sigc::signal1<T_return, T_arg1, T_accumulator>, public signal_base
00416   //{
00417   //public:
00418   //  typedef DBusCxxPointer<accumulated> pointer;
00419   //
00420   //  accumulated(const std::string& interface, const std::string& name):
00421   //    signal_base(interface, name)
00422   //  {
00423   //    m_internal_callback_connection =
00424   //      this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
00425   //      
00426   //    m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
00427   //  }
00428 
00429   //  accumulated(const std::string& path, const std::string& interface, const std::string& name):
00430   //    signal_base(path, interface, name)
00431   //  {
00432   //    m_internal_callback_connection =
00433   //      this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
00434   //      
00435   //    m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
00436   //  }
00437 
00438   //  accumulated(const std::string& interface, const std::string& name, const accumulated& src):
00439   //    sigc::signal1<T_return, T_arg1, T_accumulator>(src),
00440   //    signal_base(interface, name)
00441   //  {}
00442 
00443   //  accumulated(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src):
00444   //    sigc::signal1<T_return, T_arg1, T_accumulator>(src),
00445   //    signal_base(path, interface, name)
00446   //  {}
00447 
00448   //  static pointer create(const std::string& interface, const std::string& name)
00449   //  {
00450   //    return pointer( new accumulated(interface, name) );
00451   //  }
00452     
00453   //  static pointer create(const std::string& path, const std::string& interface, const std::string& name)
00454   //  {
00455   //    return pointer( new accumulated(path, interface, name) );
00456   //  }
00457     
00458   //  static pointer create(const std::string& interface, const std::string& name, const accumulated& src)
00459   //  {
00460   //    return pointer( new accumulated(interface, name, src) );
00461   //  }
00462     
00463   //  static pointer create(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src)
00464   //  {
00465   //    return pointer( new accumulated(path, interface, name, src) );
00466   //  }
00467     
00468   //  virtual signal_base::pointer clone()
00469   //  {
00470   //    return signal_base::pointer( new accumulated(*this) );
00471   //  }
00472 
00473   //protected:
00474 
00475   //  sigc::connection m_internal_callback_connection;
00476 
00477   //  virtual HandlerResult on_dbus_incoming( SignalMessage::const_pointer msg )
00478   //  {
00479   //    // T_return _retval;
00480   //      //    
00481   //    T_arg1 _val_1;
00482 
00483   //    m_internal_callback_connection.block();
00484     
00485   //    try {
00486   //      Message::iterator i = msg->begin();
00487   //      i  >> _val_1;
00488   //      this->emit(_val_1);
00489   //    }
00490   //    catch ( ErrorInvalidTypecast& e ) {
00491   //      m_internal_callback_connection.unblock();
00492   //      return NOT_HANDLED;
00493   //    }
00494     
00495   //    m_internal_callback_connection.unblock();
00496 
00497   //    return HANDLED;
00498   //  }
00499 
00500 
00501   //  T_return internal_callback(T_arg1 arg1)
00502   //  {
00503     
00504   //  }
00505 
00506   //};
00507 
00508   typedef DBusCxxPointer<signal> pointer;
00509   
00510   signal(const std::string& interface, const std::string& name):
00511     signal_base(interface, name)
00512   {
00513     m_internal_callback_connection =
00514       this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
00515   }
00516   
00517   signal(const std::string& path, const std::string& interface, const std::string& name):
00518     signal_base(path, interface, name)
00519   {
00520     m_internal_callback_connection =
00521       this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
00522   }
00523   
00524   signal(const std::string& interface, const std::string& name, const signal& src) :
00525     sigc::signal<T_return, T_arg1>(src),
00526     signal_base(interface, name)
00527   { }
00528 
00529   signal(const std::string& path, const std::string& interface, const std::string& name, const signal& src) :
00530     sigc::signal<T_return, T_arg1>(src),
00531     signal_base(path, interface, name)
00532   { }
00533 
00534   static pointer create(const std::string& interface, const std::string& name)
00535   {
00536     return pointer( new signal(interface, name) );
00537   }
00538 
00539   static pointer create(const std::string& path, const std::string& interface, const std::string& name)
00540   {
00541     return pointer( new signal(path, interface, name) );
00542   }
00543 
00544   static pointer create(const std::string& interface, const std::string& name, const signal& src)
00545   {
00546     return pointer( new signal(interface, name, src) );
00547   }
00548 
00549   static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal& src)
00550   {
00551     return pointer( new signal(path, interface, name, src) );
00552   }
00553 
00554   virtual signal_base::pointer clone()
00555   {
00556     return signal_base::pointer( new signal(*this) );
00557   }
00558 
00559   protected:
00560 
00561   friend class Interface;
00562 
00563   sigc::connection m_internal_callback_connection;
00564 
00565   T_return internal_callback(T_arg1 arg1)
00566   {
00567     DBUS_CXX_DEBUG( "signal::internal_callback: "  << arg1 );
00568     SignalMessage::pointer msg = SignalMessage::create(m_path, m_interface, m_name);
00569     if ( not m_destination.empty() ) msg->set_destination(m_destination);
00570     msg  << arg1;
00571     bool result = this->handle_dbus_outgoing(msg);
00572     DBUS_CXX_DEBUG( "signal::internal_callback: result=" << result );
00573   }
00574 
00575 };
00576 
00577 
00593 template <class T_return, class T_arg1,class T_arg2>
00594 class signal <T_return, T_arg1,T_arg2, nil,nil,nil,nil,nil>
00595   : public sigc::signal<T_return, T_arg1,T_arg2>, public signal_base
00596 {
00597 public:
00598 
00599   //template <class T_accumulator>
00600   //class accumulated
00601   //: public sigc::signal2<T_return, T_arg1,T_arg2, T_accumulator>, public signal_base
00602   //{
00603   //public:
00604   //  typedef DBusCxxPointer<accumulated> pointer;
00605   //
00606   //  accumulated(const std::string& interface, const std::string& name):
00607   //    signal_base(interface, name)
00608   //  {
00609   //    m_internal_callback_connection =
00610   //      this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
00611   //      
00612   //    m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
00613   //  }
00614 
00615   //  accumulated(const std::string& path, const std::string& interface, const std::string& name):
00616   //    signal_base(path, interface, name)
00617   //  {
00618   //    m_internal_callback_connection =
00619   //      this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
00620   //      
00621   //    m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
00622   //  }
00623 
00624   //  accumulated(const std::string& interface, const std::string& name, const accumulated& src):
00625   //    sigc::signal2<T_return, T_arg1,T_arg2, T_accumulator>(src),
00626   //    signal_base(interface, name)
00627   //  {}
00628 
00629   //  accumulated(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src):
00630   //    sigc::signal2<T_return, T_arg1,T_arg2, T_accumulator>(src),
00631   //    signal_base(path, interface, name)
00632   //  {}
00633 
00634   //  static pointer create(const std::string& interface, const std::string& name)
00635   //  {
00636   //    return pointer( new accumulated(interface, name) );
00637   //  }
00638     
00639   //  static pointer create(const std::string& path, const std::string& interface, const std::string& name)
00640   //  {
00641   //    return pointer( new accumulated(path, interface, name) );
00642   //  }
00643     
00644   //  static pointer create(const std::string& interface, const std::string& name, const accumulated& src)
00645   //  {
00646   //    return pointer( new accumulated(interface, name, src) );
00647   //  }
00648     
00649   //  static pointer create(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src)
00650   //  {
00651   //    return pointer( new accumulated(path, interface, name, src) );
00652   //  }
00653     
00654   //  virtual signal_base::pointer clone()
00655   //  {
00656   //    return signal_base::pointer( new accumulated(*this) );
00657   //  }
00658 
00659   //protected:
00660 
00661   //  sigc::connection m_internal_callback_connection;
00662 
00663   //  virtual HandlerResult on_dbus_incoming( SignalMessage::const_pointer msg )
00664   //  {
00665   //    // T_return _retval;
00666   //      //    
00667   //    T_arg1 _val_1;
00668   //    T_arg2 _val_2;
00669 
00670   //    m_internal_callback_connection.block();
00671     
00672   //    try {
00673   //      Message::iterator i = msg->begin();
00674   //      i  >> _val_1 >> _val_2;
00675   //      this->emit(_val_1,_val_2);
00676   //    }
00677   //    catch ( ErrorInvalidTypecast& e ) {
00678   //      m_internal_callback_connection.unblock();
00679   //      return NOT_HANDLED;
00680   //    }
00681     
00682   //    m_internal_callback_connection.unblock();
00683 
00684   //    return HANDLED;
00685   //  }
00686 
00687 
00688   //  T_return internal_callback(T_arg1 arg1,T_arg2 arg2)
00689   //  {
00690     
00691   //  }
00692 
00693   //};
00694 
00695   typedef DBusCxxPointer<signal> pointer;
00696   
00697   signal(const std::string& interface, const std::string& name):
00698     signal_base(interface, name)
00699   {
00700     m_internal_callback_connection =
00701       this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
00702   }
00703   
00704   signal(const std::string& path, const std::string& interface, const std::string& name):
00705     signal_base(path, interface, name)
00706   {
00707     m_internal_callback_connection =
00708       this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
00709   }
00710   
00711   signal(const std::string& interface, const std::string& name, const signal& src) :
00712     sigc::signal<T_return, T_arg1,T_arg2>(src),
00713     signal_base(interface, name)
00714   { }
00715 
00716   signal(const std::string& path, const std::string& interface, const std::string& name, const signal& src) :
00717     sigc::signal<T_return, T_arg1,T_arg2>(src),
00718     signal_base(path, interface, name)
00719   { }
00720 
00721   static pointer create(const std::string& interface, const std::string& name)
00722   {
00723     return pointer( new signal(interface, name) );
00724   }
00725 
00726   static pointer create(const std::string& path, const std::string& interface, const std::string& name)
00727   {
00728     return pointer( new signal(path, interface, name) );
00729   }
00730 
00731   static pointer create(const std::string& interface, const std::string& name, const signal& src)
00732   {
00733     return pointer( new signal(interface, name, src) );
00734   }
00735 
00736   static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal& src)
00737   {
00738     return pointer( new signal(path, interface, name, src) );
00739   }
00740 
00741   virtual signal_base::pointer clone()
00742   {
00743     return signal_base::pointer( new signal(*this) );
00744   }
00745 
00746   protected:
00747 
00748   friend class Interface;
00749 
00750   sigc::connection m_internal_callback_connection;
00751 
00752   T_return internal_callback(T_arg1 arg1,T_arg2 arg2)
00753   {
00754     DBUS_CXX_DEBUG( "signal::internal_callback: "  << arg1 << arg2 );
00755     SignalMessage::pointer msg = SignalMessage::create(m_path, m_interface, m_name);
00756     if ( not m_destination.empty() ) msg->set_destination(m_destination);
00757     msg  << arg1 << arg2;
00758     bool result = this->handle_dbus_outgoing(msg);
00759     DBUS_CXX_DEBUG( "signal::internal_callback: result=" << result );
00760   }
00761 
00762 };
00763 
00764 
00780 template <class T_return, class T_arg1,class T_arg2,class T_arg3>
00781 class signal <T_return, T_arg1,T_arg2,T_arg3, nil,nil,nil,nil>
00782   : public sigc::signal<T_return, T_arg1,T_arg2,T_arg3>, public signal_base
00783 {
00784 public:
00785 
00786   //template <class T_accumulator>
00787   //class accumulated
00788   //: public sigc::signal3<T_return, T_arg1,T_arg2,T_arg3, T_accumulator>, public signal_base
00789   //{
00790   //public:
00791   //  typedef DBusCxxPointer<accumulated> pointer;
00792   //
00793   //  accumulated(const std::string& interface, const std::string& name):
00794   //    signal_base(interface, name)
00795   //  {
00796   //    m_internal_callback_connection =
00797   //      this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
00798   //      
00799   //    m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
00800   //  }
00801 
00802   //  accumulated(const std::string& path, const std::string& interface, const std::string& name):
00803   //    signal_base(path, interface, name)
00804   //  {
00805   //    m_internal_callback_connection =
00806   //      this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
00807   //      
00808   //    m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
00809   //  }
00810 
00811   //  accumulated(const std::string& interface, const std::string& name, const accumulated& src):
00812   //    sigc::signal3<T_return, T_arg1,T_arg2,T_arg3, T_accumulator>(src),
00813   //    signal_base(interface, name)
00814   //  {}
00815 
00816   //  accumulated(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src):
00817   //    sigc::signal3<T_return, T_arg1,T_arg2,T_arg3, T_accumulator>(src),
00818   //    signal_base(path, interface, name)
00819   //  {}
00820 
00821   //  static pointer create(const std::string& interface, const std::string& name)
00822   //  {
00823   //    return pointer( new accumulated(interface, name) );
00824   //  }
00825     
00826   //  static pointer create(const std::string& path, const std::string& interface, const std::string& name)
00827   //  {
00828   //    return pointer( new accumulated(path, interface, name) );
00829   //  }
00830     
00831   //  static pointer create(const std::string& interface, const std::string& name, const accumulated& src)
00832   //  {
00833   //    return pointer( new accumulated(interface, name, src) );
00834   //  }
00835     
00836   //  static pointer create(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src)
00837   //  {
00838   //    return pointer( new accumulated(path, interface, name, src) );
00839   //  }
00840     
00841   //  virtual signal_base::pointer clone()
00842   //  {
00843   //    return signal_base::pointer( new accumulated(*this) );
00844   //  }
00845 
00846   //protected:
00847 
00848   //  sigc::connection m_internal_callback_connection;
00849 
00850   //  virtual HandlerResult on_dbus_incoming( SignalMessage::const_pointer msg )
00851   //  {
00852   //    // T_return _retval;
00853   //      //    
00854   //    T_arg1 _val_1;
00855   //    T_arg2 _val_2;
00856   //    T_arg3 _val_3;
00857 
00858   //    m_internal_callback_connection.block();
00859     
00860   //    try {
00861   //      Message::iterator i = msg->begin();
00862   //      i  >> _val_1 >> _val_2 >> _val_3;
00863   //      this->emit(_val_1,_val_2,_val_3);
00864   //    }
00865   //    catch ( ErrorInvalidTypecast& e ) {
00866   //      m_internal_callback_connection.unblock();
00867   //      return NOT_HANDLED;
00868   //    }
00869     
00870   //    m_internal_callback_connection.unblock();
00871 
00872   //    return HANDLED;
00873   //  }
00874 
00875 
00876   //  T_return internal_callback(T_arg1 arg1,T_arg2 arg2,T_arg3 arg3)
00877   //  {
00878     
00879   //  }
00880 
00881   //};
00882 
00883   typedef DBusCxxPointer<signal> pointer;
00884   
00885   signal(const std::string& interface, const std::string& name):
00886     signal_base(interface, name)
00887   {
00888     m_internal_callback_connection =
00889       this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
00890   }
00891   
00892   signal(const std::string& path, const std::string& interface, const std::string& name):
00893     signal_base(path, interface, name)
00894   {
00895     m_internal_callback_connection =
00896       this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
00897   }
00898   
00899   signal(const std::string& interface, const std::string& name, const signal& src) :
00900     sigc::signal<T_return, T_arg1,T_arg2,T_arg3>(src),
00901     signal_base(interface, name)
00902   { }
00903 
00904   signal(const std::string& path, const std::string& interface, const std::string& name, const signal& src) :
00905     sigc::signal<T_return, T_arg1,T_arg2,T_arg3>(src),
00906     signal_base(path, interface, name)
00907   { }
00908 
00909   static pointer create(const std::string& interface, const std::string& name)
00910   {
00911     return pointer( new signal(interface, name) );
00912   }
00913 
00914   static pointer create(const std::string& path, const std::string& interface, const std::string& name)
00915   {
00916     return pointer( new signal(path, interface, name) );
00917   }
00918 
00919   static pointer create(const std::string& interface, const std::string& name, const signal& src)
00920   {
00921     return pointer( new signal(interface, name, src) );
00922   }
00923 
00924   static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal& src)
00925   {
00926     return pointer( new signal(path, interface, name, src) );
00927   }
00928 
00929   virtual signal_base::pointer clone()
00930   {
00931     return signal_base::pointer( new signal(*this) );
00932   }
00933 
00934   protected:
00935 
00936   friend class Interface;
00937 
00938   sigc::connection m_internal_callback_connection;
00939 
00940   T_return internal_callback(T_arg1 arg1,T_arg2 arg2,T_arg3 arg3)
00941   {
00942     DBUS_CXX_DEBUG( "signal::internal_callback: "  << arg1 << arg2 << arg3 );
00943     SignalMessage::pointer msg = SignalMessage::create(m_path, m_interface, m_name);
00944     if ( not m_destination.empty() ) msg->set_destination(m_destination);
00945     msg  << arg1 << arg2 << arg3;
00946     bool result = this->handle_dbus_outgoing(msg);
00947     DBUS_CXX_DEBUG( "signal::internal_callback: result=" << result );
00948   }
00949 
00950 };
00951 
00952 
00968 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
00969 class signal <T_return, T_arg1,T_arg2,T_arg3,T_arg4, nil,nil,nil>
00970   : public sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4>, public signal_base
00971 {
00972 public:
00973 
00974   //template <class T_accumulator>
00975   //class accumulated
00976   //: public sigc::signal4<T_return, T_arg1,T_arg2,T_arg3,T_arg4, T_accumulator>, public signal_base
00977   //{
00978   //public:
00979   //  typedef DBusCxxPointer<accumulated> pointer;
00980   //
00981   //  accumulated(const std::string& interface, const std::string& name):
00982   //    signal_base(interface, name)
00983   //  {
00984   //    m_internal_callback_connection =
00985   //      this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
00986   //      
00987   //    m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
00988   //  }
00989 
00990   //  accumulated(const std::string& path, const std::string& interface, const std::string& name):
00991   //    signal_base(path, interface, name)
00992   //  {
00993   //    m_internal_callback_connection =
00994   //      this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
00995   //      
00996   //    m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
00997   //  }
00998 
00999   //  accumulated(const std::string& interface, const std::string& name, const accumulated& src):
01000   //    sigc::signal4<T_return, T_arg1,T_arg2,T_arg3,T_arg4, T_accumulator>(src),
01001   //    signal_base(interface, name)
01002   //  {}
01003 
01004   //  accumulated(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src):
01005   //    sigc::signal4<T_return, T_arg1,T_arg2,T_arg3,T_arg4, T_accumulator>(src),
01006   //    signal_base(path, interface, name)
01007   //  {}
01008 
01009   //  static pointer create(const std::string& interface, const std::string& name)
01010   //  {
01011   //    return pointer( new accumulated(interface, name) );
01012   //  }
01013     
01014   //  static pointer create(const std::string& path, const std::string& interface, const std::string& name)
01015   //  {
01016   //    return pointer( new accumulated(path, interface, name) );
01017   //  }
01018     
01019   //  static pointer create(const std::string& interface, const std::string& name, const accumulated& src)
01020   //  {
01021   //    return pointer( new accumulated(interface, name, src) );
01022   //  }
01023     
01024   //  static pointer create(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src)
01025   //  {
01026   //    return pointer( new accumulated(path, interface, name, src) );
01027   //  }
01028     
01029   //  virtual signal_base::pointer clone()
01030   //  {
01031   //    return signal_base::pointer( new accumulated(*this) );
01032   //  }
01033 
01034   //protected:
01035 
01036   //  sigc::connection m_internal_callback_connection;
01037 
01038   //  virtual HandlerResult on_dbus_incoming( SignalMessage::const_pointer msg )
01039   //  {
01040   //    // T_return _retval;
01041   //      //    
01042   //    T_arg1 _val_1;
01043   //    T_arg2 _val_2;
01044   //    T_arg3 _val_3;
01045   //    T_arg4 _val_4;
01046 
01047   //    m_internal_callback_connection.block();
01048     
01049   //    try {
01050   //      Message::iterator i = msg->begin();
01051   //      i  >> _val_1 >> _val_2 >> _val_3 >> _val_4;
01052   //      this->emit(_val_1,_val_2,_val_3,_val_4);
01053   //    }
01054   //    catch ( ErrorInvalidTypecast& e ) {
01055   //      m_internal_callback_connection.unblock();
01056   //      return NOT_HANDLED;
01057   //    }
01058     
01059   //    m_internal_callback_connection.unblock();
01060 
01061   //    return HANDLED;
01062   //  }
01063 
01064 
01065   //  T_return internal_callback(T_arg1 arg1,T_arg2 arg2,T_arg3 arg3,T_arg4 arg4)
01066   //  {
01067     
01068   //  }
01069 
01070   //};
01071 
01072   typedef DBusCxxPointer<signal> pointer;
01073   
01074   signal(const std::string& interface, const std::string& name):
01075     signal_base(interface, name)
01076   {
01077     m_internal_callback_connection =
01078       this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
01079   }
01080   
01081   signal(const std::string& path, const std::string& interface, const std::string& name):
01082     signal_base(path, interface, name)
01083   {
01084     m_internal_callback_connection =
01085       this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
01086   }
01087   
01088   signal(const std::string& interface, const std::string& name, const signal& src) :
01089     sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4>(src),
01090     signal_base(interface, name)
01091   { }
01092 
01093   signal(const std::string& path, const std::string& interface, const std::string& name, const signal& src) :
01094     sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4>(src),
01095     signal_base(path, interface, name)
01096   { }
01097 
01098   static pointer create(const std::string& interface, const std::string& name)
01099   {
01100     return pointer( new signal(interface, name) );
01101   }
01102 
01103   static pointer create(const std::string& path, const std::string& interface, const std::string& name)
01104   {
01105     return pointer( new signal(path, interface, name) );
01106   }
01107 
01108   static pointer create(const std::string& interface, const std::string& name, const signal& src)
01109   {
01110     return pointer( new signal(interface, name, src) );
01111   }
01112 
01113   static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal& src)
01114   {
01115     return pointer( new signal(path, interface, name, src) );
01116   }
01117 
01118   virtual signal_base::pointer clone()
01119   {
01120     return signal_base::pointer( new signal(*this) );
01121   }
01122 
01123   protected:
01124 
01125   friend class Interface;
01126 
01127   sigc::connection m_internal_callback_connection;
01128 
01129   T_return internal_callback(T_arg1 arg1,T_arg2 arg2,T_arg3 arg3,T_arg4 arg4)
01130   {
01131     DBUS_CXX_DEBUG( "signal::internal_callback: "  << arg1 << arg2 << arg3 << arg4 );
01132     SignalMessage::pointer msg = SignalMessage::create(m_path, m_interface, m_name);
01133     if ( not m_destination.empty() ) msg->set_destination(m_destination);
01134     msg  << arg1 << arg2 << arg3 << arg4;
01135     bool result = this->handle_dbus_outgoing(msg);
01136     DBUS_CXX_DEBUG( "signal::internal_callback: result=" << result );
01137   }
01138 
01139 };
01140 
01141 
01157 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
01158 class signal <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, nil,nil>
01159   : public sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>, public signal_base
01160 {
01161 public:
01162 
01163   //template <class T_accumulator>
01164   //class accumulated
01165   //: public sigc::signal5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, T_accumulator>, public signal_base
01166   //{
01167   //public:
01168   //  typedef DBusCxxPointer<accumulated> pointer;
01169   //
01170   //  accumulated(const std::string& interface, const std::string& name):
01171   //    signal_base(interface, name)
01172   //  {
01173   //    m_internal_callback_connection =
01174   //      this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
01175   //      
01176   //    m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
01177   //  }
01178 
01179   //  accumulated(const std::string& path, const std::string& interface, const std::string& name):
01180   //    signal_base(path, interface, name)
01181   //  {
01182   //    m_internal_callback_connection =
01183   //      this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
01184   //      
01185   //    m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
01186   //  }
01187 
01188   //  accumulated(const std::string& interface, const std::string& name, const accumulated& src):
01189   //    sigc::signal5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, T_accumulator>(src),
01190   //    signal_base(interface, name)
01191   //  {}
01192 
01193   //  accumulated(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src):
01194   //    sigc::signal5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, T_accumulator>(src),
01195   //    signal_base(path, interface, name)
01196   //  {}
01197 
01198   //  static pointer create(const std::string& interface, const std::string& name)
01199   //  {
01200   //    return pointer( new accumulated(interface, name) );
01201   //  }
01202     
01203   //  static pointer create(const std::string& path, const std::string& interface, const std::string& name)
01204   //  {
01205   //    return pointer( new accumulated(path, interface, name) );
01206   //  }
01207     
01208   //  static pointer create(const std::string& interface, const std::string& name, const accumulated& src)
01209   //  {
01210   //    return pointer( new accumulated(interface, name, src) );
01211   //  }
01212     
01213   //  static pointer create(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src)
01214   //  {
01215   //    return pointer( new accumulated(path, interface, name, src) );
01216   //  }
01217     
01218   //  virtual signal_base::pointer clone()
01219   //  {
01220   //    return signal_base::pointer( new accumulated(*this) );
01221   //  }
01222 
01223   //protected:
01224 
01225   //  sigc::connection m_internal_callback_connection;
01226 
01227   //  virtual HandlerResult on_dbus_incoming( SignalMessage::const_pointer msg )
01228   //  {
01229   //    // T_return _retval;
01230   //      //    
01231   //    T_arg1 _val_1;
01232   //    T_arg2 _val_2;
01233   //    T_arg3 _val_3;
01234   //    T_arg4 _val_4;
01235   //    T_arg5 _val_5;
01236 
01237   //    m_internal_callback_connection.block();
01238     
01239   //    try {
01240   //      Message::iterator i = msg->begin();
01241   //      i  >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5;
01242   //      this->emit(_val_1,_val_2,_val_3,_val_4,_val_5);
01243   //    }
01244   //    catch ( ErrorInvalidTypecast& e ) {
01245   //      m_internal_callback_connection.unblock();
01246   //      return NOT_HANDLED;
01247   //    }
01248     
01249   //    m_internal_callback_connection.unblock();
01250 
01251   //    return HANDLED;
01252   //  }
01253 
01254 
01255   //  T_return internal_callback(T_arg1 arg1,T_arg2 arg2,T_arg3 arg3,T_arg4 arg4,T_arg5 arg5)
01256   //  {
01257     
01258   //  }
01259 
01260   //};
01261 
01262   typedef DBusCxxPointer<signal> pointer;
01263   
01264   signal(const std::string& interface, const std::string& name):
01265     signal_base(interface, name)
01266   {
01267     m_internal_callback_connection =
01268       this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
01269   }
01270   
01271   signal(const std::string& path, const std::string& interface, const std::string& name):
01272     signal_base(path, interface, name)
01273   {
01274     m_internal_callback_connection =
01275       this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
01276   }
01277   
01278   signal(const std::string& interface, const std::string& name, const signal& src) :
01279     sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(src),
01280     signal_base(interface, name)
01281   { }
01282 
01283   signal(const std::string& path, const std::string& interface, const std::string& name, const signal& src) :
01284     sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(src),
01285     signal_base(path, interface, name)
01286   { }
01287 
01288   static pointer create(const std::string& interface, const std::string& name)
01289   {
01290     return pointer( new signal(interface, name) );
01291   }
01292 
01293   static pointer create(const std::string& path, const std::string& interface, const std::string& name)
01294   {
01295     return pointer( new signal(path, interface, name) );
01296   }
01297 
01298   static pointer create(const std::string& interface, const std::string& name, const signal& src)
01299   {
01300     return pointer( new signal(interface, name, src) );
01301   }
01302 
01303   static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal& src)
01304   {
01305     return pointer( new signal(path, interface, name, src) );
01306   }
01307 
01308   virtual signal_base::pointer clone()
01309   {
01310     return signal_base::pointer( new signal(*this) );
01311   }
01312 
01313   protected:
01314 
01315   friend class Interface;
01316 
01317   sigc::connection m_internal_callback_connection;
01318 
01319   T_return internal_callback(T_arg1 arg1,T_arg2 arg2,T_arg3 arg3,T_arg4 arg4,T_arg5 arg5)
01320   {
01321     DBUS_CXX_DEBUG( "signal::internal_callback: "  << arg1 << arg2 << arg3 << arg4 << arg5 );
01322     SignalMessage::pointer msg = SignalMessage::create(m_path, m_interface, m_name);
01323     if ( not m_destination.empty() ) msg->set_destination(m_destination);
01324     msg  << arg1 << arg2 << arg3 << arg4 << arg5;
01325     bool result = this->handle_dbus_outgoing(msg);
01326     DBUS_CXX_DEBUG( "signal::internal_callback: result=" << result );
01327   }
01328 
01329 };
01330 
01331 
01347 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
01348 class signal <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, nil>
01349   : public sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>, public signal_base
01350 {
01351 public:
01352 
01353   //template <class T_accumulator>
01354   //class accumulated
01355   //: public sigc::signal6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, T_accumulator>, public signal_base
01356   //{
01357   //public:
01358   //  typedef DBusCxxPointer<accumulated> pointer;
01359   //
01360   //  accumulated(const std::string& interface, const std::string& name):
01361   //    signal_base(interface, name)
01362   //  {
01363   //    m_internal_callback_connection =
01364   //      this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
01365   //      
01366   //    m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
01367   //  }
01368 
01369   //  accumulated(const std::string& path, const std::string& interface, const std::string& name):
01370   //    signal_base(path, interface, name)
01371   //  {
01372   //    m_internal_callback_connection =
01373   //      this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
01374   //      
01375   //    m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
01376   //  }
01377 
01378   //  accumulated(const std::string& interface, const std::string& name, const accumulated& src):
01379   //    sigc::signal6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, T_accumulator>(src),
01380   //    signal_base(interface, name)
01381   //  {}
01382 
01383   //  accumulated(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src):
01384   //    sigc::signal6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, T_accumulator>(src),
01385   //    signal_base(path, interface, name)
01386   //  {}
01387 
01388   //  static pointer create(const std::string& interface, const std::string& name)
01389   //  {
01390   //    return pointer( new accumulated(interface, name) );
01391   //  }
01392     
01393   //  static pointer create(const std::string& path, const std::string& interface, const std::string& name)
01394   //  {
01395   //    return pointer( new accumulated(path, interface, name) );
01396   //  }
01397     
01398   //  static pointer create(const std::string& interface, const std::string& name, const accumulated& src)
01399   //  {
01400   //    return pointer( new accumulated(interface, name, src) );
01401   //  }
01402     
01403   //  static pointer create(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src)
01404   //  {
01405   //    return pointer( new accumulated(path, interface, name, src) );
01406   //  }
01407     
01408   //  virtual signal_base::pointer clone()
01409   //  {
01410   //    return signal_base::pointer( new accumulated(*this) );
01411   //  }
01412 
01413   //protected:
01414 
01415   //  sigc::connection m_internal_callback_connection;
01416 
01417   //  virtual HandlerResult on_dbus_incoming( SignalMessage::const_pointer msg )
01418   //  {
01419   //    // T_return _retval;
01420   //      //    
01421   //    T_arg1 _val_1;
01422   //    T_arg2 _val_2;
01423   //    T_arg3 _val_3;
01424   //    T_arg4 _val_4;
01425   //    T_arg5 _val_5;
01426   //    T_arg6 _val_6;
01427 
01428   //    m_internal_callback_connection.block();
01429     
01430   //    try {
01431   //      Message::iterator i = msg->begin();
01432   //      i  >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5 >> _val_6;
01433   //      this->emit(_val_1,_val_2,_val_3,_val_4,_val_5,_val_6);
01434   //    }
01435   //    catch ( ErrorInvalidTypecast& e ) {
01436   //      m_internal_callback_connection.unblock();
01437   //      return NOT_HANDLED;
01438   //    }
01439     
01440   //    m_internal_callback_connection.unblock();
01441 
01442   //    return HANDLED;
01443   //  }
01444 
01445 
01446   //  T_return internal_callback(T_arg1 arg1,T_arg2 arg2,T_arg3 arg3,T_arg4 arg4,T_arg5 arg5,T_arg6 arg6)
01447   //  {
01448     
01449   //  }
01450 
01451   //};
01452 
01453   typedef DBusCxxPointer<signal> pointer;
01454   
01455   signal(const std::string& interface, const std::string& name):
01456     signal_base(interface, name)
01457   {
01458     m_internal_callback_connection =
01459       this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
01460   }
01461   
01462   signal(const std::string& path, const std::string& interface, const std::string& name):
01463     signal_base(path, interface, name)
01464   {
01465     m_internal_callback_connection =
01466       this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
01467   }
01468   
01469   signal(const std::string& interface, const std::string& name, const signal& src) :
01470     sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(src),
01471     signal_base(interface, name)
01472   { }
01473 
01474   signal(const std::string& path, const std::string& interface, const std::string& name, const signal& src) :
01475     sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(src),
01476     signal_base(path, interface, name)
01477   { }
01478 
01479   static pointer create(const std::string& interface, const std::string& name)
01480   {
01481     return pointer( new signal(interface, name) );
01482   }
01483 
01484   static pointer create(const std::string& path, const std::string& interface, const std::string& name)
01485   {
01486     return pointer( new signal(path, interface, name) );
01487   }
01488 
01489   static pointer create(const std::string& interface, const std::string& name, const signal& src)
01490   {
01491     return pointer( new signal(interface, name, src) );
01492   }
01493 
01494   static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal& src)
01495   {
01496     return pointer( new signal(path, interface, name, src) );
01497   }
01498 
01499   virtual signal_base::pointer clone()
01500   {
01501     return signal_base::pointer( new signal(*this) );
01502   }
01503 
01504   protected:
01505 
01506   friend class Interface;
01507 
01508   sigc::connection m_internal_callback_connection;
01509 
01510   T_return internal_callback(T_arg1 arg1,T_arg2 arg2,T_arg3 arg3,T_arg4 arg4,T_arg5 arg5,T_arg6 arg6)
01511   {
01512     DBUS_CXX_DEBUG( "signal::internal_callback: "  << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 );
01513     SignalMessage::pointer msg = SignalMessage::create(m_path, m_interface, m_name);
01514     if ( not m_destination.empty() ) msg->set_destination(m_destination);
01515     msg  << arg1 << arg2 << arg3 << arg4 << arg5 << arg6;
01516     bool result = this->handle_dbus_outgoing(msg);
01517     DBUS_CXX_DEBUG( "signal::internal_callback: result=" << result );
01518   }
01519 
01520 };
01521 
01522 
01523 
01524 } /* namespace DBus */
01525 
01526 #endif /* _DBUS_CXX_SIGNAL_H_ */

Generated on Thu May 28 16:50:50 2009 for dbus-cxx by doxygen 1.5.7.1