/home/raskolnikov/dev/psynth/trunk/src/psynth/base/arg_parser.hpp

Go to the documentation of this file.

/*
 *  Copyright (C) 2007, 2009 Juan Pedro Bolívar Puente
 *
 *  This file is part of Psychosynth.
 *   
 *  Psychosynth 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 3 of the License, or
 *  (at your option) any later version.
 *
 *  Psychosynth 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, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef PSYNTH_ARG_PARSER_H
#define PSYNTH_ARG_PARSER_H

#include <sstream>
#include <cstring>
#include <string>
#include <limits>
#include <list>
#include <map>

#include <psynth/base/exception.hpp>
#include <psynth/base/iterator.hpp>
#include <psynth/base/util.hpp>

namespace psynth
{
namespace base
{

PSYNTH_DECLARE_ERROR (error, arg_parser_error)
PSYNTH_DECLARE_ERROR (arg_parser_error, unknown_option_error)
PSYNTH_DECLARE_ERROR (arg_parser_error, parse_option_error)

class parse_error : public std::exception {};

namespace detail
{

struct ltstr
{
    bool operator  () (const char *s1, const char *s2) const
    {
        return strcmp (s1, s2) < 0;
    }
};

struct atoi_func
{
    int operator () (const char *str)
    {
        char* end = 0;
        int res = strtol (str, &end, 10);
        if (end <= str)
            throw parse_error ();
        return res;
    }
};

struct atof_func
{
    float operator () (const char *str)
    {
        char* end = 0;
        float res = strtof (str, &end);
        
        if (end <= str)
            throw parse_error ();
        return res;
    }
};

template <class T>
struct atoany_func
{
    T operator () (const char *str)
    {
        return T (str);
    }
};

} /* namespace detail */

class option
{
public:
    virtual ~option ()
    {
    }

    virtual bool parse (const char *arg)
    {
        return false;
    };

    virtual bool parse ()
    {
        return false;
    };
};

template <class T, class ConvFunc = detail::atoany_func <T> >
class option_generic : public option
{
public:
    option_generic (T* data)
        : _data (data)
    {}

    bool parse (const char *arg)
    {
        *_data = ConvFunc ()(arg);
        return true;
    }

private:
    T* _data;
};

class option_flag : public option
{
    bool* _flag;

public:
    option_flag (bool* f)
        : _flag (f)
    {}

    bool parse ()
    {
        *_flag = true;
        return true;
    }
};

class option_not_flag : public option
{
    bool* _flag;

public:
    option_not_flag (bool* f)
        : _flag (f)
    {}

    bool parse ()
    {
        *_flag = false;
        return true;
    }
};

template <class T>
class option_stream : public option
{
    T *m_data;

public:
    option_stream (T * data):
        m_data (data)
    {}

    bool parse (const char *arg)
    {
        std::stringstream stream (std::string (arg), std::ios_base::in);
        stream.exceptions (std::stringstream::eofbit |
                           std::stringstream::failbit |
                           std::stringstream::badbit);
        try {
            stream >> *m_data;
        } catch (...) {
            throw parse_error ();
        }
        
        return true;
    }
};

typedef option_generic <int, detail::atoi_func> option_int;
typedef option_generic <float, detail::atof_func> option_float;
typedef option_generic <std::string> option_string;
typedef option_generic <const char*> option_cstring;

class arg_parser : public boost::noncopyable
{
public:
    typedef std::list <const char*>::iterator iterator;

    typedef std::list <const char*>::const_iterator const_iterator;

    void add (unsigned char flag, const char* str, int* data)
    {
        add (flag, str, data ? new option_int (data) : 0);
    }

    void add (unsigned char flag, const char* str, float* data)
    {
        add (flag, str, data ? new option_float (data) : 0);
    }

    void add (unsigned char flag, const char* str, bool* data)
    {
        add (flag, str, data ? new option_flag (data) : 0);
    }

    void add (unsigned char flag, const char* str, std::string* data)
    {
        add (flag, str, data ? new option_string (data) : 0);
    }

    void add (unsigned char flag, const char* str, const char** data)
    {
        add (flag, str, data ? new option_cstring (data) : 0);
    }

    void add (unsigned char flag, const char* str, option* op);
    
    void parse (int argc, const char* argv[]);

    iterator begin ()
    {
        return _free.begin ();
    }

    const_iterator begin () const
    {
        return _free.begin ();
    }

    iterator end ()
    {
        return _free.end ();
    }

    const_iterator end () const
    {
        return _free.end ();
    }

    size_t free_args () const
    {
        return _free.size ();
    }

    bool has_free_args () const
    {
        return !_free.empty ();
    }

private:
    typedef ptr_iterator<std::list<option*>::iterator> option_iterator;
    typedef std::list<option*> option_list;
    typedef std::list<std::unique_ptr<option> > unique_option_list;
    typedef std::map <const char*, option_list, detail::ltstr>
    option_map;

    static const unsigned char null_flag = '\0';
    
    option_list              _short [256];
    option_map               _long;
    unique_option_list       _all;
    std::list <const char *> _free;

    const char** parse_short (const char** argv, const char** argv_end);
    const char** parse_long (const char** argv, const char** argv_end);    
};

} /* namespace base */
} /* namespace psynth */

#endif /* PSYNTH_ARGPARSER_H */