// Custom includes
#include "../Utils/membind.hh"
#include <boost/format.hpp>
-#include <boost/parameter/binding.hpp>
+#include "../Utils/parameter.hh"
#define prefix_ inline
///////////////////////////////cti.p///////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
-// senf::console::ParsedCommandOverloadBase
+// senf::console::detail::ArgumentInfoBase
-template <class Type>
-prefix_ senf::console::detail::ParameterInfo<Type> &
-senf::console::ParsedCommandOverloadBase::arg(unsigned n)
+prefix_ senf::console::detail::ArgumentInfoBase::ArgumentInfoBase(std::string const & type_)
+ : type (type_), name (), hasDefault (false)
+{}
+
+///////////////////////////////////////////////////////////////////////////
+// senf::console::detail::ArgumentInfo<ParameterType>
+
+template <class ParameterType>
+prefix_ typename senf::console::detail::ArgumentInfo<ParameterType>::ptr
+senf::console::detail::ArgumentInfo<ParameterType>::create()
+{
+ return ptr(new ArgumentInfo());
+}
+
+template <class ParameterType>
+prefix_ senf::console::detail::ArgumentInfo<ParameterType>::ArgumentInfo()
+ : ArgumentInfoBase ( ArgumentTraits<ParameterType>::description() ),
+ defaultValue ()
+{}
+
+template <class ParameterType>
+prefix_ std::string senf::console::detail::ArgumentInfo<ParameterType>::defaultValueStr()
const
{
- return dynamic_cast<detail::ParameterInfo<Type> &>(arg(n));
+ return hasDefault ? ArgumentTraits<ParameterType>::str(defaultValue) : "";
}
+///////////////////////////////////////////////////////////////////////////
+// senf::console::ParsedCommandOverloadBase
+
template <class Type>
prefix_ void senf::console::ParsedCommandOverloadBase::addParameter()
{
- parameters_.push_back(detail::ParameterInfo<Type>::create());
+ parameters_.push_back(detail::ArgumentInfo<Type>::create());
}
///////////////////////////////////////////////////////////////////////////
#include BOOST_PP_ITERATE()
///////////////////////////////////////////////////////////////////////////
-// senf::console::ParsedCommandAttributorBase
-
-template <class Type>
-prefix_ void senf::console::ParsedCommandAttributorBase::defaultValue(Type const & value)
- const
-{
- overload().arg<Type>(index_).defaultValue = value;
- overload().arg(index_).hasDefault = true;
-}
-
-///////////////////////////////////////////////////////////////////////////
// senf::console::ParsedCommandAttributor<Overload>
template <class Overload>
{}
///////////////////////////////////////////////////////////////////////////
-// senf::console::ParsedAttributeAttributorBase<Overload,Self>
+// 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);
+}
+
+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);
+}
+
+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);
+}
+
+template <class Overload, class Self, class ReturnType>
+prefix_
+senf::console::ParsedArgumentAttributorBase<Overload,Self,ReturnType>::
+ParsedArgumentAttributorBase(Overload & overload, unsigned index)
+ : ParsedCommandAttributor<Overload> (overload, index)
+{}
template <class Overload, class Self>
prefix_ Self
-senf::console::ParsedAttributeAttributorBase<Overload,Self>::doc(std::string const & doc)
+senf::console::ParsedArgumentAttributorBase<Overload,Self,void>::doc(std::string const & doc)
const
{
this->ParsedCommandAttributorBase::nodeDoc(doc);
}
template <class Overload, class Self>
-prefix_ Self senf::console::ParsedAttributeAttributorBase<Overload,Self>::
+prefix_ Self senf::console::ParsedArgumentAttributorBase<Overload,Self,void>::
overloadDoc(std::string const & doc)
const
{
template <class Overload, class Self>
prefix_
-senf::console::ParsedAttributeAttributorBase<Overload,Self>::
-ParsedAttributeAttributorBase(Overload & overload, unsigned index)
+senf::console::ParsedArgumentAttributorBase<Overload,Self,void>::
+ParsedArgumentAttributorBase(Overload & overload, unsigned index)
: ParsedCommandAttributor<Overload> (overload, index)
{}
///////////////////////////////////////////////////////////////////////////
-// senf::console::ParsedAttributeAttributor<Overload,index,flag>
+// senf::console::ParsedArgumentAttributor<Overload,index,flag>
+
+template <class Overload, unsigned index, bool flag>
+prefix_ typename senf::console::ParsedArgumentAttributor<Overload,index,flag>::next_type
+senf::console::ParsedArgumentAttributor<Overload,index,flag>::arg()
+ const
+{
+ return next();
+}
template <class Overload, unsigned index, bool flag>
template <class ArgumentPack>
-prefix_ typename senf::console::ParsedAttributeAttributor<Overload,index,flag>::next_type
-senf::console::ParsedAttributeAttributor<Overload,index,flag>::
+prefix_ typename senf::console::ParsedArgumentAttributor<Overload,index,flag>::next_type
+senf::console::ParsedArgumentAttributor<Overload,index,flag>::
argInfo(ArgumentPack const & args)
const
{
- typedef typename boost::parameter::binding<
- ArgumentPack, tag::detail::default_value_>::type default_value_t;
- return argInfo( args, boost::is_same<default_value_t, void>() );
+# define ProcessArg(tag) \
+ argInfo( kw:: tag, args, senf::has_parameter< ArgumentPack, kw::type:: tag >() )
+
+ ProcessArg(name);
+ ProcessArg(description);
+ ProcessArg(default_value);
+ ProcessArg(type_name);
+ ProcessArg(default_doc);
+ ProcessArg(parser);
+
+ return next();
+
+# undef HaveArg
}
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>
template <class ArgumentPack>
-prefix_ typename senf::console::ParsedAttributeAttributor<Overload,index,flag>::next_type
-senf::console::ParsedAttributeAttributor<Overload,index,flag>::
-argInfo(ArgumentPack const & args, boost::mpl::true_)
+prefix_ void senf::console::ParsedArgumentAttributor<Overload,index,flag>::
+argInfo(boost::parameter::keyword<kw::type::name> const &, ArgumentPack const & args,
+ boost::mpl::true_)
const
{
- return argInfo( args[tag::name_ | ""],
- args[tag::description_ | ""] );
+ this->argName(args[kw::name]);
+}
+template <class Overload, unsigned index, bool flag>
+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]);
}
template <class Overload, unsigned index, bool flag>
template <class ArgumentPack>
-prefix_ typename senf::console::ParsedAttributeAttributor<Overload,index,flag>::next_type
-senf::console::ParsedAttributeAttributor<Overload,index,flag>::
-argInfo(ArgumentPack const & args, boost::mpl::false_)
+prefix_ void senf::console::ParsedArgumentAttributor<Overload,index,flag>::
+argInfo(boost::parameter::keyword<kw::type::default_value> const &, ArgumentPack const & args,
+ boost::mpl::true_)
const
{
- return argInfo( args[tag::name_ | ""],
- args[tag::description_ | ""],
- args[tag::default_value_ | value_type()] );
+ this->defaultValue(args[kw::default_value]);
}
template <class Overload, unsigned index, bool flag>
-prefix_ typename senf::console::ParsedAttributeAttributor<Overload,index,flag>::next_type
-senf::console::ParsedAttributeAttributor<Overload,index,flag>::argInfo(std::string const & name,
- std::string const & doc)
+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->argName(name);
- this->argDoc(doc);
- return next();
+ this->typeName(args[kw::type_name]);
}
template <class Overload, unsigned index, bool flag>
-prefix_ typename senf::console::ParsedAttributeAttributor<Overload,index,flag>::next_type
-senf::console::ParsedAttributeAttributor<Overload,index,flag>::argInfo(std::string const & name,
- std::string const & doc,
- value_type const & value)
+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
{
- this->argName(name);
- this->argDoc(doc);
- defaultValue(value);
- return next();
+ BOOST_STATIC_ASSERT(( senf::has_parameter<ArgumentPack, kw::type::default_value>::value ));
+ this->defaultDoc(args[kw::default_doc]);
+}
+
+template <class Overload, unsigned index, bool flag>
+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::ParsedAttributeAttributor<Overload,index,flag>::
-ParsedAttributeAttributor(Overload & overload)
- : ParsedAttributeAttributorBase<Overload, ParsedAttributeAttributor> (overload, index)
+senf::console::ParsedArgumentAttributor<Overload,index,flag>::
+ParsedArgumentAttributor(Overload & overload)
+ : ParsedArgumentAttributorBase<Overload, ParsedArgumentAttributor> (overload, index)
{}
template <class Overload, unsigned index, bool flag>
-prefix_ senf::console::ParsedAttributeAttributor<Overload, index+1>
-senf::console::ParsedAttributeAttributor<Overload,index,flag>::next()
+prefix_ typename senf::console::ParsedArgumentAttributor<Overload,index,flag>::next_type
+senf::console::ParsedArgumentAttributor<Overload,index,flag>::next()
const
{
- return ParsedAttributeAttributor<Overload, index+1>(this->overload());
+ return ParsedArgumentAttributor<Overload, index+1>(this->overload());
}
template <class Overload, unsigned index, bool flag>
-prefix_ void senf::console::ParsedAttributeAttributor<Overload,index,flag>::
+prefix_ void senf::console::ParsedArgumentAttributor<Overload,index,flag>::
defaultValue(value_type const & value)
const
{
- ParsedCommandAttributorBase::defaultValue<arg_type>(value);
+ this->overload().arg<index>().defaultValue = value;
+ this->overload().arg(index).hasDefault = true;
+}
+
+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::ParsedAttributeAttributor<Overload, index, false>
+// senf::console::ParsedArgumentAttributor<Overload, index, false>
template <class Overload, unsigned index>
prefix_
-senf::console::ParsedAttributeAttributor<Overload, index, false>::
-ParsedAttributeAttributor(Overload & overload)
- : ParsedCommandAttributor<Overload> (overload, index)
+senf::console::ParsedArgumentAttributor<Overload, index, false>::
+ParsedArgumentAttributor(Overload & overload)
+ : ParsedArgumentAttributorBase<
+ Overload, ParsedArgumentAttributor<Overload, index, false> > (overload, index)
{}
///////////////////////////////////////////////////////////////////////////
// namespace members
-namespace {
+namespace senf {
+namespace console {
+namespace detail {
+
+#ifndef DOXYGEN
+
+ struct ParsedCommandAddNodeAccess
+ {
+ template <class Attributor, class Node>
+ static Attributor attributor(Node & node)
+ { return Attributor(node); }
+ };
// What is THIS about ??
// 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, unsigned arity=Traits::arity>
+ 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 Traits traits;
+ typedef typename Traits::traits traits;
template <class Function>
static typename senf::console::ParsedCommandOverload<traits>::ptr create(Function fn)
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)
+ {
+ 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) ) );
+ }
+
+#endif
+
+}}}
+
+#ifndef DOXYGEN
template <class Function>
-prefix_ senf::console::ParsedAttributeAttributor<
- senf::console::ParsedCommandOverload<
- typename senf::console::detail::ParsedCommandTraits<Function>::traits> >
+typename senf::console::detail::ParsedCommandTraits<Function>::Attributor
senf::console::senf_console_add_node(DirectoryNode & node, std::string const & name,
Function fn, int)
{
- OverloadedCommandNode & cmdNode (
- node.hasChild(name)
- ? dynamic_cast<OverloadedCommandNode &>(node(name))
- : node.add(name, OverloadedCommandNode::create()) );
-
- typedef detail::ParsedCommandTraits<Function> CmdTraits;
- typedef ParsedCommandOverload<typename CmdTraits::traits> Overload;
- typedef ParsedAttributeAttributor<Overload> Attributor;
-
- return Attributor(
- cmdNode.add( CreateParsedCommandOverload<
- typename CmdTraits::traits, ! CmdTraits::has_ostream_arg>::create(fn) ) );
+ return senf::console::detail::addOverloadedCommandNode<Function>(node, name, 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)
+{
+ return senf::console::detail::addOverloadedCommandNode<Signature>(node, name, fn);
}
template <class Owner, class Function>
-prefix_ senf::console::ParsedAttributeAttributor<
- senf::console::ParsedCommandOverload<
- typename senf::console::detail::ParsedCommandTraits<Function>::traits> >
-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 *)
+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 *)
{
- OverloadedCommandNode & cmdNode (
- node.hasChild(name)
- ? dynamic_cast<OverloadedCommandNode &>(node(name))
- : node.add(name, OverloadedCommandNode::create()) );
-
- typedef detail::ParsedCommandTraits<Function> CmdTraits;
- typedef ParsedCommandOverload<typename CmdTraits::traits> Overload;
- typedef ParsedAttributeAttributor<Overload> Attributor;
-
- return Attributor(
- cmdNode.add( CreateParsedCommandOverload<
- typename CmdTraits::traits, ! CmdTraits::has_ostream_arg>::create(
- senf::membind(fn,&owner)) ) );
+ return senf::console::detail::addOverloadedCommandNode<Function>(
+ node, name, senf::membind(fn,&owner));
}
+#endif
+
///////////////////////////////cti.e///////////////////////////////////////
#undef prefix_
projects / senf.git / blobdiff