Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 9368 in orxonox.OLD for branches


Ignore:
Timestamp:
Jul 20, 2006, 8:28:10 PM (18 years ago)
Author:
bensch
Message:

compiles everywhere (i think)

File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/proxy/src/lib/util/sigslot/signal.h

    r9362 r9368  
    9595  class _connection_base0
    9696  {
    97     public:
    98       virtual has_slots<mt_policy>* getdest() const = 0;
    99       virtual void emit() = 0;
    100       virtual _connection_base0* clone() = 0;
    101       virtual _connection_base0* duplicate(has_slots<mt_policy>* pnewdest) = 0;
     97  public:
     98    virtual has_slots<mt_policy>* getdest() const = 0;
     99    virtual void emit() = 0;
     100    virtual _connection_base0* clone() = 0;
     101    virtual _connection_base0* duplicate(has_slots<mt_policy>* pnewdest) = 0;
    102102  };
    103103
     
    105105  class _connection_base1
    106106  {
    107     public:
    108       virtual has_slots<mt_policy>* getdest() const = 0;
    109       virtual void emit(arg1_type) = 0;
    110       virtual _connection_base1<arg1_type, mt_policy>* clone() = 0;
    111       virtual _connection_base1<arg1_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest) = 0;
     107  public:
     108    virtual has_slots<mt_policy>* getdest() const = 0;
     109    virtual void emit(arg1_type) = 0;
     110    virtual _connection_base1<arg1_type, mt_policy>* clone() = 0;
     111    virtual _connection_base1<arg1_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest) = 0;
    112112  };
    113113
     
    115115  class _connection_base2
    116116  {
    117     public:
    118       virtual has_slots<mt_policy>* getdest() const = 0;
    119       virtual void emit(arg1_type, arg2_type) = 0;
    120       virtual _connection_base2<arg1_type, arg2_type, mt_policy>* clone() = 0;
    121       virtual _connection_base2<arg1_type, arg2_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest) = 0;
     117  public:
     118    virtual has_slots<mt_policy>* getdest() const = 0;
     119    virtual void emit(arg1_type, arg2_type) = 0;
     120    virtual _connection_base2<arg1_type, arg2_type, mt_policy>* clone() = 0;
     121    virtual _connection_base2<arg1_type, arg2_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest) = 0;
    122122  };
    123123
     
    125125  class _connection_base3
    126126  {
    127     public:
    128       virtual has_slots<mt_policy>* getdest() const = 0;
    129       virtual void emit(arg1_type, arg2_type, arg3_type) = 0;
    130       virtual _connection_base3<arg1_type, arg2_type, arg3_type, mt_policy>* clone() = 0;
    131       virtual _connection_base3<arg1_type, arg2_type, arg3_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest) = 0;
     127  public:
     128    virtual has_slots<mt_policy>* getdest() const = 0;
     129    virtual void emit(arg1_type, arg2_type, arg3_type) = 0;
     130    virtual _connection_base3<arg1_type, arg2_type, arg3_type, mt_policy>* clone() = 0;
     131    virtual _connection_base3<arg1_type, arg2_type, arg3_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest) = 0;
    132132  };
    133133
     
    135135  class _connection_base4
    136136  {
    137     public:
    138       virtual has_slots<mt_policy>* getdest() const = 0;
    139       virtual void emit(arg1_type, arg2_type, arg3_type, arg4_type) = 0;
    140       virtual _connection_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>* clone() = 0;
    141       virtual _connection_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest) = 0;
     137  public:
     138    virtual has_slots<mt_policy>* getdest() const = 0;
     139    virtual void emit(arg1_type, arg2_type, arg3_type, arg4_type) = 0;
     140    virtual _connection_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>* clone() = 0;
     141    virtual _connection_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest) = 0;
    142142  };
    143143
     
    146146  class _connection_base5
    147147  {
    148     public:
    149       virtual has_slots<mt_policy>* getdest() const = 0;
    150       virtual void emit(arg1_type, arg2_type, arg3_type, arg4_type,
    151                         arg5_type) = 0;
    152       virtual _connection_base5<arg1_type, arg2_type, arg3_type, arg4_type,
    153       arg5_type, mt_policy>* clone() = 0;
    154       virtual _connection_base5<arg1_type, arg2_type, arg3_type, arg4_type,
    155       arg5_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest) = 0;
     148  public:
     149    virtual has_slots<mt_policy>* getdest() const = 0;
     150    virtual void emit(arg1_type, arg2_type, arg3_type, arg4_type,
     151                      arg5_type) = 0;
     152    virtual _connection_base5<arg1_type, arg2_type, arg3_type, arg4_type,
     153    arg5_type, mt_policy>* clone() = 0;
     154    virtual _connection_base5<arg1_type, arg2_type, arg3_type, arg4_type,
     155    arg5_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest) = 0;
    156156  };
    157157
     
    160160  class _connection_base6
    161161  {
    162     public:
    163       virtual has_slots<mt_policy>* getdest() const = 0;
    164       virtual void emit(arg1_type, arg2_type, arg3_type, arg4_type, arg5_type,
    165                         arg6_type) = 0;
    166       virtual _connection_base6<arg1_type, arg2_type, arg3_type, arg4_type,
    167       arg5_type, arg6_type, mt_policy>* clone() = 0;
    168       virtual _connection_base6<arg1_type, arg2_type, arg3_type, arg4_type,
    169       arg5_type, arg6_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest) = 0;
     162  public:
     163    virtual has_slots<mt_policy>* getdest() const = 0;
     164    virtual void emit(arg1_type, arg2_type, arg3_type, arg4_type, arg5_type,
     165                      arg6_type) = 0;
     166    virtual _connection_base6<arg1_type, arg2_type, arg3_type, arg4_type,
     167    arg5_type, arg6_type, mt_policy>* clone() = 0;
     168    virtual _connection_base6<arg1_type, arg2_type, arg3_type, arg4_type,
     169    arg5_type, arg6_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest) = 0;
    170170  };
    171171
     
    174174  class _connection_base7
    175175  {
    176     public:
    177       virtual has_slots<mt_policy>* getdest() const = 0;
    178       virtual void emit(arg1_type, arg2_type, arg3_type, arg4_type, arg5_type,
    179                         arg6_type, arg7_type) = 0;
    180       virtual _connection_base7<arg1_type, arg2_type, arg3_type, arg4_type,
    181       arg5_type, arg6_type, arg7_type, mt_policy>* clone() = 0;
    182       virtual _connection_base7<arg1_type, arg2_type, arg3_type, arg4_type,
    183       arg5_type, arg6_type, arg7_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest) = 0;
     176  public:
     177    virtual has_slots<mt_policy>* getdest() const = 0;
     178    virtual void emit(arg1_type, arg2_type, arg3_type, arg4_type, arg5_type,
     179                      arg6_type, arg7_type) = 0;
     180    virtual _connection_base7<arg1_type, arg2_type, arg3_type, arg4_type,
     181    arg5_type, arg6_type, arg7_type, mt_policy>* clone() = 0;
     182    virtual _connection_base7<arg1_type, arg2_type, arg3_type, arg4_type,
     183    arg5_type, arg6_type, arg7_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest) = 0;
    184184  };
    185185
     
    188188  class _connection_base8
    189189  {
    190     public:
    191       virtual has_slots<mt_policy>* getdest() const = 0;
    192       virtual void emit(arg1_type, arg2_type, arg3_type, arg4_type, arg5_type,
    193                         arg6_type, arg7_type, arg8_type) = 0;
    194       virtual _connection_base8<arg1_type, arg2_type, arg3_type, arg4_type,
    195       arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>* clone() = 0;
    196       virtual _connection_base8<arg1_type, arg2_type, arg3_type, arg4_type,
    197       arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest) = 0;
     190  public:
     191    virtual has_slots<mt_policy>* getdest() const = 0;
     192    virtual void emit(arg1_type, arg2_type, arg3_type, arg4_type, arg5_type,
     193                      arg6_type, arg7_type, arg8_type) = 0;
     194    virtual _connection_base8<arg1_type, arg2_type, arg3_type, arg4_type,
     195    arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>* clone() = 0;
     196    virtual _connection_base8<arg1_type, arg2_type, arg3_type, arg4_type,
     197    arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest) = 0;
    198198  };
    199199
     
    201201  class _signal_base0 : public _signal_base<mt_policy>
    202202  {
    203     public:
    204       typedef std::list<_connection_base0<mt_policy> *>  connections_list;
    205 
    206       _signal_base0()
    207       {
    208         ;
    209       }
    210 
    211       _signal_base0(const _signal_base0& s)
    212           : _signal_base<mt_policy>(s)
    213       {
    214         lock_block<mt_policy> lock(this);
    215         typename connections_list::const_iterator it = s.m_connected_slots.begin();
    216         typename connections_list::const_iterator itEnd = s.m_connected_slots.end();
    217 
    218         while(it != itEnd)
    219         {
    220           (*it)->getdest()->signal_connect(this);
    221           m_connected_slots.push_back((*it)->clone());
    222 
    223           ++it;
    224         }
    225       }
    226 
    227       ~_signal_base0()
    228       {
    229         disconnect_all();
    230       }
    231 
    232       void disconnect_all()
    233       {
    234         lock_block<mt_policy> lock(this);
    235         typename connections_list::const_iterator it = m_connected_slots.begin();
    236         typename connections_list::const_iterator itEnd = m_connected_slots.end();
    237 
    238         while(it != itEnd)
    239         {
    240           (*it)->getdest()->signal_disconnect(this);
     203  public:
     204    typedef std::list<_connection_base0<mt_policy> *>  connections_list;
     205
     206    _signal_base0()
     207    {
     208      ;
     209    }
     210
     211    _signal_base0(const _signal_base0& s)
     212        : _signal_base<mt_policy>(s)
     213    {
     214      lock_block<mt_policy> lock(this);
     215      typename connections_list::const_iterator it = s.m_connected_slots.begin();
     216      typename connections_list::const_iterator itEnd = s.m_connected_slots.end();
     217
     218      while(it != itEnd)
     219      {
     220        (*it)->getdest()->signal_connect(this);
     221        m_connected_slots.push_back((*it)->clone());
     222
     223        ++it;
     224      }
     225    }
     226
     227    ~_signal_base0()
     228    {
     229      disconnect_all();
     230    }
     231
     232    void disconnect_all()
     233    {
     234      lock_block<mt_policy> lock(this);
     235      typename connections_list::const_iterator it = m_connected_slots.begin();
     236      typename connections_list::const_iterator itEnd = m_connected_slots.end();
     237
     238      while(it != itEnd)
     239      {
     240        (*it)->getdest()->signal_disconnect(this);
     241        delete *it;
     242
     243        ++it;
     244      }
     245
     246      m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
     247    }
     248
     249    void disconnect(has_slots<mt_policy>* pclass)
     250    {
     251      lock_block<mt_policy> lock(this);
     252      typename connections_list::iterator it = m_connected_slots.begin();
     253      typename connections_list::iterator itEnd = m_connected_slots.end();
     254
     255      while(it != itEnd)
     256      {
     257        if((*it)->getdest() == pclass)
     258        {
    241259          delete *it;
    242 
    243           ++it;
    244         }
    245 
    246         m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
    247       }
    248 
    249       void disconnect(has_slots<mt_policy>* pclass)
    250       {
    251         lock_block<mt_policy> lock(this);
    252         typename connections_list::iterator it = m_connected_slots.begin();
    253         typename connections_list::iterator itEnd = m_connected_slots.end();
    254 
    255         while(it != itEnd)
    256         {
    257           if((*it)->getdest() == pclass)
    258           {
    259             delete *it;
    260             m_connected_slots.erase(it);
    261             pclass->signal_disconnect(this);
    262             return;
    263           }
    264 
    265           ++it;
    266         }
    267       }
    268 
    269       void slot_disconnect(has_slots<mt_policy>* pslot)
    270       {
    271         lock_block<mt_policy> lock(this);
    272         typename connections_list::iterator it = m_connected_slots.begin();
    273         typename connections_list::iterator itEnd = m_connected_slots.end();
    274 
    275         while(it != itEnd)
    276         {
    277           typename connections_list::iterator itNext = it;
    278           ++itNext;
    279 
    280           if((*it)->getdest() == pslot)
    281           {
    282             m_connected_slots.erase(it);
    283             //                  delete *it;
    284           }
    285 
    286           it = itNext;
    287         }
    288       }
    289 
    290       void slot_duplicate(const has_slots<mt_policy>* oldtarget, has_slots<mt_policy>* newtarget)
    291       {
    292         lock_block<mt_policy> lock(this);
    293         typename connections_list::iterator it = m_connected_slots.begin();
    294         typename connections_list::iterator itEnd = m_connected_slots.end();
    295 
    296         while(it != itEnd)
    297         {
    298           if((*it)->getdest() == oldtarget)
    299           {
    300             m_connected_slots.push_back((*it)->duplicate(newtarget));
    301           }
    302 
    303           ++it;
    304         }
    305       }
    306 
    307     protected:
    308       connections_list m_connected_slots;
     260          m_connected_slots.erase(it);
     261          pclass->signal_disconnect(this);
     262          return;
     263        }
     264
     265        ++it;
     266      }
     267    }
     268
     269    void slot_disconnect(has_slots<mt_policy>* pslot)
     270    {
     271      lock_block<mt_policy> lock(this);
     272      typename connections_list::iterator it = m_connected_slots.begin();
     273      typename connections_list::iterator itEnd = m_connected_slots.end();
     274
     275      while(it != itEnd)
     276      {
     277        typename connections_list::iterator itNext = it;
     278        ++itNext;
     279
     280        if((*it)->getdest() == pslot)
     281        {
     282          m_connected_slots.erase(it);
     283          //                    delete *it;
     284        }
     285
     286        it = itNext;
     287      }
     288    }
     289
     290    void slot_duplicate(const has_slots<mt_policy>* oldtarget, has_slots<mt_policy>* newtarget)
     291    {
     292      lock_block<mt_policy> lock(this);
     293      typename connections_list::iterator it = m_connected_slots.begin();
     294      typename connections_list::iterator itEnd = m_connected_slots.end();
     295
     296      while(it != itEnd)
     297      {
     298        if((*it)->getdest() == oldtarget)
     299        {
     300          m_connected_slots.push_back((*it)->duplicate(newtarget));
     301        }
     302
     303        ++it;
     304      }
     305    }
     306
     307  protected:
     308    connections_list m_connected_slots;
    309309  };
    310310
     
    312312  class _signal_base1 : public _signal_base<mt_policy>
    313313  {
    314     public:
    315       typedef std::list<_connection_base1<arg1_type, mt_policy> *>  connections_list;
    316 
    317       _signal_base1()
    318       {
    319         ;
    320       }
    321 
    322       _signal_base1(const _signal_base1<arg1_type, mt_policy>& s)
    323           : _signal_base<mt_policy>(s)
    324       {
    325         lock_block<mt_policy> lock(this);
    326         typename connections_list::const_iterator it = s.m_connected_slots.begin();
    327         typename connections_list::const_iterator itEnd = s.m_connected_slots.end();
    328 
    329         while(it != itEnd)
    330         {
    331           (*it)->getdest()->signal_connect(this);
    332           m_connected_slots.push_back((*it)->clone());
    333 
    334           ++it;
    335         }
    336       }
    337 
    338       void slot_duplicate(const has_slots<mt_policy>* oldtarget, has_slots<mt_policy>* newtarget)
    339       {
    340         lock_block<mt_policy> lock(this);
    341         typename connections_list::iterator it = m_connected_slots.begin();
    342         typename connections_list::iterator itEnd = m_connected_slots.end();
    343 
    344         while(it != itEnd)
    345         {
    346           if((*it)->getdest() == oldtarget)
    347           {
    348             m_connected_slots.push_back((*it)->duplicate(newtarget));
    349           }
    350 
    351           ++it;
    352         }
    353       }
    354 
    355       ~_signal_base1()
    356       {
    357         disconnect_all();
    358       }
    359 
    360       void disconnect_all()
    361       {
    362         lock_block<mt_policy> lock(this);
    363         typename connections_list::const_iterator it = m_connected_slots.begin();
    364         typename connections_list::const_iterator itEnd = m_connected_slots.end();
    365 
    366         while(it != itEnd)
    367         {
    368           (*it)->getdest()->signal_disconnect(this);
     314  public:
     315    typedef std::list<_connection_base1<arg1_type, mt_policy> *>  connections_list;
     316
     317    _signal_base1()
     318    {
     319      ;
     320    }
     321
     322    _signal_base1(const _signal_base1<arg1_type, mt_policy>& s)
     323        : _signal_base<mt_policy>(s)
     324    {
     325      lock_block<mt_policy> lock(this);
     326      typename connections_list::const_iterator it = s.m_connected_slots.begin();
     327      typename connections_list::const_iterator itEnd = s.m_connected_slots.end();
     328
     329      while(it != itEnd)
     330      {
     331        (*it)->getdest()->signal_connect(this);
     332        m_connected_slots.push_back((*it)->clone());
     333
     334        ++it;
     335      }
     336    }
     337
     338    void slot_duplicate(const has_slots<mt_policy>* oldtarget, has_slots<mt_policy>* newtarget)
     339    {
     340      lock_block<mt_policy> lock(this);
     341      typename connections_list::iterator it = m_connected_slots.begin();
     342      typename connections_list::iterator itEnd = m_connected_slots.end();
     343
     344      while(it != itEnd)
     345      {
     346        if((*it)->getdest() == oldtarget)
     347        {
     348          m_connected_slots.push_back((*it)->duplicate(newtarget));
     349        }
     350
     351        ++it;
     352      }
     353    }
     354
     355    ~_signal_base1()
     356    {
     357      disconnect_all();
     358    }
     359
     360    void disconnect_all()
     361    {
     362      lock_block<mt_policy> lock(this);
     363      typename connections_list::const_iterator it = m_connected_slots.begin();
     364      typename connections_list::const_iterator itEnd = m_connected_slots.end();
     365
     366      while(it != itEnd)
     367      {
     368        (*it)->getdest()->signal_disconnect(this);
     369        delete *it;
     370
     371        ++it;
     372      }
     373
     374      m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
     375    }
     376
     377    void disconnect(has_slots<mt_policy>* pclass)
     378    {
     379      lock_block<mt_policy> lock(this);
     380      typename connections_list::iterator it = m_connected_slots.begin();
     381      typename connections_list::iterator itEnd = m_connected_slots.end();
     382
     383      while(it != itEnd)
     384      {
     385        if((*it)->getdest() == pclass)
     386        {
    369387          delete *it;
    370 
    371           ++it;
    372         }
    373 
    374         m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
    375       }
    376 
    377       void disconnect(has_slots<mt_policy>* pclass)
    378       {
    379         lock_block<mt_policy> lock(this);
    380         typename connections_list::iterator it = m_connected_slots.begin();
    381         typename connections_list::iterator itEnd = m_connected_slots.end();
    382 
    383         while(it != itEnd)
    384         {
    385           if((*it)->getdest() == pclass)
    386           {
    387             delete *it;
    388             m_connected_slots.erase(it);
    389             pclass->signal_disconnect(this);
    390             return;
    391           }
    392 
    393           ++it;
    394         }
    395       }
    396 
    397       void slot_disconnect(has_slots<mt_policy>* pslot)
    398       {
    399         lock_block<mt_policy> lock(this);
    400         typename connections_list::iterator it = m_connected_slots.begin();
    401         typename connections_list::iterator itEnd = m_connected_slots.end();
    402 
    403         while(it != itEnd)
    404         {
    405           typename connections_list::iterator itNext = it;
    406           ++itNext;
    407 
    408           if((*it)->getdest() == pslot)
    409           {
    410             m_connected_slots.erase(it);
    411             //                  delete *it;
    412           }
    413 
    414           it = itNext;
    415         }
    416       }
    417 
    418 
    419     protected:
    420       connections_list m_connected_slots;
     388          m_connected_slots.erase(it);
     389          pclass->signal_disconnect(this);
     390          return;
     391        }
     392
     393        ++it;
     394      }
     395    }
     396
     397    void slot_disconnect(has_slots<mt_policy>* pslot)
     398    {
     399      lock_block<mt_policy> lock(this);
     400      typename connections_list::iterator it = m_connected_slots.begin();
     401      typename connections_list::iterator itEnd = m_connected_slots.end();
     402
     403      while(it != itEnd)
     404      {
     405        typename connections_list::iterator itNext = it;
     406        ++itNext;
     407
     408        if((*it)->getdest() == pslot)
     409        {
     410          m_connected_slots.erase(it);
     411          //                    delete *it;
     412        }
     413
     414        it = itNext;
     415      }
     416    }
     417
     418
     419  protected:
     420    connections_list m_connected_slots;
    421421  };
    422422
     
    424424  class _signal_base2 : public _signal_base<mt_policy>
    425425  {
    426     public:
    427       typedef std::list<_connection_base2<arg1_type, arg2_type, mt_policy> *>
    428       connections_list;
    429 
    430       _signal_base2()
    431       {
    432         ;
    433       }
    434 
    435       _signal_base2(const _signal_base2<arg1_type, arg2_type, mt_policy>& s)
    436           : _signal_base<mt_policy>(s)
    437       {
    438         lock_block<mt_policy> lock(this);
    439         typename connections_list::const_iterator it = s.m_connected_slots.begin();
    440         typename connections_list::const_iterator itEnd = s.m_connected_slots.end();
    441 
    442         while(it != itEnd)
    443         {
    444           (*it)->getdest()->signal_connect(this);
    445           m_connected_slots.push_back((*it)->clone());
    446 
    447           ++it;
    448         }
    449       }
    450 
    451       void slot_duplicate(const has_slots<mt_policy>* oldtarget, has_slots<mt_policy>* newtarget)
    452       {
    453         lock_block<mt_policy> lock(this);
    454         typename connections_list::iterator it = m_connected_slots.begin();
    455         typename connections_list::iterator itEnd = m_connected_slots.end();
    456 
    457         while(it != itEnd)
    458         {
    459           if((*it)->getdest() == oldtarget)
    460           {
    461             m_connected_slots.push_back((*it)->duplicate(newtarget));
    462           }
    463 
    464           ++it;
    465         }
    466       }
    467 
    468       ~_signal_base2()
    469       {
    470         disconnect_all();
    471       }
    472 
    473       void disconnect_all()
    474       {
    475         lock_block<mt_policy> lock(this);
    476         typename connections_list::const_iterator it = m_connected_slots.begin();
    477         typename connections_list::const_iterator itEnd = m_connected_slots.end();
    478 
    479         while(it != itEnd)
    480         {
    481           (*it)->getdest()->signal_disconnect(this);
     426  public:
     427    typedef std::list<_connection_base2<arg1_type, arg2_type, mt_policy> *>
     428    connections_list;
     429
     430    _signal_base2()
     431    {
     432      ;
     433    }
     434
     435    _signal_base2(const _signal_base2<arg1_type, arg2_type, mt_policy>& s)
     436        : _signal_base<mt_policy>(s)
     437    {
     438      lock_block<mt_policy> lock(this);
     439      typename connections_list::const_iterator it = s.m_connected_slots.begin();
     440      typename connections_list::const_iterator itEnd = s.m_connected_slots.end();
     441
     442      while(it != itEnd)
     443      {
     444        (*it)->getdest()->signal_connect(this);
     445        m_connected_slots.push_back((*it)->clone());
     446
     447        ++it;
     448      }
     449    }
     450
     451    void slot_duplicate(const has_slots<mt_policy>* oldtarget, has_slots<mt_policy>* newtarget)
     452    {
     453      lock_block<mt_policy> lock(this);
     454      typename connections_list::iterator it = m_connected_slots.begin();
     455      typename connections_list::iterator itEnd = m_connected_slots.end();
     456
     457      while(it != itEnd)
     458      {
     459        if((*it)->getdest() == oldtarget)
     460        {
     461          m_connected_slots.push_back((*it)->duplicate(newtarget));
     462        }
     463
     464        ++it;
     465      }
     466    }
     467
     468    ~_signal_base2()
     469    {
     470      disconnect_all();
     471    }
     472
     473    void disconnect_all()
     474    {
     475      lock_block<mt_policy> lock(this);
     476      typename connections_list::const_iterator it = m_connected_slots.begin();
     477      typename connections_list::const_iterator itEnd = m_connected_slots.end();
     478
     479      while(it != itEnd)
     480      {
     481        (*it)->getdest()->signal_disconnect(this);
     482        delete *it;
     483
     484        ++it;
     485      }
     486
     487      m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
     488    }
     489
     490    void disconnect(has_slots<mt_policy>* pclass)
     491    {
     492      lock_block<mt_policy> lock(this);
     493      typename connections_list::iterator it = m_connected_slots.begin();
     494      typename connections_list::iterator itEnd = m_connected_slots.end();
     495
     496      while(it != itEnd)
     497      {
     498        if((*it)->getdest() == pclass)
     499        {
    482500          delete *it;
    483 
    484           ++it;
    485         }
    486 
    487         m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
    488       }
    489 
    490       void disconnect(has_slots<mt_policy>* pclass)
    491       {
    492         lock_block<mt_policy> lock(this);
    493         typename connections_list::iterator it = m_connected_slots.begin();
    494         typename connections_list::iterator itEnd = m_connected_slots.end();
    495 
    496         while(it != itEnd)
    497         {
    498           if((*it)->getdest() == pclass)
    499           {
    500             delete *it;
    501             m_connected_slots.erase(it);
    502             pclass->signal_disconnect(this);
    503             return;
    504           }
    505 
    506           ++it;
    507         }
    508       }
    509 
    510       void slot_disconnect(has_slots<mt_policy>* pslot)
    511       {
    512         lock_block<mt_policy> lock(this);
    513         typename connections_list::iterator it = m_connected_slots.begin();
    514         typename connections_list::iterator itEnd = m_connected_slots.end();
    515 
    516         while(it != itEnd)
    517         {
    518           typename connections_list::iterator itNext = it;
    519           ++itNext;
    520 
    521           if((*it)->getdest() == pslot)
    522           {
    523             m_connected_slots.erase(it);
    524             //                  delete *it;
    525           }
    526 
    527           it = itNext;
    528         }
    529       }
    530 
    531     protected:
    532       connections_list m_connected_slots;
     501          m_connected_slots.erase(it);
     502          pclass->signal_disconnect(this);
     503          return;
     504        }
     505
     506        ++it;
     507      }
     508    }
     509
     510    void slot_disconnect(has_slots<mt_policy>* pslot)
     511    {
     512      lock_block<mt_policy> lock(this);
     513      typename connections_list::iterator it = m_connected_slots.begin();
     514      typename connections_list::iterator itEnd = m_connected_slots.end();
     515
     516      while(it != itEnd)
     517      {
     518        typename connections_list::iterator itNext = it;
     519        ++itNext;
     520
     521        if((*it)->getdest() == pslot)
     522        {
     523          m_connected_slots.erase(it);
     524          //                    delete *it;
     525        }
     526
     527        it = itNext;
     528      }
     529    }
     530
     531  protected:
     532    connections_list m_connected_slots;
    533533  };
    534534
     
    536536  class _signal_base3 : public _signal_base<mt_policy>
    537537  {
    538     public:
    539       typedef std::list<_connection_base3<arg1_type, arg2_type, arg3_type, mt_policy> *>
    540       connections_list;
    541 
    542       _signal_base3()
    543       {
    544         ;
    545       }
    546 
    547       _signal_base3(const _signal_base3<arg1_type, arg2_type, arg3_type, mt_policy>& s)
    548           : _signal_base<mt_policy>(s)
    549       {
    550         lock_block<mt_policy> lock(this);
    551         typename connections_list::const_iterator it = s.m_connected_slots.begin();
    552         typename connections_list::const_iterator itEnd = s.m_connected_slots.end();
    553 
    554         while(it != itEnd)
    555         {
    556           (*it)->getdest()->signal_connect(this);
    557           m_connected_slots.push_back((*it)->clone());
    558 
    559           ++it;
    560         }
    561       }
    562 
    563       void slot_duplicate(const has_slots<mt_policy>* oldtarget, has_slots<mt_policy>* newtarget)
    564       {
    565         lock_block<mt_policy> lock(this);
    566         typename connections_list::iterator it = m_connected_slots.begin();
    567         typename connections_list::iterator itEnd = m_connected_slots.end();
    568 
    569         while(it != itEnd)
    570         {
    571           if((*it)->getdest() == oldtarget)
    572           {
    573             m_connected_slots.push_back((*it)->duplicate(newtarget));
    574           }
    575 
    576           ++it;
    577         }
    578       }
    579 
    580       ~_signal_base3()
    581       {
    582         disconnect_all();
    583       }
    584 
    585       void disconnect_all()
    586       {
    587         lock_block<mt_policy> lock(this);
    588         typename connections_list::const_iterator it = m_connected_slots.begin();
    589         typename connections_list::const_iterator itEnd = m_connected_slots.end();
    590 
    591         while(it != itEnd)
    592         {
    593           (*it)->getdest()->signal_disconnect(this);
     538  public:
     539    typedef std::list<_connection_base3<arg1_type, arg2_type, arg3_type, mt_policy> *>
     540    connections_list;
     541
     542    _signal_base3()
     543    {
     544      ;
     545    }
     546
     547    _signal_base3(const _signal_base3<arg1_type, arg2_type, arg3_type, mt_policy>& s)
     548        : _signal_base<mt_policy>(s)
     549    {
     550      lock_block<mt_policy> lock(this);
     551      typename connections_list::const_iterator it = s.m_connected_slots.begin();
     552      typename connections_list::const_iterator itEnd = s.m_connected_slots.end();
     553
     554      while(it != itEnd)
     555      {
     556        (*it)->getdest()->signal_connect(this);
     557        m_connected_slots.push_back((*it)->clone());
     558
     559        ++it;
     560      }
     561    }
     562
     563    void slot_duplicate(const has_slots<mt_policy>* oldtarget, has_slots<mt_policy>* newtarget)
     564    {
     565      lock_block<mt_policy> lock(this);
     566      typename connections_list::iterator it = m_connected_slots.begin();
     567      typename connections_list::iterator itEnd = m_connected_slots.end();
     568
     569      while(it != itEnd)
     570      {
     571        if((*it)->getdest() == oldtarget)
     572        {
     573          m_connected_slots.push_back((*it)->duplicate(newtarget));
     574        }
     575
     576        ++it;
     577      }
     578    }
     579
     580    ~_signal_base3()
     581    {
     582      disconnect_all();
     583    }
     584
     585    void disconnect_all()
     586    {
     587      lock_block<mt_policy> lock(this);
     588      typename connections_list::const_iterator it = m_connected_slots.begin();
     589      typename connections_list::const_iterator itEnd = m_connected_slots.end();
     590
     591      while(it != itEnd)
     592      {
     593        (*it)->getdest()->signal_disconnect(this);
     594        delete *it;
     595
     596        ++it;
     597      }
     598
     599      m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
     600    }
     601
     602    void disconnect(has_slots<mt_policy>* pclass)
     603    {
     604      lock_block<mt_policy> lock(this);
     605      typename connections_list::iterator it = m_connected_slots.begin();
     606      typename connections_list::iterator itEnd = m_connected_slots.end();
     607
     608      while(it != itEnd)
     609      {
     610        if((*it)->getdest() == pclass)
     611        {
    594612          delete *it;
    595 
    596           ++it;
    597         }
    598 
    599         m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
    600       }
    601 
    602       void disconnect(has_slots<mt_policy>* pclass)
    603       {
    604         lock_block<mt_policy> lock(this);
    605         typename connections_list::iterator it = m_connected_slots.begin();
    606         typename connections_list::iterator itEnd = m_connected_slots.end();
    607 
    608         while(it != itEnd)
    609         {
    610           if((*it)->getdest() == pclass)
    611           {
    612             delete *it;
    613             m_connected_slots.erase(it);
    614             pclass->signal_disconnect(this);
    615             return;
    616           }
    617 
    618           ++it;
    619         }
    620       }
    621 
    622       void slot_disconnect(has_slots<mt_policy>* pslot)
    623       {
    624         lock_block<mt_policy> lock(this);
    625         typename connections_list::iterator it = m_connected_slots.begin();
    626         typename connections_list::iterator itEnd = m_connected_slots.end();
    627 
    628         while(it != itEnd)
    629         {
    630           typename connections_list::iterator itNext = it;
    631           ++itNext;
    632 
    633           if((*it)->getdest() == pslot)
    634           {
    635             m_connected_slots.erase(it);
    636             //                  delete *it;
    637           }
    638 
    639           it = itNext;
    640         }
    641       }
    642 
    643     protected:
    644       connections_list m_connected_slots;
     613          m_connected_slots.erase(it);
     614          pclass->signal_disconnect(this);
     615          return;
     616        }
     617
     618        ++it;
     619      }
     620    }
     621
     622    void slot_disconnect(has_slots<mt_policy>* pslot)
     623    {
     624      lock_block<mt_policy> lock(this);
     625      typename connections_list::iterator it = m_connected_slots.begin();
     626      typename connections_list::iterator itEnd = m_connected_slots.end();
     627
     628      while(it != itEnd)
     629      {
     630        typename connections_list::iterator itNext = it;
     631        ++itNext;
     632
     633        if((*it)->getdest() == pslot)
     634        {
     635          m_connected_slots.erase(it);
     636          //                    delete *it;
     637        }
     638
     639        it = itNext;
     640      }
     641    }
     642
     643  protected:
     644    connections_list m_connected_slots;
    645645  };
    646646
     
    648648  class _signal_base4 : public _signal_base<mt_policy>
    649649  {
    650     public:
    651       typedef std::list<_connection_base4<arg1_type, arg2_type, arg3_type,
    652       arg4_type, mt_policy> *>  connections_list;
    653 
    654       _signal_base4()
    655       {
    656         ;
    657       }
    658 
    659       _signal_base4(const _signal_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>& s)
    660           : _signal_base<mt_policy>(s)
    661       {
    662         lock_block<mt_policy> lock(this);
    663         typename connections_list::const_iterator it = s.m_connected_slots.begin();
    664         typename connections_list::const_iterator itEnd = s.m_connected_slots.end();
    665 
    666         while(it != itEnd)
    667         {
    668           (*it)->getdest()->signal_connect(this);
    669           m_connected_slots.push_back((*it)->clone());
    670 
    671           ++it;
    672         }
    673       }
    674 
    675       void slot_duplicate(const has_slots<mt_policy>* oldtarget, has_slots<mt_policy>* newtarget)
    676       {
    677         lock_block<mt_policy> lock(this);
    678         typename connections_list::iterator it = m_connected_slots.begin();
    679         typename connections_list::iterator itEnd = m_connected_slots.end();
    680 
    681         while(it != itEnd)
    682         {
    683           if((*it)->getdest() == oldtarget)
    684           {
    685             m_connected_slots.push_back((*it)->duplicate(newtarget));
    686           }
    687 
    688           ++it;
    689         }
    690       }
    691 
    692       ~_signal_base4()
    693       {
    694         disconnect_all();
    695       }
    696 
    697       void disconnect_all()
    698       {
    699         lock_block<mt_policy> lock(this);
    700         typename connections_list::const_iterator it = m_connected_slots.begin();
    701         typename connections_list::const_iterator itEnd = m_connected_slots.end();
    702 
    703         while(it != itEnd)
    704         {
    705           (*it)->getdest()->signal_disconnect(this);
     650  public:
     651    typedef std::list<_connection_base4<arg1_type, arg2_type, arg3_type,
     652    arg4_type, mt_policy> *>  connections_list;
     653
     654    _signal_base4()
     655    {
     656      ;
     657    }
     658
     659    _signal_base4(const _signal_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>& s)
     660        : _signal_base<mt_policy>(s)
     661    {
     662      lock_block<mt_policy> lock(this);
     663      typename connections_list::const_iterator it = s.m_connected_slots.begin();
     664      typename connections_list::const_iterator itEnd = s.m_connected_slots.end();
     665
     666      while(it != itEnd)
     667      {
     668        (*it)->getdest()->signal_connect(this);
     669        m_connected_slots.push_back((*it)->clone());
     670
     671        ++it;
     672      }
     673    }
     674
     675    void slot_duplicate(const has_slots<mt_policy>* oldtarget, has_slots<mt_policy>* newtarget)
     676    {
     677      lock_block<mt_policy> lock(this);
     678      typename connections_list::iterator it = m_connected_slots.begin();
     679      typename connections_list::iterator itEnd = m_connected_slots.end();
     680
     681      while(it != itEnd)
     682      {
     683        if((*it)->getdest() == oldtarget)
     684        {
     685          m_connected_slots.push_back((*it)->duplicate(newtarget));
     686        }
     687
     688        ++it;
     689      }
     690    }
     691
     692    ~_signal_base4()
     693    {
     694      disconnect_all();
     695    }
     696
     697    void disconnect_all()
     698    {
     699      lock_block<mt_policy> lock(this);
     700      typename connections_list::const_iterator it = m_connected_slots.begin();
     701      typename connections_list::const_iterator itEnd = m_connected_slots.end();
     702
     703      while(it != itEnd)
     704      {
     705        (*it)->getdest()->signal_disconnect(this);
     706        delete *it;
     707
     708        ++it;
     709      }
     710
     711      m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
     712    }
     713
     714    void disconnect(has_slots<mt_policy>* pclass)
     715    {
     716      lock_block<mt_policy> lock(this);
     717      typename connections_list::iterator it = m_connected_slots.begin();
     718      typename connections_list::iterator itEnd = m_connected_slots.end();
     719
     720      while(it != itEnd)
     721      {
     722        if((*it)->getdest() == pclass)
     723        {
    706724          delete *it;
    707 
    708           ++it;
    709         }
    710 
    711         m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
    712       }
    713 
    714       void disconnect(has_slots<mt_policy>* pclass)
    715       {
    716         lock_block<mt_policy> lock(this);
    717         typename connections_list::iterator it = m_connected_slots.begin();
    718         typename connections_list::iterator itEnd = m_connected_slots.end();
    719 
    720         while(it != itEnd)
    721         {
    722           if((*it)->getdest() == pclass)
    723           {
    724             delete *it;
    725             m_connected_slots.erase(it);
    726             pclass->signal_disconnect(this);
    727             return;
    728           }
    729 
    730           ++it;
    731         }
    732       }
    733 
    734       void slot_disconnect(has_slots<mt_policy>* pslot)
    735       {
    736         lock_block<mt_policy> lock(this);
    737         typename connections_list::iterator it = m_connected_slots.begin();
    738         typename connections_list::iterator itEnd = m_connected_slots.end();
    739 
    740         while(it != itEnd)
    741         {
    742           typename connections_list::iterator itNext = it;
    743           ++itNext;
    744 
    745           if((*it)->getdest() == pslot)
    746           {
    747             m_connected_slots.erase(it);
    748             //                  delete *it;
    749           }
    750 
    751           it = itNext;
    752         }
    753       }
    754 
    755     protected:
    756       connections_list m_connected_slots;
     725          m_connected_slots.erase(it);
     726          pclass->signal_disconnect(this);
     727          return;
     728        }
     729
     730        ++it;
     731      }
     732    }
     733
     734    void slot_disconnect(has_slots<mt_policy>* pslot)
     735    {
     736      lock_block<mt_policy> lock(this);
     737      typename connections_list::iterator it = m_connected_slots.begin();
     738      typename connections_list::iterator itEnd = m_connected_slots.end();
     739
     740      while(it != itEnd)
     741      {
     742        typename connections_list::iterator itNext = it;
     743        ++itNext;
     744
     745        if((*it)->getdest() == pslot)
     746        {
     747          m_connected_slots.erase(it);
     748          //                    delete *it;
     749        }
     750
     751        it = itNext;
     752      }
     753    }
     754
     755  protected:
     756    connections_list m_connected_slots;
    757757  };
    758758
     
    761761  class _signal_base5 : public _signal_base<mt_policy>
    762762  {
    763     public:
    764       typedef std::list<_connection_base5<arg1_type, arg2_type, arg3_type,
    765       arg4_type, arg5_type, mt_policy> *>  connections_list;
    766 
    767       _signal_base5()
    768       {
    769         ;
    770       }
    771 
    772       _signal_base5(const _signal_base5<arg1_type, arg2_type, arg3_type, arg4_type,
    773                     arg5_type, mt_policy>& s)
    774           : _signal_base<mt_policy>(s)
    775       {
    776         lock_block<mt_policy> lock(this);
    777         typename connections_list::const_iterator it = s.m_connected_slots.begin();
    778         typename connections_list::const_iterator itEnd = s.m_connected_slots.end();
    779 
    780         while(it != itEnd)
    781         {
    782           (*it)->getdest()->signal_connect(this);
    783           m_connected_slots.push_back((*it)->clone());
    784 
    785           ++it;
    786         }
    787       }
    788 
    789       void slot_duplicate(const has_slots<mt_policy>* oldtarget, has_slots<mt_policy>* newtarget)
    790       {
    791         lock_block<mt_policy> lock(this);
    792         typename connections_list::iterator it = m_connected_slots.begin();
    793         typename connections_list::iterator itEnd = m_connected_slots.end();
    794 
    795         while(it != itEnd)
    796         {
    797           if((*it)->getdest() == oldtarget)
    798           {
    799             m_connected_slots.push_back((*it)->duplicate(newtarget));
    800           }
    801 
    802           ++it;
    803         }
    804       }
    805 
    806       ~_signal_base5()
    807       {
    808         disconnect_all();
    809       }
    810 
    811       void disconnect_all()
    812       {
    813         lock_block<mt_policy> lock(this);
    814         typename connections_list::const_iterator it = m_connected_slots.begin();
    815         typename connections_list::const_iterator itEnd = m_connected_slots.end();
    816 
    817         while(it != itEnd)
    818         {
    819           (*it)->getdest()->signal_disconnect(this);
     763  public:
     764    typedef std::list<_connection_base5<arg1_type, arg2_type, arg3_type,
     765    arg4_type, arg5_type, mt_policy> *>  connections_list;
     766
     767    _signal_base5()
     768    {
     769      ;
     770    }
     771
     772    _signal_base5(const _signal_base5<arg1_type, arg2_type, arg3_type, arg4_type,
     773                  arg5_type, mt_policy>& s)
     774        : _signal_base<mt_policy>(s)
     775    {
     776      lock_block<mt_policy> lock(this);
     777      typename connections_list::const_iterator it = s.m_connected_slots.begin();
     778      typename connections_list::const_iterator itEnd = s.m_connected_slots.end();
     779
     780      while(it != itEnd)
     781      {
     782        (*it)->getdest()->signal_connect(this);
     783        m_connected_slots.push_back((*it)->clone());
     784
     785        ++it;
     786      }
     787    }
     788
     789    void slot_duplicate(const has_slots<mt_policy>* oldtarget, has_slots<mt_policy>* newtarget)
     790    {
     791      lock_block<mt_policy> lock(this);
     792      typename connections_list::iterator it = m_connected_slots.begin();
     793      typename connections_list::iterator itEnd = m_connected_slots.end();
     794
     795      while(it != itEnd)
     796      {
     797        if((*it)->getdest() == oldtarget)
     798        {
     799          m_connected_slots.push_back((*it)->duplicate(newtarget));
     800        }
     801
     802        ++it;
     803      }
     804    }
     805
     806    ~_signal_base5()
     807    {
     808      disconnect_all();
     809    }
     810
     811    void disconnect_all()
     812    {
     813      lock_block<mt_policy> lock(this);
     814      typename connections_list::const_iterator it = m_connected_slots.begin();
     815      typename connections_list::const_iterator itEnd = m_connected_slots.end();
     816
     817      while(it != itEnd)
     818      {
     819        (*it)->getdest()->signal_disconnect(this);
     820        delete *it;
     821
     822        ++it;
     823      }
     824
     825      m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
     826    }
     827
     828    void disconnect(has_slots<mt_policy>* pclass)
     829    {
     830      lock_block<mt_policy> lock(this);
     831      typename connections_list::iterator it = m_connected_slots.begin();
     832      typename connections_list::iterator itEnd = m_connected_slots.end();
     833
     834      while(it != itEnd)
     835      {
     836        if((*it)->getdest() == pclass)
     837        {
    820838          delete *it;
    821 
    822           ++it;
    823         }
    824 
    825         m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
    826       }
    827 
    828       void disconnect(has_slots<mt_policy>* pclass)
    829       {
    830         lock_block<mt_policy> lock(this);
    831         typename connections_list::iterator it = m_connected_slots.begin();
    832         typename connections_list::iterator itEnd = m_connected_slots.end();
    833 
    834         while(it != itEnd)
    835         {
    836           if((*it)->getdest() == pclass)
    837           {
    838             delete *it;
    839             m_connected_slots.erase(it);
    840             pclass->signal_disconnect(this);
    841             return;
    842           }
    843 
    844           ++it;
    845         }
    846       }
    847 
    848       void slot_disconnect(has_slots<mt_policy>* pslot)
    849       {
    850         lock_block<mt_policy> lock(this);
    851         typename connections_list::iterator it = m_connected_slots.begin();
    852         typename connections_list::iterator itEnd = m_connected_slots.end();
    853 
    854         while(it != itEnd)
    855         {
    856           typename connections_list::iterator itNext = it;
    857           ++itNext;
    858 
    859           if((*it)->getdest() == pslot)
    860           {
    861             m_connected_slots.erase(it);
    862             //                  delete *it;
    863           }
    864 
    865           it = itNext;
    866         }
    867       }
    868 
    869     protected:
    870       connections_list m_connected_slots;
     839          m_connected_slots.erase(it);
     840          pclass->signal_disconnect(this);
     841          return;
     842        }
     843
     844        ++it;
     845      }
     846    }
     847
     848    void slot_disconnect(has_slots<mt_policy>* pslot)
     849    {
     850      lock_block<mt_policy> lock(this);
     851      typename connections_list::iterator it = m_connected_slots.begin();
     852      typename connections_list::iterator itEnd = m_connected_slots.end();
     853
     854      while(it != itEnd)
     855      {
     856        typename connections_list::iterator itNext = it;
     857        ++itNext;
     858
     859        if((*it)->getdest() == pslot)
     860        {
     861          m_connected_slots.erase(it);
     862          //                    delete *it;
     863        }
     864
     865        it = itNext;
     866      }
     867    }
     868
     869  protected:
     870    connections_list m_connected_slots;
    871871  };
    872872
     
    875875  class _signal_base6 : public _signal_base<mt_policy>
    876876  {
    877     public:
    878       typedef std::list<_connection_base6<arg1_type, arg2_type, arg3_type,
    879       arg4_type, arg5_type, arg6_type, mt_policy> *>  connections_list;
    880 
    881       _signal_base6()
    882       {
    883         ;
    884       }
    885 
    886       _signal_base6(const _signal_base6<arg1_type, arg2_type, arg3_type, arg4_type,
    887                     arg5_type, arg6_type, mt_policy>& s)
    888           : _signal_base<mt_policy>(s)
    889       {
    890         lock_block<mt_policy> lock(this);
    891         typename connections_list::const_iterator it = s.m_connected_slots.begin();
    892         typename connections_list::const_iterator itEnd = s.m_connected_slots.end();
    893 
    894         while(it != itEnd)
    895         {
    896           (*it)->getdest()->signal_connect(this);
    897           m_connected_slots.push_back((*it)->clone());
    898 
    899           ++it;
    900         }
    901       }
    902 
    903       void slot_duplicate(const has_slots<mt_policy>* oldtarget, has_slots<mt_policy>* newtarget)
    904       {
    905         lock_block<mt_policy> lock(this);
    906         typename connections_list::iterator it = m_connected_slots.begin();
    907         typename connections_list::iterator itEnd = m_connected_slots.end();
    908 
    909         while(it != itEnd)
    910         {
    911           if((*it)->getdest() == oldtarget)
    912           {
    913             m_connected_slots.push_back((*it)->duplicate(newtarget));
    914           }
    915 
    916           ++it;
    917         }
    918       }
    919 
    920       ~_signal_base6()
    921       {
    922         disconnect_all();
    923       }
    924 
    925       void disconnect_all()
    926       {
    927         lock_block<mt_policy> lock(this);
    928         typename connections_list::const_iterator it = m_connected_slots.begin();
    929         typename connections_list::const_iterator itEnd = m_connected_slots.end();
    930 
    931         while(it != itEnd)
    932         {
    933           (*it)->getdest()->signal_disconnect(this);
     877  public:
     878    typedef std::list<_connection_base6<arg1_type, arg2_type, arg3_type,
     879    arg4_type, arg5_type, arg6_type, mt_policy> *>  connections_list;
     880
     881    _signal_base6()
     882    {
     883      ;
     884    }
     885
     886    _signal_base6(const _signal_base6<arg1_type, arg2_type, arg3_type, arg4_type,
     887                  arg5_type, arg6_type, mt_policy>& s)
     888        : _signal_base<mt_policy>(s)
     889    {
     890      lock_block<mt_policy> lock(this);
     891      typename connections_list::const_iterator it = s.m_connected_slots.begin();
     892      typename connections_list::const_iterator itEnd = s.m_connected_slots.end();
     893
     894      while(it != itEnd)
     895      {
     896        (*it)->getdest()->signal_connect(this);
     897        m_connected_slots.push_back((*it)->clone());
     898
     899        ++it;
     900      }
     901    }
     902
     903    void slot_duplicate(const has_slots<mt_policy>* oldtarget, has_slots<mt_policy>* newtarget)
     904    {
     905      lock_block<mt_policy> lock(this);
     906      typename connections_list::iterator it = m_connected_slots.begin();
     907      typename connections_list::iterator itEnd = m_connected_slots.end();
     908
     909      while(it != itEnd)
     910      {
     911        if((*it)->getdest() == oldtarget)
     912        {
     913          m_connected_slots.push_back((*it)->duplicate(newtarget));
     914        }
     915
     916        ++it;
     917      }
     918    }
     919
     920    ~_signal_base6()
     921    {
     922      disconnect_all();
     923    }
     924
     925    void disconnect_all()
     926    {
     927      lock_block<mt_policy> lock(this);
     928      typename connections_list::const_iterator it = m_connected_slots.begin();
     929      typename connections_list::const_iterator itEnd = m_connected_slots.end();
     930
     931      while(it != itEnd)
     932      {
     933        (*it)->getdest()->signal_disconnect(this);
     934        delete *it;
     935
     936        ++it;
     937      }
     938
     939      m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
     940    }
     941
     942    void disconnect(has_slots<mt_policy>* pclass)
     943    {
     944      lock_block<mt_policy> lock(this);
     945      typename connections_list::iterator it = m_connected_slots.begin();
     946      typename connections_list::iterator itEnd = m_connected_slots.end();
     947
     948      while(it != itEnd)
     949      {
     950        if((*it)->getdest() == pclass)
     951        {
    934952          delete *it;
    935 
    936           ++it;
    937         }
    938 
    939         m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
    940       }
    941 
    942       void disconnect(has_slots<mt_policy>* pclass)
    943       {
    944         lock_block<mt_policy> lock(this);
    945         typename connections_list::iterator it = m_connected_slots.begin();
    946         typename connections_list::iterator itEnd = m_connected_slots.end();
    947 
    948         while(it != itEnd)
    949         {
    950           if((*it)->getdest() == pclass)
    951           {
    952             delete *it;
    953             m_connected_slots.erase(it);
    954             pclass->signal_disconnect(this);
    955             return;
    956           }
    957 
    958           ++it;
    959         }
    960       }
    961 
    962       void slot_disconnect(has_slots<mt_policy>* pslot)
    963       {
    964         lock_block<mt_policy> lock(this);
    965         typename connections_list::iterator it = m_connected_slots.begin();
    966         typename connections_list::iterator itEnd = m_connected_slots.end();
    967 
    968         while(it != itEnd)
    969         {
    970           typename connections_list::iterator itNext = it;
    971           ++itNext;
    972 
    973           if((*it)->getdest() == pslot)
    974           {
    975             m_connected_slots.erase(it);
    976             //                  delete *it;
    977           }
    978 
    979           it = itNext;
    980         }
    981       }
    982 
    983     protected:
    984       connections_list m_connected_slots;
     953          m_connected_slots.erase(it);
     954          pclass->signal_disconnect(this);
     955          return;
     956        }
     957
     958        ++it;
     959      }
     960    }
     961
     962    void slot_disconnect(has_slots<mt_policy>* pslot)
     963    {
     964      lock_block<mt_policy> lock(this);
     965      typename connections_list::iterator it = m_connected_slots.begin();
     966      typename connections_list::iterator itEnd = m_connected_slots.end();
     967
     968      while(it != itEnd)
     969      {
     970        typename connections_list::iterator itNext = it;
     971        ++itNext;
     972
     973        if((*it)->getdest() == pslot)
     974        {
     975          m_connected_slots.erase(it);
     976          //                    delete *it;
     977        }
     978
     979        it = itNext;
     980      }
     981    }
     982
     983  protected:
     984    connections_list m_connected_slots;
    985985  };
    986986
     
    989989  class _signal_base7 : public _signal_base<mt_policy>
    990990  {
    991     public:
    992       typedef std::list<_connection_base7<arg1_type, arg2_type, arg3_type,
    993       arg4_type, arg5_type, arg6_type, arg7_type, mt_policy> *>  connections_list;
    994 
    995       _signal_base7()
    996       {
    997         ;
    998       }
    999 
    1000       _signal_base7(const _signal_base7<arg1_type, arg2_type, arg3_type, arg4_type,
    1001                     arg5_type, arg6_type, arg7_type, mt_policy>& s)
    1002           : _signal_base<mt_policy>(s)
    1003       {
    1004         lock_block<mt_policy> lock(this);
    1005         typename connections_list::const_iterator it = s.m_connected_slots.begin();
    1006         typename connections_list::const_iterator itEnd = s.m_connected_slots.end();
    1007 
    1008         while(it != itEnd)
    1009         {
    1010           (*it)->getdest()->signal_connect(this);
    1011           m_connected_slots.push_back((*it)->clone());
    1012 
    1013           ++it;
    1014         }
    1015       }
    1016 
    1017       void slot_duplicate(const has_slots<mt_policy>* oldtarget, has_slots<mt_policy>* newtarget)
    1018       {
    1019         lock_block<mt_policy> lock(this);
    1020         typename connections_list::iterator it = m_connected_slots.begin();
    1021         typename connections_list::iterator itEnd = m_connected_slots.end();
    1022 
    1023         while(it != itEnd)
    1024         {
    1025           if((*it)->getdest() == oldtarget)
    1026           {
    1027             m_connected_slots.push_back((*it)->duplicate(newtarget));
    1028           }
    1029 
    1030           ++it;
    1031         }
    1032       }
    1033 
    1034       ~_signal_base7()
    1035       {
    1036         disconnect_all();
    1037       }
    1038 
    1039       void disconnect_all()
    1040       {
    1041         lock_block<mt_policy> lock(this);
    1042         typename connections_list::const_iterator it = m_connected_slots.begin();
    1043         typename connections_list::const_iterator itEnd = m_connected_slots.end();
    1044 
    1045         while(it != itEnd)
    1046         {
    1047           (*it)->getdest()->signal_disconnect(this);
     991  public:
     992    typedef std::list<_connection_base7<arg1_type, arg2_type, arg3_type,
     993    arg4_type, arg5_type, arg6_type, arg7_type, mt_policy> *>  connections_list;
     994
     995    _signal_base7()
     996    {
     997      ;
     998    }
     999
     1000    _signal_base7(const _signal_base7<arg1_type, arg2_type, arg3_type, arg4_type,
     1001                  arg5_type, arg6_type, arg7_type, mt_policy>& s)
     1002        : _signal_base<mt_policy>(s)
     1003    {
     1004      lock_block<mt_policy> lock(this);
     1005      typename connections_list::const_iterator it = s.m_connected_slots.begin();
     1006      typename connections_list::const_iterator itEnd = s.m_connected_slots.end();
     1007
     1008      while(it != itEnd)
     1009      {
     1010        (*it)->getdest()->signal_connect(this);
     1011        m_connected_slots.push_back((*it)->clone());
     1012
     1013        ++it;
     1014      }
     1015    }
     1016
     1017    void slot_duplicate(const has_slots<mt_policy>* oldtarget, has_slots<mt_policy>* newtarget)
     1018    {
     1019      lock_block<mt_policy> lock(this);
     1020      typename connections_list::iterator it = m_connected_slots.begin();
     1021      typename connections_list::iterator itEnd = m_connected_slots.end();
     1022
     1023      while(it != itEnd)
     1024      {
     1025        if((*it)->getdest() == oldtarget)
     1026        {
     1027          m_connected_slots.push_back((*it)->duplicate(newtarget));
     1028        }
     1029
     1030        ++it;
     1031      }
     1032    }
     1033
     1034    ~_signal_base7()
     1035    {
     1036      disconnect_all();
     1037    }
     1038
     1039    void disconnect_all()
     1040    {
     1041      lock_block<mt_policy> lock(this);
     1042      typename connections_list::const_iterator it = m_connected_slots.begin();
     1043      typename connections_list::const_iterator itEnd = m_connected_slots.end();
     1044
     1045      while(it != itEnd)
     1046      {
     1047        (*it)->getdest()->signal_disconnect(this);
     1048        delete *it;
     1049
     1050        ++it;
     1051      }
     1052
     1053      m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
     1054    }
     1055
     1056    void disconnect(has_slots<mt_policy>* pclass)
     1057    {
     1058      lock_block<mt_policy> lock(this);
     1059      typename connections_list::iterator it = m_connected_slots.begin();
     1060      typename connections_list::iterator itEnd = m_connected_slots.end();
     1061
     1062      while(it != itEnd)
     1063      {
     1064        if((*it)->getdest() == pclass)
     1065        {
    10481066          delete *it;
    1049 
    1050           ++it;
    1051         }
    1052 
    1053         m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
    1054       }
    1055 
    1056       void disconnect(has_slots<mt_policy>* pclass)
    1057       {
    1058         lock_block<mt_policy> lock(this);
    1059         typename connections_list::iterator it = m_connected_slots.begin();
    1060         typename connections_list::iterator itEnd = m_connected_slots.end();
    1061 
    1062         while(it != itEnd)
    1063         {
    1064           if((*it)->getdest() == pclass)
    1065           {
    1066             delete *it;
    1067             m_connected_slots.erase(it);
    1068             pclass->signal_disconnect(this);
    1069             return;
    1070           }
    1071 
    1072           ++it;
    1073         }
    1074       }
    1075 
    1076       void slot_disconnect(has_slots<mt_policy>* pslot)
    1077       {
    1078         lock_block<mt_policy> lock(this);
    1079         typename connections_list::iterator it = m_connected_slots.begin();
    1080         typename connections_list::iterator itEnd = m_connected_slots.end();
    1081 
    1082         while(it != itEnd)
    1083         {
    1084           typename connections_list::iterator itNext = it;
    1085           ++itNext;
    1086 
    1087           if((*it)->getdest() == pslot)
    1088           {
    1089             m_connected_slots.erase(it);
    1090             //                  delete *it;
    1091           }
    1092 
    1093           it = itNext;
    1094         }
    1095       }
    1096 
    1097     protected:
    1098       connections_list m_connected_slots;
     1067          m_connected_slots.erase(it);
     1068          pclass->signal_disconnect(this);
     1069          return;
     1070        }
     1071
     1072        ++it;
     1073      }
     1074    }
     1075
     1076    void slot_disconnect(has_slots<mt_policy>* pslot)
     1077    {
     1078      lock_block<mt_policy> lock(this);
     1079      typename connections_list::iterator it = m_connected_slots.begin();
     1080      typename connections_list::iterator itEnd = m_connected_slots.end();
     1081
     1082      while(it != itEnd)
     1083      {
     1084        typename connections_list::iterator itNext = it;
     1085        ++itNext;
     1086
     1087        if((*it)->getdest() == pslot)
     1088        {
     1089          m_connected_slots.erase(it);
     1090          //                    delete *it;
     1091        }
     1092
     1093        it = itNext;
     1094      }
     1095    }
     1096
     1097  protected:
     1098    connections_list m_connected_slots;
    10991099  };
    11001100
     
    11031103  class _signal_base8 : public _signal_base<mt_policy>
    11041104  {
    1105     public:
    1106       typedef std::list<_connection_base8<arg1_type, arg2_type, arg3_type,
    1107       arg4_type, arg5_type, arg6_type, arg7_type, arg8_type, mt_policy> *>
    1108       connections_list;
    1109 
    1110       _signal_base8()
    1111       {
    1112         ;
    1113       }
    1114 
    1115       _signal_base8(const _signal_base8<arg1_type, arg2_type, arg3_type, arg4_type,
    1116                     arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>& s)
    1117           : _signal_base<mt_policy>(s)
    1118       {
    1119         lock_block<mt_policy> lock(this);
    1120         typename connections_list::const_iterator it = s.m_connected_slots.begin();
    1121         typename connections_list::const_iterator itEnd = s.m_connected_slots.end();
    1122 
    1123         while(it != itEnd)
    1124         {
    1125           (*it)->getdest()->signal_connect(this);
    1126           m_connected_slots.push_back((*it)->clone());
    1127 
    1128           ++it;
    1129         }
    1130       }
    1131 
    1132       void slot_duplicate(const has_slots<mt_policy>* oldtarget, has_slots<mt_policy>* newtarget)
    1133       {
    1134         lock_block<mt_policy> lock(this);
    1135         typename connections_list::iterator it = m_connected_slots.begin();
    1136         typename connections_list::iterator itEnd = m_connected_slots.end();
    1137 
    1138         while(it != itEnd)
    1139         {
    1140           if((*it)->getdest() == oldtarget)
    1141           {
    1142             m_connected_slots.push_back((*it)->duplicate(newtarget));
    1143           }
    1144 
    1145           ++it;
    1146         }
    1147       }
    1148 
    1149       ~_signal_base8()
    1150       {
    1151         disconnect_all();
    1152       }
    1153 
    1154       void disconnect_all()
    1155       {
    1156         lock_block<mt_policy> lock(this);
    1157         typename connections_list::const_iterator it = m_connected_slots.begin();
    1158         typename connections_list::const_iterator itEnd = m_connected_slots.end();
    1159 
    1160         while(it != itEnd)
    1161         {
    1162           (*it)->getdest()->signal_disconnect(this);
     1105  public:
     1106    typedef std::list<_connection_base8<arg1_type, arg2_type, arg3_type,
     1107    arg4_type, arg5_type, arg6_type, arg7_type, arg8_type, mt_policy> *>
     1108    connections_list;
     1109
     1110    _signal_base8()
     1111    {
     1112      ;
     1113    }
     1114
     1115    _signal_base8(const _signal_base8<arg1_type, arg2_type, arg3_type, arg4_type,
     1116                  arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>& s)
     1117        : _signal_base<mt_policy>(s)
     1118    {
     1119      lock_block<mt_policy> lock(this);
     1120      typename connections_list::const_iterator it = s.m_connected_slots.begin();
     1121      typename connections_list::const_iterator itEnd = s.m_connected_slots.end();
     1122
     1123      while(it != itEnd)
     1124      {
     1125        (*it)->getdest()->signal_connect(this);
     1126        m_connected_slots.push_back((*it)->clone());
     1127
     1128        ++it;
     1129      }
     1130    }
     1131
     1132    void slot_duplicate(const has_slots<mt_policy>* oldtarget, has_slots<mt_policy>* newtarget)
     1133    {
     1134      lock_block<mt_policy> lock(this);
     1135      typename connections_list::iterator it = m_connected_slots.begin();
     1136      typename connections_list::iterator itEnd = m_connected_slots.end();
     1137
     1138      while(it != itEnd)
     1139      {
     1140        if((*it)->getdest() == oldtarget)
     1141        {
     1142          m_connected_slots.push_back((*it)->duplicate(newtarget));
     1143        }
     1144
     1145        ++it;
     1146      }
     1147    }
     1148
     1149    ~_signal_base8()
     1150    {
     1151      disconnect_all();
     1152    }
     1153
     1154    void disconnect_all()
     1155    {
     1156      lock_block<mt_policy> lock(this);
     1157      typename connections_list::const_iterator it = m_connected_slots.begin();
     1158      typename connections_list::const_iterator itEnd = m_connected_slots.end();
     1159
     1160      while(it != itEnd)
     1161      {
     1162        (*it)->getdest()->signal_disconnect(this);
     1163        delete *it;
     1164
     1165        ++it;
     1166      }
     1167
     1168      m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
     1169    }
     1170
     1171    void disconnect(has_slots<mt_policy>* pclass)
     1172    {
     1173      lock_block<mt_policy> lock(this);
     1174      typename connections_list::iterator it = m_connected_slots.begin();
     1175      typename connections_list::iterator itEnd = m_connected_slots.end();
     1176
     1177      while(it != itEnd)
     1178      {
     1179        if((*it)->getdest() == pclass)
     1180        {
    11631181          delete *it;
    1164 
    1165           ++it;
    1166         }
    1167 
    1168         m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
    1169       }
    1170 
    1171       void disconnect(has_slots<mt_policy>* pclass)
    1172       {
    1173         lock_block<mt_policy> lock(this);
    1174         typename connections_list::iterator it = m_connected_slots.begin();
    1175         typename connections_list::iterator itEnd = m_connected_slots.end();
    1176 
    1177         while(it != itEnd)
    1178         {
    1179           if((*it)->getdest() == pclass)
    1180           {
    1181             delete *it;
    1182             m_connected_slots.erase(it);
    1183             pclass->signal_disconnect(this);
    1184             return;
    1185           }
    1186 
    1187           ++it;
    1188         }
    1189       }
    1190 
    1191       void slot_disconnect(has_slots<mt_policy>* pslot)
    1192       {
    1193         lock_block<mt_policy> lock(this);
    1194         typename connections_list::iterator it = m_connected_slots.begin();
    1195         typename connections_list::iterator itEnd = m_connected_slots.end();
    1196 
    1197         while(it != itEnd)
    1198         {
    1199           typename connections_list::iterator itNext = it;
    1200           ++itNext;
    1201 
    1202           if((*it)->getdest() == pslot)
    1203           {
    1204             m_connected_slots.erase(it);
    1205             //                  delete *it;
    1206           }
    1207 
    1208           it = itNext;
    1209         }
    1210       }
    1211 
    1212     protected:
    1213       connections_list m_connected_slots;
     1182          m_connected_slots.erase(it);
     1183          pclass->signal_disconnect(this);
     1184          return;
     1185        }
     1186
     1187        ++it;
     1188      }
     1189    }
     1190
     1191    void slot_disconnect(has_slots<mt_policy>* pslot)
     1192    {
     1193      lock_block<mt_policy> lock(this);
     1194      typename connections_list::iterator it = m_connected_slots.begin();
     1195      typename connections_list::iterator itEnd = m_connected_slots.end();
     1196
     1197      while(it != itEnd)
     1198      {
     1199        typename connections_list::iterator itNext = it;
     1200        ++itNext;
     1201
     1202        if((*it)->getdest() == pslot)
     1203        {
     1204          m_connected_slots.erase(it);
     1205          //                    delete *it;
     1206        }
     1207
     1208        it = itNext;
     1209      }
     1210    }
     1211
     1212  protected:
     1213    connections_list m_connected_slots;
    12141214  };
    12151215
     
    12181218  class _connection0 : public _connection_base0<mt_policy>
    12191219  {
    1220     public:
    1221       _connection0()
    1222       {
    1223         pobject = NULL;
    1224         pmemfun = NULL;
    1225       }
    1226 
    1227       _connection0(dest_type* pobject, void (dest_type::*pmemfun)())
    1228       {
    1229         m_pobject = pobject;
    1230         m_pmemfun = pmemfun;
    1231       }
    1232 
    1233       virtual _connection_base0<mt_policy>* clone()
    1234       {
    1235         return new _connection0<dest_type, mt_policy>(*this);
    1236       }
    1237 
    1238       virtual _connection_base0<mt_policy>* duplicate(has_slots<mt_policy>* pnewdest)
    1239       {
    1240         return new _connection0<dest_type, mt_policy>((dest_type *)pnewdest, m_pmemfun);
    1241       }
    1242 
    1243       virtual void emit()
    1244       {
    1245         (m_pobject->*m_pmemfun)();
    1246       }
    1247 
    1248       virtual has_slots<mt_policy>* getdest() const
    1249       {
    1250         return m_pobject;
    1251       }
    1252 
    1253     private:
    1254       dest_type* m_pobject;
    1255       void (dest_type::* m_pmemfun)();
     1220  public:
     1221    _connection0()
     1222    {
     1223      m_pobject = NULL;
     1224      m_pmemfun = NULL;
     1225    }
     1226
     1227    _connection0(dest_type* pobject, void (dest_type::*pmemfun)())
     1228    {
     1229      m_pobject = pobject;
     1230      m_pmemfun = pmemfun;
     1231    }
     1232
     1233    virtual _connection_base0<mt_policy>* clone()
     1234    {
     1235      return new _connection0<dest_type, mt_policy>(*this);
     1236    }
     1237
     1238    virtual _connection_base0<mt_policy>* duplicate(has_slots<mt_policy>* pnewdest)
     1239    {
     1240      return new _connection0<dest_type, mt_policy>((dest_type *)pnewdest, m_pmemfun);
     1241    }
     1242
     1243    virtual void emit()
     1244    {
     1245      (m_pobject->*m_pmemfun)();
     1246    }
     1247
     1248    virtual has_slots<mt_policy>* getdest() const
     1249    {
     1250      return m_pobject;
     1251    }
     1252
     1253  private:
     1254    dest_type* m_pobject;
     1255    void (dest_type::* m_pmemfun)();
    12561256  };
    12571257
     
    12591259  class _connection1 : public _connection_base1<arg1_type, mt_policy>
    12601260  {
    1261     public:
    1262       _connection1()
    1263       {
    1264         pobject = NULL;
    1265         pmemfun = NULL;
    1266       }
    1267 
    1268       _connection1(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type))
    1269       {
    1270         m_pobject = pobject;
    1271         m_pmemfun = pmemfun;
    1272       }
    1273 
    1274       virtual _connection_base1<arg1_type, mt_policy>* clone()
    1275       {
    1276         return new _connection1<dest_type, arg1_type, mt_policy>(*this);
    1277       }
    1278 
    1279       virtual _connection_base1<arg1_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest)
    1280       {
    1281         return new _connection1<dest_type, arg1_type, mt_policy>((dest_type *)pnewdest, m_pmemfun);
    1282       }
    1283 
    1284       virtual void emit(arg1_type a1)
    1285       {
    1286         (m_pobject->*m_pmemfun)(a1);
    1287       }
    1288 
    1289       virtual has_slots<mt_policy>* getdest() const
    1290       {
    1291         return m_pobject;
    1292       }
    1293 
    1294     private:
    1295       dest_type* m_pobject;
    1296       void (dest_type::* m_pmemfun)(arg1_type);
     1261  public:
     1262    _connection1()
     1263    {
     1264      m_pobject = NULL;
     1265      m_pmemfun = NULL;
     1266    }
     1267
     1268    _connection1(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type))
     1269    {
     1270      m_pobject = pobject;
     1271      m_pmemfun = pmemfun;
     1272    }
     1273
     1274    virtual _connection_base1<arg1_type, mt_policy>* clone()
     1275    {
     1276      return new _connection1<dest_type, arg1_type, mt_policy>(*this);
     1277    }
     1278
     1279    virtual _connection_base1<arg1_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest)
     1280    {
     1281      return new _connection1<dest_type, arg1_type, mt_policy>((dest_type *)pnewdest, m_pmemfun);
     1282    }
     1283
     1284    virtual void emit(arg1_type a1)
     1285    {
     1286      (m_pobject->*m_pmemfun)(a1);
     1287    }
     1288
     1289    virtual has_slots<mt_policy>* getdest() const
     1290    {
     1291      return m_pobject;
     1292    }
     1293
     1294  private:
     1295    dest_type* m_pobject;
     1296    void (dest_type::* m_pmemfun)(arg1_type);
    12971297  };
    12981298
     
    13001300  class _connection2 : public _connection_base2<arg1_type, arg2_type, mt_policy>
    13011301  {
    1302     public:
    1303       _connection2()
    1304       {
    1305         pobject = NULL;
    1306         pmemfun = NULL;
    1307       }
    1308 
    1309       _connection2(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type,
    1310                    arg2_type))
    1311       {
    1312         m_pobject = pobject;
    1313         m_pmemfun = pmemfun;
    1314       }
    1315 
    1316       virtual _connection_base2<arg1_type, arg2_type, mt_policy>* clone()
    1317       {
    1318         return new _connection2<dest_type, arg1_type, arg2_type, mt_policy>(*this);
    1319       }
    1320 
    1321       virtual _connection_base2<arg1_type, arg2_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest)
    1322       {
    1323         return new _connection2<dest_type, arg1_type, arg2_type, mt_policy>((dest_type *)pnewdest, m_pmemfun);
    1324       }
    1325 
    1326       virtual void emit(arg1_type a1, arg2_type a2)
    1327       {
    1328         (m_pobject->*m_pmemfun)(a1, a2);
    1329       }
    1330 
    1331       virtual has_slots<mt_policy>* getdest() const
    1332       {
    1333         return m_pobject;
    1334       }
    1335 
    1336     private:
    1337       dest_type* m_pobject;
    1338       void (dest_type::* m_pmemfun)(arg1_type, arg2_type);
     1302  public:
     1303    _connection2()
     1304    {
     1305      m_pobject = NULL;
     1306      m_pmemfun = NULL;
     1307    }
     1308
     1309    _connection2(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type,
     1310                 arg2_type))
     1311    {
     1312      m_pobject = pobject;
     1313      m_pmemfun = pmemfun;
     1314    }
     1315
     1316    virtual _connection_base2<arg1_type, arg2_type, mt_policy>* clone()
     1317    {
     1318      return new _connection2<dest_type, arg1_type, arg2_type, mt_policy>(*this);
     1319    }
     1320
     1321    virtual _connection_base2<arg1_type, arg2_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest)
     1322    {
     1323      return new _connection2<dest_type, arg1_type, arg2_type, mt_policy>((dest_type *)pnewdest, m_pmemfun);
     1324    }
     1325
     1326    virtual void emit(arg1_type a1, arg2_type a2)
     1327    {
     1328      (m_pobject->*m_pmemfun)(a1, a2);
     1329    }
     1330
     1331    virtual has_slots<mt_policy>* getdest() const
     1332    {
     1333      return m_pobject;
     1334    }
     1335
     1336  private:
     1337    dest_type* m_pobject;
     1338    void (dest_type::* m_pmemfun)(arg1_type, arg2_type);
    13391339  };
    13401340
     
    13421342  class _connection3 : public _connection_base3<arg1_type, arg2_type, arg3_type, mt_policy>
    13431343  {
    1344     public:
    1345       _connection3()
    1346       {
    1347         pobject = NULL;
    1348         pmemfun = NULL;
    1349       }
    1350 
    1351       _connection3(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type,
    1352                    arg2_type, arg3_type))
    1353       {
    1354         m_pobject = pobject;
    1355         m_pmemfun = pmemfun;
    1356       }
    1357 
    1358       virtual _connection_base3<arg1_type, arg2_type, arg3_type, mt_policy>* clone()
    1359       {
    1360         return new _connection3<dest_type, arg1_type, arg2_type, arg3_type, mt_policy>(*this);
    1361       }
    1362 
    1363       virtual _connection_base3<arg1_type, arg2_type, arg3_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest)
    1364       {
    1365         return new _connection3<dest_type, arg1_type, arg2_type, arg3_type, mt_policy>((dest_type *)pnewdest, m_pmemfun);
    1366       }
    1367 
    1368       virtual void emit(arg1_type a1, arg2_type a2, arg3_type a3)
    1369       {
    1370         (m_pobject->*m_pmemfun)(a1, a2, a3);
    1371       }
    1372 
    1373       virtual has_slots<mt_policy>* getdest() const
    1374       {
    1375         return m_pobject;
    1376       }
    1377 
    1378     private:
    1379       dest_type* m_pobject;
    1380       void (dest_type::* m_pmemfun)(arg1_type, arg2_type, arg3_type);
     1344  public:
     1345    _connection3()
     1346    {
     1347      m_pobject = NULL;
     1348      m_pmemfun = NULL;
     1349    }
     1350
     1351    _connection3(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type,
     1352                 arg2_type, arg3_type))
     1353    {
     1354      m_pobject = pobject;
     1355      m_pmemfun = pmemfun;
     1356    }
     1357
     1358    virtual _connection_base3<arg1_type, arg2_type, arg3_type, mt_policy>* clone()
     1359    {
     1360      return new _connection3<dest_type, arg1_type, arg2_type, arg3_type, mt_policy>(*this);
     1361    }
     1362
     1363    virtual _connection_base3<arg1_type, arg2_type, arg3_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest)
     1364    {
     1365      return new _connection3<dest_type, arg1_type, arg2_type, arg3_type, mt_policy>((dest_type *)pnewdest, m_pmemfun);
     1366    }
     1367
     1368    virtual void emit(arg1_type a1, arg2_type a2, arg3_type a3)
     1369    {
     1370      (m_pobject->*m_pmemfun)(a1, a2, a3);
     1371    }
     1372
     1373    virtual has_slots<mt_policy>* getdest() const
     1374    {
     1375      return m_pobject;
     1376    }
     1377
     1378  private:
     1379    dest_type* m_pobject;
     1380    void (dest_type::* m_pmemfun)(arg1_type, arg2_type, arg3_type);
    13811381  };
    13821382
     
    13861386        arg3_type, arg4_type, mt_policy>
    13871387  {
    1388     public:
    1389       _connection4()
    1390       {
    1391         pobject = NULL;
    1392         pmemfun = NULL;
    1393       }
    1394 
    1395       _connection4(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type,
    1396                    arg2_type, arg3_type, arg4_type))
    1397       {
    1398         m_pobject = pobject;
    1399         m_pmemfun = pmemfun;
    1400       }
    1401 
    1402       virtual _connection_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>* clone()
    1403       {
    1404         return new _connection4<dest_type, arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>(*this);
    1405       }
    1406 
    1407       virtual _connection_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest)
    1408       {
    1409         return new _connection4<dest_type, arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>((dest_type *)pnewdest, m_pmemfun);
    1410       }
    1411 
    1412       virtual void emit(arg1_type a1, arg2_type a2, arg3_type a3,
    1413                         arg4_type a4)
    1414       {
    1415         (m_pobject->*m_pmemfun)(a1, a2, a3, a4);
    1416       }
    1417 
    1418       virtual has_slots<mt_policy>* getdest() const
    1419       {
    1420         return m_pobject;
    1421       }
    1422 
    1423     private:
    1424       dest_type* m_pobject;
    1425       void (dest_type::* m_pmemfun)(arg1_type, arg2_type, arg3_type,
    1426                                     arg4_type);
     1388  public:
     1389    _connection4()
     1390    {
     1391      m_pobject = NULL;
     1392      m_pmemfun = NULL;
     1393    }
     1394
     1395    _connection4(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type,
     1396                 arg2_type, arg3_type, arg4_type))
     1397    {
     1398      m_pobject = pobject;
     1399      m_pmemfun = pmemfun;
     1400    }
     1401
     1402    virtual _connection_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>* clone()
     1403    {
     1404      return new _connection4<dest_type, arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>(*this);
     1405    }
     1406
     1407    virtual _connection_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest)
     1408    {
     1409      return new _connection4<dest_type, arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>((dest_type *)pnewdest, m_pmemfun);
     1410    }
     1411
     1412    virtual void emit(arg1_type a1, arg2_type a2, arg3_type a3,
     1413                      arg4_type a4)
     1414    {
     1415      (m_pobject->*m_pmemfun)(a1, a2, a3, a4);
     1416    }
     1417
     1418    virtual has_slots<mt_policy>* getdest() const
     1419    {
     1420      return m_pobject;
     1421    }
     1422
     1423  private:
     1424    dest_type* m_pobject;
     1425    void (dest_type::* m_pmemfun)(arg1_type, arg2_type, arg3_type,
     1426                                  arg4_type);
    14271427  };
    14281428
     
    14321432        arg3_type, arg4_type, arg5_type, mt_policy>
    14331433  {
    1434     public:
    1435       _connection5()
    1436       {
    1437         pobject = NULL;
    1438         pmemfun = NULL;
    1439       }
    1440 
    1441       _connection5(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type,
    1442                    arg2_type, arg3_type, arg4_type, arg5_type))
    1443       {
    1444         m_pobject = pobject;
    1445         m_pmemfun = pmemfun;
    1446       }
    1447 
    1448       virtual _connection_base5<arg1_type, arg2_type, arg3_type, arg4_type,
    1449       arg5_type, mt_policy>* clone()
    1450       {
    1451         return new _connection5<dest_type, arg1_type, arg2_type, arg3_type, arg4_type,
    1452                arg5_type, mt_policy>(*this);
    1453       }
    1454 
    1455       virtual _connection_base5<arg1_type, arg2_type, arg3_type, arg4_type,
    1456       arg5_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest)
    1457       {
    1458         return new _connection5<dest_type, arg1_type, arg2_type, arg3_type, arg4_type,
    1459                arg5_type, mt_policy>((dest_type *)pnewdest, m_pmemfun);
    1460       }
    1461 
    1462       virtual void emit(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
    1463                         arg5_type a5)
    1464       {
    1465         (m_pobject->*m_pmemfun)(a1, a2, a3, a4, a5);
    1466       }
    1467 
    1468       virtual has_slots<mt_policy>* getdest() const
    1469       {
    1470         return m_pobject;
    1471       }
    1472 
    1473     private:
    1474       dest_type* m_pobject;
    1475       void (dest_type::* m_pmemfun)(arg1_type, arg2_type, arg3_type, arg4_type,
    1476                                     arg5_type);
     1434  public:
     1435    _connection5()
     1436    {
     1437      m_pobject = NULL;
     1438      m_pmemfun = NULL;
     1439    }
     1440
     1441    _connection5(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type,
     1442                 arg2_type, arg3_type, arg4_type, arg5_type))
     1443    {
     1444      m_pobject = pobject;
     1445      m_pmemfun = pmemfun;
     1446    }
     1447
     1448    virtual _connection_base5<arg1_type, arg2_type, arg3_type, arg4_type,
     1449    arg5_type, mt_policy>* clone()
     1450    {
     1451      return new _connection5<dest_type, arg1_type, arg2_type, arg3_type, arg4_type,
     1452             arg5_type, mt_policy>(*this);
     1453    }
     1454
     1455    virtual _connection_base5<arg1_type, arg2_type, arg3_type, arg4_type,
     1456    arg5_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest)
     1457    {
     1458      return new _connection5<dest_type, arg1_type, arg2_type, arg3_type, arg4_type,
     1459             arg5_type, mt_policy>((dest_type *)pnewdest, m_pmemfun);
     1460    }
     1461
     1462    virtual void emit(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
     1463                      arg5_type a5)
     1464    {
     1465      (m_pobject->*m_pmemfun)(a1, a2, a3, a4, a5);
     1466    }
     1467
     1468    virtual has_slots<mt_policy>* getdest() const
     1469    {
     1470      return m_pobject;
     1471    }
     1472
     1473  private:
     1474    dest_type* m_pobject;
     1475    void (dest_type::* m_pmemfun)(arg1_type, arg2_type, arg3_type, arg4_type,
     1476                                  arg5_type);
    14771477  };
    14781478
     
    14821482        arg3_type, arg4_type, arg5_type, arg6_type, mt_policy>
    14831483  {
    1484     public:
    1485       _connection6()
    1486       {
    1487         pobject = NULL;
    1488         pmemfun = NULL;
    1489       }
    1490 
    1491       _connection6(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type,
    1492                    arg2_type, arg3_type, arg4_type, arg5_type, arg6_type))
    1493       {
    1494         m_pobject = pobject;
    1495         m_pmemfun = pmemfun;
    1496       }
    1497 
    1498       virtual _connection_base6<arg1_type, arg2_type, arg3_type, arg4_type,
    1499       arg5_type, arg6_type, mt_policy>* clone()
    1500       {
    1501         return new _connection6<dest_type, arg1_type, arg2_type, arg3_type, arg4_type,
    1502                arg5_type, arg6_type, mt_policy>(*this);
    1503       }
    1504 
    1505       virtual _connection_base6<arg1_type, arg2_type, arg3_type, arg4_type,
    1506       arg5_type, arg6_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest)
    1507       {
    1508         return new _connection6<dest_type, arg1_type, arg2_type, arg3_type, arg4_type,
    1509                arg5_type, arg6_type, mt_policy>((dest_type *)pnewdest, m_pmemfun);
    1510       }
    1511 
    1512       virtual void emit(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
    1513                         arg5_type a5, arg6_type a6)
    1514       {
    1515         (m_pobject->*m_pmemfun)(a1, a2, a3, a4, a5, a6);
    1516       }
    1517 
    1518       virtual has_slots<mt_policy>* getdest() const
    1519       {
    1520         return m_pobject;
    1521       }
    1522 
    1523     private:
    1524       dest_type* m_pobject;
    1525       void (dest_type::* m_pmemfun)(arg1_type, arg2_type, arg3_type, arg4_type,
    1526                                     arg5_type, arg6_type);
     1484  public:
     1485    _connection6()
     1486    {
     1487      m_pobject = NULL;
     1488      m_pmemfun = NULL;
     1489    }
     1490
     1491    _connection6(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type,
     1492                 arg2_type, arg3_type, arg4_type, arg5_type, arg6_type))
     1493    {
     1494      m_pobject = pobject;
     1495      m_pmemfun = pmemfun;
     1496    }
     1497
     1498    virtual _connection_base6<arg1_type, arg2_type, arg3_type, arg4_type,
     1499    arg5_type, arg6_type, mt_policy>* clone()
     1500    {
     1501      return new _connection6<dest_type, arg1_type, arg2_type, arg3_type, arg4_type,
     1502             arg5_type, arg6_type, mt_policy>(*this);
     1503    }
     1504
     1505    virtual _connection_base6<arg1_type, arg2_type, arg3_type, arg4_type,
     1506    arg5_type, arg6_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest)
     1507    {
     1508      return new _connection6<dest_type, arg1_type, arg2_type, arg3_type, arg4_type,
     1509             arg5_type, arg6_type, mt_policy>((dest_type *)pnewdest, m_pmemfun);
     1510    }
     1511
     1512    virtual void emit(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
     1513                      arg5_type a5, arg6_type a6)
     1514    {
     1515      (m_pobject->*m_pmemfun)(a1, a2, a3, a4, a5, a6);
     1516    }
     1517
     1518    virtual has_slots<mt_policy>* getdest() const
     1519    {
     1520      return m_pobject;
     1521    }
     1522
     1523  private:
     1524    dest_type* m_pobject;
     1525    void (dest_type::* m_pmemfun)(arg1_type, arg2_type, arg3_type, arg4_type,
     1526                                  arg5_type, arg6_type);
    15271527  };
    15281528
     
    15321532        arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, mt_policy>
    15331533  {
    1534     public:
    1535       _connection7()
    1536       {
    1537         pobject = NULL;
    1538         pmemfun = NULL;
    1539       }
    1540 
    1541       _connection7(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type,
    1542                    arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type))
    1543       {
    1544         m_pobject = pobject;
    1545         m_pmemfun = pmemfun;
    1546       }
    1547 
    1548       virtual _connection_base7<arg1_type, arg2_type, arg3_type, arg4_type,
    1549       arg5_type, arg6_type, arg7_type, mt_policy>* clone()
    1550       {
    1551         return new _connection7<dest_type, arg1_type, arg2_type, arg3_type, arg4_type,
    1552                arg5_type, arg6_type, arg7_type, mt_policy>(*this);
    1553       }
    1554 
    1555       virtual _connection_base7<arg1_type, arg2_type, arg3_type, arg4_type,
    1556       arg5_type, arg6_type, arg7_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest)
    1557       {
    1558         return new _connection7<dest_type, arg1_type, arg2_type, arg3_type, arg4_type,
    1559                arg5_type, arg6_type, arg7_type, mt_policy>((dest_type *)pnewdest, m_pmemfun);
    1560       }
    1561 
    1562       virtual void emit(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
    1563                         arg5_type a5, arg6_type a6, arg7_type a7)
    1564       {
    1565         (m_pobject->*m_pmemfun)(a1, a2, a3, a4, a5, a6, a7);
    1566       }
    1567 
    1568       virtual has_slots<mt_policy>* getdest() const
    1569       {
    1570         return m_pobject;
    1571       }
    1572 
    1573     private:
    1574       dest_type* m_pobject;
    1575       void (dest_type::* m_pmemfun)(arg1_type, arg2_type, arg3_type, arg4_type,
    1576                                     arg5_type, arg6_type, arg7_type);
     1534  public:
     1535    _connection7()
     1536    {
     1537      m_pobject = NULL;
     1538      m_pmemfun = NULL;
     1539    }
     1540
     1541    _connection7(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type,
     1542                 arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type))
     1543    {
     1544      m_pobject = pobject;
     1545      m_pmemfun = pmemfun;
     1546    }
     1547
     1548    virtual _connection_base7<arg1_type, arg2_type, arg3_type, arg4_type,
     1549    arg5_type, arg6_type, arg7_type, mt_policy>* clone()
     1550    {
     1551      return new _connection7<dest_type, arg1_type, arg2_type, arg3_type, arg4_type,
     1552             arg5_type, arg6_type, arg7_type, mt_policy>(*this);
     1553    }
     1554
     1555    virtual _connection_base7<arg1_type, arg2_type, arg3_type, arg4_type,
     1556    arg5_type, arg6_type, arg7_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest)
     1557    {
     1558      return new _connection7<dest_type, arg1_type, arg2_type, arg3_type, arg4_type,
     1559             arg5_type, arg6_type, arg7_type, mt_policy>((dest_type *)pnewdest, m_pmemfun);
     1560    }
     1561
     1562    virtual void emit(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
     1563                      arg5_type a5, arg6_type a6, arg7_type a7)
     1564    {
     1565      (m_pobject->*m_pmemfun)(a1, a2, a3, a4, a5, a6, a7);
     1566    }
     1567
     1568    virtual has_slots<mt_policy>* getdest() const
     1569    {
     1570      return m_pobject;
     1571    }
     1572
     1573  private:
     1574    dest_type* m_pobject;
     1575    void (dest_type::* m_pmemfun)(arg1_type, arg2_type, arg3_type, arg4_type,
     1576                                  arg5_type, arg6_type, arg7_type);
    15771577  };
    15781578
     
    15831583        arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>
    15841584  {
    1585     public:
    1586       _connection8()
    1587       {
    1588         pobject = NULL;
    1589         pmemfun = NULL;
    1590       }
    1591 
    1592       _connection8(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type,
    1593                    arg2_type, arg3_type, arg4_type, arg5_type, arg6_type,
    1594                    arg7_type, arg8_type))
    1595       {
    1596         m_pobject = pobject;
    1597         m_pmemfun = pmemfun;
    1598       }
    1599 
    1600       virtual _connection_base8<arg1_type, arg2_type, arg3_type, arg4_type,
    1601       arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>* clone()
    1602       {
    1603         return new _connection8<dest_type, arg1_type, arg2_type, arg3_type, arg4_type,
    1604                arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>(*this);
    1605       }
    1606 
    1607       virtual _connection_base8<arg1_type, arg2_type, arg3_type, arg4_type,
    1608       arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest)
    1609       {
    1610         return new _connection8<dest_type, arg1_type, arg2_type, arg3_type, arg4_type,
    1611                arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>((dest_type *)pnewdest, m_pmemfun);
    1612       }
    1613 
    1614       virtual void emit(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
    1615                         arg5_type a5, arg6_type a6, arg7_type a7, arg8_type a8)
    1616       {
    1617         (m_pobject->*m_pmemfun)(a1, a2, a3, a4, a5, a6, a7, a8);
    1618       }
    1619 
    1620       virtual has_slots<mt_policy>* getdest() const
    1621       {
    1622         return m_pobject;
    1623       }
    1624 
    1625     private:
    1626       dest_type* m_pobject;
    1627       void (dest_type::* m_pmemfun)(arg1_type, arg2_type, arg3_type, arg4_type,
    1628                                     arg5_type, arg6_type, arg7_type, arg8_type);
     1585  public:
     1586    _connection8()
     1587    {
     1588      m_pobject = NULL;
     1589      m_pmemfun = NULL;
     1590    }
     1591
     1592    _connection8(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type,
     1593                 arg2_type, arg3_type, arg4_type, arg5_type, arg6_type,
     1594                 arg7_type, arg8_type))
     1595    {
     1596      m_pobject = pobject;
     1597      m_pmemfun = pmemfun;
     1598    }
     1599
     1600    virtual _connection_base8<arg1_type, arg2_type, arg3_type, arg4_type,
     1601    arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>* clone()
     1602    {
     1603      return new _connection8<dest_type, arg1_type, arg2_type, arg3_type, arg4_type,
     1604             arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>(*this);
     1605    }
     1606
     1607    virtual _connection_base8<arg1_type, arg2_type, arg3_type, arg4_type,
     1608    arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest)
     1609    {
     1610      return new _connection8<dest_type, arg1_type, arg2_type, arg3_type, arg4_type,
     1611             arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>((dest_type *)pnewdest, m_pmemfun);
     1612    }
     1613
     1614    virtual void emit(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
     1615                      arg5_type a5, arg6_type a6, arg7_type a7, arg8_type a8)
     1616    {
     1617      (m_pobject->*m_pmemfun)(a1, a2, a3, a4, a5, a6, a7, a8);
     1618    }
     1619
     1620    virtual has_slots<mt_policy>* getdest() const
     1621    {
     1622      return m_pobject;
     1623    }
     1624
     1625  private:
     1626    dest_type* m_pobject;
     1627    void (dest_type::* m_pmemfun)(arg1_type, arg2_type, arg3_type, arg4_type,
     1628                                  arg5_type, arg6_type, arg7_type, arg8_type);
    16291629  };
    16301630
     
    16321632  class signal0 : public _signal_base0<mt_policy>
    16331633  {
    1634     public:
    1635       signal0()
    1636       {
    1637         ;
    1638       }
    1639 
    1640       signal0(const signal0<mt_policy>& s)
    1641           : _signal_base0<mt_policy>(s)
    1642       {
    1643         ;
    1644       }
    1645 
    1646       template<class desttype>
    1647       void connect(desttype* pclass, void (desttype::*pmemfun)())
    1648       {
    1649         lock_block<mt_policy> lock(this);
    1650         _connection0<desttype, mt_policy>* conn =
    1651           new _connection0<desttype, mt_policy>(pclass, pmemfun);
    1652         m_connected_slots.push_back(conn);
    1653         pclass->signal_connect(this);
    1654       }
    1655 
    1656       void emit()
    1657       {
    1658         lock_block<mt_policy> lock(this);
    1659         typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
    1660         typename connections_list::const_iterator itEnd = m_connected_slots.end();
    1661 
    1662         while(it != itEnd)
    1663         {
    1664           itNext = it;
    1665           ++itNext;
    1666 
    1667           (*it)->emit();
    1668 
    1669           it = itNext;
    1670         }
    1671       }
    1672 
    1673       void operator()()
    1674       {
    1675         lock_block<mt_policy> lock(this);
    1676         typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
    1677         typename connections_list::const_iterator itEnd = m_connected_slots.end();
    1678 
    1679         while(it != itEnd)
    1680         {
    1681           itNext = it;
    1682           ++itNext;
    1683 
    1684           (*it)->emit();
    1685 
    1686           it = itNext;
    1687         }
    1688       }
     1634  public:
     1635    signal0()
     1636    {
     1637      ;
     1638    }
     1639
     1640    signal0(const signal0<mt_policy>& s)
     1641        : _signal_base0<mt_policy>(s)
     1642    {
     1643      ;
     1644    }
     1645
     1646    template<class desttype>
     1647    void connect(desttype* pclass, void (desttype::*pmemfun)())
     1648    {
     1649      lock_block<mt_policy> lock(this);
     1650      _connection0<desttype, mt_policy>* conn =
     1651        new _connection0<desttype, mt_policy>(pclass, pmemfun);
     1652      this->m_connected_slots.push_back(conn);
     1653      pclass->signal_connect(this);
     1654    }
     1655
     1656    void emit()
     1657    {
     1658      lock_block<mt_policy> lock(this);
     1659      typename _signal_base0<mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
     1660      typename _signal_base0<mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
     1661
     1662      while(it != itEnd)
     1663      {
     1664        itNext = it;
     1665        ++itNext;
     1666
     1667        (*it)->emit();
     1668
     1669        it = itNext;
     1670      }
     1671    }
     1672
     1673    void operator()()
     1674    {
     1675      lock_block<mt_policy> lock(this);
     1676      typename _signal_base0<mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
     1677      typename _signal_base0<mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
     1678
     1679      while(it != itEnd)
     1680      {
     1681        itNext = it;
     1682        ++itNext;
     1683
     1684        (*it)->emit();
     1685
     1686        it = itNext;
     1687      }
     1688    }
    16891689  };
    16901690
     
    16921692  class signal1 : public _signal_base1<arg1_type, mt_policy>
    16931693  {
    1694     public:
    1695       signal1()
    1696       {
    1697         ;
    1698       }
    1699 
    1700       signal1(const signal1<arg1_type, mt_policy>& s)
    1701           : _signal_base1<arg1_type, mt_policy>(s)
    1702       {
    1703         ;
    1704       }
    1705 
    1706       template<class desttype>
    1707       void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type))
    1708       {
    1709         lock_block<mt_policy> lock(this);
    1710         _connection1<desttype, arg1_type, mt_policy>* conn =
    1711           new _connection1<desttype, arg1_type, mt_policy>(pclass, pmemfun);
    1712         m_connected_slots.push_back(conn);
    1713         pclass->signal_connect(this);
    1714       }
    1715 
    1716       void emit(arg1_type a1)
    1717       {
    1718         lock_block<mt_policy> lock(this);
    1719         typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
    1720         typename connections_list::const_iterator itEnd = m_connected_slots.end();
    1721 
    1722         while(it != itEnd)
    1723         {
    1724           itNext = it;
    1725           ++itNext;
    1726 
    1727           (*it)->emit(a1);
    1728 
    1729           it = itNext;
    1730         }
    1731       }
    1732 
    1733       void operator()(arg1_type a1)
    1734       {
    1735         lock_block<mt_policy> lock(this);
    1736         typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
    1737         typename connections_list::const_iterator itEnd = m_connected_slots.end();
    1738 
    1739         while(it != itEnd)
    1740         {
    1741           itNext = it;
    1742           ++itNext;
    1743 
    1744           (*it)->emit(a1);
    1745 
    1746           it = itNext;
    1747         }
    1748       }
     1694  public:
     1695    signal1()
     1696    {
     1697      ;
     1698    }
     1699
     1700    signal1(const signal1<arg1_type, mt_policy>& s)
     1701        : _signal_base1<arg1_type, mt_policy>(s)
     1702    {
     1703      ;
     1704    }
     1705
     1706    template<class desttype>
     1707    void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type))
     1708    {
     1709      lock_block<mt_policy> lock(this);
     1710      _connection1<desttype, arg1_type, mt_policy>* conn =
     1711        new _connection1<desttype, arg1_type, mt_policy>(pclass, pmemfun);
     1712      this->m_connected_slots.push_back(conn);
     1713      pclass->signal_connect(this);
     1714    }
     1715
     1716    void emit(arg1_type a1)
     1717    {
     1718      lock_block<mt_policy> lock(this);
     1719      typename _signal_base1<arg1_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
     1720      typename _signal_base1<arg1_type, mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
     1721
     1722      while(it != itEnd)
     1723      {
     1724        itNext = it;
     1725        ++itNext;
     1726
     1727        (*it)->emit(a1);
     1728
     1729        it = itNext;
     1730      }
     1731    }
     1732
     1733    void operator()(arg1_type a1)
     1734    {
     1735      lock_block<mt_policy> lock(this);
     1736      typename _signal_base1<arg1_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
     1737      typename _signal_base1<arg1_type, mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
     1738
     1739      while(it != itEnd)
     1740      {
     1741        itNext = it;
     1742        ++itNext;
     1743
     1744        (*it)->emit(a1);
     1745
     1746        it = itNext;
     1747      }
     1748    }
    17491749  };
    17501750
     
    17521752  class signal2 : public _signal_base2<arg1_type, arg2_type, mt_policy>
    17531753  {
    1754     public:
    1755       signal2()
    1756       {
    1757         ;
    1758       }
    1759 
    1760       signal2(const signal2<arg1_type, arg2_type, mt_policy>& s)
    1761           : _signal_base2<arg1_type, arg2_type, mt_policy>(s)
    1762       {
    1763         ;
    1764       }
    1765 
    1766       template<class desttype>
    1767       void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type,
    1768                    arg2_type))
    1769       {
    1770         lock_block<mt_policy> lock(this);
    1771         _connection2<desttype, arg1_type, arg2_type, mt_policy>* conn = new
    1772             _connection2<desttype, arg1_type, arg2_type, mt_policy>(pclass, pmemfun);
    1773         m_connected_slots.push_back(conn);
    1774         pclass->signal_connect(this);
    1775       }
    1776 
    1777       void emit(arg1_type a1, arg2_type a2)
    1778       {
    1779         lock_block<mt_policy> lock(this);
    1780         typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
    1781         typename connections_list::const_iterator itEnd = m_connected_slots.end();
    1782 
    1783         while(it != itEnd)
    1784         {
    1785           itNext = it;
    1786           ++itNext;
    1787 
    1788           (*it)->emit(a1, a2);
    1789 
    1790           it = itNext;
    1791         }
    1792       }
    1793 
    1794       void operator()(arg1_type a1, arg2_type a2)
    1795       {
    1796         lock_block<mt_policy> lock(this);
    1797         typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
    1798         typename connections_list::const_iterator itEnd = m_connected_slots.end();
    1799 
    1800         while(it != itEnd)
    1801         {
    1802           itNext = it;
    1803           ++itNext;
    1804 
    1805           (*it)->emit(a1, a2);
    1806 
    1807           it = itNext;
    1808         }
    1809       }
     1754  public:
     1755    signal2()
     1756    {
     1757      ;
     1758    }
     1759
     1760    signal2(const signal2<arg1_type, arg2_type, mt_policy>& s)
     1761        : _signal_base2<arg1_type, arg2_type, mt_policy>(s)
     1762    {
     1763      ;
     1764    }
     1765
     1766    template<class desttype>
     1767    void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type,
     1768                 arg2_type))
     1769    {
     1770      lock_block<mt_policy> lock(this);
     1771      _connection2<desttype, arg1_type, arg2_type, mt_policy>* conn = new
     1772          _connection2<desttype, arg1_type, arg2_type, mt_policy>(pclass, pmemfun);
     1773      this->m_connected_slots.push_back(conn);
     1774      pclass->signal_connect(this);
     1775    }
     1776
     1777    void emit(arg1_type a1, arg2_type a2)
     1778    {
     1779      lock_block<mt_policy> lock(this);
     1780      typename _signal_base2<arg1_type, arg2_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
     1781      typename _signal_base2<arg1_type, arg2_type, mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
     1782
     1783      while(it != itEnd)
     1784      {
     1785        itNext = it;
     1786        ++itNext;
     1787
     1788        (*it)->emit(a1, a2);
     1789
     1790        it = itNext;
     1791      }
     1792    }
     1793
     1794    void operator()(arg1_type a1, arg2_type a2)
     1795    {
     1796      lock_block<mt_policy> lock(this);
     1797      typename _signal_base2<arg1_type, arg2_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
     1798      typename _signal_base2<arg1_type, arg2_type, mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
     1799
     1800      while(it != itEnd)
     1801      {
     1802        itNext = it;
     1803        ++itNext;
     1804
     1805        (*it)->emit(a1, a2);
     1806
     1807        it = itNext;
     1808      }
     1809    }
    18101810  };
    18111811
     
    18131813  class signal3 : public _signal_base3<arg1_type, arg2_type, arg3_type, mt_policy>
    18141814  {
    1815     public:
    1816       signal3()
    1817       {
    1818         ;
    1819       }
    1820 
    1821       signal3(const signal3<arg1_type, arg2_type, arg3_type, mt_policy>& s)
    1822           : _signal_base3<arg1_type, arg2_type, arg3_type, mt_policy>(s)
    1823       {
    1824         ;
    1825       }
    1826 
    1827       template<class desttype>
    1828       void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type,
    1829                    arg2_type, arg3_type))
    1830       {
    1831         lock_block<mt_policy> lock(this);
    1832         _connection3<desttype, arg1_type, arg2_type, arg3_type, mt_policy>* conn =
    1833           new _connection3<desttype, arg1_type, arg2_type, arg3_type, mt_policy>(pclass,
    1834               pmemfun);
    1835         m_connected_slots.push_back(conn);
    1836         pclass->signal_connect(this);
    1837       }
    1838 
    1839       void emit(arg1_type a1, arg2_type a2, arg3_type a3)
    1840       {
    1841         lock_block<mt_policy> lock(this);
    1842         typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
    1843         typename connections_list::const_iterator itEnd = m_connected_slots.end();
    1844 
    1845         while(it != itEnd)
    1846         {
    1847           itNext = it;
    1848           ++itNext;
    1849 
    1850           (*it)->emit(a1, a2, a3);
    1851 
    1852           it = itNext;
    1853         }
    1854       }
    1855 
    1856       void operator()(arg1_type a1, arg2_type a2, arg3_type a3)
    1857       {
    1858         lock_block<mt_policy> lock(this);
    1859         typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
    1860         typename connections_list::const_iterator itEnd = m_connected_slots.end();
    1861 
    1862         while(it != itEnd)
    1863         {
    1864           itNext = it;
    1865           ++itNext;
    1866 
    1867           (*it)->emit(a1, a2, a3);
    1868 
    1869           it = itNext;
    1870         }
    1871       }
     1815  public:
     1816    signal3()
     1817    {
     1818      ;
     1819    }
     1820
     1821    signal3(const signal3<arg1_type, arg2_type, arg3_type, mt_policy>& s)
     1822        : _signal_base3<arg1_type, arg2_type, arg3_type, mt_policy>(s)
     1823    {
     1824      ;
     1825    }
     1826
     1827    template<class desttype>
     1828    void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type,
     1829                 arg2_type, arg3_type))
     1830    {
     1831      lock_block<mt_policy> lock(this);
     1832      _connection3<desttype, arg1_type, arg2_type, arg3_type, mt_policy>* conn =
     1833        new _connection3<desttype, arg1_type, arg2_type, arg3_type, mt_policy>(pclass,
     1834            pmemfun);
     1835      this->m_connected_slots.push_back(conn);
     1836      pclass->signal_connect(this);
     1837    }
     1838
     1839    void emit(arg1_type a1, arg2_type a2, arg3_type a3)
     1840    {
     1841      lock_block<mt_policy> lock(this);
     1842      typename _signal_base3<arg1_type, arg2_type, arg3_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
     1843      typename _signal_base3<arg1_type, arg2_type, arg3_type, mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
     1844
     1845      while(it != itEnd)
     1846      {
     1847        itNext = it;
     1848        ++itNext;
     1849
     1850        (*it)->emit(a1, a2, a3);
     1851
     1852        it = itNext;
     1853      }
     1854    }
     1855
     1856    void operator()(arg1_type a1, arg2_type a2, arg3_type a3)
     1857    {
     1858      lock_block<mt_policy> lock(this);
     1859      typename _signal_base3<arg1_type, arg2_type, arg3_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
     1860      typename _signal_base3<arg1_type, arg2_type, arg3_type, mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
     1861
     1862      while(it != itEnd)
     1863      {
     1864        itNext = it;
     1865        ++itNext;
     1866
     1867        (*it)->emit(a1, a2, a3);
     1868
     1869        it = itNext;
     1870      }
     1871    }
    18721872  };
    18731873
     
    18761876        arg4_type, mt_policy>
    18771877  {
    1878     public:
    1879       signal4()
    1880       {
    1881         ;
    1882       }
    1883 
    1884       signal4(const signal4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>& s)
    1885           : _signal_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>(s)
    1886       {
    1887         ;
    1888       }
    1889 
    1890       template<class desttype>
    1891       void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type,
    1892                    arg2_type, arg3_type, arg4_type))
    1893       {
    1894         lock_block<mt_policy> lock(this);
    1895         _connection4<desttype, arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>*
    1896         conn = new _connection4<desttype, arg1_type, arg2_type, arg3_type,
    1897                arg4_type, mt_policy>(pclass, pmemfun);
    1898         m_connected_slots.push_back(conn);
    1899         pclass->signal_connect(this);
    1900       }
    1901 
    1902       void emit(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4)
    1903       {
    1904         lock_block<mt_policy> lock(this);
    1905         typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
    1906         typename connections_list::const_iterator itEnd = m_connected_slots.end();
    1907 
    1908         while(it != itEnd)
    1909         {
    1910           itNext = it;
    1911           ++itNext;
    1912 
    1913           (*it)->emit(a1, a2, a3, a4);
    1914 
    1915           it = itNext;
    1916         }
    1917       }
    1918 
    1919       void operator()(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4)
    1920       {
    1921         lock_block<mt_policy> lock(this);
    1922         typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
    1923         typename connections_list::const_iterator itEnd = m_connected_slots.end();
    1924 
    1925         while(it != itEnd)
    1926         {
    1927           itNext = it;
    1928           ++itNext;
    1929 
    1930           (*it)->emit(a1, a2, a3, a4);
    1931 
    1932           it = itNext;
    1933         }
    1934       }
     1878  public:
     1879    signal4()
     1880    {
     1881      ;
     1882    }
     1883
     1884    signal4(const signal4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>& s)
     1885        : _signal_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>(s)
     1886    {
     1887      ;
     1888    }
     1889
     1890    template<class desttype>
     1891    void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type,
     1892                 arg2_type, arg3_type, arg4_type))
     1893    {
     1894      lock_block<mt_policy> lock(this);
     1895      _connection4<desttype, arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>*
     1896      conn = new _connection4<desttype, arg1_type, arg2_type, arg3_type,
     1897             arg4_type, mt_policy>(pclass, pmemfun);
     1898      this->m_connected_slots.push_back(conn);
     1899      pclass->signal_connect(this);
     1900    }
     1901
     1902    void emit(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4)
     1903    {
     1904      lock_block<mt_policy> lock(this);
     1905      typename _signal_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
     1906      typename _signal_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
     1907
     1908      while(it != itEnd)
     1909      {
     1910        itNext = it;
     1911        ++itNext;
     1912
     1913        (*it)->emit(a1, a2, a3, a4);
     1914
     1915        it = itNext;
     1916      }
     1917    }
     1918
     1919    void operator()(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4)
     1920    {
     1921      lock_block<mt_policy> lock(this);
     1922      typename _signal_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
     1923      typename _signal_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
     1924
     1925      while(it != itEnd)
     1926      {
     1927        itNext = it;
     1928        ++itNext;
     1929
     1930        (*it)->emit(a1, a2, a3, a4);
     1931
     1932        it = itNext;
     1933      }
     1934    }
    19351935  };
    19361936
     
    19401940        arg4_type, arg5_type, mt_policy>
    19411941  {
    1942     public:
    1943       signal5()
    1944       {
    1945         ;
    1946       }
    1947 
    1948       signal5(const signal5<arg1_type, arg2_type, arg3_type, arg4_type,
    1949               arg5_type, mt_policy>& s)
    1950           : _signal_base5<arg1_type, arg2_type, arg3_type, arg4_type,
    1951           arg5_type, mt_policy>(s)
    1952       {
    1953         ;
    1954       }
    1955 
    1956       template<class desttype>
    1957       void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type,
    1958                    arg2_type, arg3_type, arg4_type, arg5_type))
    1959       {
    1960         lock_block<mt_policy> lock(this);
    1961         _connection5<desttype, arg1_type, arg2_type, arg3_type, arg4_type,
    1962         arg5_type, mt_policy>* conn = new _connection5<desttype, arg1_type, arg2_type,
    1963                                       arg3_type, arg4_type, arg5_type, mt_policy>(pclass, pmemfun);
    1964         m_connected_slots.push_back(conn);
    1965         pclass->signal_connect(this);
    1966       }
    1967 
    1968       void emit(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
    1969                 arg5_type a5)
    1970       {
    1971         lock_block<mt_policy> lock(this);
    1972         typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
    1973         typename connections_list::const_iterator itEnd = m_connected_slots.end();
    1974 
    1975         while(it != itEnd)
    1976         {
    1977           itNext = it;
    1978           ++itNext;
    1979 
    1980           (*it)->emit(a1, a2, a3, a4, a5);
    1981 
    1982           it = itNext;
    1983         }
    1984       }
    1985 
    1986       void operator()(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
    1987                       arg5_type a5)
    1988       {
    1989         lock_block<mt_policy> lock(this);
    1990         typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
    1991         typename connections_list::const_iterator itEnd = m_connected_slots.end();
    1992 
    1993         while(it != itEnd)
    1994         {
    1995           itNext = it;
    1996           ++itNext;
    1997 
    1998           (*it)->emit(a1, a2, a3, a4, a5);
    1999 
    2000           it = itNext;
    2001         }
    2002       }
     1942  public:
     1943    signal5()
     1944    {
     1945      ;
     1946    }
     1947
     1948    signal5(const signal5<arg1_type, arg2_type, arg3_type, arg4_type,
     1949            arg5_type, mt_policy>& s)
     1950        : _signal_base5<arg1_type, arg2_type, arg3_type, arg4_type,
     1951        arg5_type, mt_policy>(s)
     1952    {
     1953      ;
     1954    }
     1955
     1956    template<class desttype>
     1957    void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type,
     1958                 arg2_type, arg3_type, arg4_type, arg5_type))
     1959    {
     1960      lock_block<mt_policy> lock(this);
     1961      _connection5<desttype, arg1_type, arg2_type, arg3_type, arg4_type,
     1962      arg5_type, mt_policy>* conn = new _connection5<desttype, arg1_type, arg2_type,
     1963                                    arg3_type, arg4_type, arg5_type, mt_policy>(pclass, pmemfun);
     1964      this->m_connected_slots.push_back(conn);
     1965      pclass->signal_connect(this);
     1966    }
     1967
     1968    void emit(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
     1969              arg5_type a5)
     1970    {
     1971      lock_block<mt_policy> lock(this);
     1972      typename _signal_base5<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
     1973      typename _signal_base5<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
     1974
     1975      while(it != itEnd)
     1976      {
     1977        itNext = it;
     1978        ++itNext;
     1979
     1980        (*it)->emit(a1, a2, a3, a4, a5);
     1981
     1982        it = itNext;
     1983      }
     1984    }
     1985
     1986    void operator()(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
     1987                    arg5_type a5)
     1988    {
     1989      lock_block<mt_policy> lock(this);
     1990      typename _signal_base5<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
     1991      typename _signal_base5<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
     1992
     1993      while(it != itEnd)
     1994      {
     1995        itNext = it;
     1996        ++itNext;
     1997
     1998        (*it)->emit(a1, a2, a3, a4, a5);
     1999
     2000        it = itNext;
     2001      }
     2002    }
    20032003  };
    20042004
     
    20092009        arg4_type, arg5_type, arg6_type, mt_policy>
    20102010  {
    2011     public:
    2012       signal6()
    2013       {
    2014         ;
    2015       }
    2016 
    2017       signal6(const signal6<arg1_type, arg2_type, arg3_type, arg4_type,
    2018               arg5_type, arg6_type, mt_policy>& s)
    2019           : _signal_base6<arg1_type, arg2_type, arg3_type, arg4_type,
    2020           arg5_type, arg6_type, mt_policy>(s)
    2021       {
    2022         ;
    2023       }
    2024 
    2025       template<class desttype>
    2026       void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type,
    2027                    arg2_type, arg3_type, arg4_type, arg5_type, arg6_type))
    2028       {
    2029         lock_block<mt_policy> lock(this);
    2030         _connection6<desttype, arg1_type, arg2_type, arg3_type, arg4_type,
    2031         arg5_type, arg6_type, mt_policy>* conn =
    2032           new _connection6<desttype, arg1_type, arg2_type, arg3_type,
    2033           arg4_type, arg5_type, arg6_type, mt_policy>(pclass, pmemfun);
    2034         m_connected_slots.push_back(conn);
    2035         pclass->signal_connect(this);
    2036       }
    2037 
    2038       void emit(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
    2039                 arg5_type a5, arg6_type a6)
    2040       {
    2041         lock_block<mt_policy> lock(this);
    2042         typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
    2043         typename connections_list::const_iterator itEnd = m_connected_slots.end();
    2044 
    2045         while(it != itEnd)
    2046         {
    2047           itNext = it;
    2048           ++itNext;
    2049 
    2050           (*it)->emit(a1, a2, a3, a4, a5, a6);
    2051 
    2052           it = itNext;
    2053         }
    2054       }
    2055 
    2056       void operator()(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
    2057                       arg5_type a5, arg6_type a6)
    2058       {
    2059         lock_block<mt_policy> lock(this);
    2060         typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
    2061         typename connections_list::const_iterator itEnd = m_connected_slots.end();
    2062 
    2063         while(it != itEnd)
    2064         {
    2065           itNext = it;
    2066           ++itNext;
    2067 
    2068           (*it)->emit(a1, a2, a3, a4, a5, a6);
    2069 
    2070           it = itNext;
    2071         }
    2072       }
     2011  public:
     2012    signal6()
     2013    {
     2014      ;
     2015    }
     2016
     2017    signal6(const signal6<arg1_type, arg2_type, arg3_type, arg4_type,
     2018            arg5_type, arg6_type, mt_policy>& s)
     2019        : _signal_base6<arg1_type, arg2_type, arg3_type, arg4_type,
     2020        arg5_type, arg6_type, mt_policy>(s)
     2021    {
     2022      ;
     2023    }
     2024
     2025    template<class desttype>
     2026    void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type,
     2027                 arg2_type, arg3_type, arg4_type, arg5_type, arg6_type))
     2028    {
     2029      lock_block<mt_policy> lock(this);
     2030      _connection6<desttype, arg1_type, arg2_type, arg3_type, arg4_type,
     2031      arg5_type, arg6_type, mt_policy>* conn =
     2032        new _connection6<desttype, arg1_type, arg2_type, arg3_type,
     2033        arg4_type, arg5_type, arg6_type, mt_policy>(pclass, pmemfun);
     2034      this->m_connected_slots.push_back(conn);
     2035      pclass->signal_connect(this);
     2036    }
     2037
     2038    void emit(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
     2039              arg5_type a5, arg6_type a6)
     2040    {
     2041      lock_block<mt_policy> lock(this);
     2042      typename _signal_base6<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
     2043      typename _signal_base6<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
     2044
     2045      while(it != itEnd)
     2046      {
     2047        itNext = it;
     2048        ++itNext;
     2049
     2050        (*it)->emit(a1, a2, a3, a4, a5, a6);
     2051
     2052        it = itNext;
     2053      }
     2054    }
     2055
     2056    void operator()(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
     2057                    arg5_type a5, arg6_type a6)
     2058    {
     2059      lock_block<mt_policy> lock(this);
     2060      typename _signal_base6<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
     2061      typename _signal_base6<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
     2062
     2063      while(it != itEnd)
     2064      {
     2065        itNext = it;
     2066        ++itNext;
     2067
     2068        (*it)->emit(a1, a2, a3, a4, a5, a6);
     2069
     2070        it = itNext;
     2071      }
     2072    }
    20732073  };
    20742074
     
    20782078        arg4_type, arg5_type, arg6_type, arg7_type, mt_policy>
    20792079  {
    2080     public:
    2081       signal7()
    2082       {
    2083         ;
    2084       }
    2085 
    2086       signal7(const signal7<arg1_type, arg2_type, arg3_type, arg4_type,
    2087               arg5_type, arg6_type, arg7_type, mt_policy>& s)
    2088           : _signal_base7<arg1_type, arg2_type, arg3_type, arg4_type,
    2089           arg5_type, arg6_type, arg7_type, mt_policy>(s)
    2090       {
    2091         ;
    2092       }
    2093 
    2094       template<class desttype>
    2095       void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type,
    2096                    arg2_type, arg3_type, arg4_type, arg5_type, arg6_type,
    2097                    arg7_type))
    2098       {
    2099         lock_block<mt_policy> lock(this);
    2100         _connection7<desttype, arg1_type, arg2_type, arg3_type, arg4_type,
    2101         arg5_type, arg6_type, arg7_type, mt_policy>* conn =
    2102           new _connection7<desttype, arg1_type, arg2_type, arg3_type,
    2103           arg4_type, arg5_type, arg6_type, arg7_type, mt_policy>(pclass, pmemfun);
    2104         m_connected_slots.push_back(conn);
    2105         pclass->signal_connect(this);
    2106       }
    2107 
    2108       void emit(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
    2109                 arg5_type a5, arg6_type a6, arg7_type a7)
    2110       {
    2111         lock_block<mt_policy> lock(this);
    2112         typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
    2113         typename connections_list::const_iterator itEnd = m_connected_slots.end();
    2114 
    2115         while(it != itEnd)
    2116         {
    2117           itNext = it;
    2118           ++itNext;
    2119 
    2120           (*it)->emit(a1, a2, a3, a4, a5, a6, a7);
    2121 
    2122           it = itNext;
    2123         }
    2124       }
    2125 
    2126       void operator()(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
    2127                       arg5_type a5, arg6_type a6, arg7_type a7)
    2128       {
    2129         lock_block<mt_policy> lock(this);
    2130         typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
    2131         typename connections_list::const_iterator itEnd = m_connected_slots.end();
    2132 
    2133         while(it != itEnd)
    2134         {
    2135           itNext = it;
    2136           ++itNext;
    2137 
    2138           (*it)->emit(a1, a2, a3, a4, a5, a6, a7);
    2139 
    2140           it = itNext;
    2141         }
    2142       }
     2080  public:
     2081    signal7()
     2082    {
     2083      ;
     2084    }
     2085
     2086    signal7(const signal7<arg1_type, arg2_type, arg3_type, arg4_type,
     2087            arg5_type, arg6_type, arg7_type, mt_policy>& s)
     2088        : _signal_base7<arg1_type, arg2_type, arg3_type, arg4_type,
     2089        arg5_type, arg6_type, arg7_type, mt_policy>(s)
     2090    {
     2091      ;
     2092    }
     2093
     2094    template<class desttype>
     2095    void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type,
     2096                 arg2_type, arg3_type, arg4_type, arg5_type, arg6_type,
     2097                 arg7_type))
     2098    {
     2099      lock_block<mt_policy> lock(this);
     2100      _connection7<desttype, arg1_type, arg2_type, arg3_type, arg4_type,
     2101      arg5_type, arg6_type, arg7_type, mt_policy>* conn =
     2102        new _connection7<desttype, arg1_type, arg2_type, arg3_type,
     2103        arg4_type, arg5_type, arg6_type, arg7_type, mt_policy>(pclass, pmemfun);
     2104      this->m_connected_slots.push_back(conn);
     2105      pclass->signal_connect(this);
     2106    }
     2107
     2108    void emit(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
     2109              arg5_type a5, arg6_type a6, arg7_type a7)
     2110    {
     2111      lock_block<mt_policy> lock(this);
     2112      typename _signal_base7<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
     2113      typename _signal_base7<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
     2114
     2115      while(it != itEnd)
     2116      {
     2117        itNext = it;
     2118        ++itNext;
     2119
     2120        (*it)->emit(a1, a2, a3, a4, a5, a6, a7);
     2121
     2122        it = itNext;
     2123      }
     2124    }
     2125
     2126    void operator()(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
     2127                    arg5_type a5, arg6_type a6, arg7_type a7)
     2128    {
     2129      lock_block<mt_policy> lock(this);
     2130      typename _signal_base7<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
     2131      typename _signal_base7<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
     2132
     2133      while(it != itEnd)
     2134      {
     2135        itNext = it;
     2136        ++itNext;
     2137
     2138        (*it)->emit(a1, a2, a3, a4, a5, a6, a7);
     2139
     2140        it = itNext;
     2141      }
     2142    }
    21432143  };
    21442144
     
    21482148        arg4_type, arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>
    21492149  {
    2150     public:
    2151       signal8()
    2152       {
    2153         ;
    2154       }
    2155 
    2156       signal8(const signal8<arg1_type, arg2_type, arg3_type, arg4_type,
    2157               arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>& s)
    2158           : _signal_base8<arg1_type, arg2_type, arg3_type, arg4_type,
    2159           arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>(s)
    2160       {
    2161         ;
    2162       }
    2163 
    2164       template<class desttype>
    2165       void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type,
    2166                    arg2_type, arg3_type, arg4_type, arg5_type, arg6_type,
    2167                    arg7_type, arg8_type))
    2168       {
    2169         lock_block<mt_policy> lock(this);
    2170         _connection8<desttype, arg1_type, arg2_type, arg3_type, arg4_type,
    2171         arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>* conn =
    2172           new _connection8<desttype, arg1_type, arg2_type, arg3_type,
    2173           arg4_type, arg5_type, arg6_type, arg7_type,
    2174           arg8_type, mt_policy>(pclass, pmemfun);
    2175         m_connected_slots.push_back(conn);
    2176         pclass->signal_connect(this);
    2177       }
    2178 
    2179       void emit(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
    2180                 arg5_type a5, arg6_type a6, arg7_type a7, arg8_type a8)
    2181       {
    2182         lock_block<mt_policy> lock(this);
    2183         typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
    2184         typename connections_list::const_iterator itEnd = m_connected_slots.end();
    2185 
    2186         while(it != itEnd)
    2187         {
    2188           itNext = it;
    2189           ++itNext;
    2190 
    2191           (*it)->emit(a1, a2, a3, a4, a5, a6, a7, a8);
    2192 
    2193           it = itNext;
    2194         }
    2195       }
    2196 
    2197       void operator()(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
    2198                       arg5_type a5, arg6_type a6, arg7_type a7, arg8_type a8)
    2199       {
    2200         lock_block<mt_policy> lock(this);
    2201         typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
    2202         typename connections_list::const_iterator itEnd = m_connected_slots.end();
    2203 
    2204         while(it != itEnd)
    2205         {
    2206           itNext = it;
    2207           ++itNext;
    2208 
    2209           (*it)->emit(a1, a2, a3, a4, a5, a6, a7, a8);
    2210 
    2211           it = itNext;
    2212         }
    2213       }
     2150  public:
     2151    signal8()
     2152    {
     2153      ;
     2154    }
     2155
     2156    signal8(const signal8<arg1_type, arg2_type, arg3_type, arg4_type,
     2157            arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>& s)
     2158        : _signal_base8<arg1_type, arg2_type, arg3_type, arg4_type,
     2159        arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>(s)
     2160    {
     2161      ;
     2162    }
     2163
     2164    template<class desttype>
     2165    void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type,
     2166                 arg2_type, arg3_type, arg4_type, arg5_type, arg6_type,
     2167                 arg7_type, arg8_type))
     2168    {
     2169      lock_block<mt_policy> lock(this);
     2170      _connection8<desttype, arg1_type, arg2_type, arg3_type, arg4_type,
     2171      arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>* conn =
     2172        new _connection8<desttype, arg1_type, arg2_type, arg3_type,
     2173        arg4_type, arg5_type, arg6_type, arg7_type,
     2174        arg8_type, mt_policy>(pclass, pmemfun);
     2175      this->m_connected_slots.push_back(conn);
     2176      pclass->signal_connect(this);
     2177    }
     2178
     2179    void emit(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
     2180              arg5_type a5, arg6_type a6, arg7_type a7, arg8_type a8)
     2181    {
     2182      lock_block<mt_policy> lock(this);
     2183      typename _signal_base8<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
     2184      typename _signal_base8<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
     2185
     2186      while(it != itEnd)
     2187      {
     2188        itNext = it;
     2189        ++itNext;
     2190
     2191        (*it)->emit(a1, a2, a3, a4, a5, a6, a7, a8);
     2192
     2193        it = itNext;
     2194      }
     2195    }
     2196
     2197    void operator()(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
     2198                    arg5_type a5, arg6_type a6, arg7_type a7, arg8_type a8)
     2199    {
     2200      lock_block<mt_policy> lock(this);
     2201      typename _signal_base8<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
     2202      typename _signal_base8<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
     2203
     2204      while(it != itEnd)
     2205      {
     2206        itNext = it;
     2207        ++itNext;
     2208
     2209        (*it)->emit(a1, a2, a3, a4, a5, a6, a7, a8);
     2210
     2211        it = itNext;
     2212      }
     2213    }
    22142214  };
    22152215
Note: See TracChangeset for help on using the changeset viewer.