// $Id$
//
// Copyright (C) 2008
// Fraunhofer Institute for Open Communication Systems (FOKUS)
//
// 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
//
// 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.
//
// 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 */

#include "ParsedCommand.ih"

// Custom includes
#include <senf/Utils/membind.hh>
#include <boost/format.hpp>
#include <senf/Utils/parameter.hh>

#define prefix_ inline
//-/////////////////////////////////////////////////////////////////////////////////////////////////

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// 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(),
                         ArgumentTraits<ParameterType>::singleToken ),
      defaultValue ()
{}

template <class ParameterType>
prefix_ std::string senf::console::detail::ArgumentInfo<ParameterType>::defaultValueStr()
    const
{
    return hasDefault ? ArgumentTraits<ParameterType>::str(defaultValue) : "";
}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// senf::console::ParsedCommandOverloadBase

template <class Type>
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,                       \
                                         SENF_ABSOLUTE_INCLUDE_PATH(Utils/Console/ParsedCommand.mpp),   \
                                         2))
#include BOOST_PP_ITERATE()

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// senf::console::ParsedCommandAttributor<Overload>

template <class Overload>
prefix_ Overload & senf::console::ParsedCommandAttributor<Overload>::overload()
    const
{
    return static_cast<Overload &>(ParsedCommandAttributorBase::overload());
}

template <class Overload>
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)
{
    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>::
shortdoc(std::string const & doc)
{
    this->ParsedCommandAttributorBase::shortDoc(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)
{
    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)
{
    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(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)
{
    this->ParsedCommandAttributorBase::nodeDoc(doc);
    return static_cast<Self const &>(*this);
}

template <class Overload, class Self>
prefix_ Self senf::console::ParsedArgumentAttributorBase<Overload, Self, void>::
shortdoc(std::string const & doc)
{
    this->ParsedCommandAttributorBase::shortDoc(doc);
    return static_cast<Self const &>(*this);
}

template <class Overload, class Self>
prefix_ Self senf::console::ParsedArgumentAttributorBase<Overload,Self,void>::
overloadDoc(std::string const & doc)
{
    this->ParsedCommandAttributorBase::overloadDoc(doc);
    return static_cast<Self const &>(*this);
}

template <class Overload, class Self>
prefix_
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>
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::ParsedArgumentAttributor<Overload,index,flag>::next_type
senf::console::ParsedArgumentAttributor<Overload,index,flag>::
argInfo(ArgumentPack const & args)
{
#   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 ProcessArg
}

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_)
{}

template <class Overload, unsigned index, bool flag>
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_)
{
    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_)
{
    this->argDoc(args[kw::description]);
}

template <class Overload, unsigned index, bool flag>
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_)
{
    this->defaultValue(args[kw::default_value]);
}

template <class Overload, unsigned index, bool flag>
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_)
{
    this->typeName(args[kw::type_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::default_doc> const &, ArgumentPack const & args,
        boost::mpl::true_)
{
    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_)
{
    this->parser(args[kw::parser]);
}

template <class Overload, unsigned index, bool flag>
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>
prefix_ typename senf::console::ParsedArgumentAttributor<Overload,index,flag>::next_type
senf::console::ParsedArgumentAttributor<Overload,index,flag>::next()
    const
{
    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)
{
    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)
{
    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(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 {
namespace console {
namespace detail {

#ifndef DOXYGEN

    struct ParsedCommandAddNodeAccess
    {
        template <class Attributor, class NodePtr>
        static Attributor attributor(NodePtr ptr)
            { return Attributor(ptr); }
    };

    template <class Signature, class Fn>
    typename senf::console::detail::ParsedCommandTraits<Signature>::Attributor
    addOverloadedCommandNode(Fn fn)
    {
        typedef senf::console::detail::ParsedCommandTraits<Signature> CmdTraits;
        typedef senf::console::ParsedCommandOverload<typename CmdTraits::traits> Overload;
        typedef senf::console::ParsedArgumentAttributor<Overload> Attributor;

        return detail::ParsedCommandAddNodeAccess::attributor<Attributor>(
            CreateParsedCommandOverload<CmdTraits>::create(fn));
    }

#endif

}}}

//-/////////////////////////////////////////////////////////////////////////////////////////////////

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>
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 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>
prefix_ typename senf::console::detail::ParsedCommandTraits<Signature>::Attributor
senf::console::factory::
Command(boost::function<Signature> fn)
{
    return detail::addOverloadedCommandNode<Signature>(fn);
}

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 detail::addOverloadedCommandNode<Function>(fn);
}

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));
}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
#undef prefix_


// Local Variables:
// mode: c++
// fill-column: 100
// comment-column: 40
// c-file-style: "senf"
// indent-tabs-mode: nil
// ispell-local-dictionary: "american"
// compile-command: "scons -u test"
// End: