X-Git-Url: http://g0dil.de/git?a=blobdiff_plain;f=senf%2FUtils%2FConsole%2FParsedCommand.cti;h=019ae8a9d9790cad8b7b9ff7d6c806eb29a894e6;hb=d506c3134c5c01272c01608c86b8285176b50226;hp=a35a827be51e2f43b3690b88f406aae6fa721a6c;hpb=601d1f509f5bb24df167a4dd5a20da67a0af9af8;p=senf.git

diff --git a/senf/Utils/Console/ParsedCommand.cti b/senf/Utils/Console/ParsedCommand.cti
index a35a827..019ae8a 100644
--- a/senf/Utils/Console/ParsedCommand.cti
+++ b/senf/Utils/Console/ParsedCommand.cti
@@ -1,24 +1,29 @@
 // $Id$
 //
-// Copyright (C) 2008 
+// Copyright (C) 2008
 // Fraunhofer Institute for Open Communication Systems (FOKUS)
-// Competence Center NETwork research (NET), St. Augustin, GERMANY
-//     Stefan Bund <g0dil@berlios.de>
 //
-// This program is free software; you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation; either version 2 of the License, or
-// (at your option) any later version.
+// The contents of this file are subject to the Fraunhofer FOKUS Public License
+// Version 1.0 (the "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at 
+// http://senf.berlios.de/license.html
 //
-// This program 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 General Public License for more details.
+// The Fraunhofer FOKUS Public License Version 1.0 is based on, 
+// but modifies the Mozilla Public License Version 1.1.
+// See the full license text for the amendments.
 //
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the
-// Free Software Foundation, Inc.,
-// 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+// Software distributed under the License is distributed on an "AS IS" basis, 
+// WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License 
+// for the specific language governing rights and limitations under the License.
+//
+// The Original Code is Fraunhofer FOKUS code.
+//
+// The Initial Developer of the Original Code is Fraunhofer-Gesellschaft e.V. 
+// (registered association), Hansastraße 27 c, 80686 Munich, Germany.
+// All Rights Reserved.
+//
+// Contributor(s):
+//   Stefan Bund <g0dil@berlios.de>
 
 /** \file
     \brief ParsedCommand inline template implementation */
@@ -26,14 +31,14 @@
 #include "ParsedCommand.ih"
 
 // Custom includes
-#include "../../Utils/membind.hh"
+#include <senf/Utils/membind.hh>
 #include <boost/format.hpp>
-#include "../../Utils/parameter.hh"
+#include <senf/Utils/parameter.hh>
 
 #define prefix_ inline
-///////////////////////////////cti.p///////////////////////////////////////
+//-/////////////////////////////////////////////////////////////////////////////////////////////////
 
-///////////////////////////////////////////////////////////////////////////
+//-/////////////////////////////////////////////////////////////////////////////////////////////////
 // senf::console::detail::ArgumentInfo<ParameterType>
 
 template <class ParameterType>
@@ -45,7 +50,7 @@ senf::console::detail::ArgumentInfo<ParameterType>::create()
 
 template <class ParameterType>
 prefix_ senf::console::detail::ArgumentInfo<ParameterType>::ArgumentInfo()
-    : ArgumentInfoBase ( ArgumentTraits<ParameterType>::description(), 
+    : ArgumentInfoBase ( ArgumentTraits<ParameterType>::description(),
                          ArgumentTraits<ParameterType>::singleToken ),
       defaultValue ()
 {}
@@ -57,7 +62,7 @@ prefix_ std::string senf::console::detail::ArgumentInfo<ParameterType>::defaultV
     return hasDefault ? ArgumentTraits<ParameterType>::str(defaultValue) : "";
 }
 
-///////////////////////////////////////////////////////////////////////////
+//-/////////////////////////////////////////////////////////////////////////////////////////////////
 // senf::console::ParsedCommandOverloadBase
 
 template <class Type>
@@ -66,7 +71,7 @@ prefix_ void senf::console::ParsedCommandOverloadBase::addParameter()
     parameters_.push_back(detail::ArgumentInfo<Type>::create());
 }
 
-///////////////////////////////////////////////////////////////////////////
+//-/////////////////////////////////////////////////////////////////////////////////////////////////
 // senf::console::ParsedCommandOverload<FunctionTraits,n>
 
 #define BOOST_PP_ITERATION_PARAMS_1 (4, (0, SENF_CONSOLE_MAX_COMMAND_ARITY,                       \
