OverloadedCommand.hh

Go to the documentation of this file.

//
// Copyright (c) 2020 Fraunhofer Institute for Applied Information Technology (FIT)
//                    Network Research Group (NET)
//                    Schloss Birlinghoven, 53754 Sankt Augustin, GERMANY
//                    Contact: support@wiback.org
//
// This file is part of the SENF code tree.
// It is licensed under the 3-clause BSD License (aka New BSD License).
// See LICENSE.txt in the top level directory for details or visit
// https://opensource.org/licenses/BSD-3-Clause
//


#ifndef HH_SENF_Utils_Console_OverloadedCommand_
#define HH_SENF_Utils_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: