dbus-cxx logo

dbus_signal.h

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

Generated on Thu Mar 18 09:30:54 2010 for dbus-cxx by doxygen 1.6.1