@@ -74,7 +79,7 @@ prefix_ void senf::console::ParsedCommandOverloadBase::addParameter()
                                          2))
 #include BOOST_PP_ITERATE()
 
-///////////////////////////////////////////////////////////////////////////
+//-/////////////////////////////////////////////////////////////////////////////////////////////////
 // senf::console::ParsedCommandAttributor<Overload>
 
 template <class Overload>
@@ -85,19 +90,23 @@ prefix_ Overload & senf::console::ParsedCommandAttributor<Overload>::overload()
 }
 
 template <class Overload>
-prefix_
-senf::console::ParsedCommandAttributor<Overload>::ParsedCommandAttributor(Overload & overload,
-                                                                          unsigned index)
+prefix_ senf::console::ParsedCommandAttributor<Overload>::
+ParsedCommandAttributor(typename Overload::ptr overload, unsigned index)
     : ParsedCommandAttributorBase (overload, index)
 {}
 
-///////////////////////////////////////////////////////////////////////////
+template <class Overload>
+prefix_ senf::console::ParsedCommandAttributor<Overload>::
+ParsedCommandAttributor(ParsedCommandAttributorBase const & other, unsigned index)
+    : ParsedCommandAttributorBase (other, index)
+{}
+
+//-/////////////////////////////////////////////////////////////////////////////////////////////////
 // senf::console::ParsedArgumentAttributorBase<Overload,Self>
 
 template <class Overload, class Self, class ReturnType>
 prefix_ Self
 senf::console::ParsedArgumentAttributorBase<Overload,Self,ReturnType>::doc(std::string const & doc)
