diff -ru src-old/BindStorage.hpp src/BindStorage.hpp
--- src-old/BindStorage.hpp	2010-10-10 22:52:14.000000000 +0200
+++ src/BindStorage.hpp	2010-10-10 23:23:05.000000000 +0200
@@ -85,6 +85,16 @@
             bool operator()(T1, T2, T3, T4) {
                 return (mo->*mf)();
             }
+
+            template<class T1, class T2, class T3, class T4, class T5>
+            bool operator()(T1, T2, T3, T4, T5) {
+                return (mo->*mf)();
+            }
+
+            template<class T1, class T2, class T3, class T4, class T5, class T6>
+            bool operator()(T1, T2, T3, T4, T5, T6) {
+                return (mo->*mf)();
+            }
         };
 
         template<class F, class O>
@@ -115,6 +125,16 @@
             bool operator()(T1& t1, T2, T3, T4) {
                 return (mo->*mf)(t1);
             }
+
+            template<class T1, class T2, class T3, class T4, class T5>
+            bool operator()(T1, T2, T3, T4, T5) {
+                return (mo->*mf)();
+            }
+
+            template<class T1, class T2, class T3, class T4, class T5, class T6>
+            bool operator()(T1, T2, T3, T4, T5, T6) {
+                return (mo->*mf)();
+            }
         };
 
         template<class F, class O>
@@ -140,6 +160,16 @@
             bool operator()(T1& t1, T2 t2, T3, T4) {
                 return (mo->*mf)(t1,t2);
             }
+
+            template<class T1, class T2, class T3, class T4, class T5>
+            bool operator()(T1, T2, T3, T4, T5) {
+                return (mo->*mf)();
+            }
+
+            template<class T1, class T2, class T3, class T4, class T5, class T6>
+            bool operator()(T1, T2, T3, T4, T5, T6) {
+                return (mo->*mf)();
+            }
         };
 
         template<class F, class O>
@@ -160,6 +190,16 @@
             bool operator()(T1& t1, T2 t2, T3 t3, T4) {
                 return (mo->*mf)(t1,t2,t3);
             }
+
+            template<class T1, class T2, class T3, class T4, class T5>
+            bool operator()(T1, T2, T3, T4, T5) {
+                return (mo->*mf)();
+            }
+
+            template<class T1, class T2, class T3, class T4, class T5, class T6>
+            bool operator()(T1, T2, T3, T4, T5, T6) {
+                return (mo->*mf)();
+            }
         };
 
         template<class F, class O>
@@ -175,6 +215,51 @@
             bool operator()(T1& t1, T2 t2, T3 t3, T4 t4) {
                 return (mo->*mf)(t1,t2,t3,t4);
             }
+
+            template<class T1, class T2, class T3, class T4, class T5>
+            bool operator()(T1, T2, T3, T4, T5) {
+                return (mo->*mf)();
+            }
+
+            template<class T1, class T2, class T3, class T4, class T5, class T6>
+            bool operator()(T1, T2, T3, T4, T5, T6) {
+                return (mo->*mf)();
+            }
+        };
+
+        template<class F, class O>
+        struct quickbind_impl<F,O,5>
+        {
+            F mf;
+            O mo;
+
+            quickbind_impl(F f, O o)
+                : mf(f), mo(o) {}
+
+            template<class T1, class T2, class T3, class T4, class T5>
+            bool operator()(T1, T2, T3, T4, T5) {
+                return (mo->*mf)();
+            }
+
+            template<class T1, class T2, class T3, class T4, class T5, class T6>
+            bool operator()(T1, T2, T3, T4, T5, T6) {
+                return (mo->*mf)();
+            }
+        };
+
+        template<class F, class O>
+        struct quickbind_impl<F,O,6>
+        {
+            F mf;
+            O mo;
+
+            quickbind_impl(F f, O o)
+                : mf(f), mo(o) {}
+
+            template<class T1, class T2, class T3, class T4, class T5, class T6>
+            bool operator()(T1, T2, T3, T4, T5, T6) {
+                return (mo->*mf)();
+            }
         };
 
 
@@ -212,6 +297,16 @@
             bool operator()(T1, T2, T3, T4) {
                 return mf();
             }
+
+            template<class T1, class T2, class T3, class T4, class T5>
+            bool operator()(T1, T2, T3, T4, T5) {
+                return mf();
+            }
+
+            template<class T1, class T2, class T3, class T4, class T5, class T6>
+            bool operator()(T1, T2, T3, T4, T5, T6) {
+                return mf();
+            }
         };
 
         template<class F>
@@ -241,6 +336,16 @@
             bool operator()(T1& t1, T2, T3, T4) {
                 return mf(t1);
             }
+
+            template<class T1, class T2, class T3, class T4, class T5>
+            bool operator()(T1, T2, T3, T4, T5) {
+                return mf();
+            }
+
+            template<class T1, class T2, class T3, class T4, class T5, class T6>
+            bool operator()(T1, T2, T3, T4, T5, T6) {
+                return mf();
+            }
         };
 
         template<class F>
@@ -265,6 +370,16 @@
             bool operator()(T1& t1, T2& t2, T3, T4) {
                 return mf(t1,t2);
             }
+
+            template<class T1, class T2, class T3, class T4, class T5>
+            bool operator()(T1, T2, T3, T4, T5) {
+                return mf();
+            }
+
+            template<class T1, class T2, class T3, class T4, class T5, class T6>
+            bool operator()(T1, T2, T3, T4, T5, T6) {
+                return mf();
+            }
         };
 
         template<class F>
@@ -284,6 +399,16 @@
             bool operator()(T1& t1, T2& t2, T3& t3, T4) {
                 return mf(t1,t2,t3);
             }
+
+            template<class T1, class T2, class T3, class T4, class T5>
+            bool operator()(T1, T2, T3, T4, T5) {
+                return mf();
+            }
+
+            template<class T1, class T2, class T3, class T4, class T5, class T6>
+            bool operator()(T1, T2, T3, T4, T5, T6) {
+                return mf();
+            }
         };
 
         template<class F>
@@ -297,6 +422,49 @@
             bool operator()(T1& t1, T2& t2, T3& t3, T4& t4) {
                 return mf(t1,t2,t3,t4);
             }
