sprint/function/detail/adapter.h

Go to the documentation of this file.

/******************************************************************************
*   sprint::adapter
*
*   Copyright (C) 2005-2011  Paolo Medici <www.pmx.it>
*
*  This library is free software; you can redistribute it and/or
*  modify it under the terms of the GNU Lesser General Public
*  License as published by the Free Software Foundation; either
*  version 2.1 of the License, or (at your option) any later version.
*
*  This library is distributed in the hope that it will be useful,
*  but WITHOUT ANY WARRANTY; without even the implied warranty of
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
*  Lesser General Public License for more details.
*
*  You should have received a copy of the GNU Lesser General Public
*  License along with this library; if not, write to the Free Software
*  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*
*******************************************************************************/

#ifndef _SPRINT_DETAIL_FUNCTION_adapter_H
#define _SPRINT_DETAIL_FUNCTION_adapter_H

// $generated on Oct 30 2011 11:42:48$

#include <sprint/function/function.h>

namespace sprint {
        namespace detail {

template<class R, class _Invoker>
class adapter0: public function0<R> {
        typename _Invoker::ParamType m_p;
 public:
        adapter0( const typename _Invoker::ParamType & p) : m_p(p) { }
        virtual ~adapter0() { }
        virtual R operator()(void) { return _Invoker::run(m_p); }
};

template<class _Invoker>
class adapter0<void, _Invoker>: public function0<void> {
        typename _Invoker::ParamType m_p;
 public:
        adapter0( const typename _Invoker::ParamType & p) : m_p(p) { }
        virtual ~adapter0() { }
        virtual void operator()(void) { _Invoker::run(m_p); }
 };

template<class R, class _Invoker, class P1>
class adapter1: public function1<R, P1> {
        typename _Invoker::ParamType m_p;
 public:
        adapter1( const typename _Invoker::ParamType & p) : m_p(p) { }
        virtual ~adapter1() { }
        virtual R operator()(P1 p1) { return _Invoker::run(m_p, p1); }
};

template<class _Invoker,class P1>
class adapter1<void, _Invoker, P1>: public function1<void, P1> {
        typename _Invoker::ParamType m_p;
 public:
        adapter1( const typename _Invoker::ParamType & p) : m_p(p) { }
        virtual ~adapter1() { }
        virtual void operator()(P1 p1) { _Invoker::run(m_p, p1); }
 };

template<class R, class _Invoker, class P1, class P2>
class adapter2: public function2<R, P1, P2> {
        typename _Invoker::ParamType m_p;
 public:
        adapter2( const typename _Invoker::ParamType & p) : m_p(p) { }
        virtual ~adapter2() { }
        virtual R operator()(P1 p1, P2 p2) { return _Invoker::run(m_p, p1, p2); }
};

template<class _Invoker,class P1, class P2>
class adapter2<void, _Invoker, P1, P2>: public function2<void, P1, P2> {
        typename _Invoker::ParamType m_p;
 public:
        adapter2( const typename _Invoker::ParamType & p) : m_p(p) { }
        virtual ~adapter2() { }
        virtual void operator()(P1 p1, P2 p2) { _Invoker::run(m_p, p1, p2); }
 };

template<class R, class _Invoker, class P1, class P2, class P3>
class adapter3: public function3<R, P1, P2, P3> {
        typename _Invoker::ParamType m_p;
 public:
        adapter3( const typename _Invoker::ParamType & p) : m_p(p) { }
        virtual ~adapter3() { }
        virtual R operator()(P1 p1, P2 p2, P3 p3) { return _Invoker::run(m_p, p1, p2, p3); }
};

template<class _Invoker,class P1, class P2, class P3>
class adapter3<void, _Invoker, P1, P2, P3>: public function3<void, P1, P2, P3> {
        typename _Invoker::ParamType m_p;
 public:
        adapter3( const typename _Invoker::ParamType & p) : m_p(p) { }
        virtual ~adapter3() { }
        virtual void operator()(P1 p1, P2 p2, P3 p3) { _Invoker::run(m_p, p1, p2, p3); }
 };

template<class R, class _Invoker, class P1, class P2, class P3, class P4>
class adapter4: public function4<R, P1, P2, P3, P4> {
        typename _Invoker::ParamType m_p;
 public:
        adapter4( const typename _Invoker::ParamType & p) : m_p(p) { }
        virtual ~adapter4() { }
        virtual R operator()(P1 p1, P2 p2, P3 p3, P4 p4) { return _Invoker::run(m_p, p1, p2, p3, p4); }
};

template<class _Invoker,class P1, class P2, class P3, class P4>
class adapter4<void, _Invoker, P1, P2, P3, P4>: public function4<void, P1, P2, P3, P4> {
        typename _Invoker::ParamType m_p;
 public:
        adapter4( const typename _Invoker::ParamType & p) : m_p(p) { }
        virtual ~adapter4() { }
        virtual void operator()(P1 p1, P2 p2, P3 p3, P4 p4) { _Invoker::run(m_p, p1, p2, p3, p4); }
 };

template<class R, class _Invoker, class P1, class P2, class P3, class P4, class P5>
class adapter5: public function5<R, P1, P2, P3, P4, P5> {
        typename _Invoker::ParamType m_p;
 public:
        adapter5( const typename _Invoker::ParamType & p) : m_p(p) { }
        virtual ~adapter5() { }
        virtual R operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) { return _Invoker::run(m_p, p1, p2, p3, p4, p5); }
};

template<class _Invoker,class P1, class P2, class P3, class P4, class P5>
class adapter5<void, _Invoker, P1, P2, P3, P4, P5>: public function5<void, P1, P2, P3, P4, P5> {
        typename _Invoker::ParamType m_p;
 public:
        adapter5( const typename _Invoker::ParamType & p) : m_p(p) { }
        virtual ~adapter5() { }
        virtual void operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) { _Invoker::run(m_p, p1, p2, p3, p4, p5); }
 };

