mockpp: OnConsecutiveCalls.h Source File

00001 
00009 /**************************************************************************
00010 
00011    begin                : Fri Apr 7 2006
00012    copyright            : (C) 2002-2010 by Ewald Arnold
00013    email                : mockpp at ewald-arnold dot de
00014 
00015    This program is free software; you can redistribute it and/or modify
00016    it under the terms of the GNU Lesser General Public License as
00017    published by the Free Software Foundation; either version 2 of the License,
00018    or (at your option) any later version.
00019 
00020    This program is distributed in the hope that it will be useful,
00021    but WITHOUT ANY WARRANTY; without even the implied warranty of
00022    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00023    GNU General Public License for more details.
00024 
00025    You should have received a copy of the GNU Lesser General Public License
00026    along with this program; if not, write to the Free Software
00027    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
00028 
00029  **/
00030 
00031 #ifndef MOCKPP_ONCONSECUTIVECALLS_H
00032 #define MOCKPP_ONCONSECUTIVECALLS_H
00033 
00034 #include <mockpp/mockpp.h> // always first
00035 
00036 #include <mockpp/stub/StubSequence.h>
00037 #include <mockpp/stub/TypelessStubSequence.h>
00038 
00039 
00040 MOCKPP_NS_START
00041 
00042 
00049 template <typename R,  // ReturnType
00050           typename I>  // Invocation
00051 typename Stub<R, I>::AP onConsecutiveCalls(  AutoPointer<Stub<R, I> > stub1
00052                                           )
00053 {
00054   MOCKPP_STL::vector<Stub<R, I>*> vec;
00055   vec.push_back( stub1.release());
00056   return new StubSequence<R, I>( vec.begin(), vec.end() );
00057 }
00058 
00059 
00066 template <typename R,  // ReturnType
00067           typename I>  // Invocation
00068 typename Stub<R, I>::AP onConsecutiveCalls(  Stub<R, I> *stub1
00069                                           )
00070 {
00071   MOCKPP_STL::vector<Stub<I, R>*> vec;
00072   vec.push_back( stub1);
00073   return new StubSequence<R, I>( vec.begin(), vec.end() );
00074 }
00075 
00076 
00083 template <typename R>  // ReturnType
00084 typename TypelessStub<R>::AP onConsecutiveCalls(  AutoPointer<TypelessStub<R> > stub1
00085                                                )
00086 {
00087   MOCKPP_STL::vector<TypelessStub<R>*> vec;
00088   vec.push_back( stub1.release());
00089   return new TypelessStubSequence<R>( vec.begin(), vec.end() );
00090 }
00091 
00092 
00099 template <typename R>  // ReturnType
00100 typename TypelessStub<R>::AP onConsecutiveCalls(  TypelessStub<R> *stub1
00101                                           )
00102 {
00103   MOCKPP_STL::vector<TypelessStub<R>*> vec;
00104   vec.push_back( stub1);
00105   return new TypelessStubSequence<R>( vec.begin(), vec.end() );
00106 }
00107 
00108 
00116 template <typename R,  // ReturnType
00117           typename I>  // Invocation
00118 typename Stub<R, I>::AP onConsecutiveCalls(  AutoPointer<Stub<R, I> > stub1
00119                                            , AutoPointer<Stub<R, I> > stub2
00120                                           )
00121 {
00122   MOCKPP_STL::vector<Stub<R, I>*> vec;
00123   vec.push_back( stub1.release());
00124   vec.push_back( stub2.release());
00125   return new StubSequence<R, I>( vec.begin(), vec.end() );
00126 }
00127 
00128 
00136 template <typename R,  // ReturnType
00137           typename I>  // Invocation
00138 typename Stub<R, I>::AP onConsecutiveCalls(  Stub<R, I> *stub1
00139                                            , Stub<R, I> *stub2
00140                                           )
00141 {
00142   MOCKPP_STL::vector<Stub<I, R>*> vec;
00143   vec.push_back( stub1);
00144   vec.push_back( stub2);
00145   return new StubSequence<R, I>( vec.begin(), vec.end() );
00146 }
00147 
00148 
00156 template <typename R>  // ReturnType
00157 typename TypelessStub<R>::AP onConsecutiveCalls(  AutoPointer<TypelessStub<R> > stub1
00158                                                 , AutoPointer<TypelessStub<R> > stub2
00159                                                )
00160 {
00161   MOCKPP_STL::vector<TypelessStub<R>*> vec;
00162   vec.push_back( stub1.release());
00163   vec.push_back( stub2.release());
00164   return new TypelessStubSequence<R>( vec.begin(), vec.end() );
00165 }
00166 
00167 
00175 template <typename R>  // ReturnType
00176 typename TypelessStub<R>::AP onConsecutiveCalls(  TypelessStub<R> *stub1
00177                                                 , TypelessStub<R> *stub2
00178                                           )
00179 {
00180   MOCKPP_STL::vector<TypelessStub<R>*> vec;
00181   vec.push_back( stub1);
00182   vec.push_back( stub2);
00183   return new TypelessStubSequence<R>( vec.begin(), vec.end() );
00184 }
00185 
00186 
00195 template <typename R,  // ReturnType
00196           typename I>  // Invocation
00197 typename Stub<R, I>::AP onConsecutiveCalls(  AutoPointer<Stub<R, I> > stub1
00198                                            , AutoPointer<Stub<R, I> > stub2
00199                                            , AutoPointer<Stub<R, I> > stub3
00200                                           )
00201 {
00202   MOCKPP_STL::vector<Stub<R, I>*> vec;
00203   vec.push_back( stub1.release());
00204   vec.push_back( stub2.release());
00205   vec.push_back( stub3.release());
00206   return new StubSequence<R, I>( vec.begin(), vec.end() );
00207 }
00208 
00209 
00218 template <typename R,  // ReturnType
00219           typename I>  // Invocation
00220 typename Stub<R, I>::AP onConsecutiveCalls(  Stub<R, I> *stub1
00221                                            , Stub<R, I> *stub2
00222                                            , Stub<R, I> *stub3
00223                                           )
00224 {
00225   MOCKPP_STL::vector<Stub<I, R>*> vec;
00226   vec.push_back( stub1);
00227   vec.push_back( stub2);
00228   vec.push_back( stub3);
00229   return new StubSequence<R, I>( vec.begin(), vec.end() );
00230 }
00231 
00232 
00241 template <typename R>  // ReturnType
00242 typename TypelessStub<R>::AP onConsecutiveCalls(  AutoPointer<TypelessStub<R> > stub1
00243                                                 , AutoPointer<TypelessStub<R> > stub2
00244                                                 , AutoPointer<TypelessStub<R> > stub3
00245                                                )
00246 {
00247   MOCKPP_STL::vector<TypelessStub<R>*> vec;
00248   vec.push_back( stub1.release());
00249   vec.push_back( stub2.release());
00250   vec.push_back( stub3.release());
00251   return new TypelessStubSequence<R>( vec.begin(), vec.end() );
00252 }
00253 
00254 
00263 template <typename R>  // ReturnType
00264 typename TypelessStub<R>::AP onConsecutiveCalls(  TypelessStub<R> *stub1
00265                                                 , TypelessStub<R> *stub2
00266                                                 , TypelessStub<R> *stub3
00267                                           )
00268 {
00269   MOCKPP_STL::vector<TypelessStub<R>*> vec;
00270   vec.push_back( stub1);
00271   vec.push_back( stub2);
00272   vec.push_back( stub3);
00273   return new TypelessStubSequence<R>( vec.begin(), vec.end() );
00274 }
00275 
00276 
00286 template <typename R,  // ReturnType
00287           typename I>  // Invocation
00288 typename Stub<R, I>::AP onConsecutiveCalls(  AutoPointer<Stub<R, I> > stub1
00289                                            , AutoPointer<Stub<R, I> > stub2
00290                                            , AutoPointer<Stub<R, I> > stub3
00291                                            , AutoPointer<Stub<R, I> > stub4
00292                                           )
00293 {
00294   MOCKPP_STL::vector<Stub<R, I>*> vec;
00295   vec.push_back( stub1.release());
00296   vec.push_back( stub2.release());
00297   vec.push_back( stub3.release());
00298   vec.push_back( stub4.release());
00299   return new StubSequence<R, I>( vec.begin(), vec.end() );
00300 }
00301 
00302 
00312 template <typename R,  // ReturnType
00313           typename I>  // Invocation
00314 typename Stub<R, I>::AP onConsecutiveCalls(  Stub<R, I> *stub1
00315                                            , Stub<R, I> *stub2
00316                                            , Stub<R, I> *stub3
00317                                            , Stub<R, I> *stub4
00318                                           )
00319 {
00320   MOCKPP_STL::vector<Stub<I, R>*> vec;
00321   vec.push_back( stub1);
00322   vec.push_back( stub2);
00323   vec.push_back( stub3);
00324   vec.push_back( stub4);
00325   return new StubSequence<R, I>( vec.begin(), vec.end() );
00326 }
00327 
00328 
00338 template <typename R>  // ReturnType
00339 typename TypelessStub<R>::AP onConsecutiveCalls(  AutoPointer<TypelessStub<R> > stub1
00340                                                 , AutoPointer<TypelessStub<R> > stub2
00341                                                 , AutoPointer<TypelessStub<R> > stub3
00342                                                 , AutoPointer<TypelessStub<R> > stub4
00343                                                )
00344 {
00345   MOCKPP_STL::vector<TypelessStub<R>*> vec;
00346   vec.push_back( stub1.release());
00347   vec.push_back( stub2.release());
00348   vec.push_back( stub3.release());
00349   vec.push_back( stub4.release());
00350   return new TypelessStubSequence<R>( vec.begin(), vec.end() );
00351 }
00352 
00353 
00363 template <typename R>  // ReturnType
00364 typename TypelessStub<R>::AP onConsecutiveCalls(  TypelessStub<R> *stub1
00365                                                 , TypelessStub<R> *stub2
00366                                                 , TypelessStub<R> *stub3
00367                                                 , TypelessStub<R> *stub4
00368                                           )
00369 {
00370   MOCKPP_STL::vector<TypelessStub<R>*> vec;
00371   vec.push_back( stub1);
00372   vec.push_back( stub2);
00373   vec.push_back( stub3);
00374   vec.push_back( stub4);
00375   return new TypelessStubSequence<R>( vec.begin(), vec.end() );
00376 }
00377 
00378 
00389 template <typename R,  // ReturnType
00390           typename I>  // Invocation
00391 typename Stub<R, I>::AP onConsecutiveCalls(  AutoPointer<Stub<R, I> > stub1
00392                                            , AutoPointer<Stub<R, I> > stub2
00393                                            , AutoPointer<Stub<R, I> > stub3
00394                                            , AutoPointer<Stub<R, I> > stub4
00395                                            , AutoPointer<Stub<R, I> > stub5
00396                                           )
00397 {
00398   MOCKPP_STL::vector<Stub<R, I>*> vec;
00399   vec.push_back( stub1.release());
00400   vec.push_back( stub2.release());
00401   vec.push_back( stub3.release());
00402   vec.push_back( stub4.release());
00403   vec.push_back( stub5.release());
00404   return new StubSequence<R, I>( vec.begin(), vec.end() );
00405 }
00406 
00407 
00418 template <typename R,  // ReturnType
00419           typename I>  // Invocation
00420 typename Stub<R, I>::AP onConsecutiveCalls(  Stub<R, I> *stub1
00421                                            , Stub<R, I> *stub2
00422                                            , Stub<R, I> *stub3
00423                                            , Stub<R, I> *stub4
00424                                            , Stub<R, I> *stub5
00425                                           )
00426 {
00427   MOCKPP_STL::vector<Stub<I, R>*> vec;
00428   vec.push_back( stub1);
00429   vec.push_back( stub2);
00430   vec.push_back( stub3);
00431   vec.push_back( stub4);
00432   vec.push_back( stub5);
00433   return new StubSequence<R, I>( vec.begin(), vec.end() );
00434 }
00435 
00436 
00447 template <typename R>  // ReturnType
00448 typename TypelessStub<R>::AP onConsecutiveCalls(  AutoPointer<TypelessStub<R> > stub1
00449                                                 , AutoPointer<TypelessStub<R> > stub2
00450                                                 , AutoPointer<TypelessStub<R> > stub3
00451                                                 , AutoPointer<TypelessStub<R> > stub4
00452                                                 , AutoPointer<TypelessStub<R> > stub5
00453                                                )
00454 {
00455   MOCKPP_STL::vector<TypelessStub<R>*> vec;
00456   vec.push_back( stub1.release());
00457   vec.push_back( stub2.release());
00458   vec.push_back( stub3.release());
00459   vec.push_back( stub4.release());
00460   vec.push_back( stub5.release());
00461   return new TypelessStubSequence<R>( vec.begin(), vec.end() );
00462 }
00463 
00464 
00475 template <typename R>  // ReturnType
00476 typename TypelessStub<R>::AP onConsecutiveCalls(  TypelessStub<R> *stub1
00477                                                 , TypelessStub<R> *stub2
00478                                                 , TypelessStub<R> *stub3
00479                                                 , TypelessStub<R> *stub4
00480                                                 , TypelessStub<R> *stub5
00481                                           )
00482 {
00483   MOCKPP_STL::vector<TypelessStub<R>*> vec;
00484   vec.push_back( stub1);
00485   vec.push_back( stub2);
00486   vec.push_back( stub3);
00487   vec.push_back( stub4);
00488   vec.push_back( stub5);
00489   return new TypelessStubSequence<R>( vec.begin(), vec.end() );
00490 }
00491 
00492 
00504 template <typename R,  // ReturnType
00505           typename I>  // Invocation
00506 typename Stub<R, I>::AP onConsecutiveCalls(  AutoPointer<Stub<R, I> > stub1
00507                                            , AutoPointer<Stub<R, I> > stub2
00508                                            , AutoPointer<Stub<R, I> > stub3
00509                                            , AutoPointer<Stub<R, I> > stub4
00510                                            , AutoPointer<Stub<R, I> > stub5
00511                                            , AutoPointer<Stub<R, I> > stub6
00512                                           )
00513 {
00514   MOCKPP_STL::vector<Stub<R, I>*> vec;
00515   vec.push_back( stub1.release());
00516   vec.push_back( stub2.release());
00517   vec.push_back( stub3.release());
00518   vec.push_back( stub4.release());
00519   vec.push_back( stub5.release());
00520   vec.push_back( stub6.release());
00521   return new StubSequence<R, I>( vec.begin(), vec.end() );
00522 }
00523 
00524 
00536 template <typename R,  // ReturnType
00537           typename I>  // Invocation
00538 typename Stub<R, I>::AP onConsecutiveCalls(  Stub<R, I> *stub1
00539                                            , Stub<R, I> *stub2
00540                                            , Stub<R, I> *stub3
00541                                            , Stub<R, I> *stub4
00542                                            , Stub<R, I> *stub5
00543                                            , Stub<R, I> *stub6
00544                                           )
00545 {
00546   MOCKPP_STL::vector<Stub<I, R>*> vec;
00547   vec.push_back( stub1);
00548   vec.push_back( stub2);
00549   vec.push_back( stub3);
00550   vec.push_back( stub4);
00551   vec.push_back( stub5);
00552   vec.push_back( stub6);
00553   return new StubSequence<R, I>( vec.begin(), vec.end() );
00554 }
00555 
00556 
00568 template <typename R>  // ReturnType
00569 typename TypelessStub<R>::AP onConsecutiveCalls(  AutoPointer<TypelessStub<R> > stub1
00570                                                 , AutoPointer<TypelessStub<R> > stub2
00571                                                 , AutoPointer<TypelessStub<R> > stub3
00572                                                 , AutoPointer<TypelessStub<R> > stub4
00573                                                 , AutoPointer<TypelessStub<R> > stub5
00574                                                 , AutoPointer<TypelessStub<R> > stub6
00575                                                )
00576 {
00577   MOCKPP_STL::vector<TypelessStub<R>*> vec;
00578   vec.push_back( stub1.release());
00579   vec.push_back( stub2.release());
00580   vec.push_back( stub3.release());
00581   vec.push_back( stub4.release());
00582   vec.push_back( stub5.release());
00583   vec.push_back( stub6.release());
00584   return new TypelessStubSequence<R>( vec.begin(), vec.end() );
00585 }
00586 
00587 
00599 template <typename R>  // ReturnType
00600 typename TypelessStub<R>::AP onConsecutiveCalls(  TypelessStub<R> *stub1
00601                                                 , TypelessStub<R> *stub2
00602                                                 , TypelessStub<R> *stub3
00603                                                 , TypelessStub<R> *stub4
00604                                                 , TypelessStub<R> *stub5
00605                                                 , TypelessStub<R> *stub6
00606                                           )
00607 {
00608   MOCKPP_STL::vector<TypelessStub<R>*> vec;
00609   vec.push_back( stub1);
00610   vec.push_back( stub2);
00611   vec.push_back( stub3);
00612   vec.push_back( stub4);
00613   vec.push_back( stub5);
00614   vec.push_back( stub6);
00615   return new TypelessStubSequence<R>( vec.begin(), vec.end() );
00616 }
00617 
00618 
00631 template <typename R,  // ReturnType
00632           typename I>  // Invocation
00633 typename Stub<R, I>::AP onConsecutiveCalls(  AutoPointer<Stub<R, I> > stub1
00634                                            , AutoPointer<Stub<R, I> > stub2
00635                                            , AutoPointer<Stub<R, I> > stub3
00636                                            , AutoPointer<Stub<R, I> > stub4
00637                                            , AutoPointer<Stub<R, I> > stub5
00638                                            , AutoPointer<Stub<R, I> > stub6
00639                                            , AutoPointer<Stub<R, I> > stub7
00640                                           )
00641 {
00642   MOCKPP_STL::vector<Stub<R, I>*> vec;
00643   vec.push_back( stub1.release());
00644   vec.push_back( stub2.release());
00645   vec.push_back( stub3.release());
00646   vec.push_back( stub4.release());
00647   vec.push_back( stub5.release());
00648   vec.push_back( stub6.release());
00649   vec.push_back( stub7.release());
00650   return new StubSequence<R, I>( vec.begin(), vec.end() );
00651 }
00652 
00653 
00666 template <typename R,  // ReturnType
00667           typename I>  // Invocation
00668 typename Stub<R, I>::AP onConsecutiveCalls(  Stub<R, I> *stub1
00669                                            , Stub<R, I> *stub2
00670                                            , Stub<R, I> *stub3
00671                                            , Stub<R, I> *stub4
00672                                            , Stub<R, I> *stub5
00673                                            , Stub<R, I> *stub6
00674                                            , Stub<R, I> *stub7
00675                                           )
00676 {
00677   MOCKPP_STL::vector<Stub<I, R>*> vec;
00678   vec.push_back( stub1);
00679   vec.push_back( stub2);
00680   vec.push_back( stub3);
00681   vec.push_back( stub4);
00682   vec.push_back( stub5);
00683   vec.push_back( stub6);
00684   vec.push_back( stub7);
00685   return new StubSequence<R, I>( vec.begin(), vec.end() );
00686 }
00687 
00688 
00701 template <typename R>  // ReturnType
00702 typename TypelessStub<R>::AP onConsecutiveCalls(  AutoPointer<TypelessStub<R> > stub1
00703                                                 , AutoPointer<TypelessStub<R> > stub2
00704                                                 , AutoPointer<TypelessStub<R> > stub3
00705                                                 , AutoPointer<TypelessStub<R> > stub4
00706                                                 , AutoPointer<TypelessStub<R> > stub5
00707                                                 , AutoPointer<TypelessStub<R> > stub6
00708                                                 , AutoPointer<TypelessStub<R> > stub7
00709                                                )
00710 {
00711   MOCKPP_STL::vector<TypelessStub<R>*> vec;
00712   vec.push_back( stub1.release());
00713   vec.push_back( stub2.release());
00714   vec.push_back( stub3.release());
00715   vec.push_back( stub4.release());
00716   vec.push_back( stub5.release());
00717   vec.push_back( stub6.release());
00718   vec.push_back( stub7.release());
00719   return new TypelessStubSequence<R>( vec.begin(), vec.end() );
00720 }
00721 
00722 
00735 template <typename R>  // ReturnType
00736 typename TypelessStub<R>::AP onConsecutiveCalls(  TypelessStub<R> *stub1
00737                                                 , TypelessStub<R> *stub2
00738                                                 , TypelessStub<R> *stub3
00739                                                 , TypelessStub<R> *stub4
00740                                                 , TypelessStub<R> *stub5
00741                                                 , TypelessStub<R> *stub6
00742                                                 , TypelessStub<R> *stub7
00743                                           )
00744 {
00745   MOCKPP_STL::vector<TypelessStub<R>*> vec;
00746   vec.push_back( stub1);
00747   vec.push_back( stub2);
00748   vec.push_back( stub3);
00749   vec.push_back( stub4);
00750   vec.push_back( stub5);
00751   vec.push_back( stub6);
00752   vec.push_back( stub7);
00753   return new TypelessStubSequence<R>( vec.begin(), vec.end() );
00754 }
00755 
00756 
00770 template <typename R,  // ReturnType
00771           typename I>  // Invocation
00772 typename Stub<R, I>::AP onConsecutiveCalls(  AutoPointer<Stub<R, I> > stub1
00773                                            , AutoPointer<Stub<R, I> > stub2
00774                                            , AutoPointer<Stub<R, I> > stub3
00775                                            , AutoPointer<Stub<R, I> > stub4
00776                                            , AutoPointer<Stub<R, I> > stub5
00777                                            , AutoPointer<Stub<R, I> > stub6
00778                                            , AutoPointer<Stub<R, I> > stub7
00779                                            , AutoPointer<Stub<R, I> > stub8
00780                                           )
00781 {
00782   MOCKPP_STL::vector<Stub<R, I>*> vec;
00783   vec.push_back( stub1.release());
00784   vec.push_back( stub2.release());
00785   vec.push_back( stub3.release());
00786   vec.push_back( stub4.release());
00787   vec.push_back( stub5.release());
00788   vec.push_back( stub6.release());
00789   vec.push_back( stub7.release());
00790   vec.push_back( stub8.release());
00791   return new StubSequence<R, I>( vec.begin(), vec.end() );
00792 }
00793 
00794 
00808 template <typename R,  // ReturnType
00809           typename I>  // Invocation
00810 typename Stub<R, I>::AP onConsecutiveCalls(  Stub<R, I> *stub1
00811                                            , Stub<R, I> *stub2
00812                                            , Stub<R, I> *stub3
00813                                            , Stub<R, I> *stub4
00814                                            , Stub<R, I> *stub5
00815                                            , Stub<R, I> *stub6
00816                                            , Stub<R, I> *stub7
00817                                            , Stub<R, I> *stub8
00818                                           )
00819 {
00820   MOCKPP_STL::vector<Stub<I, R>*> vec;
00821   vec.push_back( stub1);
00822   vec.push_back( stub2);
00823   vec.push_back( stub3);
00824   vec.push_back( stub4);
00825   vec.push_back( stub5);
00826   vec.push_back( stub6);
00827   vec.push_back( stub7);
00828   vec.push_back( stub8);
00829   return new StubSequence<R, I>( vec.begin(), vec.end() );
00830 }
00831 
00832 
00846 template <typename R>  // ReturnType
00847 typename TypelessStub<R>::AP onConsecutiveCalls(  AutoPointer<TypelessStub<R> > stub1
00848                                                 , AutoPointer<TypelessStub<R> > stub2
00849                                                 , AutoPointer<TypelessStub<R> > stub3
00850                                                 , AutoPointer<TypelessStub<R> > stub4
00851                                                 , AutoPointer<TypelessStub<R> > stub5
00852                                                 , AutoPointer<TypelessStub<R> > stub6
00853                                                 , AutoPointer<TypelessStub<R> > stub7
00854                                                 , AutoPointer<TypelessStub<R> > stub8
00855                                                )
00856 {
00857   MOCKPP_STL::vector<TypelessStub<R>*> vec;
00858   vec.push_back( stub1.release());
00859   vec.push_back( stub2.release());
00860   vec.push_back( stub3.release());
00861   vec.push_back( stub4.release());
00862   vec.push_back( stub5.release());
00863   vec.push_back( stub6.release());
00864   vec.push_back( stub7.release());
00865   vec.push_back( stub8.release());
00866   return new TypelessStubSequence<R>( vec.begin(), vec.end() );
00867 }
00868 
00869 
00883 template <typename R>  // ReturnType
00884 typename TypelessStub<R>::AP onConsecutiveCalls(  TypelessStub<R> *stub1
00885                                                 , TypelessStub<R> *stub2
00886                                                 , TypelessStub<R> *stub3
00887                                                 , TypelessStub<R> *stub4
00888                                                 , TypelessStub<R> *stub5
00889                                                 , TypelessStub<R> *stub6
00890                                                 , TypelessStub<R> *stub7
00891                                                 , TypelessStub<R> *stub8
00892                                           )
00893 {
00894   MOCKPP_STL::vector<TypelessStub<R>*> vec;
00895   vec.push_back( stub1);
00896   vec.push_back( stub2);
00897   vec.push_back( stub3);
00898   vec.push_back( stub4);
00899   vec.push_back( stub5);
00900   vec.push_back( stub6);
00901   vec.push_back( stub7);
00902   vec.push_back( stub8);
00903   return new TypelessStubSequence<R>( vec.begin(), vec.end() );
00904 }
00905 
00906 
00921 template <typename R,  // ReturnType
00922           typename I>  // Invocation
00923 typename Stub<R, I>::AP onConsecutiveCalls(  AutoPointer<Stub<R, I> > stub1
00924                                            , AutoPointer<Stub<R, I> > stub2
00925                                            , AutoPointer<Stub<R, I> > stub3
00926                                            , AutoPointer<Stub<R, I> > stub4
00927                                            , AutoPointer<Stub<R, I> > stub5
00928                                            , AutoPointer<Stub<R, I> > stub6
00929                                            , AutoPointer<Stub<R, I> > stub7
00930                                            , AutoPointer<Stub<R, I> > stub8
00931                                            , AutoPointer<Stub<R, I> > stub9
00932                                           )
00933 {
00934   MOCKPP_STL::vector<Stub<R, I>*> vec;
00935   vec.push_back( stub1.release());
00936   vec.push_back( stub2.release());
00937   vec.push_back( stub3.release());
00938   vec.push_back( stub4.release());
00939   vec.push_back( stub5.release());
00940   vec.push_back( stub6.release());
00941   vec.push_back( stub7.release());
00942   vec.push_back( stub8.release());
00943   vec.push_back( stub9.release());
00944   return new StubSequence<R, I>( vec.begin(), vec.end() );
00945 }
00946 
00947 
00962 template <typename R,  // ReturnType
00963           typename I>  // Invocation
00964 typename Stub<R, I>::AP onConsecutiveCalls(  Stub<R, I> *stub1
00965                                            , Stub<R, I> *stub2
00966                                            , Stub<R, I> *stub3
00967                                            , Stub<R, I> *stub4
00968                                            , Stub<R, I> *stub5
00969                                            , Stub<R, I> *stub6
00970                                            , Stub<R, I> *stub7
00971                                            , Stub<R, I> *stub8
00972                                            , Stub<R, I> *stub9
00973                                           )
00974 {
00975   MOCKPP_STL::vector<Stub<I, R>*> vec;
00976   vec.push_back( stub1);
00977   vec.push_back( stub2);
00978   vec.push_back( stub3);
00979   vec.push_back( stub4);
00980   vec.push_back( stub5);
00981   vec.push_back( stub6);
00982   vec.push_back( stub7);
00983   vec.push_back( stub8);
00984   vec.push_back( stub9);
00985   return new StubSequence<R, I>( vec.begin(), vec.end() );
00986 }
00987 
00988 
01003 template <typename R>  // ReturnType
01004 typename TypelessStub<R>::AP onConsecutiveCalls(  AutoPointer<TypelessStub<R> > stub1
01005                                                 , AutoPointer<TypelessStub<R> > stub2
01006                                                 , AutoPointer<TypelessStub<R> > stub3
01007                                                 , AutoPointer<TypelessStub<R> > stub4
01008                                                 , AutoPointer<TypelessStub<R> > stub5
01009                                                 , AutoPointer<TypelessStub<R> > stub6
01010                                                 , AutoPointer<TypelessStub<R> > stub7
01011                                                 , AutoPointer<TypelessStub<R> > stub8
01012                                                 , AutoPointer<TypelessStub<R> > stub9
01013                                                )
01014 {
01015   MOCKPP_STL::vector<TypelessStub<R>*> vec;
01016   vec.push_back( stub1.release());
01017   vec.push_back( stub2.release());
01018   vec.push_back( stub3.release());
01019   vec.push_back( stub4.release());
01020   vec.push_back( stub5.release());
01021   vec.push_back( stub6.release());
01022   vec.push_back( stub7.release());
01023   vec.push_back( stub8.release());
01024   vec.push_back( stub9.release());
01025   return new TypelessStubSequence<R>( vec.begin(), vec.end() );
01026 }
01027 
01028 
01043 template <typename R>  // ReturnType
01044 typename TypelessStub<R>::AP onConsecutiveCalls(  TypelessStub<R> *stub1
01045                                                 , TypelessStub<R> *stub2
01046                                                 , TypelessStub<R> *stub3
01047                                                 , TypelessStub<R> *stub4
01048                                                 , TypelessStub<R> *stub5
01049                                                 , TypelessStub<R> *stub6
01050                                                 , TypelessStub<R> *stub7
01051                                                 , TypelessStub<R> *stub8
01052                                                 , TypelessStub<R> *stub9
01053                                           )
01054 {
01055   MOCKPP_STL::vector<TypelessStub<R>*> vec;
01056   vec.push_back( stub1);
01057   vec.push_back( stub2);
01058   vec.push_back( stub3);
01059   vec.push_back( stub4);
01060   vec.push_back( stub5);
01061   vec.push_back( stub6);
01062   vec.push_back( stub7);
01063   vec.push_back( stub8);
01064   vec.push_back( stub9);
01065   return new TypelessStubSequence<R>( vec.begin(), vec.end() );
01066 }
01067 
01068 
01084 template <typename R,  // ReturnType
01085           typename I>  // Invocation
01086 typename Stub<R, I>::AP onConsecutiveCalls(  AutoPointer<Stub<R, I> > stub1
01087                                            , AutoPointer<Stub<R, I> > stub2
01088                                            , AutoPointer<Stub<R, I> > stub3
01089                                            , AutoPointer<Stub<R, I> > stub4
01090                                            , AutoPointer<Stub<R, I> > stub5
01091                                            , AutoPointer<Stub<R, I> > stub6
01092                                            , AutoPointer<Stub<R, I> > stub7
01093                                            , AutoPointer<Stub<R, I> > stub8
01094                                            , AutoPointer<Stub<R, I> > stub9
01095                                            , AutoPointer<Stub<R, I> > stub10
01096                                           )
01097 {
01098   MOCKPP_STL::vector<Stub<R, I>*> vec;
01099   vec.push_back( stub1.release());
01100   vec.push_back( stub2.release());
01101   vec.push_back( stub3.release());
01102   vec.push_back( stub4.release());
01103   vec.push_back( stub5.release());
01104   vec.push_back( stub6.release());
01105   vec.push_back( stub7.release());
01106   vec.push_back( stub8.release());
01107   vec.push_back( stub9.release());
01108   vec.push_back( stub10.release());
01109   return new StubSequence<R, I>( vec.begin(), vec.end() );
01110 }
01111 
01112 
01128 template <typename R,  // ReturnType
01129           typename I>  // Invocation
01130 typename Stub<R, I>::AP onConsecutiveCalls(  Stub<R, I> *stub1
01131                                            , Stub<R, I> *stub2
01132                                            , Stub<R, I> *stub3
01133                                            , Stub<R, I> *stub4
01134                                            , Stub<R, I> *stub5
01135                                            , Stub<R, I> *stub6
01136                                            , Stub<R, I> *stub7
01137                                            , Stub<R, I> *stub8
01138                                            , Stub<R, I> *stub9
01139                                            , Stub<R, I> *stub10
01140                                           )
01141 {
01142   MOCKPP_STL::vector<Stub<I, R>*> vec;
01143   vec.push_back( stub1);
01144   vec.push_back( stub2);
01145   vec.push_back( stub3);
01146   vec.push_back( stub4);
01147   vec.push_back( stub5);
01148   vec.push_back( stub6);
01149   vec.push_back( stub7);
01150   vec.push_back( stub8);
01151   vec.push_back( stub9);
01152   vec.push_back( stub10);
01153   return new StubSequence<R, I>( vec.begin(), vec.end() );
01154 }
01155 
01156 
01172 template <typename R>  // ReturnType
01173 typename TypelessStub<R>::AP onConsecutiveCalls(  AutoPointer<TypelessStub<R> > stub1
01174                                                 , AutoPointer<TypelessStub<R> > stub2
01175                                                 , AutoPointer<TypelessStub<R> > stub3
01176                                                 , AutoPointer<TypelessStub<R> > stub4
01177                                                 , AutoPointer<TypelessStub<R> > stub5
01178                                                 , AutoPointer<TypelessStub<R> > stub6
01179                                                 , AutoPointer<TypelessStub<R> > stub7
01180                                                 , AutoPointer<TypelessStub<R> > stub8
01181                                                 , AutoPointer<TypelessStub<R> > stub9
01182                                                 , AutoPointer<TypelessStub<R> > stub10
01183                                                )
01184 {
01185   MOCKPP_STL::vector<TypelessStub<R>*> vec;
01186   vec.push_back( stub1.release());
01187   vec.push_back( stub2.release());
01188   vec.push_back( stub3.release());
01189   vec.push_back( stub4.release());
01190   vec.push_back( stub5.release());
01191   vec.push_back( stub6.release());
01192   vec.push_back( stub7.release());
01193   vec.push_back( stub8.release());
01194   vec.push_back( stub9.release());
01195   vec.push_back( stub10.release());
01196   return new TypelessStubSequence<R>( vec.begin(), vec.end() );
01197 }
01198 
01199 
01215 template <typename R>  // ReturnType
01216 typename TypelessStub<R>::AP onConsecutiveCalls(  TypelessStub<R> *stub1
01217                                                 , TypelessStub<R> *stub2
01218                                                 , TypelessStub<R> *stub3
01219                                                 , TypelessStub<R> *stub4
01220                                                 , TypelessStub<R> *stub5
01221                                                 , TypelessStub<R> *stub6
01222                                                 , TypelessStub<R> *stub7
01223                                                 , TypelessStub<R> *stub8
01224                                                 , TypelessStub<R> *stub9
01225                                                 , TypelessStub<R> *stub10
01226                                           )
01227 {
01228   MOCKPP_STL::vector<TypelessStub<R>*> vec;
01229   vec.push_back( stub1);
01230   vec.push_back( stub2);
01231   vec.push_back( stub3);
01232   vec.push_back( stub4);
01233   vec.push_back( stub5);
01234   vec.push_back( stub6);
01235   vec.push_back( stub7);
01236   vec.push_back( stub8);
01237   vec.push_back( stub9);
01238   vec.push_back( stub10);
01239   return new TypelessStubSequence<R>( vec.begin(), vec.end() );
01240 }
01241 
01242 
01243 MOCKPP_NS_END
01244 
01245 
01246 #endif // MOCKPP_ONCONSECUTIVECALLS_H
01247