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 <sstream>
00009 #include <dbus-cxx/signal_base.h>
00010 
00011 namespace DBus {
00012 
00013   class Interface;
00014 
00030 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>
00031 class signal 
00032   : public sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>, public signal_base
00033 {
00034 public:
00035 
00036   //template <class T_accumulator>
00037   //class accumulated
00038   //: public sigc::signal7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7, T_accumulator>, public signal_base
00039   //{
00040   //public:
00041   //  typedef DBusCxxPointer<accumulated> pointer;
00042   //
00043   //  accumulated(const std::string& interface, const std::string& name):
00044   //    signal_base(interface, name)
00045   //  {
00046   //    m_internal_callback_connection =
00047   //      this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
00048   //      
00049   //    m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
00050   //  }
00051 
00052   //  accumulated(const std::string& path, const std::string& interface, const std::string& name):
00053   //    signal_base(path, interface, name)
00054   //  {
00055   //    m_internal_callback_connection =
00056   //      this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
00057   //      
00058   //    m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
00059   //  }
00060 
00061   //  accumulated(const std::string& interface, const std::string& name, const accumulated& src):
00062   //    sigc::signal7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7, T_accumulator>(src),
00063   //    signal_base(interface, name)
00064   //  {}
00065 
00066   //  accumulated(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src):
00067   //    sigc::signal7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7, T_accumulator>(src),
00068   //    signal_base(path, interface, name)
00069   //  {}
00070 
00071   //  static pointer create(const std::string& interface, const std::string& name)
00072   //  {
00073   //    return pointer( new accumulated(interface, name) );
00074   //  }
00075     
00076   //  static pointer create(const std::string& path, const std::string& interface, const std::string& name)
00077   //  {
00078   //    return pointer( new accumulated(path, interface, name) );
00079   //  }
00080     
00081   //  static pointer create(const std::string& interface, const std::string& name, const accumulated& src)
00082   //  {
00083   //    return pointer( new accumulated(interface, name, src) );
00084   //  }
00085     
00086   //  static pointer create(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src)
00087   //  {
00088   //    return pointer( new accumulated(path, interface, name, src) );
00089   //  }
00090     
00091   //  virtual signal_base::pointer clone()
00092   //  {
00093   //    return signal_base::pointer( new accumulated(*this) );
00094   //  }
00095 
00096   //protected:
00097 
00098   //  sigc::connection m_internal_callback_connection;
00099 
00100   //  virtual HandlerResult on_dbus_incoming( SignalMessage::const_pointer msg )
00101   //  {
00102   //    // T_return _retval;
00103   //      //    
00104   //    T_arg1 _val_1;
00105   //    T_arg2 _val_2;
00106   //    T_arg3 _val_3;
00107   //    T_arg4 _val_4;
00108   //    T_arg5 _val_5;
00109   //    T_arg6 _val_6;
00110   //    T_arg7 _val_7;
00111 
00112   //    m_internal_callback_connection.block();
00113     
00114   //    try {
00115   //      Message::iterator i = msg->begin();
00116   //      i  >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5 >> _val_6 >> _val_7;
00117   //      this->emit(_val_1,_val_2,_val_3,_val_4,_val_5,_val_6,_val_7);
00118   //    }
00119   //    catch ( ErrorInvalidTypecast& e ) {
00120   //      m_internal_callback_connection.unblock();
00121   //      return NOT_HANDLED;
00122   //    }
00123     
00124   //    m_internal_callback_connection.unblock();
00125 
00126   //    return HANDLED;
00127   //  }
00128 
00129 
00130   //  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)
00131   //  {
00132     
00133   //  }
00134 
00135   //};
00136 
00137   typedef DBusCxxPointer<signal> pointer;
00138   
00139   signal(const std::string& interface, const std::string& name):
00140     signal_base(interface, name)
00141   {
00142     m_internal_callback_connection =
00143       this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
00144   }
00145   
00146   signal(const std::string& path, const std::string& interface, const std::string& name):
00147     signal_base(path, interface, name)
00148   {
00149     m_internal_callback_connection =
00150       this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
00151   }
00152   
00153   signal(const std::string& interface, const std::string& name, const signal& src) :
00154     sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(src),
00155     signal_base(interface, name)
00156   { }
00157 
00158   signal(const std::string& path, const std::string& interface, const std::string& name, const signal& src) :
00159     sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(src),
00160     signal_base(path, interface, name)
00161   { }
00162 
00163   static pointer create(const std::string& interface, const std::string& name)
00164   {
00165     return pointer( new signal(interface, name) );
00166   }
00167 
00168   static pointer create(const std::string& path, const std::string& interface, const std::string& name)
00169   {
00170     return pointer( new signal(path, interface, name) );
00171   }
00172 
00173   static pointer create(const std::string& interface, const std::string& name, const signal& src)
00174   {
00175     return pointer( new signal(interface, name, src) );
00176   }
00177 
00178   static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal& src)
00179   {
00180     return pointer( new signal(path, interface, name, src) );
00181   }
00182 
00183   virtual signal_base::pointer clone()
00184   {
00185     return signal_base::pointer( new signal(*this) );
00186   }
00187 
00189   virtual std::string introspect(int space_depth=0) const
00190   {
00191     std::ostringstream sout;
00192     std::string spaces;
00193     for (int i=0; i < space_depth; i++ ) spaces += " ";
00194     sout << spaces << "<signal name=\"" << name() << "\">\n";
00195     
00196     sout << spaces << "  <arg name=\"" << m_arg_names[1-1] << "\" type=\"" << signature<T_arg1>() << "\"/>\n";
00197     sout << spaces << "  <arg name=\"" << m_arg_names[2-1] << "\" type=\"" << signature<T_arg2>() << "\"/>\n";
00198     sout << spaces << "  <arg name=\"" << m_arg_names[3-1] << "\" type=\"" << signature<T_arg3>() << "\"/>\n";
00199     sout << spaces << "  <arg name=\"" << m_arg_names[4-1] << "\" type=\"" << signature<T_arg4>() << "\"/>\n";
00200     sout << spaces << "  <arg name=\"" << m_arg_names[5-1] << "\" type=\"" << signature<T_arg5>() << "\"/>\n";
00201     sout << spaces << "  <arg name=\"" << m_arg_names[6-1] << "\" type=\"" << signature<T_arg6>() << "\"/>\n";
00202     sout << spaces << "  <arg name=\"" << m_arg_names[7-1] << "\" type=\"" << signature<T_arg7>() << "\"/>\n";
00203     sout << spaces << "</signal>\n";
00204     return sout.str();
00205   }
00206 
00207   virtual std::string arg_name(size_t i) {
00208     if ( i < 7 ) return m_arg_names[i];
00209     return std::string();
00210   }
00211 
00212   virtual void set_arg_name(size_t i, const std::string& name) {
00213     if ( i < 7 ) m_arg_names[i] = name;
00214   }
00215 
00216   protected:
00217 
00218   friend class Interface;
00219 
00220   std::string m_arg_names[7];
00221 
00222   sigc::connection m_internal_callback_connection;
00223 
00224   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)
00225   {
00226     DBUS_CXX_DEBUG( "signal::internal_callback: "  << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7 );
00227     SignalMessage::pointer __msg = SignalMessage::create(m_path, m_interface, m_name);
00228     if ( not m_destination.empty() ) __msg->set_destination(m_destination);
00229     *__msg  << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7;
00230     #ifdef DBUS_CXX_DEBUG_ENABLED
00231       bool result = this->handle_dbus_outgoing(__msg);
00232       DBUS_CXX_DEBUG( "signal::internal_callback: result=" << result );
00233     #else
00234       this->handle_dbus_outgoing(__msg);
00235     #endif
00236   }
00237 
00238 };
00239 
00240 
00241 
00257 template <class T_return>
00258 class signal <T_return, nil,nil,nil,nil,nil,nil,nil>
00259   : public sigc::signal<T_return>, public signal_base
00260 {
00261 public:
00262 
00263   //template <class T_accumulator>
00264   //class accumulated
00265   //: public sigc::signal0<T_return, T_accumulator>, public signal_base
00266   //{
00267   //public:
00268   //  typedef DBusCxxPointer<accumulated> pointer;
00269   //
00270   //  accumulated(const std::string& interface, const std::string& name):
00271   //    signal_base(interface, name)
00272   //  {
00273   //    m_internal_callback_connection =
00274   //      this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
00275   //      
00276   //    m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
00277   //  }
00278 
00279   //  accumulated(const std::string& path, const std::string& interface, const std::string& name):
00280   //    signal_base(path, interface, name)
00281   //  {
00282   //    m_internal_callback_connection =
00283   //      this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
00284   //      
00285   //    m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
00286   //  }
00287 
00288   //  accumulated(const std::string& interface, const std::string& name, const accumulated& src):
00289   //    sigc::signal0<T_return, T_accumulator>(src),
00290   //    signal_base(interface, name)
00291   //  {}
00292 
00293   //  accumulated(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src):
00294   //    sigc::signal0<T_return, T_accumulator>(src),
00295   //    signal_base(path, interface, name)
00296   //  {}
00297 
00298   //  static pointer create(const std::string& interface, const std::string& name)
00299   //  {
00300   //    return pointer( new accumulated(interface, name) );
00301   //  }
00302     
00303   //  static pointer create(const std::string& path, const std::string& interface, const std::string& name)
00304   //  {
00305   //    return pointer( new accumulated(path, interface, name) );
00306   //  }
00307     
00308   //  static pointer create(const std::string& interface, const std::string& name, const accumulated& src)
00309   //  {
00310   //    return pointer( new accumulated(interface, name, src) );
00311   //  }
00312     
00313   //  static pointer create(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src)
00314   //  {
00315   //    return pointer( new accumulated(path, interface, name, src) );
00316   //  }
00317     
00318   //  virtual signal_base::pointer clone()
00319   //  {
00320   //    return signal_base::pointer( new accumulated(*this) );
00321   //  }
00322 
00323   //protected:
00324 
00325   //  sigc::connection m_internal_callback_connection;
00326 
00327   //  virtual HandlerResult on_dbus_incoming( SignalMessage::const_pointer msg )
00328   //  {
00329   //    // T_return _retval;
00330   //      //    
00331 
00332   //    m_internal_callback_connection.block();
00333     
00334   //    try {
00335   //      Message::iterator i = msg->begin();
00336   //      i ;
00337   //      this->emit();
00338   //    }
00339   //    catch ( ErrorInvalidTypecast& e ) {
00340   //      m_internal_callback_connection.unblock();
00341   //      return NOT_HANDLED;
00342   //    }
00343     
00344   //    m_internal_callback_connection.unblock();
00345 
00346   //    return HANDLED;
00347   //  }
00348 
00349 
00350   //  T_return internal_callback()
00351   //  {
00352     
00353   //  }
00354 
00355   //};
00356 
00357   typedef DBusCxxPointer<signal> pointer;
00358   
00359   signal(const std::string& interface, const std::string& name):
00360     signal_base(interface, name)
00361   {
00362     m_internal_callback_connection =
00363       this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
00364   }
00365   
00366   signal(const std::string& path, const std::string& interface, const std::string& name):
00367     signal_base(path, interface, name)
00368   {
00369     m_internal_callback_connection =
00370       this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
00371   }
00372   
00373   signal(const std::string& interface, const std::string& name, const signal& src) :
00374     sigc::signal<T_return>(src),
00375     signal_base(interface, name)
00376   { }
00377 
00378   signal(const std::string& path, const std::string& interface, const std::string& name, const signal& src) :
00379     sigc::signal<T_return>(src),
00380     signal_base(path, interface, name)
00381   { }
00382 
00383   static pointer create(const std::string& interface, const std::string& name)
00384   {
00385     return pointer( new signal(interface, name) );
00386   }
00387 
00388   static pointer create(const std::string& path, const std::string& interface, const std::string& name)
00389   {
00390     return pointer( new signal(path, interface, name) );
00391   }
00392 
00393   static pointer create(const std::string& interface, const std::string& name, const signal& src)
00394   {
00395     return pointer( new signal(interface, name, src) );
00396   }
00397 
00398   static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal& src)
00399   {
00400     return pointer( new signal(path, interface, name, src) );
00401   }
00402 
00403   virtual signal_base::pointer clone()
00404   {
00405     return signal_base::pointer( new signal(*this) );
00406   }
00407 
00409   virtual std::string introspect(int space_depth=0) const
00410   {
00411     std::ostringstream sout;
00412     std::string spaces;
00413     for (int i=0; i < space_depth; i++ ) spaces += " ";
00414     sout << spaces << "<signal name=\"" << name() << "\">\n";
00415     
00416     sout << spaces << "</signal>\n";
00417     return sout.str();
00418   }
00419 
00420   virtual std::string arg_name(size_t i) {
00421     if ( i < 0 ) return m_arg_names[i];
00422     return std::string();
00423   }
00424 
00425   virtual void set_arg_name(size_t i, const std::string& name) {
00426     if ( i < 0 ) m_arg_names[i] = name;
00427   }
00428 
00429   protected:
00430 
00431   friend class Interface;
00432 
00433   std::string m_arg_names[0];
00434 
00435   sigc::connection m_internal_callback_connection;
00436 
00437   T_return internal_callback()
00438   {
00439     DBUS_CXX_DEBUG( "signal::internal_callback: "  );
00440     SignalMessage::pointer __msg = SignalMessage::create(m_path, m_interface, m_name);
00441     if ( not m_destination.empty() ) __msg->set_destination(m_destination);
00442     
00443     #ifdef DBUS_CXX_DEBUG_ENABLED
00444       bool result = this->handle_dbus_outgoing(__msg);
00445       DBUS_CXX_DEBUG( "signal::internal_callback: result=" << result );
00446     #else
00447       this->handle_dbus_outgoing(__msg);
00448     #endif
00449   }
00450 
00451 };
00452 
00453 
00469 template <class T_return, class T_arg1>
00470 class signal <T_return, T_arg1, nil,nil,nil,nil,nil,nil>
00471   : public sigc::signal<T_return, T_arg1>, public signal_base
00472 {
00473 public:
00474 
00475   //template <class T_accumulator>
00476   //class accumulated
00477   //: public sigc::signal1<T_return, T_arg1, T_accumulator>, public signal_base
00478   //{
00479   //public:
00480   //  typedef DBusCxxPointer<accumulated> pointer;
00481   //
00482   //  accumulated(const std::string& interface, const std::string& name):
00483   //    signal_base(interface, name)
00484   //  {
00485   //    m_internal_callback_connection =
00486   //      this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
00487   //      
00488   //    m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
00489   //  }
00490 
00491   //  accumulated(const std::string& path, const std::string& interface, const std::string& name):
00492   //    signal_base(path, interface, name)
00493   //  {
00494   //    m_internal_callback_connection =
00495   //      this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
00496   //      
00497   //    m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
00498   //  }
00499 
00500   //  accumulated(const std::string& interface, const std::string& name, const accumulated& src):
00501   //    sigc::signal1<T_return, T_arg1, T_accumulator>(src),
00502   //    signal_base(interface, name)
00503   //  {}
00504 
00505   //  accumulated(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src):
00506   //    sigc::signal1<T_return, T_arg1, T_accumulator>(src),
00507   //    signal_base(path, interface, name)
00508   //  {}
00509 
00510   //  static pointer create(const std::string& interface, const std::string& name)
00511   //  {
00512   //    return pointer( new accumulated(interface, name) );
00513   //  }
00514     
00515   //  static pointer create(const std::string& path, const std::string& interface, const std::string& name)
00516   //  {
00517   //    return pointer( new accumulated(path, interface, name) );
00518   //  }
00519     
00520   //  static pointer create(const std::string& interface, const std::string& name, const accumulated& src)
00521   //  {
00522   //    return pointer( new accumulated(interface, name, src) );
00523   //  }
00524     
00525   //  static pointer create(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src)
00526   //  {
00527   //    return pointer( new accumulated(path, interface, name, src) );
00528   //  }
00529     
00530   //  virtual signal_base::pointer clone()
00531   //  {
00532   //    return signal_base::pointer( new accumulated(*this) );
00533   //  }
00534 
00535   //protected:
00536 
00537   //  sigc::connection m_internal_callback_connection;
00538 
00539   //  virtual HandlerResult on_dbus_incoming( SignalMessage::const_pointer msg )
00540   //  {
00541   //    // T_return _retval;
00542   //      //    
00543   //    T_arg1 _val_1;
00544 
00545   //    m_internal_callback_connection.block();
00546     
00547   //    try {
00548   //      Message::iterator i = msg->begin();
00549   //      i  >> _val_1;
00550   //      this->emit(_val_1);
00551   //    }
00552   //    catch ( ErrorInvalidTypecast& e ) {
00553   //      m_internal_callback_connection.unblock();
00554   //      return NOT_HANDLED;
00555   //    }
00556     
00557   //    m_internal_callback_connection.unblock();
00558 
00559   //    return HANDLED;
00560   //  }
00561 
00562 
00563   //  T_return internal_callback(T_arg1 arg1)
00564   //  {
00565     
00566   //  }
00567 
00568   //};
00569 
00570   typedef DBusCxxPointer<signal> pointer;
00571   
00572   signal(const std::string& interface, const std::string& name):
00573     signal_base(interface, name)
00574   {
00575     m_internal_callback_connection =
00576       this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
00577   }
00578   
00579   signal(const std::string& path, const std::string& interface, const std::string& name):
00580     signal_base(path, interface, name)
00581   {
00582     m_internal_callback_connection =
00583       this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
00584   }
00585   
00586   signal(const std::string& interface, const std::string& name, const signal& src) :
00587     sigc::signal<T_return, T_arg1>(src),
00588     signal_base(interface, name)
00589   { }
00590 
00591   signal(const std::string& path, const std::string& interface, const std::string& name, const signal& src) :
00592     sigc::signal<T_return, T_arg1>(src),
00593     signal_base(path, interface, name)
00594   { }
00595 
00596   static pointer create(const std::string& interface, const std::string& name)
00597   {
00598     return pointer( new signal(interface, name) );
00599   }
00600 
00601   static pointer create(const std::string& path, const std::string& interface, const std::string& name)
00602   {
00603     return pointer( new signal(path, interface, name) );
00604   }
00605 
00606   static pointer create(const std::string& interface, const std::string& name, const signal& src)
00607   {
00608     return pointer( new signal(interface, name, src) );
00609   }
00610 
00611   static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal& src)
00612   {
00613     return pointer( new signal(path, interface, name, src) );
00614   }
00615 
00616   virtual signal_base::pointer clone()
00617   {
00618     return signal_base::pointer( new signal(*this) );
00619   }
00620 
00622   virtual std::string introspect(int space_depth=0) const
00623   {
00624     std::ostringstream sout;
00625     std::string spaces;
00626     for (int i=0; i < space_depth; i++ ) spaces += " ";
00627     sout << spaces << "<signal name=\"" << name() << "\">\n";
00628     
00629     sout << spaces << "  <arg name=\"" << m_arg_names[1-1] << "\" type=\"" << signature<T_arg1>() << "\"/>\n";
00630     sout << spaces << "</signal>\n";
00631     return sout.str();
00632   }
00633 
00634   virtual std::string arg_name(size_t i) {
00635     if ( i < 1 ) return m_arg_names[i];
00636     return std::string();
00637   }
00638 
00639   virtual void set_arg_name(size_t i, const std::string& name) {
00640     if ( i < 1 ) m_arg_names[i] = name;
00641   }
00642 
00643   protected:
00644 
00645   friend class Interface;
00646 
00647   std::string m_arg_names[1];
00648 
00649   sigc::connection m_internal_callback_connection;
00650 
00651   T_return internal_callback(T_arg1 arg1)
00652   {
00653     DBUS_CXX_DEBUG( "signal::internal_callback: "  << arg1 );
00654     SignalMessage::pointer __msg = SignalMessage::create(m_path, m_interface, m_name);
00655     if ( not m_destination.empty() ) __msg->set_destination(m_destination);
00656     *__msg  << arg1;
00657     #ifdef DBUS_CXX_DEBUG_ENABLED
00658       bool result = this->handle_dbus_outgoing(__msg);
00659       DBUS_CXX_DEBUG( "signal::internal_callback: result=" << result );
00660     #else
00661       this->handle_dbus_outgoing(__msg);
00662     #endif
00663   }
00664 
00665 };
00666 
00667 
00683 template <class T_return, class T_arg1,class T_arg2>
00684 class signal <T_return, T_arg1,T_arg2, nil,nil,nil,nil,nil>
00685   : public sigc::signal<T_return, T_arg1,T_arg2>, public signal_base
00686 {
00687 public:
00688 
00689   //template <class T_accumulator>
00690   //class accumulated
00691   //: public sigc::signal2<T_return, T_arg1,T_arg2, T_accumulator>, public signal_base
00692   //{
00693   //public:
00694   //  typedef DBusCxxPointer<accumulated> pointer;
00695   //
00696   //  accumulated(const std::string& interface, const std::string& name):
00697   //    signal_base(interface, name)
00698   //  {
00699   //    m_internal_callback_connection =
00700   //      this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
00701   //      
00702   //    m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
00703   //  }
00704 
00705   //  accumulated(const std::string& path, const std::string& interface, const std::string& name):
00706   //    signal_base(path, interface, name)
00707   //  {
00708   //    m_internal_callback_connection =
00709   //      this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
00710   //      
00711   //    m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
00712   //  }
00713 
00714   //  accumulated(const std::string& interface, const std::string& name, const accumulated& src):
00715   //    sigc::signal2<T_return, T_arg1,T_arg2, T_accumulator>(src),
00716   //    signal_base(interface, name)
00717   //  {}
00718 
00719   //  accumulated(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src):
00720   //    sigc::signal2<T_return, T_arg1,T_arg2, T_accumulator>(src),
00721   //    signal_base(path, interface, name)
00722   //  {}
00723 
00724   //  static pointer create(const std::string& interface, const std::string& name)
00725   //  {
00726   //    return pointer( new accumulated(interface, name) );
00727   //  }
00728     
00729   //  static pointer create(const std::string& path, const std::string& interface, const std::string& name)
00730   //  {
00731   //    return pointer( new accumulated(path, interface, name) );
00732   //  }
00733     
00734   //  static pointer create(const std::string& interface, const std::string& name, const accumulated& src)
00735   //  {
00736   //    return pointer( new accumulated(interface, name, src) );
00737   //  }
00738     
00739   //  static pointer create(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src)
00740   //  {
00741   //    return pointer( new accumulated(path, interface, name, src) );
00742   //  }
00743     
00744   //  virtual signal_base::pointer clone()
00745   //  {
00746   //    return signal_base::pointer( new accumulated(*this) );
00747   //  }
00748 
00749   //protected:
00750 
00751   //  sigc::connection m_internal_callback_connection;
00752 
00753   //  virtual HandlerResult on_dbus_incoming( SignalMessage::const_pointer msg )
00754   //  {
00755   //    // T_return _retval;
00756   //      //    
00757   //    T_arg1 _val_1;
00758   //    T_arg2 _val_2;
00759 
00760   //    m_internal_callback_connection.block();
00761     
00762   //    try {
00763   //      Message::iterator i = msg->begin();
00764   //      i  >> _val_1 >> _val_2;
00765   //      this->emit(_val_1,_val_2);
00766   //    }
00767   //    catch ( ErrorInvalidTypecast& e ) {
00768   //      m_internal_callback_connection.unblock();
00769   //      return NOT_HANDLED;
00770   //    }
00771     
00772   //    m_internal_callback_connection.unblock();
00773 
00774   //    return HANDLED;
00775   //  }
00776 
00777 
00778   //  T_return internal_callback(T_arg1 arg1,T_arg2 arg2)
00779   //  {
00780     
00781   //  }
00782 
00783   //};
00784 
00785   typedef DBusCxxPointer<signal> pointer;
00786   
00787   signal(const std::string& interface, const std::string& name):
00788     signal_base(interface, name)
00789   {
00790     m_internal_callback_connection =
00791       this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
00792   }
00793   
00794   signal(const std::string& path, const std::string& interface, const std::string& name):
00795     signal_base(path, interface, name)
00796   {
00797     m_internal_callback_connection =
00798       this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
00799   }
00800   
00801   signal(const std::string& interface, const std::string& name, const signal& src) :
00802     sigc::signal<T_return, T_arg1,T_arg2>(src),
00803     signal_base(interface, name)
00804   { }
00805 
00806   signal(const std::string& path, const std::string& interface, const std::string& name, const signal& src) :
00807     sigc::signal<T_return, T_arg1,T_arg2>(src),
00808     signal_base(path, interface, name)
00809   { }
00810 
00811   static pointer create(const std::string& interface, const std::string& name)
00812   {
00813     return pointer( new signal(interface, name) );
00814   }
00815 
00816   static pointer create(const std::string& path, const std::string& interface, const std::string& name)
00817   {
00818     return pointer( new signal(path, interface, name) );
00819   }
00820 
00821   static pointer create(const std::string& interface, const std::string& name, const signal& src)
00822   {
00823     return pointer( new signal(interface, name, src) );
00824   }
00825 
00826   static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal& src)
00827   {
00828     return pointer( new signal(path, interface, name, src) );
00829   }
00830 
00831   virtual signal_base::pointer clone()
00832   {
00833     return signal_base::pointer( new signal(*this) );
00834   }
00835 
00837   virtual std::string introspect(int space_depth=0) const
00838   {
00839     std::ostringstream sout;
00840     std::string spaces;
00841     for (int i=0; i < space_depth; i++ ) spaces += " ";
00842     sout << spaces << "<signal name=\"" << name() << "\">\n";
00843     
00844     sout << spaces << "  <arg name=\"" << m_arg_names[1-1] << "\" type=\"" << signature<T_arg1>() << "\"/>\n";
00845     sout << spaces << "  <arg name=\"" << m_arg_names[2-1] << "\" type=\"" << signature<T_arg2>() << "\"/>\n";
00846     sout << spaces << "</signal>\n";
00847     return sout.str();
00848   }
00849 
00850   virtual std::string arg_name(size_t i) {
00851     if ( i < 2 ) return m_arg_names[i];
00852     return std::string();
00853   }
00854 
00855   virtual void set_arg_name(size_t i, const std::string& name) {
00856     if ( i < 2 ) m_arg_names[i] = name;
00857   }
00858 
00859   protected:
00860 
00861   friend class Interface;
00862 
00863   std::string m_arg_names[2];
00864 
00865   sigc::connection m_internal_callback_connection;
00866 
00867   T_return internal_callback(T_arg1 arg1,T_arg2 arg2)
00868   {
00869     DBUS_CXX_DEBUG( "signal::internal_callback: "  << arg1 << arg2 );
00870     SignalMessage::pointer __msg = SignalMessage::create(m_path, m_interface, m_name);
00871     if ( not m_destination.empty() ) __msg->set_destination(m_destination);
00872     *__msg  << arg1 << arg2;
00873     #ifdef DBUS_CXX_DEBUG_ENABLED
00874       bool result = this->handle_dbus_outgoing(__msg);
00875       DBUS_CXX_DEBUG( "signal::internal_callback: result=" << result );
00876     #else
00877       this->handle_dbus_outgoing(__msg);
00878     #endif
00879   }
00880 
00881 };
00882 
00883 
00899 template <class T_return, class T_arg1,class T_arg2,class T_arg3>
00900 class signal <T_return, T_arg1,T_arg2,T_arg3, nil,nil,nil,nil>
00901   : public sigc::signal<T_return, T_arg1,T_arg2,T_arg3>, public signal_base
00902 {
00903 public:
00904 
00905   //template <class T_accumulator>
00906   //class accumulated
00907   //: public sigc::signal3<T_return, T_arg1,T_arg2,T_arg3, T_accumulator>, public signal_base
00908   //{
00909   //public:
00910   //  typedef DBusCxxPointer<accumulated> pointer;
00911   //
00912   //  accumulated(const std::string& interface, const std::string& name):
00913   //    signal_base(interface, name)
00914   //  {
00915   //    m_internal_callback_connection =
00916   //      this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
00917   //      
00918   //    m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
00919   //  }
00920 
00921   //  accumulated(const std::string& path, const std::string& interface, const std::string& name):
00922   //    signal_base(path, interface, name)
00923   //  {
00924   //    m_internal_callback_connection =
00925   //      this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
00926   //      
00927   //    m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
00928   //  }
00929 
00930   //  accumulated(const std::string& interface, const std::string& name, const accumulated& src):
00931   //    sigc::signal3<T_return, T_arg1,T_arg2,T_arg3, T_accumulator>(src),
00932   //    signal_base(interface, name)
00933   //  {}
00934 
00935   //  accumulated(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src):
00936   //    sigc::signal3<T_return, T_arg1,T_arg2,T_arg3, T_accumulator>(src),
00937   //    signal_base(path, interface, name)
00938   //  {}
00939 
00940   //  static pointer create(const std::string& interface, const std::string& name)
00941   //  {
00942   //    return pointer( new accumulated(interface, name) );
00943   //  }
00944     
00945   //  static pointer create(const std::string& path, const std::string& interface, const std::string& name)
00946   //  {
00947   //    return pointer( new accumulated(path, interface, name) );
00948   //  }
00949     
00950   //  static pointer create(const std::string& interface, const std::string& name, const accumulated& src)
00951   //  {
00952   //    return pointer( new accumulated(interface, name, src) );
00953   //  }
00954     
00955   //  static pointer create(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src)
00956   //  {
00957   //    return pointer( new accumulated(path, interface, name, src) );
00958   //  }
00959     
00960   //  virtual signal_base::pointer clone()
00961   //  {
00962   //    return signal_base::pointer( new accumulated(*this) );
00963   //  }
00964 
00965   //protected:
00966 
00967   //  sigc::connection m_internal_callback_connection;
00968 
00969   //  virtual HandlerResult on_dbus_incoming( SignalMessage::const_pointer msg )
00970   //  {
00971   //    // T_return _retval;
00972   //      //    
00973   //    T_arg1 _val_1;
00974   //    T_arg2 _val_2;
00975   //    T_arg3 _val_3;
00976 
00977   //    m_internal_callback_connection.block();
00978     
00979   //    try {
00980   //      Message::iterator i = msg->begin();
00981   //      i  >> _val_1 >> _val_2 >> _val_3;
00982   //      this->emit(_val_1,_val_2,_val_3);
00983   //    }
00984   //    catch ( ErrorInvalidTypecast& e ) {
00985   //      m_internal_callback_connection.unblock();
00986   //      return NOT_HANDLED;
00987   //    }
00988     
00989   //    m_internal_callback_connection.unblock();
00990 
00991   //    return HANDLED;
00992   //  }
00993 
00994 
00995   //  T_return internal_callback(T_arg1 arg1,T_arg2 arg2,T_arg3 arg3)
00996   //  {
00997     
00998   //  }
00999 
01000   //};
01001 
01002   typedef DBusCxxPointer<signal> pointer;
01003   
01004   signal(const std::string& interface, const std::string& name):
01005     signal_base(interface, name)
01006   {
01007     m_internal_callback_connection =
01008       this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
01009   }
01010   
01011   signal(const std::string& path, const std::string& interface, const std::string& name):
01012     signal_base(path, interface, name)
01013   {
01014     m_internal_callback_connection =
01015       this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
01016   }
01017   
01018   signal(const std::string& interface, const std::string& name, const signal& src) :
01019     sigc::signal<T_return, T_arg1,T_arg2,T_arg3>(src),
01020     signal_base(interface, name)
01021   { }
01022 
01023   signal(const std::string& path, const std::string& interface, const std::string& name, const signal& src) :
01024     sigc::signal<T_return, T_arg1,T_arg2,T_arg3>(src),
01025     signal_base(path, interface, name)
01026   { }
01027 
01028   static pointer create(const std::string& interface, const std::string& name)
01029   {
01030     return pointer( new signal(interface, name) );
01031   }
01032 
01033   static pointer create(const std::string& path, const std::string& interface, const std::string& name)
01034   {
01035     return pointer( new signal(path, interface, name) );
01036   }
01037 
01038   static pointer create(const std::string& interface, const std::string& name, const signal& src)
01039   {
01040     return pointer( new signal(interface, name, src) );
01041   }
01042 
01043   static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal& src)
01044   {
01045     return pointer( new signal(path, interface, name, src) );
01046   }
01047 
01048   virtual signal_base::pointer clone()
01049   {
01050     return signal_base::pointer( new signal(*this) );
01051   }
01052 
01054   virtual std::string introspect(int space_depth=0) const
01055   {
01056     std::ostringstream sout;
01057     std::string spaces;
01058     for (int i=0; i < space_depth; i++ ) spaces += " ";
01059     sout << spaces << "<signal name=\"" << name() << "\">\n";
01060     
01061     sout << spaces << "  <arg name=\"" << m_arg_names[1-1] << "\" type=\"" << signature<T_arg1>() << "\"/>\n";
01062     sout << spaces << "  <arg name=\"" << m_arg_names[2-1] << "\" type=\"" << signature<T_arg2>() << "\"/>\n";
01063     sout << spaces << "  <arg name=\"" << m_arg_names[3-1] << "\" type=\"" << signature<T_arg3>() << "\"/>\n";
01064     sout << spaces << "</signal>\n";
01065     return sout.str();
01066   }
01067 
01068   virtual std::string arg_name(size_t i) {
01069     if ( i < 3 ) return m_arg_names[i];
01070     return std::string();
01071   }
01072 
01073   virtual void set_arg_name(size_t i, const std::string& name) {
01074     if ( i < 3 ) m_arg_names[i] = name;
01075   }
01076 
01077   protected:
01078 
01079   friend class Interface;
01080 
01081   std::string m_arg_names[3];
01082 
01083   sigc::connection m_internal_callback_connection;
01084 
01085   T_return internal_callback(T_arg1 arg1,T_arg2 arg2,T_arg3 arg3)
01086   {
01087     DBUS_CXX_DEBUG( "signal::internal_callback: "  << arg1 << arg2 << arg3 );
01088     SignalMessage::pointer __msg = SignalMessage::create(m_path, m_interface, m_name);
01089     if ( not m_destination.empty() ) __msg->set_destination(m_destination);
01090     *__msg  << arg1 << arg2 << arg3;
01091     #ifdef DBUS_CXX_DEBUG_ENABLED
01092       bool result = this->handle_dbus_outgoing(__msg);
01093       DBUS_CXX_DEBUG( "signal::internal_callback: result=" << result );
01094     #else
01095       this->handle_dbus_outgoing(__msg);
01096     #endif
01097   }
01098 
01099 };
01100 
01101 
01117 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
01118 class signal <T_return, T_arg1,T_arg2,T_arg3,T_arg4, nil,nil,nil>
01119   : public sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4>, public signal_base
01120 {
01121 public:
01122 
01123   //template <class T_accumulator>
01124   //class accumulated
01125   //: public sigc::signal4<T_return, T_arg1,T_arg2,T_arg3,T_arg4, T_accumulator>, public signal_base
01126   //{
01127   //public:
01128   //  typedef DBusCxxPointer<accumulated> pointer;
01129   //
01130   //  accumulated(const std::string& interface, const std::string& name):
01131   //    signal_base(interface, name)
01132   //  {
01133   //    m_internal_callback_connection =
01134   //      this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
01135   //      
01136   //    m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
01137   //  }
01138 
01139   //  accumulated(const std::string& path, const std::string& interface, const std::string& name):
01140   //    signal_base(path, interface, name)
01141   //  {
01142   //    m_internal_callback_connection =
01143   //      this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
01144   //      
01145   //    m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
01146   //  }
01147 
01148   //  accumulated(const std::string& interface, const std::string& name, const accumulated& src):
01149   //    sigc::signal4<T_return, T_arg1,T_arg2,T_arg3,T_arg4, T_accumulator>(src),
01150   //    signal_base(interface, name)
01151   //  {}
01152 
01153   //  accumulated(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src):
01154   //    sigc::signal4<T_return, T_arg1,T_arg2,T_arg3,T_arg4, T_accumulator>(src),
01155   //    signal_base(path, interface, name)
01156   //  {}
01157 
01158   //  static pointer create(const std::string& interface, const std::string& name)
01159   //  {
01160   //    return pointer( new accumulated(interface, name) );
01161   //  }
01162     
01163   //  static pointer create(const std::string& path, const std::string& interface, const std::string& name)
01164   //  {
01165   //    return pointer( new accumulated(path, interface, name) );
01166   //  }
01167     
01168   //  static pointer create(const std::string& interface, const std::string& name, const accumulated& src)
01169   //  {
01170   //    return pointer( new accumulated(interface, name, src) );
01171   //  }
01172     
01173   //  static pointer create(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src)
01174   //  {
01175   //    return pointer( new accumulated(path, interface, name, src) );
01176   //  }
01177     
01178   //  virtual signal_base::pointer clone()
01179   //  {
01180   //    return signal_base::pointer( new accumulated(*this) );
01181   //  }
01182 
01183   //protected:
01184 
01185   //  sigc::connection m_internal_callback_connection;
01186 
01187   //  virtual HandlerResult on_dbus_incoming( SignalMessage::const_pointer msg )
01188   //  {
01189   //    // T_return _retval;
01190   //      //    
01191   //    T_arg1 _val_1;
01192   //    T_arg2 _val_2;
01193   //    T_arg3 _val_3;
01194   //    T_arg4 _val_4;
01195 
01196   //    m_internal_callback_connection.block();
01197     
01198   //    try {
01199   //      Message::iterator i = msg->begin();
01200   //      i  >> _val_1 >> _val_2 >> _val_3 >> _val_4;
01201   //      this->emit(_val_1,_val_2,_val_3,_val_4);
01202   //    }
01203   //    catch ( ErrorInvalidTypecast& e ) {
01204   //      m_internal_callback_connection.unblock();
01205   //      return NOT_HANDLED;
01206   //    }
01207     
01208   //    m_internal_callback_connection.unblock();
01209 
01210   //    return HANDLED;
01211   //  }
01212 
01213 
01214   //  T_return internal_callback(T_arg1 arg1,T_arg2 arg2,T_arg3 arg3,T_arg4 arg4)
01215   //  {
01216     
01217   //  }
01218 
01219   //};
01220 
01221   typedef DBusCxxPointer<signal> pointer;
01222   
01223   signal(const std::string& interface, const std::string& name):
01224     signal_base(interface, name)
01225   {
01226     m_internal_callback_connection =
01227       this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
01228   }
01229   
01230   signal(const std::string& path, const std::string& interface, const std::string& name):
01231     signal_base(path, interface, name)
01232   {
01233     m_internal_callback_connection =
01234       this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
01235   }
01236   
01237   signal(const std::string& interface, const std::string& name, const signal& src) :
01238     sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4>(src),
01239     signal_base(interface, name)
01240   { }
01241 
01242   signal(const std::string& path, const std::string& interface, const std::string& name, const signal& src) :
01243     sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4>(src),
01244     signal_base(path, interface, name)
01245   { }
01246 
01247   static pointer create(const std::string& interface, const std::string& name)
01248   {
01249     return pointer( new signal(interface, name) );
01250   }
01251 
01252   static pointer create(const std::string& path, const std::string& interface, const std::string& name)
01253   {
01254     return pointer( new signal(path, interface, name) );
01255   }
01256 
01257   static pointer create(const std::string& interface, const std::string& name, const signal& src)
01258   {
01259     return pointer( new signal(interface, name, src) );
01260   }
01261 
01262   static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal& src)
01263   {
01264     return pointer( new signal(path, interface, name, src) );
01265   }
01266 
01267   virtual signal_base::pointer clone()
01268   {
01269     return signal_base::pointer( new signal(*this) );
01270   }
01271 
01273   virtual std::string introspect(int space_depth=0) const
01274   {
01275     std::ostringstream sout;
01276     std::string spaces;
01277     for (int i=0; i < space_depth; i++ ) spaces += " ";
01278     sout << spaces << "<signal name=\"" << name() << "\">\n";
01279     
01280     sout << spaces << "  <arg name=\"" << m_arg_names[1-1] << "\" type=\"" << signature<T_arg1>() << "\"/>\n";
01281     sout << spaces << "  <arg name=\"" << m_arg_names[2-1] << "\" type=\"" << signature<T_arg2>() << "\"/>\n";
01282     sout << spaces << "  <arg name=\"" << m_arg_names[3-1] << "\" type=\"" << signature<T_arg3>() << "\"/>\n";
01283     sout << spaces << "  <arg name=\"" << m_arg_names[4-1] << "\" type=\"" << signature<T_arg4>() << "\"/>\n";
01284     sout << spaces << "</signal>\n";
01285     return sout.str();
01286   }
01287 
01288   virtual std::string arg_name(size_t i) {
01289     if ( i < 4 ) return m_arg_names[i];
01290     return std::string();
01291   }
01292 
01293   virtual void set_arg_name(size_t i, const std::string& name) {
01294     if ( i < 4 ) m_arg_names[i] = name;
01295   }
01296 
01297   protected:
01298 
01299   friend class Interface;
01300 
01301   std::string m_arg_names[4];
01302 
01303   sigc::connection m_internal_callback_connection;
01304 
01305   T_return internal_callback(T_arg1 arg1,T_arg2 arg2,T_arg3 arg3,T_arg4 arg4)
01306   {
01307     DBUS_CXX_DEBUG( "signal::internal_callback: "  << arg1 << arg2 << arg3 << arg4 );
01308     SignalMessage::pointer __msg = SignalMessage::create(m_path, m_interface, m_name);
01309     if ( not m_destination.empty() ) __msg->set_destination(m_destination);
01310     *__msg  << arg1 << arg2 << arg3 << arg4;
01311     #ifdef DBUS_CXX_DEBUG_ENABLED
01312       bool result = this->handle_dbus_outgoing(__msg);
01313       DBUS_CXX_DEBUG( "signal::internal_callback: result=" << result );
01314     #else
01315       this->handle_dbus_outgoing(__msg);
01316     #endif
01317   }
01318 
01319 };
01320 
01321 
01337 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
01338 class signal <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, nil,nil>
01339   : public sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>, public signal_base
01340 {
01341 public:
01342 
01343   //template <class T_accumulator>
01344   //class accumulated
01345   //: public sigc::signal5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, T_accumulator>, public signal_base
01346   //{
01347   //public:
01348   //  typedef DBusCxxPointer<accumulated> pointer;
01349   //
01350   //  accumulated(const std::string& interface, const std::string& name):
01351   //    signal_base(interface, name)
01352   //  {
01353   //    m_internal_callback_connection =
01354   //      this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
01355   //      
01356   //    m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
01357   //  }
01358 
01359   //  accumulated(const std::string& path, const std::string& interface, const std::string& name):
01360   //    signal_base(path, interface, name)
01361   //  {
01362   //    m_internal_callback_connection =
01363   //      this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
01364   //      
01365   //    m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
01366   //  }
01367 
01368   //  accumulated(const std::string& interface, const std::string& name, const accumulated& src):
01369   //    sigc::signal5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, T_accumulator>(src),
01370   //    signal_base(interface, name)
01371   //  {}
01372 
01373   //  accumulated(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src):
01374   //    sigc::signal5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, T_accumulator>(src),
01375   //    signal_base(path, interface, name)
01376   //  {}
01377 
01378   //  static pointer create(const std::string& interface, const std::string& name)
01379   //  {
01380   //    return pointer( new accumulated(interface, name) );
01381   //  }
01382     
01383   //  static pointer create(const std::string& path, const std::string& interface, const std::string& name)
01384   //  {
01385   //    return pointer( new accumulated(path, interface, name) );
01386   //  }
01387     
01388   //  static pointer create(const std::string& interface, const std::string& name, const accumulated& src)
01389   //  {
01390   //    return pointer( new accumulated(interface, name, src) );
01391   //  }
01392     
01393   //  static pointer create(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src)
01394   //  {
01395   //    return pointer( new accumulated(path, interface, name, src) );
01396   //  }
01397     
01398   //  virtual signal_base::pointer clone()
01399   //  {
01400   //    return signal_base::pointer( new accumulated(*this) );
01401   //  }
01402 
01403   //protected:
01404 
01405   //  sigc::connection m_internal_callback_connection;
01406 
01407   //  virtual HandlerResult on_dbus_incoming( SignalMessage::const_pointer msg )
01408   //  {
01409   //    // T_return _retval;
01410   //      //    
01411   //    T_arg1 _val_1;
01412   //    T_arg2 _val_2;
01413   //    T_arg3 _val_3;
01414   //    T_arg4 _val_4;
01415   //    T_arg5 _val_5;
01416 
01417   //    m_internal_callback_connection.block();
01418     
01419   //    try {
01420   //      Message::iterator i = msg->begin();
01421   //      i  >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5;
01422   //      this->emit(_val_1,_val_2,_val_3,_val_4,_val_5);
01423   //    }
01424   //    catch ( ErrorInvalidTypecast& e ) {
01425   //      m_internal_callback_connection.unblock();
01426   //      return NOT_HANDLED;
01427   //    }
01428     
01429   //    m_internal_callback_connection.unblock();
01430 
01431   //    return HANDLED;
01432   //  }
01433 
01434 
01435   //  T_return internal_callback(T_arg1 arg1,T_arg2 arg2,T_arg3 arg3,T_arg4 arg4,T_arg5 arg5)
01436   //  {
01437     
01438   //  }
01439 
01440   //};
01441 
01442   typedef DBusCxxPointer<signal> pointer;
01443   
01444   signal(const std::string& interface, const std::string& name):
01445     signal_base(interface, name)
01446   {
01447     m_internal_callback_connection =
01448       this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
01449   }
01450   
01451   signal(const std::string& path, const std::string& interface, const std::string& name):
01452     signal_base(path, interface, name)
01453   {
01454     m_internal_callback_connection =
01455       this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
01456   }
01457   
01458   signal(const std::string& interface, const std::string& name, const signal& src) :
01459     sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(src),
01460     signal_base(interface, name)
01461   { }
01462 
01463   signal(const std::string& path, const std::string& interface, const std::string& name, const signal& src) :
01464     sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(src),
01465     signal_base(path, interface, name)
01466   { }
01467 
01468   static pointer create(const std::string& interface, const std::string& name)
01469   {
01470     return pointer( new signal(interface, name) );
01471   }
01472 
01473   static pointer create(const std::string& path, const std::string& interface, const std::string& name)
01474   {
01475     return pointer( new signal(path, interface, name) );
01476   }
01477 
01478   static pointer create(const std::string& interface, const std::string& name, const signal& src)
01479   {
01480     return pointer( new signal(interface, name, src) );
01481   }
01482 
01483   static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal& src)
01484   {
01485     return pointer( new signal(path, interface, name, src) );
01486   }
01487 
01488   virtual signal_base::pointer clone()
01489   {
01490     return signal_base::pointer( new signal(*this) );
01491   }
01492 
01494   virtual std::string introspect(int space_depth=0) const
01495   {
01496     std::ostringstream sout;
01497     std::string spaces;
01498     for (int i=0; i < space_depth; i++ ) spaces += " ";
01499     sout << spaces << "<signal name=\"" << name() << "\">\n";
01500     
01501     sout << spaces << "  <arg name=\"" << m_arg_names[1-1] << "\" type=\"" << signature<T_arg1>() << "\"/>\n";
01502     sout << spaces << "  <arg name=\"" << m_arg_names[2-1] << "\" type=\"" << signature<T_arg2>() << "\"/>\n";
01503     sout << spaces << "  <arg name=\"" << m_arg_names[3-1] << "\" type=\"" << signature<T_arg3>() << "\"/>\n";
01504     sout << spaces << "  <arg name=\"" << m_arg_names[4-1] << "\" type=\"" << signature<T_arg4>() << "\"/>\n";
01505     sout << spaces << "  <arg name=\"" << m_arg_names[5-1] << "\" type=\"" << signature<T_arg5>() << "\"/>\n";
01506     sout << spaces << "</signal>\n";
01507     return sout.str();
01508   }
01509 
01510   virtual std::string arg_name(size_t i) {
01511     if ( i < 5 ) return m_arg_names[i];
01512     return std::string();
01513   }
01514 
01515   virtual void set_arg_name(size_t i, const std::string& name) {
01516     if ( i < 5 ) m_arg_names[i] = name;
01517   }
01518 
01519   protected:
01520 
01521   friend class Interface;
01522 
01523   std::string m_arg_names[5];
01524 
01525   sigc::connection m_internal_callback_connection;
01526 
01527   T_return internal_callback(T_arg1 arg1,T_arg2 arg2,T_arg3 arg3,T_arg4 arg4,T_arg5 arg5)
01528   {
01529     DBUS_CXX_DEBUG( "signal::internal_callback: "  << arg1 << arg2 << arg3 << arg4 << arg5 );
01530     SignalMessage::pointer __msg = SignalMessage::create(m_path, m_interface, m_name);
01531     if ( not m_destination.empty() ) __msg->set_destination(m_destination);
01532     *__msg  << arg1 << arg2 << arg3 << arg4 << arg5;
01533     #ifdef DBUS_CXX_DEBUG_ENABLED
01534       bool result = this->handle_dbus_outgoing(__msg);
01535       DBUS_CXX_DEBUG( "signal::internal_callback: result=" << result );
01536     #else
01537       this->handle_dbus_outgoing(__msg);
01538     #endif
01539   }
01540 
01541 };
01542 
01543 
01559 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
01560 class signal <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, nil>
01561   : public sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>, public signal_base
01562 {
01563 public:
01564 
01565   //template <class T_accumulator>
01566   //class accumulated
01567   //: public sigc::signal6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, T_accumulator>, public signal_base
01568   //{
01569   //public:
01570   //  typedef DBusCxxPointer<accumulated> pointer;
01571   //
01572   //  accumulated(const std::string& interface, const std::string& name):
01573   //    signal_base(interface, name)
01574   //  {
01575   //    m_internal_callback_connection =
01576   //      this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
01577   //      
01578   //    m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
01579   //  }
01580 
01581   //  accumulated(const std::string& path, const std::string& interface, const std::string& name):
01582   //    signal_base(path, interface, name)
01583   //  {
01584   //    m_internal_callback_connection =
01585   //      this->connect( sigc::mem_fun(*this, &accumulated::internal_callback) );
01586   //      
01587   //    m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &accumulated::on_dbus_incoming) );
01588   //  }
01589 
01590   //  accumulated(const std::string& interface, const std::string& name, const accumulated& src):
01591   //    sigc::signal6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, T_accumulator>(src),
01592   //    signal_base(interface, name)
01593   //  {}
01594 
01595   //  accumulated(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src):
01596   //    sigc::signal6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, T_accumulator>(src),
01597   //    signal_base(path, interface, name)
01598   //  {}
01599 
01600   //  static pointer create(const std::string& interface, const std::string& name)
01601   //  {
01602   //    return pointer( new accumulated(interface, name) );
01603   //  }
01604     
01605   //  static pointer create(const std::string& path, const std::string& interface, const std::string& name)
01606   //  {
01607   //    return pointer( new accumulated(path, interface, name) );
01608   //  }
01609     
01610   //  static pointer create(const std::string& interface, const std::string& name, const accumulated& src)
01611   //  {
01612   //    return pointer( new accumulated(interface, name, src) );
01613   //  }
01614     
01615   //  static pointer create(const std::string& path, const std::string& interface, const std::string& name, const accumulated& src)
01616   //  {
01617   //    return pointer( new accumulated(path, interface, name, src) );
01618   //  }
01619     
01620   //  virtual signal_base::pointer clone()
01621   //  {
01622   //    return signal_base::pointer( new accumulated(*this) );
01623   //  }
01624 
01625   //protected:
01626 
01627   //  sigc::connection m_internal_callback_connection;
01628 
01629   //  virtual HandlerResult on_dbus_incoming( SignalMessage::const_pointer msg )
01630   //  {
01631   //    // T_return _retval;
01632   //      //    
01633   //    T_arg1 _val_1;
01634   //    T_arg2 _val_2;
01635   //    T_arg3 _val_3;
01636   //    T_arg4 _val_4;
01637   //    T_arg5 _val_5;
01638   //    T_arg6 _val_6;
01639 
01640   //    m_internal_callback_connection.block();
01641     
01642   //    try {
01643   //      Message::iterator i = msg->begin();
01644   //      i  >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5 >> _val_6;
01645   //      this->emit(_val_1,_val_2,_val_3,_val_4,_val_5,_val_6);
01646   //    }
01647   //    catch ( ErrorInvalidTypecast& e ) {
01648   //      m_internal_callback_connection.unblock();
01649   //      return NOT_HANDLED;
01650   //    }
01651     
01652   //    m_internal_callback_connection.unblock();
01653 
01654   //    return HANDLED;
01655   //  }
01656 
01657 
01658   //  T_return internal_callback(T_arg1 arg1,T_arg2 arg2,T_arg3 arg3,T_arg4 arg4,T_arg5 arg5,T_arg6 arg6)
01659   //  {
01660     
01661   //  }
01662 
01663   //};
01664 
01665   typedef DBusCxxPointer<signal> pointer;
01666   
01667   signal(const std::string& interface, const std::string& name):
01668     signal_base(interface, name)
01669   {
01670     m_internal_callback_connection =
01671       this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
01672   }
01673   
01674   signal(const std::string& path, const std::string& interface, const std::string& name):
01675     signal_base(path, interface, name)
01676   {
01677     m_internal_callback_connection =
01678       this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
01679   }
01680   
01681   signal(const std::string& interface, const std::string& name, const signal& src) :
01682     sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(src),
01683     signal_base(interface, name)
01684   { }
01685 
01686   signal(const std::string& path, const std::string& interface, const std::string& name, const signal& src) :
01687     sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(src),
01688     signal_base(path, interface, name)
01689   { }
01690 
01691   static pointer create(const std::string& interface, const std::string& name)
01692   {
01693     return pointer( new signal(interface, name) );
01694   }
01695 
01696   static pointer create(const std::string& path, const std::string& interface, const std::string& name)
01697   {
01698     return pointer( new signal(path, interface, name) );
01699   }
01700 
01701   static pointer create(const std::string& interface, const std::string& name, const signal& src)
01702   {
01703     return pointer( new signal(interface, name, src) );
01704   }
01705 
01706   static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal& src)
01707   {
01708     return pointer( new signal(path, interface, name, src) );
01709   }
01710 
01711   virtual signal_base::pointer clone()
01712   {
01713     return signal_base::pointer( new signal(*this) );
01714   }
01715 
01717   virtual std::string introspect(int space_depth=0) const
01718   {
01719     std::ostringstream sout;
01720     std::string spaces;
01721     for (int i=0; i < space_depth; i++ ) spaces += " ";
01722     sout << spaces << "<signal name=\"" << name() << "\">\n";
01723     
01724     sout << spaces << "  <arg name=\"" << m_arg_names[1-1] << "\" type=\"" << signature<T_arg1>() << "\"/>\n";
01725     sout << spaces << "  <arg name=\"" << m_arg_names[2-1] << "\" type=\"" << signature<T_arg2>() << "\"/>\n";
01726     sout << spaces << "  <arg name=\"" << m_arg_names[3-1] << "\" type=\"" << signature<T_arg3>() << "\"/>\n";
01727     sout << spaces << "  <arg name=\"" << m_arg_names[4-1] << "\" type=\"" << signature<T_arg4>() << "\"/>\n";
01728     sout << spaces << "  <arg name=\"" << m_arg_names[5-1] << "\" type=\"" << signature<T_arg5>() << "\"/>\n";
01729     sout << spaces << "  <arg name=\"" << m_arg_names[6-1] << "\" type=\"" << signature<T_arg6>() << "\"/>\n";
01730     sout << spaces << "</signal>\n";
01731     return sout.str();
01732   }
01733 
01734   virtual std::string arg_name(size_t i) {
01735     if ( i < 6 ) return m_arg_names[i];
01736     return std::string();
01737   }
01738 
01739   virtual void set_arg_name(size_t i, const std::string& name) {
01740     if ( i < 6 ) m_arg_names[i] = name;
01741   }
01742 
01743   protected:
01744 
01745   friend class Interface;
01746 
01747   std::string m_arg_names[6];
01748 
01749   sigc::connection m_internal_callback_connection;
01750 
01751   T_return internal_callback(T_arg1 arg1,T_arg2 arg2,T_arg3 arg3,T_arg4 arg4,T_arg5 arg5,T_arg6 arg6)
01752   {
01753     DBUS_CXX_DEBUG( "signal::internal_callback: "  << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 );
01754     SignalMessage::pointer __msg = SignalMessage::create(m_path, m_interface, m_name);
01755     if ( not m_destination.empty() ) __msg->set_destination(m_destination);
01756     *__msg  << arg1 << arg2 << arg3 << arg4 << arg5 << arg6;
01757     #ifdef DBUS_CXX_DEBUG_ENABLED
01758       bool result = this->handle_dbus_outgoing(__msg);
01759       DBUS_CXX_DEBUG( "signal::internal_callback: result=" << result );
01760     #else
01761       this->handle_dbus_outgoing(__msg);
01762     #endif
01763   }
01764 
01765 };
01766 
01767 
01768 
01769 } /* namespace DBus */
01770 
01771 #endif /* _DBUS_CXX_SIGNAL_H_ */

Generated on Mon Sep 21 10:59:27 2009 for dbus-cxx by doxygen 1.6.1