+
+            template<class T1, class T2, class T3, class T4, class T5>
+            bool operator()(T1, T2, T3, T4, T5) {
+                return mf();
+            }
+
+            template<class T1, class T2, class T3, class T4, class T5, class T6>
+            bool operator()(T1, T2, T3, T4, T5, T6) {
+                return mf();
+            }
+        };
+
+        template<class F>
+        struct quickbindC_impl<F,5>
+        {
+            F mf;
+
+            quickbindC_impl(F f)
+                : mf(f) {}
+
+            template<class T1, class T2, class T3, class T4, class T5>
+            bool operator()(T1, T2, T3, T4, T5) {
+                return mf();
+            }
+
+            template<class T1, class T2, class T3, class T4, class T5, class T6>
+            bool operator()(T1, T2, T3, T4, T5, T6) {
+                return mf();
+            }
+        };
+
+        template<class F>
+        struct quickbindC_impl<F,6>
+        {
+            F mf;
+
+            quickbindC_impl(F f)
+                : mf(f) {}
+
+            template<class T1, class T2, class T3, class T4, class T5, class T6>
+            bool operator()(T1, T2, T3, T4, T5, T6) {
+                return mf();
+            }
         };
 
         /**
@@ -553,6 +721,78 @@
             boost::function<ToBind> condition() const {return cond;}
         };
 
+        template<class ToBind>
+        struct BindStorageImpl<5, ToBind>
+        {
+            typedef bool result_type;
+            typedef typename boost::function_traits<ToBind>::arg1_type   arg1_type;
+            typedef typename boost::function_traits<ToBind>::arg2_type   arg2_type;
+            typedef typename boost::function_traits<ToBind>::arg3_type   arg3_type;
+            typedef typename boost::function_traits<ToBind>::arg4_type   arg4_type;
+			typedef typename boost::function_traits<ToBind>::arg5_type   arg5_type;
+
+            // stores the original function pointer
+            boost::function<ToBind> comm;
+            boost::function<ToBind> cond;
+            // Store the arguments.
+            mutable AStore<arg1_type> a1;
+            mutable AStore<arg2_type> a2;
+            mutable AStore<arg3_type> a3;
+            mutable AStore<arg4_type> a4;
+            mutable AStore<arg5_type> a5;
+
+            void store(arg1_type t1, arg2_type t2, arg3_type t3, arg4_type t4, arg5_type t5) { a1(t1); a2(t2); a3(t3); a4(t4); a5(t5);}
+            bool exec() { return comm( a1(), a2(), a3(), a4(), a5() ); }
+            bool check() const { return cond( a1(), a2(), a3(), a4(), a5() ); }
+
+            template<class F, class C, class ObjectType>
+            void setup(F f, C c, ObjectType t)
+            {
+                comm = boost::bind<bool>( boost::mem_fn(f), t, _1, _2, _3, _4, _5 ); // allocates
+                cond = quickbind<C,ObjectType>( c, t); // allocates
+            }
+
+            boost::function<ToBind> command() const {return comm;}
+            boost::function<ToBind> condition() const {return cond;}
+        };
+        
+        template<class ToBind>
+        struct BindStorageImpl<6, ToBind>
+        {
+            typedef bool result_type;
+            typedef typename boost::function_traits<ToBind>::arg1_type   arg1_type;
+            typedef typename boost::function_traits<ToBind>::arg2_type   arg2_type;
+            typedef typename boost::function_traits<ToBind>::arg3_type   arg3_type;
+            typedef typename boost::function_traits<ToBind>::arg4_type   arg4_type;
+			typedef typename boost::function_traits<ToBind>::arg5_type   arg5_type;
+			typedef typename boost::function_traits<ToBind>::arg6_type   arg6_type;
+
+            // stores the original function pointer
+            boost::function<ToBind> comm;
+            boost::function<ToBind> cond;
+            // Store the arguments.
+            mutable AStore<arg1_type> a1;
+            mutable AStore<arg2_type> a2;
+            mutable AStore<arg3_type> a3;
+            mutable AStore<arg4_type> a4;
+            mutable AStore<arg5_type> a5;
+            mutable AStore<arg5_type> a6;
+
+            void store(arg1_type t1, arg2_type t2, arg3_type t3, arg4_type t4, arg5_type t5, arg6_type t6) { a1(t1); a2(t2); a3(t3); a4(t4); a5(t5); a6(t6);}
+            bool exec() { return comm( a1(), a2(), a3(), a4(), a5(), a6() ); }
+            bool check() const { return cond( a1(), a2(), a3(), a4(), a5(), a6() ); }
+
+            template<class F, class C, class ObjectType>
+            void setup(F f, C c, ObjectType t)
+            {
+                comm = boost::bind<bool>( boost::mem_fn(f), t, _1, _2, _3, _4, _5, _6 ); // allocates
+                cond = quickbind<C,ObjectType>( c, t); // allocates
+            }
+
+            boost::function<ToBind> command() const {return comm;}
+            boost::function<ToBind> condition() const {return cond;}
+        };
+
 
         /**
          * A helper-class for the Command implementation which stores the
@@ -615,6 +855,24 @@
         };
 
         template<class F>
+        struct MethodBinderImpl<5,F>
+        {
+            template<class M, class O>
+            boost::function<F> operator()(M m, O o) {
+                return boost::bind( boost::mem_fn(m), o, _1, _2, _3, _4, _5 );
+            }
+        };
+
+        template<class F>
+        struct MethodBinderImpl<6,F>
+        {
+            template<class M, class O>
+            boost::function<F> operator()(M m, O o) {
+                return boost::bind( boost::mem_fn(m), o, _1, _2, _3, _4, _5, _6 );
+            }
+        };
+
+        template<class F>
         struct MethodBinder
             : public MethodBinderImpl<boost::function_traits<F>::arity, F>
         {};
diff -ru src-old/CommandFunctors.hpp src/CommandFunctors.hpp
--- src-old/CommandFunctors.hpp	2010-10-10 22:52:14.000000000 +0200
+++ src/CommandFunctors.hpp	2010-10-10 23:51:21.000000000 +0200
@@ -317,6 +317,157 @@
             }
         };
 
+
+        template<typename FunctionT>
+        class FunctorImpl<5, FunctionT>
+        {
+        public:
+            typedef typename FunctionT::arg1_type Arg1T;
+            typedef typename FunctionT::arg2_type Arg2T;
+            typedef typename FunctionT::arg3_type Arg3T;
+            typedef typename FunctionT::arg4_type Arg4T;
+            typedef typename FunctionT::arg5_type Arg5T;
+            FunctionT fun;
+            typename DataSource<Arg1T>::shared_ptr aa;
+            typename DataSource<Arg2T>::shared_ptr bb;
+            typename DataSource<Arg3T>::shared_ptr cc;
+            typename DataSource<Arg4T>::shared_ptr dd;
+            typename DataSource<Arg5T>::shared_ptr ee;
+
+            FunctorImpl( FunctionT f, DataSource<Arg1T>* a = 0, DataSource<Arg2T>* b = 0, DataSource<Arg3T>* c = 0, DataSource<Arg4T>* d = 0 , DataSource<Arg5T>* e = 0 )
+                : fun( f ), aa(a), bb(b), cc(c), dd(d), ee(e)
+            {
+            }
+
+            void setArguments( DataSource<Arg1T>* a, DataSource<Arg2T>* b, DataSource<Arg3T>* c, DataSource<Arg4T>* d, DataSource<Arg5T>* e  )
+            {
+                aa = a;
+                bb = b;
+                cc = c;
+                dd = d;
+                ee = e;
+            }
+
+            void readArguments()
+            {
+                aa->evaluate();
+                bb->evaluate();
+                cc->evaluate();
+                dd->evaluate();
+                ee->evaluate();
+            }
+
+            bool execute()
+            {
+                Arg1T a = aa->value();
+                Arg2T b = bb->value();
+                Arg3T c = cc->value();
+                Arg4T d = dd->value();
+                Arg5T e = ee->value();
+                return fun( a, b, c, d, e );
+            }
+
+            bool evaluate()
+            {
+                Arg1T a = aa->value();
+                Arg2T b = bb->value();
+                Arg3T c = cc->value();
+                Arg4T d = dd->value();
+                Arg5T e = ee->value();
+                bool r = fun( a, b, c, d, e );
+                aa->updated();
+                bb->updated();
+                cc->updated();
+                dd->updated();
+                ee->updated();
+                return r;
+            }
+
+            FunctorImpl<5,FunctionT> copy( std::map<const DataSourceBase*, DataSourceBase*>& alreadyCloned ) const
+            {
+                return FunctorImpl( fun, aa->copy( alreadyCloned ), bb->copy(alreadyCloned), cc->copy(alreadyCloned), dd->copy(alreadyCloned), ee->copy(alreadyCloned) );
+            }
+        };
+
+
+        template<typename FunctionT>
+        class FunctorImpl<6, FunctionT>
+        {
+        public:
+            typedef typename FunctionT::arg1_type Arg1T;
+            typedef typename FunctionT::arg2_type Arg2T;
+            typedef typename FunctionT::arg3_type Arg3T;
+            typedef typename FunctionT::arg4_type Arg4T;
+            typedef typename FunctionT::arg5_type Arg5T;
+            typedef typename FunctionT::arg6_type Arg6T;
+            FunctionT fun;
+            typename DataSource<Arg1T>::shared_ptr aa;
+            typename DataSource<Arg2T>::shared_ptr bb;
+            typename DataSource<Arg3T>::shared_ptr cc;
+            typename DataSource<Arg4T>::shared_ptr dd;
+            typename DataSource<Arg5T>::shared_ptr ee;
+            typename DataSource<Arg6T>::shared_ptr ff;
+
+            FunctorImpl( FunctionT f, DataSource<Arg1T>* a = 0, DataSource<Arg2T>* b = 0, DataSource<Arg3T>* c = 0, DataSource<Arg4T>* d = 0 , DataSource<Arg5T>* e = 0, DataSource<Arg6T>* f_ = 0 )
+                : fun( f ), aa(a), bb(b), cc(c), dd(d), ee(e), ff(f_)
+            {
+            }
+
+            void setArguments( DataSource<Arg1T>* a, DataSource<Arg2T>* b, DataSource<Arg3T>* c, DataSource<Arg4T>* d, DataSource<Arg5T>* e, DataSource<Arg6T>* f  )
+            {
+                aa = a;
+                bb = b;
+                cc = c;
+                dd = d;
+                ee = e;
+                ff = f;
+            }
+
+            void readArguments()
+            {
+                aa->evaluate();
+                bb->evaluate();
+                cc->evaluate();
+                dd->evaluate();
+                ee->evaluate();
+                ff->evaluate();
+            }
+
+            bool execute()
+            {
+                Arg1T a = aa->value();
+                Arg2T b = bb->value();
+                Arg3T c = cc->value();
+                Arg4T d = dd->value();
+                Arg5T e = ee->value();
+                Arg6T f = ff->value();
+                return fun( a, b, c, d, e, f );
+            }
+
+            bool evaluate()
+            {
+                Arg1T a = aa->value();
+                Arg2T b = bb->value();
+                Arg3T c = cc->value();
+                Arg4T d = dd->value();
+                Arg5T e = ee->value();
+                Arg6T f = ff->value();
+                bool r = fun( a, b, c, d, e, f );
+                aa->updated();
+                bb->updated();
+                cc->updated();
+                dd->updated();
+                ee->updated();
+                ff->updated();
+                return r;
+            }
+
+            FunctorImpl<6,FunctionT> copy( std::map<const DataSourceBase*, DataSourceBase*>& alreadyCloned ) const
+            {
+                return FunctorImpl( fun, aa->copy( alreadyCloned ), bb->copy(alreadyCloned), cc->copy(alreadyCloned), dd->copy(alreadyCloned), ee->copy(alreadyCloned), ff->copy(alreadyCloned) );
+            }
+        };
+
         /**
          * A functor that stores a function,
          * and DataSources to get the data from. It can be used
diff -ru src-old/CommandRepository.hpp src/CommandRepository.hpp
--- src-old/CommandRepository.hpp	2010-10-10 22:52:15.000000000 +0200
+++ src/CommandRepository.hpp	2010-10-10 23:35:50.000000000 +0200
@@ -369,6 +369,118 @@
         }
 
         /**
+         * Add a Command object, which takes five arguments, to the
+         * command interface.
+         * The command is added to the C++ and to the scripting interface.
+         *
+         * @param c A pointer to the Command object.
+         * @param description A user readable description of what this command does.
+         * @param arg1 A single word name of the first argument.
+         * @param arg1_description A user readable description of the first argument.
+         * @param arg2 A single word name of the second argument.
+         * @param arg2_description A user readable description of the second argument.
+         * @param arg3 A single word name of the third argument.
+         * @param arg3_description A user readable description of the third argument.
+         * @param arg4 A single word name of the fourth argument.
+         * @param arg4_description A user readable description of the fourth argument.
+         * @param arg5 A single word name of the fifth argument.
+         * @param arg5_description A user readable description of the fifth argument.
+         *
+         * @return true if the command could be added.
+         */
+        template<class CommandT>
+        bool addCommand( CommandT com, const char* description,
+                         const char* arg1, const char* arg1_description,
+                         const char* arg2, const char* arg2_description,
+                         const char* arg3, const char* arg3_description,
+                         const char* arg4, const char* arg4_description,
+                         const char* arg5, const char* arg5_description)
+        {
+            Logger::In in("CommandRepository");
+            typedef typename boost::remove_pointer<CommandT>::type CommandVT;
+            typedef typename boost::add_pointer<CommandVT>::type CommandPT;
+            typedef typename CommandVT::Signature ComSig;
+            BOOST_STATIC_ASSERT( boost::function_traits<typename CommandVT::Signature>::arity == 5 );
+
+            CommandPT c = this->getpointer(com);
+            detail::LocalCommand<ComSig>* lc = dynamic_cast<detail::LocalCommand<ComSig>*>( c->getCommandImpl() );
+            if ( !lc ) {
+                log(Error) << "Failed to addCommand: '"<< c->getName() <<"' is not a local command." <<endlog();
+                return false;
+            }
+            if ( this->addCommand( c ) == false )
+                return false;
+            this->add( c->getName(), new detail::OperationFactoryPart5<DispatchInterface*, detail::DataSourceArgsCommand<ComSig> >(
+                  detail::DataSourceArgsCommand<ComSig>(lc->getCommandFunction(),
+                                               lc->getConditionFunction(),
+                                               lc->getCommandProcessor(), lc->isInverted() ),
+                  description, arg1, arg1_description,
+                  arg2, arg2_description,
+                  arg3, arg3_description,
+                  arg4, arg4_description,
+                  arg5, arg5_description) );
+            return true;
+        }
+
+        /**
+         * Add a Command object, which takes six arguments, to the
+         * command interface.
+         * The command is added to the C++ and to the scripting interface.
+         *
+         * @param c A pointer to the Command object.
+         * @param description A user readable description of what this command does.
+         * @param arg1 A single word name of the first argument.
+         * @param arg1_description A user readable description of the first argument.
+         * @param arg2 A single word name of the second argument.
+         * @param arg2_description A user readable description of the second argument.
+         * @param arg3 A single word name of the third argument.
+         * @param arg3_description A user readable description of the third argument.
+         * @param arg4 A single word name of the fourth argument.
+         * @param arg4_description A user readable description of the fourth argument.
+         * @param arg5 A single word name of the fifth argument.
+         * @param arg5_description A user readable description of the fifth argument.
+         * @param arg6 A single word name of the sixth argument.
+         * @param arg6_description A user readable description of the sixth argument.
+         *
+         * @return true if the command could be added.
+         */
+        template<class CommandT>
+        bool addCommand( CommandT com, const char* description,
+                         const char* arg1, const char* arg1_description,
+                         const char* arg2, const char* arg2_description,
+                         const char* arg3, const char* arg3_description,
+                         const char* arg4, const char* arg4_description,
+                         const char* arg5, const char* arg5_description,
+                         const char* arg6, const char* arg6_description)
+        {
+            Logger::In in("CommandRepository");
+            typedef typename boost::remove_pointer<CommandT>::type CommandVT;
+            typedef typename boost::add_pointer<CommandVT>::type CommandPT;
+            typedef typename CommandVT::Signature ComSig;
+            BOOST_STATIC_ASSERT( boost::function_traits<typename CommandVT::Signature>::arity == 6 );
+
+            CommandPT c = this->getpointer(com);
+            detail::LocalCommand<ComSig>* lc = dynamic_cast<detail::LocalCommand<ComSig>*>( c->getCommandImpl() );
+            if ( !lc ) {
+                log(Error) << "Failed to addCommand: '"<< c->getName() <<"' is not a local command." <<endlog();
+                return false;
+            }
+            if ( this->addCommand( c ) == false )
+                return false;
+            this->add( c->getName(), new detail::OperationFactoryPart6<DispatchInterface*, detail::DataSourceArgsCommand<ComSig> >(
+                  detail::DataSourceArgsCommand<ComSig>(lc->getCommandFunction(),
+                                               lc->getConditionFunction(),
+                                               lc->getCommandProcessor(), lc->isInverted() ),
+                  description, arg1, arg1_description,
+                  arg2, arg2_description,
+                  arg3, arg3_description,
+                  arg4, arg4_description,
+                  arg5, arg5_description,
+                  arg6, arg6_description) );
+            return true;
+        }
+
+        /**
          * For internal use only. Retrieve a previously added Command.
          *
          * @param name The name of the Command
diff -ru src-old/DataSourceArgsCommand.hpp src/DataSourceArgsCommand.hpp
--- src-old/DataSourceArgsCommand.hpp	2010-10-10 22:52:14.000000000 +0200
+++ src/DataSourceArgsCommand.hpp	2010-10-11 00:17:20.000000000 +0200
@@ -123,6 +123,24 @@
                 return r;
             }
 
+            template<class Arg1T, class Arg2T, class Arg3T, class Arg4T, class Arg5T>
+            DataSourceArgsCommand<CommandT,CommandF>* create(DataSource<Arg1T>* a1, DataSource<Arg2T>* a2, DataSource<Arg3T>* a3, DataSource<Arg4T>* a4, DataSource<Arg5T>* a5) const
+            {
+                DataSourceArgsCommand<CommandT,CommandF>* r =  this->clone();
+                r->mcom.setArguments(a1, a2, a3, a4, a5);
+                r->mcon.setArguments(a1, a2, a3, a4, a5);
+                return r;
+            }
+
+            template<class Arg1T, class Arg2T, class Arg3T, class Arg4T, class Arg5T, class Arg6T>
+            DataSourceArgsCommand<CommandT,CommandF>* create(DataSource<Arg1T>* a1, DataSource<Arg2T>* a2, DataSource<Arg3T>* a3, DataSource<Arg4T>* a4, DataSource<Arg5T>* a5, DataSource<Arg6T>* a6) const
+            {
+                DataSourceArgsCommand<CommandT,CommandF>* r =  this->clone();
+                r->mcom.setArguments(a1, a2, a3, a4, a5, a6);
+                r->mcon.setArguments(a1, a2, a3, a4, a5, a6);
+                return r;
+            }
+
             bool ready() const {
                 return !minvoked;
             }
diff -ru src-old/Invoker.hpp src/Invoker.hpp
--- src-old/Invoker.hpp	2010-10-10 22:52:14.000000000 +0200
+++ src/Invoker.hpp	2010-10-10 23:05:28.000000000 +0200
@@ -106,6 +106,33 @@
         };
 
         template<class F>
+        struct InvokerBaseImpl<5,F>
+        {
+            typedef typename boost::function_traits<F>::result_type result_type;
+            typedef typename boost::function<F>::arg1_type arg1_type;
+            typedef typename boost::function<F>::arg2_type arg2_type;
+            typedef typename boost::function<F>::arg3_type arg3_type;
+            typedef typename boost::function<F>::arg4_type arg4_type;
+            typedef typename boost::function<F>::arg5_type arg5_type;
+            virtual ~InvokerBaseImpl() {}
+            virtual result_type operator()(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4, arg5_type a5) = 0;
+        };
+
+        template<class F>
+        struct InvokerBaseImpl<6,F>
+        {
+            typedef typename boost::function_traits<F>::result_type result_type;
+            typedef typename boost::function<F>::arg1_type arg1_type;
+            typedef typename boost::function<F>::arg2_type arg2_type;
+            typedef typename boost::function<F>::arg3_type arg3_type;
+            typedef typename boost::function<F>::arg4_type arg4_type;
+            typedef typename boost::function<F>::arg5_type arg5_type;
+            typedef typename boost::function<F>::arg6_type arg6_type;
+            virtual ~InvokerBaseImpl() {}
+            virtual result_type operator()(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4, arg5_type a5, arg6_type a6) = 0;
+        };
+
+        template<class F>
         struct InvokerBase
             : public InvokerBaseImpl<boost::function_traits<F>::arity, F>
         {};
@@ -199,6 +226,49 @@
 
         };
 
+        template<class F, class BaseImpl>
+        struct InvokerImpl<5,F,BaseImpl>
+            : public BaseImpl
+        {
+            typedef typename boost::function_traits<F>::result_type result_type;
+            typedef typename boost::function_traits<F>::arg1_type arg1_type;
+            typedef typename boost::function_traits<F>::arg2_type arg2_type;
+            typedef typename boost::function_traits<F>::arg3_type arg3_type;
+            typedef typename boost::function_traits<F>::arg4_type arg4_type;
+			typedef typename boost::function_traits<F>::arg5_type arg5_type;
+	
+            /**
+             * Invoke this operator if the method has four arguments.
+             */
+            result_type operator()(arg1_type t1, arg2_type t2, arg3_type t3, arg4_type t4, arg5_type t5)
+            {
+                return BaseImpl::template invoke<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type>(t1, t2, t3, t4, t5);
+            }
+
+        };
+
+        template<class F, class BaseImpl>
+        struct InvokerImpl<6,F,BaseImpl>
+            : public BaseImpl
+        {
+            typedef typename boost::function_traits<F>::result_type result_type;
+            typedef typename boost::function_traits<F>::arg1_type arg1_type;
+            typedef typename boost::function_traits<F>::arg2_type arg2_type;
+            typedef typename boost::function_traits<F>::arg3_type arg3_type;
+            typedef typename boost::function_traits<F>::arg4_type arg4_type;
+			typedef typename boost::function_traits<F>::arg5_type arg5_type;
+			typedef typename boost::function_traits<F>::arg6_type arg6_type;
+	
+            /**
+             * Invoke this operator if the method has four arguments.
+             */
+            result_type operator()(arg1_type t1, arg2_type t2, arg3_type t3, arg4_type t4, arg5_type t5, arg6_type t6)
+            {
+                return BaseImpl::template invoke<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type>(t1, t2, t3, t4, t5, t6);
+            }
+
+        };
+
         /**
          * Creates an invocation object with a function
          * signature to invoke and an implementation in which
@@ -342,6 +412,63 @@
             ToInvoke impl;
         };
 
+        template<class F, class ToInvoke>
+        struct InvokerSignature<5,F,ToInvoke>
+        {
+            typedef typename boost::function_traits<F>::result_type result_type;
+            typedef typename boost::function_traits<F>::arg1_type arg1_type;
+            typedef typename boost::function_traits<F>::arg2_type arg2_type;
+            typedef typename boost::function_traits<F>::arg3_type arg3_type;
+            typedef typename boost::function_traits<F>::arg4_type arg4_type;
+			typedef typename boost::function_traits<F>::arg5_type arg5_type;
+
+            InvokerSignature() : impl() {}
+            InvokerSignature(ToInvoke implementation) : impl(implementation) {}
+            ~InvokerSignature() { }
+
+            /**
+             * Invoke this operator if the method has four arguments.
+             */
+            result_type operator()(arg1_type t1, arg2_type t2, arg3_type t3, arg4_type t4, arg5_type t5)
+            {
+                if (impl)
+                    return (*impl)(t1, t2, t3, t4, t5);
+                return NA<result_type>::na();
+            }
+
+        protected:
+            ToInvoke impl;
+        };
+
+        template<class F, class ToInvoke>
+        struct InvokerSignature<6,F,ToInvoke>
+        {
+            typedef typename boost::function_traits<F>::result_type result_type;
+            typedef typename boost::function_traits<F>::arg1_type arg1_type;
+            typedef typename boost::function_traits<F>::arg2_type arg2_type;
+            typedef typename boost::function_traits<F>::arg3_type arg3_type;
+            typedef typename boost::function_traits<F>::arg4_type arg4_type;
+			typedef typename boost::function_traits<F>::arg5_type arg5_type;
+			typedef typename boost::function_traits<F>::arg6_type arg6_type;
+
+            InvokerSignature() : impl() {}
+            InvokerSignature(ToInvoke implementation) : impl(implementation) {}
+            ~InvokerSignature() { }
+
+            /**
+             * Invoke this operator if the method has four arguments.
+             */
+            result_type operator()(arg1_type t1, arg2_type t2, arg3_type t3, arg4_type t4, arg5_type t5, arg6_type t6)
+            {
+                if (impl)
+                    return (*impl)(t1, t2, t3, t4, t5, t6);
+                return NA<result_type>::na();
+            }
+
+        protected:
+            ToInvoke impl;
+        };
+
     }
 }
 #endif
