dbus-cxx logo

signal_proxy.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 <dbus-cxx/signal_proxy_base.h>
00024 
00025 #ifndef DBUSCXX_SIGNALPROXY_H_
00026 #define DBUSCXX_SIGNALPROXY_H_
00027 
00028 namespace DBus {
00379 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>
00380 class signal_proxy 
00381   : public sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>, public signal_proxy_base
00382 {
00383   public:
00384 
00385     typedef DBusCxxPointer<signal_proxy> pointer;
00386   
00387     signal_proxy(const std::string& interface, const std::string& name):
00388       signal_proxy_base(interface, name)
00389     { m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &signal_proxy::on_dbus_incoming) ); }
00390 
00391     signal_proxy(const std::string& path, const std::string& interface, const std::string& name):
00392       signal_proxy_base(path, interface, name)
00393     { m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &signal_proxy::on_dbus_incoming) ); }
00394 
00395     signal_proxy(const std::string& interface, const std::string& name, const signal_proxy& src) :
00396       sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(src),
00397       signal_proxy_base(interface, name)
00398     { m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &signal_proxy::on_dbus_incoming) ); }
00399 
00400     signal_proxy(const std::string& path, const std::string& interface, const std::string& name, const signal_proxy& src) :
00401       sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(src),
00402       signal_proxy_base(path, interface, name)
00403     { m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &signal_proxy::on_dbus_incoming) ); }
00404 
00405     static pointer create(const std::string& interface, const std::string& name)
00406     { return pointer( new signal_proxy(interface, name) ); }
00407 
00408     static pointer create(const std::string& path, const std::string& interface, const std::string& name)
00409     { return pointer( new signal_proxy(path, interface, name) ); }
00410 
00411     static pointer create(const std::string& interface, const std::string& name, const signal_proxy& src)
00412     { return pointer( new signal_proxy(interface, name, src) ); }
00413 
00414     static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal_proxy& src)
00415     { return pointer( new signal_proxy(path, interface, name, src) ); }
00416 
00417     virtual signal_base::pointer clone()
00418     { return signal_base::pointer( new signal_proxy(*this) ); }
00419 
00420   protected:
00421 
00422     virtual HandlerResult on_dbus_incoming( SignalMessage::const_pointer msg )
00423     {
00424       //T_return _retval;
00425             
00426       T_arg1 _val_1;
00427       T_arg2 _val_2;
00428       T_arg3 _val_3;
00429       T_arg4 _val_4;
00430       T_arg5 _val_5;
00431       T_arg6 _val_6;
00432       T_arg7 _val_7;
00433 
00434       try {
00435         
00436         Message::iterator i = msg->begin();
00437         i  >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5 >> _val_6 >> _val_7;
00438         
00439         this->emit(_val_1,_val_2,_val_3,_val_4,_val_5,_val_6,_val_7);
00440       }
00441       catch ( ErrorInvalidTypecast& e ) {
00442           return NOT_HANDLED;
00443       }
00444     
00445       return HANDLED;
00446     }
00447 
00448 };
00449 
00450 
00451 
00460 template <class T_return>
00461 class signal_proxy <T_return, nil,nil,nil,nil,nil,nil,nil>
00462   : public sigc::signal<T_return>, public signal_proxy_base
00463 {
00464   public:
00465 
00466     typedef DBusCxxPointer<signal_proxy> pointer;
00467   
00468     signal_proxy(const std::string& interface, const std::string& name):
00469       signal_proxy_base(interface, name)
00470     { m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &signal_proxy::on_dbus_incoming) ); }
00471 
00472     signal_proxy(const std::string& path, const std::string& interface, const std::string& name):
00473       signal_proxy_base(path, interface, name)
00474     { m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &signal_proxy::on_dbus_incoming) ); }
00475 
00476     signal_proxy(const std::string& interface, const std::string& name, const signal_proxy& src) :
00477       sigc::signal<T_return>(src),
00478       signal_proxy_base(interface, name)
00479     { m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &signal_proxy::on_dbus_incoming) ); }
00480 
00481     signal_proxy(const std::string& path, const std::string& interface, const std::string& name, const signal_proxy& src) :
00482       sigc::signal<T_return>(src),
00483       signal_proxy_base(path, interface, name)
00484     { m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &signal_proxy::on_dbus_incoming) ); }
00485 
00486     static pointer create(const std::string& interface, const std::string& name)
00487     { return pointer( new signal_proxy(interface, name) ); }
00488 
00489     static pointer create(const std::string& path, const std::string& interface, const std::string& name)
00490     { return pointer( new signal_proxy(path, interface, name) ); }
00491 
00492     static pointer create(const std::string& interface, const std::string& name, const signal_proxy& src)
00493     { return pointer( new signal_proxy(interface, name, src) ); }
00494 
00495     static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal_proxy& src)
00496     { return pointer( new signal_proxy(path, interface, name, src) ); }
00497 
00498     virtual signal_base::pointer clone()
00499     { return signal_base::pointer( new signal_proxy(*this) ); }
00500 
00501   protected:
00502 
00503     virtual HandlerResult on_dbus_incoming( SignalMessage::const_pointer msg )
00504     {
00505       //T_return _retval;
00506             
00507 
00508       try {
00509         
00510         this->emit();
00511       }
00512       catch ( ErrorInvalidTypecast& e ) {
00513           return NOT_HANDLED;
00514       }
00515     
00516       return HANDLED;
00517     }
00518 
00519 };
00520 
00521 
00530 template <class T_return, class T_arg1>
00531 class signal_proxy <T_return, T_arg1, nil,nil,nil,nil,nil,nil>
00532   : public sigc::signal<T_return, T_arg1>, public signal_proxy_base
00533 {
00534   public:
00535 
00536     typedef DBusCxxPointer<signal_proxy> pointer;
00537   
00538     signal_proxy(const std::string& interface, const std::string& name):
00539       signal_proxy_base(interface, name)
00540     { m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &signal_proxy::on_dbus_incoming) ); }
00541 
00542     signal_proxy(const std::string& path, const std::string& interface, const std::string& name):
00543       signal_proxy_base(path, interface, name)
00544     { m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &signal_proxy::on_dbus_incoming) ); }
00545 
00546     signal_proxy(const std::string& interface, const std::string& name, const signal_proxy& src) :
00547       sigc::signal<T_return, T_arg1>(src),
00548       signal_proxy_base(interface, name)
00549     { m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &signal_proxy::on_dbus_incoming) ); }
00550 
00551     signal_proxy(const std::string& path, const std::string& interface, const std::string& name, const signal_proxy& src) :
00552       sigc::signal<T_return, T_arg1>(src),
00553       signal_proxy_base(path, interface, name)
00554     { m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &signal_proxy::on_dbus_incoming) ); }
00555 
00556     static pointer create(const std::string& interface, const std::string& name)
00557     { return pointer( new signal_proxy(interface, name) ); }
00558 
00559     static pointer create(const std::string& path, const std::string& interface, const std::string& name)
00560     { return pointer( new signal_proxy(path, interface, name) ); }
00561 
00562     static pointer create(const std::string& interface, const std::string& name, const signal_proxy& src)
00563     { return pointer( new signal_proxy(interface, name, src) ); }
00564 
00565     static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal_proxy& src)
00566     { return pointer( new signal_proxy(path, interface, name, src) ); }
00567 
00568     virtual signal_base::pointer clone()
00569     { return signal_base::pointer( new signal_proxy(*this) ); }
00570 
00571   protected:
00572 
00573     virtual HandlerResult on_dbus_incoming( SignalMessage::const_pointer msg )
00574     {
00575       //T_return _retval;
00576             
00577       T_arg1 _val_1;
00578 
00579       try {
00580         
00581         Message::iterator i = msg->begin();
00582         i  >> _val_1;
00583         
00584         this->emit(_val_1);
00585       }
00586       catch ( ErrorInvalidTypecast& e ) {
00587           return NOT_HANDLED;
00588       }
00589     
00590       return HANDLED;
00591     }
00592 
00593 };
00594 
00595 
00604 template <class T_return, class T_arg1,class T_arg2>
00605 class signal_proxy <T_return, T_arg1,T_arg2, nil,nil,nil,nil,nil>
00606   : public sigc::signal<T_return, T_arg1,T_arg2>, public signal_proxy_base
00607 {
00608   public:
00609 
00610     typedef DBusCxxPointer<signal_proxy> pointer;
00611   
00612     signal_proxy(const std::string& interface, const std::string& name):
00613       signal_proxy_base(interface, name)
00614     { m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &signal_proxy::on_dbus_incoming) ); }
00615 
00616     signal_proxy(const std::string& path, const std::string& interface, const std::string& name):
00617       signal_proxy_base(path, interface, name)
00618     { m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &signal_proxy::on_dbus_incoming) ); }
00619 
00620     signal_proxy(const std::string& interface, const std::string& name, const signal_proxy& src) :
00621       sigc::signal<T_return, T_arg1,T_arg2>(src),
00622       signal_proxy_base(interface, name)
00623     { m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &signal_proxy::on_dbus_incoming) ); }
00624 
00625     signal_proxy(const std::string& path, const std::string& interface, const std::string& name, const signal_proxy& src) :
00626       sigc::signal<T_return, T_arg1,T_arg2>(src),
00627       signal_proxy_base(path, interface, name)
00628     { m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &signal_proxy::on_dbus_incoming) ); }
00629 
00630     static pointer create(const std::string& interface, const std::string& name)
00631     { return pointer( new signal_proxy(interface, name) ); }
00632 
00633     static pointer create(const std::string& path, const std::string& interface, const std::string& name)
00634     { return pointer( new signal_proxy(path, interface, name) ); }
00635 
00636     static pointer create(const std::string& interface, const std::string& name, const signal_proxy& src)
00637     { return pointer( new signal_proxy(interface, name, src) ); }
00638 
00639     static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal_proxy& src)
00640     { return pointer( new signal_proxy(path, interface, name, src) ); }
00641 
00642     virtual signal_base::pointer clone()
00643     { return signal_base::pointer( new signal_proxy(*this) ); }
00644 
00645   protected:
00646 
00647     virtual HandlerResult on_dbus_incoming( SignalMessage::const_pointer msg )
00648     {
00649       //T_return _retval;
00650             
00651       T_arg1 _val_1;
00652       T_arg2 _val_2;
00653 
00654       try {
00655         
00656         Message::iterator i = msg->begin();
00657         i  >> _val_1 >> _val_2;
00658         
00659         this->emit(_val_1,_val_2);
00660       }
00661       catch ( ErrorInvalidTypecast& e ) {
00662           return NOT_HANDLED;
00663       }
00664     
00665       return HANDLED;
00666     }
00667 
00668 };
00669 
00670 
00679 template <class T_return, class T_arg1,class T_arg2,class T_arg3>
00680 class signal_proxy <T_return, T_arg1,T_arg2,T_arg3, nil,nil,nil,nil>
00681   : public sigc::signal<T_return, T_arg1,T_arg2,T_arg3>, public signal_proxy_base
00682 {
00683   public:
00684 
00685     typedef DBusCxxPointer<signal_proxy> pointer;
00686   
00687     signal_proxy(const std::string& interface, const std::string& name):
00688       signal_proxy_base(interface, name)
00689     { m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &signal_proxy::on_dbus_incoming) ); }
00690 
00691     signal_proxy(const std::string& path, const std::string& interface, const std::string& name):
00692       signal_proxy_base(path, interface, name)
00693     { m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &signal_proxy::on_dbus_incoming) ); }
00694 
00695     signal_proxy(const std::string& interface, const std::string& name, const signal_proxy& src) :
00696       sigc::signal<T_return, T_arg1,T_arg2,T_arg3>(src),
00697       signal_proxy_base(interface, name)
00698     { m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &signal_proxy::on_dbus_incoming) ); }
00699 
00700     signal_proxy(const std::string& path, const std::string& interface, const std::string& name, const signal_proxy& src) :
00701       sigc::signal<T_return, T_arg1,T_arg2,T_arg3>(src),
00702       signal_proxy_base(path, interface, name)
00703     { m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &signal_proxy::on_dbus_incoming) ); }
00704 
00705     static pointer create(const std::string& interface, const std::string& name)
00706     { return pointer( new signal_proxy(interface, name) ); }
00707 
00708     static pointer create(const std::string& path, const std::string& interface, const std::string& name)
00709     { return pointer( new signal_proxy(path, interface, name) ); }
00710 
00711     static pointer create(const std::string& interface, const std::string& name, const signal_proxy& src)
00712     { return pointer( new signal_proxy(interface, name, src) ); }
00713 
00714     static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal_proxy& src)
00715     { return pointer( new signal_proxy(path, interface, name, src) ); }
00716 
00717     virtual signal_base::pointer clone()
00718     { return signal_base::pointer( new signal_proxy(*this) ); }
00719 
00720   protected:
00721 
00722     virtual HandlerResult on_dbus_incoming( SignalMessage::const_pointer msg )
00723     {
00724       //T_return _retval;
00725             
00726       T_arg1 _val_1;
00727       T_arg2 _val_2;
00728       T_arg3 _val_3;
00729 
00730       try {
00731         
00732         Message::iterator i = msg->begin();
00733         i  >> _val_1 >> _val_2 >> _val_3;
00734         
00735         this->emit(_val_1,_val_2,_val_3);
00736       }
00737       catch ( ErrorInvalidTypecast& e ) {
00738           return NOT_HANDLED;
00739       }
00740     
00741       return HANDLED;
00742     }
00743 
00744 };
00745 
00746 
00755 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
00756 class signal_proxy <T_return, T_arg1,T_arg2,T_arg3,T_arg4, nil,nil,nil>
00757   : public sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4>, public signal_proxy_base
00758 {
00759   public:
00760 
00761     typedef DBusCxxPointer<signal_proxy> pointer;
00762   
00763     signal_proxy(const std::string& interface, const std::string& name):
00764       signal_proxy_base(interface, name)
00765     { m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &signal_proxy::on_dbus_incoming) ); }
00766 
00767     signal_proxy(const std::string& path, const std::string& interface, const std::string& name):
00768       signal_proxy_base(path, interface, name)
00769     { m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &signal_proxy::on_dbus_incoming) ); }
00770 
00771     signal_proxy(const std::string& interface, const std::string& name, const signal_proxy& src) :
00772       sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4>(src),
00773       signal_proxy_base(interface, name)
00774     { m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &signal_proxy::on_dbus_incoming) ); }
00775 
00776     signal_proxy(const std::string& path, const std::string& interface, const std::string& name, const signal_proxy& src) :
00777       sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4>(src),
00778       signal_proxy_base(path, interface, name)
00779     { m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &signal_proxy::on_dbus_incoming) ); }
00780 
00781     static pointer create(const std::string& interface, const std::string& name)
00782     { return pointer( new signal_proxy(interface, name) ); }
00783 
00784     static pointer create(const std::string& path, const std::string& interface, const std::string& name)
00785     { return pointer( new signal_proxy(path, interface, name) ); }
00786 
00787     static pointer create(const std::string& interface, const std::string& name, const signal_proxy& src)
00788     { return pointer( new signal_proxy(interface, name, src) ); }
00789 
00790     static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal_proxy& src)
00791     { return pointer( new signal_proxy(path, interface, name, src) ); }
00792 
00793     virtual signal_base::pointer clone()
00794     { return signal_base::pointer( new signal_proxy(*this) ); }
00795 
00796   protected:
00797 
00798     virtual HandlerResult on_dbus_incoming( SignalMessage::const_pointer msg )
00799     {
00800       //T_return _retval;
00801             
00802       T_arg1 _val_1;
00803       T_arg2 _val_2;
00804       T_arg3 _val_3;
00805       T_arg4 _val_4;
00806 
00807       try {
00808         
00809         Message::iterator i = msg->begin();
00810         i  >> _val_1 >> _val_2 >> _val_3 >> _val_4;
00811         
00812         this->emit(_val_1,_val_2,_val_3,_val_4);
00813       }
00814       catch ( ErrorInvalidTypecast& e ) {
00815           return NOT_HANDLED;
00816       }
00817     
00818       return HANDLED;
00819     }
00820 
00821 };
00822 
00823 
00832 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
00833 class signal_proxy <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, nil,nil>
00834   : public sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>, public signal_proxy_base
00835 {
00836   public:
00837 
00838     typedef DBusCxxPointer<signal_proxy> pointer;
00839   
00840     signal_proxy(const std::string& interface, const std::string& name):
00841       signal_proxy_base(interface, name)
00842     { m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &signal_proxy::on_dbus_incoming) ); }
00843 
00844     signal_proxy(const std::string& path, const std::string& interface, const std::string& name):
00845       signal_proxy_base(path, interface, name)
00846     { m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &signal_proxy::on_dbus_incoming) ); }
00847 
00848     signal_proxy(const std::string& interface, const std::string& name, const signal_proxy& src) :
00849       sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(src),
00850       signal_proxy_base(interface, name)
00851     { m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &signal_proxy::on_dbus_incoming) ); }
00852 
00853     signal_proxy(const std::string& path, const std::string& interface, const std::string& name, const signal_proxy& src) :
00854       sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(src),
00855       signal_proxy_base(path, interface, name)
00856     { m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &signal_proxy::on_dbus_incoming) ); }
00857 
00858     static pointer create(const std::string& interface, const std::string& name)
00859     { return pointer( new signal_proxy(interface, name) ); }
00860 
00861     static pointer create(const std::string& path, const std::string& interface, const std::string& name)
00862     { return pointer( new signal_proxy(path, interface, name) ); }
00863 
00864     static pointer create(const std::string& interface, const std::string& name, const signal_proxy& src)
00865     { return pointer( new signal_proxy(interface, name, src) ); }
00866 
00867     static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal_proxy& src)
00868     { return pointer( new signal_proxy(path, interface, name, src) ); }
00869 
00870     virtual signal_base::pointer clone()
00871     { return signal_base::pointer( new signal_proxy(*this) ); }
00872 
00873   protected:
00874 
00875     virtual HandlerResult on_dbus_incoming( SignalMessage::const_pointer msg )
00876     {
00877       //T_return _retval;
00878             
00879       T_arg1 _val_1;
00880       T_arg2 _val_2;
00881       T_arg3 _val_3;
00882       T_arg4 _val_4;
00883       T_arg5 _val_5;
00884 
00885       try {
00886         
00887         Message::iterator i = msg->begin();
00888         i  >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5;
00889         
00890         this->emit(_val_1,_val_2,_val_3,_val_4,_val_5);
00891       }
00892       catch ( ErrorInvalidTypecast& e ) {
00893           return NOT_HANDLED;
00894       }
00895     
00896       return HANDLED;
00897     }
00898 
00899 };
00900 
00901 
00910 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
00911 class signal_proxy <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, nil>
00912   : public sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>, public signal_proxy_base
00913 {
00914   public:
00915 
00916     typedef DBusCxxPointer<signal_proxy> pointer;
00917   
00918     signal_proxy(const std::string& interface, const std::string& name):
00919       signal_proxy_base(interface, name)
00920     { m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &signal_proxy::on_dbus_incoming) ); }
00921 
00922     signal_proxy(const std::string& path, const std::string& interface, const std::string& name):
00923       signal_proxy_base(path, interface, name)
00924     { m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &signal_proxy::on_dbus_incoming) ); }
00925 
00926     signal_proxy(const std::string& interface, const std::string& name, const signal_proxy& src) :
00927       sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(src),
00928       signal_proxy_base(interface, name)
00929     { m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &signal_proxy::on_dbus_incoming) ); }
00930 
00931     signal_proxy(const std::string& path, const std::string& interface, const std::string& name, const signal_proxy& src) :
00932       sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(src),
00933       signal_proxy_base(path, interface, name)
00934     { m_signal_dbus_incoming.connect( sigc::mem_fun(*this, &signal_proxy::on_dbus_incoming) ); }
00935 
00936     static pointer create(const std::string& interface, const std::string& name)
00937     { return pointer( new signal_proxy(interface, name) ); }
00938 
00939     static pointer create(const std::string& path, const std::string& interface, const std::string& name)
00940     { return pointer( new signal_proxy(path, interface, name) ); }
00941 
00942     static pointer create(const std::string& interface, const std::string& name, const signal_proxy& src)
00943     { return pointer( new signal_proxy(interface, name, src) ); }
00944 
00945     static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal_proxy& src)
00946     { return pointer( new signal_proxy(path, interface, name, src) ); }
00947 
00948     virtual signal_base::pointer clone()
00949     { return signal_base::pointer( new signal_proxy(*this) ); }
00950 
00951   protected:
00952 
00953     virtual HandlerResult on_dbus_incoming( SignalMessage::const_pointer msg )
00954     {
00955       //T_return _retval;
00956             
00957       T_arg1 _val_1;
00958       T_arg2 _val_2;
00959       T_arg3 _val_3;
00960       T_arg4 _val_4;
00961       T_arg5 _val_5;
00962       T_arg6 _val_6;
00963 
00964       try {
00965         
00966         Message::iterator i = msg->begin();
00967         i  >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5 >> _val_6;
00968         
00969         this->emit(_val_1,_val_2,_val_3,_val_4,_val_5,_val_6);
00970       }
00971       catch ( ErrorInvalidTypecast& e ) {
00972           return NOT_HANDLED;
00973       }
00974     
00975       return HANDLED;
00976     }
00977 
00978 };
00979 
00980 
00981 
00982 } /* namespace DBus */
00983 
00984 #endif /* _DBUS_CXX_SIGNALPROXY_H_ */

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