Node.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_Node_
#define HH_SENF_Utils_Console_Node_ 1

// Custom includes
#include <map>
#include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <boost/range/iterator_range.hpp>
#include <boost/any.hpp>
#include <senf/Utils/Tags.hh>
#include <senf/Utils/Exception.hh>
#include <senf/Utils/Logger/SenfLog.hh>

//#include "Node.mpp"
//-/////////////////////////////////////////////////////////////////////////////////////////////////

namespace senf {
namespace console {

    class LinkNode;
    class DirectoryNode;
    class CommandNode;

    namespace detail { struct NodeFactory {}; }

    DirectoryNode & root();

    void dump(std::ostream & os, DirectoryNode & dir=root());

    void moveChildren(DirectoryNode & from, DirectoryNode & to);


    class GenericNode
        : public boost::enable_shared_from_this<GenericNode>
    {
        SENF_LOG_CLASS_AREA();
    public:
        //-////////////////////////////////////////////////////////////////////////
        // Types

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

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

        virtual ~GenericNode();

        std::string const & name() const; 
        boost::shared_ptr<DirectoryNode> parent() const; 

        std::string path() const;       

        std::string path(DirectoryNode const & root) const;

        ptr unlink();                   

        void rename(std::string const & newName);

        bool active() const;            

        void help(std::ostream & output) const; 
        std::string shorthelp() const;  

        ptr thisptr();                  
        cptr thisptr() const;           

        bool isChildOf(DirectoryNode & parent) const;

        bool operator== (GenericNode & other) const;
        bool operator!= (GenericNode & other) const;

        bool isDirectory() const;       
        bool isLink() const;            
        bool isCommand() const;         

        GenericNode const & followLink() const; 
        GenericNode & followLink();     

    protected:
        GenericNode();

        void name(std::string const & name);

#ifndef DOXYGEN
    private:
#else
    public:
#endif
        virtual void v_help(std::ostream & output) const = 0;

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

    private:
        std::string name_;
        DirectoryNode * parent_;

        friend class DirectoryNode;
    };

    class LinkNode
        : public GenericNode
    {
    public:
        //-////////////////////////////////////////////////////////////////////////
        // Types

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

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

        static ptr create(GenericNode & node); 

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

        GenericNode & follow() const;   

    protected:

    private:
        explicit LinkNode(GenericNode & node);

        virtual void v_help(std::ostream &) const;
        virtual std::string v_shorthelp() const;

        GenericNode::ptr node_;
    };

    class SimpleCommandNode;

    class DirectoryNode : public GenericNode
    {
        SENF_LOG_CLASS_AREA();
        typedef std::map<std::string, GenericNode::ptr> ChildMap;
    public:
        //-////////////////////////////////////////////////////////////////////////
        // Types

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

        typedef boost::iterator_range<ChildMap::const_iterator> ChildrenRange;
        typedef ChildMap::const_iterator child_iterator;

        typedef DirectoryNode node_type;
        typedef DirectoryNode & return_type;

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

        static ptr create();            

        ~DirectoryNode();

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

        template <class NodeType>
        NodeType & add(std::string const & name, boost::shared_ptr<NodeType> node);

        template <class NodeType>
        NodeType & add(std::string const & name, NodeType & node,
                       typename boost::enable_if< boost::is_convertible<NodeType &, GenericNode &> >::type * = 0);

        template <class Factory>
        typename Factory::result_type add(std::string const & name, Factory const & factory,
                                          typename boost::enable_if< boost::is_convertible<Factory const &, detail::NodeFactory const &> >::type * = 0);

        GenericNode::ptr remove(std::string const & name);

        GenericNode::ptr remove(std::string const & name, NoThrow_t);

        bool hasChild(std::string const & name) const;

        GenericNode & get(std::string const & name) const;

        GenericNode & getLink(std::string const & name) const;

        DirectoryNode & getDirectory(std::string const & name) const;

        DirectoryNode & operator[](std::string const & name) const;

        CommandNode & getCommand(std::string const & name) const;

        CommandNode & operator()(std::string const & name) const;

        ChildrenRange children() const; 

        ChildrenRange completions(std::string const & s) const;

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

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

        ptr thisptr();
        cptr thisptr() const;

    protected:
        DirectoryNode();

    private:
        void add(GenericNode::ptr node);
        virtual void v_help(std::ostream & output) const;
        virtual std::string v_shorthelp() const;

        ChildMap children_;
        std::string doc_;
        std::string shortdoc_;

        friend DirectoryNode & root();
    };

    struct UnknownNodeNameException : public senf::Exception
    { UnknownNodeNameException() : senf::Exception("Unknown node name") {}};

    class CommandNode : public GenericNode
    {
        SENF_LOG_CLASS_AREA();
    public:
        //-////////////////////////////////////////////////////////////////////////
        // Types

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

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

        void execute(std::ostream & output, ParseCommandInfo const & command) const;

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

        void operator()(std::ostream & output, ParseCommandInfo const & command) const;

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

        ptr thisptr();
        cptr thisptr() const;

    protected:
        CommandNode();

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

    private:
    };

    class SimpleCommandNode : public CommandNode
    {
        SENF_LOG_CLASS_AREA();
    public:
        //-////////////////////////////////////////////////////////////////////////
        // Types

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

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

        typedef SimpleCommandNode node_type;
        typedef SimpleCommandNode & return_type;

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

        static ptr create(Function const & fn);

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

        ptr thisptr();
        cptr thisptr() const;

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

    protected:
        SimpleCommandNode(Function const & fn);

    private:
        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;


        Function fn_;
        std::string doc_;
        std::string shortdoc_;
    };

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

namespace factory {

    class SimpleCommand
        : public detail::NodeFactory
    {
    public:
        typedef SimpleCommandNode node_type;
        typedef SimpleCommandNode & result_type;

        explicit SimpleCommand(SimpleCommandNode::Function fn);

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

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

        SimpleCommandNode::ptr node_;

        friend class senf::console::DirectoryNode;
    };

    class Directory
        : public detail::NodeFactory
    {
    public:
        typedef DirectoryNode node_type;
        typedef DirectoryNode & result_type;

        Directory();

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

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

        DirectoryNode::ptr node_;

        friend class senf::console::DirectoryNode;
    };

    class Link
        : public detail::NodeFactory
    {
    public:
        typedef LinkNode node_type;
        typedef LinkNode & result_type;

        explicit Link(GenericNode & target);

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

        LinkNode::ptr node_;

        friend class senf::console::DirectoryNode;
    };

}

}}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
#include "Node.cci"
//#include "Node.ct"
#include "Node.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: