cmdline.h

/***************************************************************************
 *   Copyright (C) 2004 by Reality Rift Studios                            *
 *   http://www.realityrift.com  -  mattias@realityrift.com                *
 *                                                                         *
 *   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 neo_application_cmdline_h
#define neo_application_cmdline_h

#include "base.h"
#include "../core/array.h"
#include "../util/command.h"

#include <string>

namespace neo {
namespace application {


class CmdBase
{
        public:
                                                                                                        
                                                           CmdBase( const std::string &shortname, const std::string &longname );

        virtual                                           ~CmdBase() { }

        bool                                               operator == ( const std::string &rhs) const;

        virtual void                                       execute() = 0;

    protected:

        std::string                                        _short;

        std::string                                        _long;
};


template< typename T > class CmdImpl
{
    public:

        template< typename F > CmdImpl( F fun ) :
            _callback( fun )
        {
        }

        virtual ~CmdImpl() { }

        util::Command< void, TYPELIST_1( T ) >             _callback;

        virtual void execute( T data )
        {
            _callback( data );
        }

        virtual void execute() { }
};


template <> class CmdImpl< core::NullType >
{
    public:

        template< typename F > CmdImpl( F fun ) :
            _callback( fun )
        {
        }

        virtual ~CmdImpl() { }

        util::Command< void, util::type::NullType >              _callback;

        virtual void execute()
        {
            _callback();
        }

        virtual void execute( util::type::NullType& )
        {
            _callback();
        }
};



template< typename T > class Cmd : public CmdBase
{
    public:

        template< typename F >                             Cmd( const std::string &shortname, const std::string &longname, F callback, T defaultvalue );

        template< typename F >                             Cmd( const std::string &shortname, const std::string &longname, F callback );

        virtual                                           ~Cmd();

        const T                                            getData();

        virtual void                                       execute();

    protected:

        T                                                 _data;

        T                                                 _default;

        bool                                              _userSupplied;

        int                                               _numArgs;

        CmdImpl< T >                                     *_impl;
};



class CmdLine
{
    public:

                                                           CmdLine();

        virtual                                           ~CmdLine();

        void                                               addCmd( CmdBase *cmd );

    protected:

        void                                               parseCmds( int argc, char **argv );

        CmdBase                                           *getCmd( const std::string &name );

        core::Array< CmdBase* >                           _cmds;
};


#include "cmdline.inl"

}
}

#endif

---