diff -ru src-old/LocalCommand.hpp src/LocalCommand.hpp
--- src-old/LocalCommand.hpp	2010-10-10 22:52:14.000000000 +0200
+++ src/LocalCommand.hpp	2010-10-10 23:36:54.000000000 +0200
@@ -137,6 +137,28 @@
                 minvoked = true;
                 return maccept = (mcp->process( this ) != 0);
             }
+
+            template<class T1, class T2, class T3, class T4, class T5>
+            bool invoke( T1 a1, T2 a2, T3 a3, T4 a4, T5 a5 ) {
+                if (!mcp ||(minvoked && !this->done()) ) // if invoked and not ready.
+                    return false;
+                this->reset();
+                // bind types from Storage<Function>
+                this->store( a1, a2, a3, a4, a5 );
+                minvoked = true;
+                return maccept = (mcp->process( this ) != 0);
+            }
+
+            template<class T1, class T2, class T3, class T4, class T5, class T6>
+            bool invoke( T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6 ) {
+                if (!mcp ||(minvoked && !this->done()) ) // if invoked and not ready.
+                    return false;
+                this->reset();
+                // bind types from Storage<Function>
+                this->store( a1, a2, a3, a4, a5, a6 );
+                minvoked = true;
+                return maccept = (mcp->process( this ) != 0);
+            }
         };
 
 