template<class R, class _Invoker, class P1, class P2, class P3, class P4, class P5, class P6>
class adapter6: public function6<R, P1, P2, P3, P4, P5, P6> {
        typename _Invoker::ParamType m_p;
 public:
        adapter6( const typename _Invoker::ParamType & p) : m_p(p) { }
        virtual ~adapter6() { }
        virtual R operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) { return _Invoker::run(m_p, p1, p2, p3, p4, p5, p6); }
};

template<class _Invoker,class P1, class P2, class P3, class P4, class P5, class P6>
class adapter6<void, _Invoker, P1, P2, P3, P4, P5, P6>: public function6<void, P1, P2, P3, P4, P5, P6> {
        typename _Invoker::ParamType m_p;
 public:
        adapter6( const typename _Invoker::ParamType & p) : m_p(p) { }
        virtual ~adapter6() { }
        virtual void operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) { _Invoker::run(m_p, p1, p2, p3, p4, p5, p6); }
 };

template<class R, class _Invoker, class P1, class P2, class P3, class P4, class P5, class P6, class P7>
class adapter7: public function7<R, P1, P2, P3, P4, P5, P6, P7> {
        typename _Invoker::ParamType m_p;
 public:
        adapter7( const typename _Invoker::ParamType & p) : m_p(p) { }
        virtual ~adapter7() { }
        virtual R operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7) { return _Invoker::run(m_p, p1, p2, p3, p4, p5, p6, p7); }
};

template<class _Invoker,class P1, class P2, class P3, class P4, class P5, class P6, class P7>
class adapter7<void, _Invoker, P1, P2, P3, P4, P5, P6, P7>: public function7<void, P1, P2, P3, P4, P5, P6, P7> {
        typename _Invoker::ParamType m_p;
 public:
        adapter7( const typename _Invoker::ParamType & p) : m_p(p) { }
        virtual ~adapter7() { }
        virtual void operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7) { _Invoker::run(m_p, p1, p2, p3, p4, p5, p6, p7); }
 };

template<class R, class _Invoker, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8>
class adapter8: public function8<R, P1, P2, P3, P4, P5, P6, P7, P8> {
        typename _Invoker::ParamType m_p;
 public:
        adapter8( const typename _Invoker::ParamType & p) : m_p(p) { }
        virtual ~adapter8() { }
        virtual R operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8) { return _Invoker::run(m_p, p1, p2, p3, p4, p5, p6, p7, p8); }
};

template<class _Invoker,class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8>
class adapter8<void, _Invoker, P1, P2, P3, P4, P5, P6, P7, P8>: public function8<void, P1, P2, P3, P4, P5, P6, P7, P8> {
        typename _Invoker::ParamType m_p;
 public:
        adapter8( const typename _Invoker::ParamType & p) : m_p(p) { }
        virtual ~adapter8() { }
        virtual void operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8) { _Invoker::run(m_p, p1, p2, p3, p4, p5, p6, p7, p8); }
 };

template<class R, class _Invoker, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9>
class adapter9: public function9<R, P1, P2, P3, P4, P5, P6, P7, P8, P9> {
        typename _Invoker::ParamType m_p;
 public:
        adapter9( const typename _Invoker::ParamType & p) : m_p(p) { }
        virtual ~adapter9() { }
        virtual R operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9) { return _Invoker::run(m_p, p1, p2, p3, p4, p5, p6, p7, p8, p9); }
};

template<class _Invoker,class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9>
class adapter9<void, _Invoker, P1, P2, P3, P4, P5, P6, P7, P8, P9>: public function9<void, P1, P2, P3, P4, P5, P6, P7, P8, P9> {
        typename _Invoker::ParamType m_p;
 public:
        adapter9( const typename _Invoker::ParamType & p) : m_p(p) { }
        virtual ~adapter9() { }
        virtual void operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9) { _Invoker::run(m_p, p1, p2, p3, p4, p5, p6, p7, p8, p9); }
 };

template<class R, class _Invoker, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class P10>
class adapter10: public function10<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> {
        typename _Invoker::ParamType m_p;
 public:
        adapter10( const typename _Invoker::ParamType & p) : m_p(p) { }
        virtual ~adapter10() { }
        virtual R operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10) { return _Invoker::run(m_p, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); }
};

template<class _Invoker,class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class P10>
class adapter10<void, _Invoker, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>: public function10<void, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> {
        typename _Invoker::ParamType m_p;
 public:
        adapter10( const typename _Invoker::ParamType & p) : m_p(p) { }
        virtual ~adapter10() { }
        virtual void operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10) { _Invoker::run(m_p, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); }
 };

template<class R, class _Invoker, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class P10, class P11>
class adapter11: public function11<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> {
        typename _Invoker::ParamType m_p;
 public:
        adapter11( const typename _Invoker::ParamType & p) : m_p(p) { }
        virtual ~adapter11() { }
        virtual R operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10, P11 p11) { return _Invoker::run(m_p, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); }
};

template<class _Invoker,class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class P10, class P11>
class adapter11<void, _Invoker, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>: public function11<void, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> {
        typename _Invoker::ParamType m_p;
 public:
        adapter11( const typename _Invoker::ParamType & p) : m_p(p) { }
        virtual ~adapter11() { }
        virtual void operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10, P11 p11) { _Invoker::run(m_p, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); }
 };


        } // detail
} // sprint

#endif