-    const
 {
     this->ParsedCommandAttributorBase::nodeDoc(doc);
     return static_cast<Self const &>(*this);
@@ -106,7 +115,6 @@ senf::console::ParsedArgumentAttributorBase<Overload,Self,ReturnType>::doc(std::
 template <class Overload, class Self, class ReturnType>
 prefix_ Self senf::console::ParsedArgumentAttributorBase<Overload,Self,ReturnType>::
 shortdoc(std::string const & doc)
-    const
 {
     this->ParsedCommandAttributorBase::shortDoc(doc);
     return static_cast<Self const &>(*this);
@@ -115,7 +123,6 @@ shortdoc(std::string const & doc)
 template <class Overload, class Self, class ReturnType>
 prefix_ Self senf::console::ParsedArgumentAttributorBase<Overload,Self,ReturnType>::
 overloadDoc(std::string const & doc)
-    const
 {
     this->ParsedCommandAttributorBase::overloadDoc(doc);
     return static_cast<Self const &>(*this);
@@ -124,7 +131,6 @@ overloadDoc(std::string const & doc)
 template <class Overload, class Self, class ReturnType>
 prefix_ Self senf::console::ParsedArgumentAttributorBase<Overload,Self,ReturnType>::
 formatter(typename Overload::Formatter f)
-    const
 {
     this->overload().formatter(f);
     return static_cast<Self const &>(*this);
@@ -133,14 +139,20 @@ formatter(typename Overload::Formatter f)
 template <class Overload, class Self, class ReturnType>
 prefix_
 senf::console::ParsedArgumentAttributorBase<Overload,Self,ReturnType>::
-ParsedArgumentAttributorBase(Overload & overload, unsigned index)
+ParsedArgumentAttributorBase(typename Overload::ptr overload, unsigned index)
     : ParsedCommandAttributor<Overload> (overload, index)
 {}
 
+template <class Overload, class Self, class ReturnType>
+prefix_
+senf::console::ParsedArgumentAttributorBase<Overload,Self,ReturnType>::
+ParsedArgumentAttributorBase(ParsedCommandAttributorBase const & other, unsigned index)
+    : ParsedCommandAttributor<Overload> (other, index)
+{}
+
 template <class Overload, class Self>
 prefix_ Self
 senf::console::ParsedArgumentAttributorBase<Overload,Self,void>::doc(std::string const & doc)
-    const
 {
     this->ParsedCommandAttributorBase::nodeDoc(doc);
     return static_cast<Self const &>(*this);
@@ -149,7 +161,6 @@ senf::console::ParsedArgumentAttributorBase<Overload,Self,void>::doc(std::string
 template <class Overload, class Self>
 prefix_ Self senf::console::ParsedArgumentAttributorBase<Overload, Self, void>::
 shortdoc(std::string const & doc)
-    const
 {
     this->ParsedCommandAttributorBase::shortDoc(doc);
     return static_cast<Self const &>(*this);
@@ -158,7 +169,6 @@ shortdoc(std::string const & doc)
 template <class Overload, class Self>
 prefix_ Self senf::console::ParsedArgumentAttributorBase<Overload,Self,void>::
 overloadDoc(std::string const & doc)
-    const
 {
     this->ParsedCommandAttributorBase::overloadDoc(doc);
     return static_cast<Self const &>(*this);
@@ -166,12 +176,19 @@ overloadDoc(std::string const & doc)
 
 template <class Overload, class Self>
 prefix_
-senf::console::ParsedArgumentAttributorBase<Overload,Self,void>::
-ParsedArgumentAttributorBase(Overload & overload, unsigned index)
+senf::console::ParsedArgumentAttributorBase<Overload, Self, void>::
+ParsedArgumentAttributorBase(typename Overload::ptr overload, unsigned index)
     : ParsedCommandAttributor<Overload> (overload, index)
 {}
 
-///////////////////////////////////////////////////////////////////////////
+template <class Overload, class Self>
+prefix_
+senf::console::ParsedArgumentAttributorBase<Overload, Self, void>::
+ParsedArgumentAttributorBase(ParsedCommandAttributorBase const & other, unsigned index)
+    : ParsedCommandAttributor<Overload> (other, index)
+{}
+
+//-/////////////////////////////////////////////////////////////////////////////////////////////////
 // senf::console::ParsedArgumentAttributor<Overload,index,flag>
 
 template <class Overload, unsigned index, bool flag>
@@ -187,7 +204,6 @@ template <class ArgumentPack>
 prefix_ typename senf::console::ParsedArgumentAttributor<Overload,index,flag>::next_type
 senf::console::ParsedArgumentAttributor<Overload,index,flag>::
 argInfo(ArgumentPack const & args)
-    const
 {
 #   define ProcessArg(tag) \
         argInfo( kw:: tag, args, senf::has_parameter< ArgumentPack, kw::type:: tag >() )
@@ -208,7 +224,6 @@ template <class Overload, unsigned index, bool flag>
 template <class Kw, class ArgumentPack>
 prefix_ void senf::console::ParsedArgumentAttributor<Overload,index,flag>::
 argInfo(Kw const &, ArgumentPack const &, boost::mpl::false_)
-    const
 {}
 
 template <class Overload, unsigned index, bool flag>
@@ -216,7 +231,6 @@ template <class ArgumentPack>
 prefix_ void senf::console::ParsedArgumentAttributor<Overload,index,flag>::
 argInfo(boost::parameter::keyword<kw::type::name> const &, ArgumentPack const & args,
         boost::mpl::true_)
-    const
 {
     this->argName(args[kw::name]);
 }
@@ -226,7 +240,6 @@ template <class ArgumentPack>
 prefix_ void senf::console::ParsedArgumentAttributor<Overload,index,flag>::
 argInfo(boost::parameter::keyword<kw::type::description> const &, ArgumentPack const & args,
         boost::mpl::true_)
-    const
 {
     this->argDoc(args[kw::description]);
 }
@@ -236,7 +249,6 @@ template <class ArgumentPack>
 prefix_ void senf::console::ParsedArgumentAttributor<Overload,index,flag>::
 argInfo(boost::parameter::keyword<kw::type::default_value> const &, ArgumentPack const & args,
         boost::mpl::true_)
-    const
 {
     this->defaultValue(args[kw::default_value]);
 }
@@ -246,7 +258,6 @@ template <class ArgumentPack>
 prefix_ void senf::console::ParsedArgumentAttributor<Overload,index,flag>::
 argInfo(boost::parameter::keyword<kw::type::type_name> const &, ArgumentPack const & args,
         boost::mpl::true_)
-    const
 {
     this->typeName(args[kw::type_name]);
 }
@@ -256,7 +267,6 @@ template <class ArgumentPack>
 prefix_ void senf::console::ParsedArgumentAttributor<Overload,index,flag>::
 argInfo(boost::parameter::keyword<kw::type::default_doc> const &, ArgumentPack const & args,
         boost::mpl::true_)
-    const
 {
     BOOST_STATIC_ASSERT(( senf::has_parameter<ArgumentPack, kw::type::default_value>::value ));
     this->defaultDoc(args[kw::default_doc]);
@@ -267,16 +277,20 @@ template <class ArgumentPack>
 prefix_ void senf::console::ParsedArgumentAttributor<Overload,index,flag>::
 argInfo(boost::parameter::keyword<kw::type::parser> const &, ArgumentPack const & args,
         boost::mpl::true_)
-    const
 {
     this->parser(args[kw::parser]);
 }
 
 template <class Overload, unsigned index, bool flag>
-prefix_
-senf::console::ParsedArgumentAttributor<Overload,index,flag>::
-ParsedArgumentAttributor(Overload & overload)
-    : ParsedArgumentAttributorBase<Overload, ParsedArgumentAttributor> (overload, index)
+prefix_ senf::console::ParsedArgumentAttributor<Overload,index,flag>::
+ParsedArgumentAttributor(typename Overload::ptr overload)
+: ParsedArgumentAttributorBase<Overload, ParsedArgumentAttributor> (overload, index)
+{}
+
+template <class Overload, unsigned index, bool flag>
+prefix_ senf::console::ParsedArgumentAttributor<Overload,index,flag>::
+ParsedArgumentAttributor(ParsedCommandAttributorBase const & other)
+    : ParsedArgumentAttributorBase<Overload, ParsedArgumentAttributor> (other, index)
 {}
 
 template <class Overload, unsigned index, bool flag>
@@ -284,13 +298,12 @@ prefix_ typename senf::console::ParsedArgumentAttributor<Overload,index,flag>::n
 senf::console::ParsedArgumentAttributor<Overload,index,flag>::next()
     const
 {
-    return ParsedArgumentAttributor<Overload, index+1>(this->overload());
+    return ParsedArgumentAttributor<Overload, index+1>(*this);
 }
 
 template <class Overload, unsigned index, bool flag>
 prefix_ void senf::console::ParsedArgumentAttributor<Overload,index,flag>::
 defaultValue(value_type const & value)
-    const
 {
     this->overload().arg<index>().defaultValue = value;
     this->overload().arg(index).hasDefault = true;
@@ -299,23 +312,29 @@ defaultValue(value_type const & value)
 template <class Overload, unsigned index, bool flag>
 template <class Fn>
 prefix_ void senf::console::ParsedArgumentAttributor<Overload,index,flag>::parser(Fn fn)
-    const
 {
     this->overload().arg<index>().parser = fn;
 }
 
-///////////////////////////////////////////////////////////////////////////
+//-/////////////////////////////////////////////////////////////////////////////////////////////////
 // senf::console::ParsedArgumentAttributor<Overload, index, false>
 
 template <class Overload, unsigned index>
 prefix_
 senf::console::ParsedArgumentAttributor<Overload, index, false>::
-ParsedArgumentAttributor(Overload & overload)
-    : ParsedArgumentAttributorBase< 
+ParsedArgumentAttributor(typename Overload::ptr overload)
+    : ParsedArgumentAttributorBase<
           Overload, ParsedArgumentAttributor<Overload, index, false> > (overload, index)
 {}
 
-///////////////////////////////////////////////////////////////////////////
+template <class Overload, unsigned index>
+prefix_
+senf::console::ParsedArgumentAttributor<Overload, index, false>::
+ParsedArgumentAttributor(ParsedCommandAttributorBase const & other)
+    : ParsedArgumentAttributorBase<Overload, ParsedArgumentAttributor> (other, index)
+{}
+
+//-/////////////////////////////////////////////////////////////////////////////////////////////////
 // namespace members
 
 namespace senf {
@@ -326,99 +345,140 @@ namespace detail {
 
     struct ParsedCommandAddNodeAccess
     {
-        template <class Attributor, class Node>
-        static Attributor attributor(Node & node)
-            { return Attributor(node); }
-    };
-
-    // What is THIS about ??
-
-    // Ok, here's the dope: parsed commands may optionally have an std::ostream & first argument. If
-    // this argument is given, then the function will be called with the console output stream as
-    // it's first argument.
-    //
-    // This is implemented in the following way: ParsedCommandOverload (the class responsible for
-    // calling the callback) will ALWAYS pass the stream as first argument. If the user callback
-    // expects os as it's first argument, 'ignoreOneArg' will be false and the user supplied
-    // function will be directly passed to ParsedCommandOverload.
-    //
-    // If however, it does NOT take an std::ostream first argument, 'ignoreOneArg' will be true and
-    // the create member will use boost::bind to DROP the first argument.
-    
-    template <class Traits, 
-              bool ignoreOneArg=! Traits::has_ostream_arg, 
-              unsigned arity=Traits::traits::arity>
-    struct CreateParsedCommandOverload
-    {};
-
-    template <class Traits, unsigned arity>
-    struct CreateParsedCommandOverload<Traits, false, arity>
-    {
-        typedef typename Traits::traits traits;
-        
-        template <class Function>
-        static typename senf::console::ParsedCommandOverload<traits>::ptr create(Function fn) 
-            { return senf::console::ParsedCommandOverload<traits>::create(fn); };
+        template <class Attributor, class NodePtr>
+        static Attributor attributor(NodePtr ptr)
+            { return Attributor(ptr); }
     };
 
-#   define BOOST_PP_ITERATION_PARAMS_1 (4, (0, SENF_CONSOLE_MAX_COMMAND_ARITY,                     \
-                                            SENF_ABSOLUTE_INCLUDE_PATH(Utils/Console/ParsedCommand.mpp), \
-                                            4))
-#   include BOOST_PP_ITERATE()
-
     template <class Signature, class Fn>
     typename senf::console::detail::ParsedCommandTraits<Signature>::Attributor
-    addOverloadedCommandNode(senf::console::DirectoryNode & node,  std::string const & name, Fn fn)
+    addOverloadedCommandNode(Fn fn)
     {
-        senf::console::OverloadedCommandNode & cmdNode (
-            node.hasChild(name) 
-            ? dynamic_cast<senf::console::OverloadedCommandNode &>(node(name))
-            : node.add(name, senf::console::OverloadedCommandNode::create()) );
-
         typedef senf::console::detail::ParsedCommandTraits<Signature> CmdTraits;
         typedef senf::console::ParsedCommandOverload<typename CmdTraits::traits> Overload;
         typedef senf::console::ParsedArgumentAttributor<Overload> Attributor;
 
-        return senf::console::detail::ParsedCommandAddNodeAccess::attributor<Attributor>(
-            cmdNode.add( CreateParsedCommandOverload<CmdTraits>::create(fn) ) );
+        return detail::ParsedCommandAddNodeAccess::attributor<Attributor>(
+            CreateParsedCommandOverload<CmdTraits>::create(fn));
     }
 
 #endif
 
 }}}
 
-#ifndef DOXYGEN
+//-/////////////////////////////////////////////////////////////////////////////////////////////////
+
+template <class Signature>
+prefix_ senf::console::SimpleOverloadAttributor
+senf::console::factory::
+Command(boost::function<Signature> fn,
+        typename boost::enable_if_c<detail::ParsedCommandTraits<Signature>::is_simple>::type *)
+{
+    return SimpleOverloadAttributor(fn);
+}
 
 template <class Function>
-typename senf::console::detail::ParsedCommandTraits<Function>::Attributor
-senf::console::senf_console_add_node(DirectoryNode & node, std::string const & name,
-                                     Function fn, int,
-                                     typename boost::enable_if_c<detail::ParsedCommandTraits<Function>::is_callable>::type *)
+prefix_ senf::console::SimpleOverloadAttributor
+senf::console::factory::
+Command(Function fn,
+        typename boost::enable_if_c<detail::ParsedCommandTraits<Function>::is_simple>::type *)
+{
+    return SimpleOverloadAttributor(fn);
+}
+
+template <class Owner, class Member>
+prefix_ senf::console::SimpleOverloadAttributor
+senf::console::factory::
+Command(Member memfn, Owner * owner,
+        typename boost::enable_if<boost::is_member_function_pointer<Member> >::type *,
+        typename boost::enable_if_c<detail::ParsedCommandTraits<Member>::is_simple>::type *)
+{
+    return SimpleOverloadAttributor(senf::membind(memfn,owner));
+}
+
+template <class Owner, class Member>
+prefix_ senf::console::SimpleOverloadAttributor
+senf::console::factory::
+Command(Member memfn, Owner const * owner,
+        typename boost::enable_if<boost::is_member_function_pointer<Member> >::type *,
+        typename boost::enable_if_c<detail::ParsedCommandTraits<Member>::is_simple>::type *)
 {
-    return senf::console::detail::addOverloadedCommandNode<Function>(node, name, fn);
+    return SimpleOverloadAttributor(senf::membind(memfn,owner));
+}
+
+template <class CastTo, class Signature>
+prefix_ typename senf::console::detail::ParsedCommandTraits<CastTo>::Attributor
+senf::console::factory::
+Command(boost::function<Signature> fn)
+{
+    return detail::addOverloadedCommandNode<CastTo>(fn);
+}
+
+template <class CastTo, class Function>
+prefix_ typename senf::console::detail::ParsedCommandTraits<CastTo>::Attributor
+senf::console::factory::
+Command(Function fn,
+        typename boost::enable_if_c<detail::ParsedCommandTraits<Function>::is_callable>::type *,
+        typename boost::disable_if<boost::is_member_function_pointer<Function> >::type *)
+{
+    return detail::addOverloadedCommandNode<CastTo>(fn);
 }
 
 template <class Signature>
-typename senf::console::detail::ParsedCommandTraits<Signature>::Attributor
-senf::console::senf_console_add_node(DirectoryNode & node, std::string const & name,
-                                     boost::function<Signature> fn, int)
+prefix_ typename senf::console::detail::ParsedCommandTraits<Signature>::Attributor
+senf::console::factory::
+Command(boost::function<Signature> fn)
 {
-    return senf::console::detail::addOverloadedCommandNode<Signature>(node, name, fn);
+    return detail::addOverloadedCommandNode<Signature>(fn);
 }
 
-template <class Owner, class Function>
-typename senf::console::detail::ParsedCommandTraits<Function>::Attributor
-senf::console::senf_console_add_node(DirectoryNode & node, Owner & owner, std::string const & name,
-                                     Function fn, int,
-                                     typename boost::enable_if_c<detail::ParsedCommandTraits<Function>::is_member>::type *)
+template <class Function>
+prefix_ typename senf::console::detail::ParsedCommandTraits<Function>::Attributor
+senf::console::factory::
+Command(Function fn,
+        typename boost::enable_if_c<detail::ParsedCommandTraits<Function>::is_callable>::type *,
+        typename boost::disable_if<boost::is_member_function_pointer<Function> >::type *)
 {
-    return senf::console::detail::addOverloadedCommandNode<Function>(
-        node, name, senf::membind(fn,&owner));
+    return detail::addOverloadedCommandNode<Function>(fn);
 }
 
-#endif
+template <class Owner, class Member>
+prefix_ typename senf::console::detail::ParsedCommandTraits<Member>::Attributor
+senf::console::factory::
+Command(Member memfn, Owner * owner,
+             typename boost::enable_if<boost::is_member_function_pointer<Member> >::type *)
+{
+    return detail::addOverloadedCommandNode<Member>(senf::membind(memfn,owner));
+}
+
+template <class Owner, class Member>
+prefix_ typename senf::console::detail::ParsedCommandTraits<Member>::Attributor
+senf::console::factory::
+Command(Member memfn, Owner const * owner,
+             typename boost::enable_if<boost::is_member_function_pointer<Member> >::type *)
+{
+    return detail::addOverloadedCommandNode<Member>(senf::membind(memfn,owner));
+}
+
+template <class CastTo, class Owner, class Member>
+prefix_ typename senf::console::detail::ParsedCommandTraits<CastTo>::Attributor
+senf::console::factory::
+Command(Member memfn, Owner * owner,
+             typename boost::enable_if<boost::is_member_function_pointer<Member> >::type *)
+{
+    return detail::addOverloadedCommandNode<CastTo>(senf::membind(memfn,owner));
+}
+
+template <class CastTo, class Owner, class Member>
+prefix_ typename senf::console::detail::ParsedCommandTraits<CastTo>::Attributor
+senf::console::factory::
+Command(Member memfn, Owner const * owner,
+             typename boost::enable_if<boost::is_member_function_pointer<Member> >::type *)
+{
+    return detail::addOverloadedCommandNode<CastTo>(senf::membind(memfn,owner));
+}
 
-///////////////////////////////cti.e///////////////////////////////////////
+//-/////////////////////////////////////////////////////////////////////////////////////////////////
 #undef prefix_