diff -ru src-old/LocalMethod.hpp src/LocalMethod.hpp
--- src-old/LocalMethod.hpp	2010-10-10 22:52:14.000000000 +0200
+++ src/LocalMethod.hpp	2010-10-10 22:57:13.000000000 +0200
@@ -110,6 +110,24 @@
                 return mmeth(t1, t2, t3, t4);
             }
 
+            /**
+             * Invoke this operator if the method has five arguments.
+             */
+            template<class T1, class T2, class T3, class T4, class T5>
+            result_type invoke(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5)
+            {
+                return mmeth(t1, t2, t3, t4, t5);
+            }
+
+            /**
+             * Invoke this operator if the method has six arguments.
+             */
+            template<class T1, class T2, class T3, class T4, class T5, class T6>
+            result_type invoke(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6)
+            {
+                return mmeth(t1, t2, t3, t4, t5, t6);
+            }
+
         };
 
         /**
diff -ru src-old/MethodRepository.hpp src/MethodRepository.hpp
--- src-old/MethodRepository.hpp	2010-10-10 22:52:14.000000000 +0200
+++ src/MethodRepository.hpp	2010-10-11 10:51:24.000000000 +0200
@@ -360,6 +360,116 @@
         }
 
         /**
+         * Add a local method object to the interface. This version
+         * of addMethod adds a Method object to the C++ interface and
+         * to the scripting interface of this component.
+         * The Method object must refer to a local method function.
+         *
+         * @param meth The method object to add.
+         * @param description A useful description.
+         * @param arg1 The name of the first argument.
+         * @param arg1_description The description of the first argument.
+         * @param arg2 The name of the second argument.
+         * @param arg2_description The description of the second argument.
+         * @param arg3 The name of the third argument.
+         * @param arg3_description The description of the third argument.
+         * @param arg4 The name of the fourth argument.
+         * @param arg4_description The description of the fourth argument.
+         * @param arg5 The name of the fifth argument.
+         * @param arg5_description The description of the fifth argument.
+         *
+         * @return true if it could be added.
+         */
+        template<class MethodT>
+        bool addMethod( MethodT meth, const char* description,
+                        const char* arg1, const char* arg1_description,
+                        const char* arg2, const char* arg2_description,
+                        const char* arg3, const char* arg3_description,
+                        const char* arg4, const char* arg4_description,
+                        const char* arg5, const char* arg5_description)
+        {
+            typedef typename boost::remove_pointer<MethodT>::type MethodVT;
+            typedef typename boost::add_pointer<MethodVT>::type MethodPT;
+            BOOST_STATIC_ASSERT( boost::function_traits<typename MethodVT::Signature>::arity == 5 );
+
+            MethodPT c = this->getpointer(meth);
+            typedef typename MethodVT::Signature Sig;
+            const detail::LocalMethod<Sig>* lm = dynamic_cast< const detail::LocalMethod<Sig>* >( c->getMethodImpl().get() );
+            if ( !lm ) {
+                log(Error) << "Failed to addMethod: '"<< c->getName() <<"' is not a local method." <<endlog();
+                return false;
+            }
+            if ( this->addMethod( c ) == false )
+                return false;
+            this->add( c->getName(), new detail::OperationFactoryPart5<DataSourceBase*, detail::DataSourceArgsMethod<Sig> >(
+                  detail::DataSourceArgsMethod<Sig>(lm->getMethodFunction()),
+                  description,
+                  arg1, arg1_description,
+                  arg2, arg2_description,
+                  arg3, arg3_description,
+                  arg4, arg4_description,
+                  arg5, arg5_description) );
+            return true;
+        }
+
+        /**
+         * Add a local method object to the interface. This version
+         * of addMethod adds a Method object to the C++ interface and
+         * to the scripting interface of this component.
+         * The Method object must refer to a local method function.
+         *
+         * @param meth The method object to add.
+         * @param description A useful description.
+         * @param arg1 The name of the first argument.
+         * @param arg1_description The description of the first argument.
+         * @param arg2 The name of the second argument.
+         * @param arg2_description The description of the second argument.
+         * @param arg3 The name of the third argument.
+         * @param arg3_description The description of the third argument.
+         * @param arg4 The name of the fourth argument.
+         * @param arg4_description The description of the fourth argument.
+         * @param arg5 The name of the fifth argument.
+         * @param arg5_description The description of the fifth argument.
+         * @param arg6 The name of the sixth argument.
+         * @param arg6_description The description of the sixth argument.
+         *
+         * @return true if it could be added.
+         */
+        template<class MethodT>
+        bool addMethod( MethodT meth, const char* description,
+                        const char* arg1, const char* arg1_description,
+                        const char* arg2, const char* arg2_description,
+                        const char* arg3, const char* arg3_description,
+                        const char* arg4, const char* arg4_description,
+                        const char* arg5, const char* arg5_description,
+                        const char* arg6, const char* arg6_description)
+        {
+            typedef typename boost::remove_pointer<MethodT>::type MethodVT;
+            typedef typename boost::add_pointer<MethodVT>::type MethodPT;
+            BOOST_STATIC_ASSERT( boost::function_traits<typename MethodVT::Signature>::arity == 6 );
+
+            MethodPT c = this->getpointer(meth);
+            typedef typename MethodVT::Signature Sig;
+            const detail::LocalMethod<Sig>* lm = dynamic_cast< const detail::LocalMethod<Sig>* >( c->getMethodImpl().get() );
+            if ( !lm ) {
+                log(Error) << "Failed to addMethod: '"<< c->getName() <<"' is not a local method." <<endlog();
+                return false;
+            }
+            if ( this->addMethod( c ) == false )
+                return false;
+            this->add( c->getName(), new detail::OperationFactoryPart6<DataSourceBase*, detail::DataSourceArgsMethod<Sig> >(
+                  detail::DataSourceArgsMethod<Sig>(lm->getMethodFunction()),
+                  description,
+                  arg1, arg1_description,
+                  arg2, arg2_description,
+                  arg3, arg3_description,
+                  arg4, arg4_description,
+                  arg5, arg5_description,
+                  arg6, arg6_description) );
+            return true;
+        }
+
+        /**
          * For internal use only. The pointer of the object of which a member function
          * must be invoked is stored in a DataSource such that the pointer can change
          * during program execution. Required in scripting for state machines.
diff -ru src-old/OperationFactory.hpp src/OperationFactory.hpp
--- src-old/OperationFactory.hpp	2010-10-10 22:52:14.000000000 +0200
+++ src/OperationFactory.hpp	2010-10-11 00:08:48.000000000 +0200
@@ -404,6 +404,190 @@
                 return fun.create(a.get(), b.get(), c.get(), d.get() );
             }
         };
+
+        template<typename ResultT, typename FunctorT>
+        class OperationFactoryPart5
+            : public OperationFactoryPart<ResultT>
+        {
+            typedef FunctorT fun_t;
+            typedef typename FunctorT::traits::arg1_type arg1_type;
+            typedef typename FunctorT::traits::arg2_type arg2_type;
+            typedef typename FunctorT::traits::arg3_type arg3_type;
+            typedef typename FunctorT::traits::arg4_type arg4_type;
+            typedef typename FunctorT::traits::arg5_type arg5_type;
+
+            fun_t fun;
+            const char* arg1name;
+            const char* arg1desc;
+            const char* arg2name;
+            const char* arg2desc;
+            const char* arg3name;
+            const char* arg3desc;
+            const char* arg4name;
+            const char* arg4desc;
+            const char* arg5name;
+            const char* arg5desc;
+        public:
+            template<class InitF>
+            OperationFactoryPart5( InitF f, const char* desc, const char* a1n,
+                                   const char* a1d, const char* a2n,
+                                   const char* a2d, const char* a3n,
+                                   const char* a3d, const char* a4n,
+                                   const char* a4d, const char* a5n,
+                                   const char* a5d )
+                : OperationFactoryPart<ResultT>( desc ), fun( f ),
+                  arg1name( a1n ), arg1desc( a1d ),
+                  arg2name( a2n ), arg2desc( a2d ),
+                  arg3name( a3n ), arg3desc( a3d ),
+                  arg4name( a4n ), arg4desc( a4d ),
+                  arg5name( a5n ), arg5desc( a5d )
+            {
+            }
+
+            std::string resultType() const
+            {
+                return DataSource<typename FunctorT::result_type>::GetType();
+            }
+
+            std::vector< ArgumentDescription > getArgumentList( ) const
+            {
+                std::vector< ArgumentDescription > mlist;
+                mlist.push_back( ArgumentDescription( arg1name, arg1desc, DataSource<arg1_type>::GetType() ) );
+                mlist.push_back( ArgumentDescription( arg2name, arg2desc, DataSource<arg2_type>::GetType() ) );
+                mlist.push_back( ArgumentDescription( arg3name, arg3desc, DataSource<arg3_type>::GetType() ) );
+                mlist.push_back( ArgumentDescription( arg4name, arg4desc, DataSource<arg4_type>::GetType() ) );
+                mlist.push_back( ArgumentDescription( arg5name, arg5desc, DataSource<arg5_type>::GetType() ) );
+                return mlist;
+            }
+
+            int arity() const { return 5; }
+
+            ResultT produce(const std::vector<DataSourceBase::shared_ptr>& args) const
+            {
+                if ( args.size() != 5 )
+                    ORO_THROW_OR_RETURN(wrong_number_of_args_exception( 5, args.size() ), ResultT());
+
+                typename DataSource<arg1_type>::shared_ptr a =
+                    AdaptDataSource<arg1_type>()( DataSourceTypeInfo<arg1_type>::getTypeInfo()->convert(args[0]) );
+                if ( !a )
+                    ORO_THROW_OR_RETURN(wrong_types_of_args_exception( 1, DataSource<arg1_type>::GetType(), args[0]->getType() ), ResultT());
+                typename DataSource<arg2_type>::shared_ptr b =
+                    AdaptDataSource<arg2_type>()( DataSourceTypeInfo<arg2_type>::getTypeInfo()->convert(args[1]) );
+                if ( !b )
+                    ORO_THROW_OR_RETURN(wrong_types_of_args_exception( 2, DataSource<arg2_type>::GetType(), args[1]->getType() ), ResultT());
+                typename DataSource<arg3_type>::shared_ptr c =
+                    AdaptDataSource<arg3_type>()( DataSourceTypeInfo<arg3_type>::getTypeInfo()->convert(args[2]) );
+                if ( !c )
+                    ORO_THROW_OR_RETURN(wrong_types_of_args_exception( 3, DataSource<arg3_type>::GetType(), args[2]->getType() ), ResultT());
+                typename DataSource<arg4_type>::shared_ptr d =
+                    AdaptDataSource<arg4_type>()( DataSourceTypeInfo<arg4_type>::getTypeInfo()->convert(args[3]) );
+                if ( !d )
+                    ORO_THROW_OR_RETURN(wrong_types_of_args_exception( 4, DataSource<arg4_type>::GetType(), args[3]->getType() ), ResultT());
+                typename DataSource<arg5_type>::shared_ptr e =
+                    AdaptDataSource<arg5_type>()( DataSourceTypeInfo<arg5_type>::getTypeInfo()->convert(args[4]) );
+                if ( !e )
+                    ORO_THROW_OR_RETURN(wrong_types_of_args_exception( 5, DataSource<arg5_type>::GetType(), args[4]->getType() ), ResultT());
+
+                return fun.create(a.get(), b.get(), c.get(), d.get(), e.get() );
+            }
+        };
+
+        template<typename ResultT, typename FunctorT>
+        class OperationFactoryPart6
+            : public OperationFactoryPart<ResultT>
+        {
+            typedef FunctorT fun_t;
+            typedef typename FunctorT::traits::arg1_type arg1_type;
+            typedef typename FunctorT::traits::arg2_type arg2_type;
+            typedef typename FunctorT::traits::arg3_type arg3_type;
+            typedef typename FunctorT::traits::arg4_type arg4_type;
+            typedef typename FunctorT::traits::arg5_type arg5_type;
+            typedef typename FunctorT::traits::arg6_type arg6_type;
+
+            fun_t fun;
+            const char* arg1name;
+            const char* arg1desc;
+            const char* arg2name;
+            const char* arg2desc;
+            const char* arg3name;
+            const char* arg3desc;
+            const char* arg4name;
+            const char* arg4desc;
+            const char* arg5name;
+            const char* arg5desc;
+            const char* arg6name;
+            const char* arg6desc;
+        public:
+            template<class InitF>
+            OperationFactoryPart6( InitF f, const char* desc, const char* a1n,
+                                   const char* a1d, const char* a2n,
+                                   const char* a2d, const char* a3n,
+                                   const char* a3d, const char* a4n,
+                                   const char* a4d, const char* a5n,
+                                   const char* a5d, const char* a6n,
+                                   const char* a6d )
+                : OperationFactoryPart<ResultT>( desc ), fun( f ),
+                  arg1name( a1n ), arg1desc( a1d ),
+                  arg2name( a2n ), arg2desc( a2d ),
+                  arg3name( a3n ), arg3desc( a3d ),
+                  arg4name( a4n ), arg4desc( a4d ),
+                  arg4name( a5n ), arg4desc( a5d ),
+                  arg4name( a6n ), arg4desc( a6d )
+            {
+            }
+
+            std::string resultType() const
+            {
+                return DataSource<typename FunctorT::result_type>::GetType();
+            }
+
+            std::vector< ArgumentDescription > getArgumentList( ) const
+            {
+                std::vector< ArgumentDescription > mlist;
+                mlist.push_back( ArgumentDescription( arg1name, arg1desc, DataSource<arg1_type>::GetType() ) );
+                mlist.push_back( ArgumentDescription( arg2name, arg2desc, DataSource<arg2_type>::GetType() ) );
+                mlist.push_back( ArgumentDescription( arg3name, arg3desc, DataSource<arg3_type>::GetType() ) );
+                mlist.push_back( ArgumentDescription( arg4name, arg4desc, DataSource<arg4_type>::GetType() ) );
+                mlist.push_back( ArgumentDescription( arg5name, arg5desc, DataSource<arg5_type>::GetType() ) );
+                mlist.push_back( ArgumentDescription( arg6name, arg6desc, DataSource<arg6_type>::GetType() ) );
+                return mlist;
+            }
+
+            int arity() const { return 6; }
+
+            ResultT produce(const std::vector<DataSourceBase::shared_ptr>& args) const
+            {
+                if ( args.size() != 6 )
+                    ORO_THROW_OR_RETURN(wrong_number_of_args_exception( 6, args.size() ), ResultT());
+
+                typename DataSource<arg1_type>::shared_ptr a =
+                    AdaptDataSource<arg1_type>()( DataSourceTypeInfo<arg1_type>::getTypeInfo()->convert(args[0]) );
+                if ( !a )
+                    ORO_THROW_OR_RETURN(wrong_types_of_args_exception( 1, DataSource<arg1_type>::GetType(), args[0]->getType() ), ResultT());
+                typename DataSource<arg2_type>::shared_ptr b =
+                    AdaptDataSource<arg2_type>()( DataSourceTypeInfo<arg2_type>::getTypeInfo()->convert(args[1]) );
+                if ( !b )
+                    ORO_THROW_OR_RETURN(wrong_types_of_args_exception( 2, DataSource<arg2_type>::GetType(), args[1]->getType() ), ResultT());
+                typename DataSource<arg3_type>::shared_ptr c =
+                    AdaptDataSource<arg3_type>()( DataSourceTypeInfo<arg3_type>::getTypeInfo()->convert(args[2]) );
+                if ( !c )
+                    ORO_THROW_OR_RETURN(wrong_types_of_args_exception( 3, DataSource<arg3_type>::GetType(), args[2]->getType() ), ResultT());
+                typename DataSource<arg4_type>::shared_ptr d =
+                    AdaptDataSource<arg4_type>()( DataSourceTypeInfo<arg4_type>::getTypeInfo()->convert(args[3]) );
+                if ( !d )
+                    ORO_THROW_OR_RETURN(wrong_types_of_args_exception( 4, DataSource<arg4_type>::GetType(), args[3]->getType() ), ResultT());
+                typename DataSource<arg5_type>::shared_ptr e =
+                    AdaptDataSource<arg5_type>()( DataSourceTypeInfo<arg5_type>::getTypeInfo()->convert(args[4]) );
+                if ( !e )
+                    ORO_THROW_OR_RETURN(wrong_types_of_args_exception( 5, DataSource<arg5_type>::GetType(), args[4]->getType() ), ResultT());
+                typename DataSource<arg6_type>::shared_ptr f =
+                    AdaptDataSource<arg6_type>()( DataSourceTypeInfo<arg6_type>::getTypeInfo()->convert(args[5]) );
+                if ( !f )
+                    ORO_THROW_OR_RETURN(wrong_types_of_args_exception( 6, DataSource<arg6_type>::GetType(), args[5]->getType() ), ResultT());
+
+                return fun.create(a.get(), b.get(), c.get(), d.get(), e.get(), f.get() );
+            }
+        };
         /**
          * @}
          */