Search:

SENF Extensible Network Framework

• Home
• Download
• Wiki
• BerliOS
• ChangeLog
• Browse SVN
• Bug Tracker

OverloadedCommand.hh

Go to the documentation of this file.

// $Id: OverloadedCommand.hh 1742 2010-11-04 14:51:56Z g0dil $
//
// Copyright (C) 2008
// Fraunhofer (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.
//
// 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.
//
// 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.

#ifndef HH_SENF_Scheduler_Console_OverloadedCommand_
#define HH_SENF_Scheduler_Console_OverloadedCommand_ 1

// Custom includes
#include "Node.hh"
#include <boost/intrusive_ptr.hpp>
#include <boost/range/iterator_range.hpp>
#include <senf/Utils/intrusive_refcount.hh>
#include <boost/optional.hpp>

//#include "OverloadedCommand.mpp"
//-/////////////////////////////////////////////////////////////////////////////////////////////////

namespace senf {
namespace console {

    class OverloadedCommandNode;

    struct ArgumentDoc {
        std::string name; 
        std::string type; 
        std::string defaultValue; 
        std::string doc; 
        bool singleToken; 
    };

    class CommandOverload
        : public senf::intrusive_refcount
    {
    public:
        //-////////////////////////////////////////////////////////////////////////
        // Types

        typedef boost::intrusive_ptr<CommandOverload> ptr;
        typedef boost::intrusive_ptr<CommandOverload const> cptr;

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

        virtual ~CommandOverload();

        void execute(boost::any & rv, std::ostream & os, ParseCommandInfo const & command);

        void operator()(boost::any & rv, std::ostream & os, ParseCommandInfo const & command);

        unsigned numArguments() const;  
        void argumentDoc(unsigned index, ArgumentDoc & doc) const;

        std::string doc() const;        

        OverloadedCommandNode & node() const; 

        unsigned overloadIndex() const; 

    protected:
        CommandOverload();

#ifndef DOXYGEN
    private:
#endif
        virtual unsigned v_numArguments() const = 0;

        virtual void v_argumentDoc(unsigned index, ArgumentDoc & doc) const = 0;

        virtual std::string v_doc() const = 0;

        virtual void v_execute(boost::any & rv, std::ostream & os, ParseCommandInfo const & command)
            const = 0;

    private:
        OverloadedCommandNode * node_;

        friend class OverloadedCommandNode;
    };

    class OverloadedCommandNode
        : public CommandNode
    {
        typedef std::vector<CommandOverload::ptr> Overloads;

    public:
        //-////////////////////////////////////////////////////////////////////////
        // Types

        typedef boost::shared_ptr<OverloadedCommandNode> ptr;
        typedef boost::shared_ptr<OverloadedCommandNode const> cptr;
        typedef boost::weak_ptr<OverloadedCommandNode> weak_ptr;

        typedef OverloadedCommandNode node_type;
        typedef OverloadedCommandNode & return_type;

        typedef boost::iterator_range<Overloads::const_iterator> OverloadsRange;

        //-////////////////////////////////////////////////////////////////////////
        //\{

        static ptr create();

        //\}
        //-////////////////////////////////////////////////////////////////////////

        template <class Command>
        Command & add(boost::intrusive_ptr<Command> overload); 

        OverloadedCommandNode & doc(std::string const & doc);
        OverloadedCommandNode & shortdoc(std::string const & doc);

        unsigned overloadIndex(CommandOverload const & overload);

        OverloadsRange overloads() const; 

        ptr thisptr();
        cptr thisptr() const;

        static OverloadedCommandNode & insertOverload(DirectoryNode & dir, std::string const & name,
                                                      CommandOverload::ptr overload);

    private:
        OverloadedCommandNode();

        virtual void v_help(std::ostream & output) const;
        virtual std::string v_shorthelp() const;
        virtual void v_execute(boost::any & rv, std::ostream & os, ParseCommandInfo const & command)
            const;

        Overloads overloads_;
        std::string doc_;
        std::string shortdoc_;
    };

    class SimpleCommandOverload
        : public CommandOverload
    {
    public:
        //-////////////////////////////////////////////////////////////////////////
        // Types

        typedef boost::intrusive_ptr<SimpleCommandOverload> ptr;
        typedef boost::function<void (std::ostream &, ParseCommandInfo const &)> Function;

        //-////////////////////////////////////////////////////////////////////////
        //\{

        static SimpleCommandOverload::ptr create(Function fn);

        //\}
        //-////////////////////////////////////////////////////////////////////////

        SimpleCommandOverload & doc(std::string const & doc);

    private:
        explicit SimpleCommandOverload(Function fn);

        virtual unsigned v_numArguments() const;
        virtual void v_argumentDoc(unsigned index, ArgumentDoc & doc) const;
        virtual std::string v_doc() const;
        virtual void v_execute(boost::any & rv, std::ostream & os, ParseCommandInfo const & command)
            const;

        Function fn_;
        std::string doc_;
    };

    class SimpleOverloadAttributor
        : public detail::NodeFactory
    {
    public:
        typedef OverloadedCommandNode node_type;
        typedef OverloadedCommandNode & result_type;

        explicit SimpleOverloadAttributor(SimpleCommandOverload::Function fn);

        SimpleOverloadAttributor const & doc(std::string const & doc) const;
        SimpleOverloadAttributor const & shortdoc(std::string const & doc) const;
        SimpleOverloadAttributor const & overloadDoc(std::string const & doc) const;

        OverloadedCommandNode & create(DirectoryNode & dir, std::string const & name) const;

    private:
        SimpleCommandOverload::ptr overload_;
        mutable boost::optional<std::string> doc_;
        mutable boost::optional<std::string> shortdoc_;
    };

}}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
#include "OverloadedCommand.cci"
//#include "OverloadedCommand.ct"
#include "OverloadedCommand.cti"
#endif


// 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:

---

Contact: senf-dev@lists.berlios.de | © 2006-2010 Fraunhofer Institute for Open Communication Systems, Network Research