args.hh

// -*- c-basic-offset: 4; related-file-name: "../../lib/args.cc" -*-
#ifndef CLICK_ARGS_HH
#define CLICK_ARGS_HH
#include <click/type_traits.hh>
#include <click/vector.hh>
#include <click/string.hh>
#include <click/confparse.hh>
#include <click/timestamp.hh>
#include <click/bitvector.hh>
#include <type_traits>
#if CLICK_BSDMODULE
# include <machine/stdarg.h>
#else
# include <stdarg.h>
#endif
CLICK_DECLS
class Element;
class ErrorHandler;
 
class ArgContext { public:
 
    ArgContext(ErrorHandler *errh = 0)
        : _errh(errh), _arg_keyword(0), _read_status(false) {
#if !CLICK_TOOL
        _context = 0;
#endif
    }
 
#if !CLICK_TOOL
    ArgContext(const Element *context, ErrorHandler *errh = 0)
        : _context(context), _errh(errh), _arg_keyword(0), _read_status(false) {
    }
 
    const Element *context() const {
        return _context;
    }
#endif
 
    ErrorHandler *errh() const {
        return _errh;
    }
 
    String error_prefix() const;
 
    void error(const char *fmt, ...) const;
 
    void warning(const char *fmt, ...) const;
 
    void message(const char *fmt, ...) const;
 
    void xmessage(const String &anno, const String &str) const;
    void xmessage(const String &anno, const char *fmt, va_list val) const;
 
  protected:
 
#if !CLICK_TOOL
    const Element *_context;
#endif
    ErrorHandler *_errh;
    const char *_arg_keyword;
    mutable bool _read_status;
 
};
 
 
template <typename T> struct Args_has_enable_direct_parse {
  private:
    template <typename X> static char test(typename X::enable_direct_parse *);
    template <typename> static int test(...);
  public:
    enum { value = (sizeof(test<T>(0)) == 1) };
};
template <typename P, bool direct = Args_has_enable_direct_parse<P>::value>
struct Args_parse_helper;
template <typename P> struct Args_parse_helper<P, false> {
    template <typename T, typename A>
    static inline T *slot(T &variable, A &args) {
        return args.slot(variable);
    }
    template <typename T, typename A>
    static inline T *initialized_slot(T &variable, A &args) {
        return args.initialized_slot(variable);
    }
    template <typename T, typename A>
    static inline bool parse(P parser, const String &str, T &s, A &args) {
        return parser.parse(str, s, args);
    }
    template <typename T1, typename T2, typename A>
    static inline bool parse(P parser, const String &str, T1 &s1, T2 &s2, A &args) {
        return parser.parse(str, s1, s2, args);
    }
};
template <typename P> struct Args_parse_helper<P, true> {
    template <typename T, typename A>
    static inline T *slot(T &variable, A &) {
        return &variable;
    }
    template <typename T, typename A>
    static inline T *initialized_slot(T &variable, A &) {
        return &variable;
    }
    template <typename T, typename A>
    static inline bool parse(P parser, const String &str, T &s, A &args) {
        return parser.direct_parse(str, s, args);
    }
    template <typename T1, typename T2, typename A>
    static inline bool parse(P parser, const String &str, T1 &s1, T2 &s2, A &args) {
        return parser.direct_parse(str, s1, s2, args);
    }
};
class Args : public ArgContext {
    struct Slot;
 
  public:
 
    Args(ErrorHandler *errh = 0);
 
    Args(const Vector<String> &conf, ErrorHandler *errh = 0);
 
#if !CLICK_TOOL
    Args(const Element *context, ErrorHandler *errh = 0);
 
    Args(const Vector<String> &conf, const Element *context,
         ErrorHandler *errh = 0);
#endif
 
 
 
    Args(const Args &x);
 
    ~Args();
 
    Args &operator=(const Args &x);
 
 
    bool empty() const {
        return (!_conf || !_conf->size()) && !_slots && _simple_slotbuf[0] == 0;
    }
 
    bool results_empty() const {
        return !_slots && _simple_slotbuf[0] == 0;
    }
 
 
    Args &clear() {
        if (_conf)
            _conf->clear();
        _kwpos.clear();
        return *this;
    }
 
    Args &bind(Vector<String> &conf);
 
    Args &push_back(const String &arg);
 
    template<typename Iter> Args &push_back(Iter begin, Iter end) {
        while (begin != end) {
            push_back(*begin);
            ++begin;
        }
        return *this;
    }
 
    Args &push_back_words(const String &str);
 
    Args &push_back_args(const String &str);
 
    Args &reset() {
        reset_from(0);
        return *this;
    }
 
 
    static constexpr int mandatory = 1;  
    static constexpr int positional = 2; 
    static constexpr int deprecated = 4; 
    static constexpr int firstmatch = 8; 
 
    template <typename T>
    Args &read(const char *keyword, T &x) {
        return read(keyword, 0, x);
    }
    template <typename T>
    Args &read_m(const char *keyword, T &x) {
        return read(keyword, mandatory, x);
    }
    template <typename T>
    Args &read_p(const char *keyword, T &x) {
        return read(keyword, positional, x);
    }
    template <typename T>
    Args &read_mp(const char *keyword, T &x) {
        return read(keyword, mandatory | positional, x);
    }
    template <typename T>
    Args &read(const char *keyword, int flags, T &x) {
        args_base_read(this, keyword, flags, x);
        return *this;
    }
 
    template <typename T, typename V>
    Args &read_or_set(const char *keyword, T &x, const V &default_value) {
        return read_or_set(keyword, 0, x, default_value);
    }
    template <typename T, typename V>
    Args &read_or_set_p(const char *keyword, T &x, const V &default_value) {
        return read_or_set(keyword, positional, x, default_value);
    }
    template <typename T, typename V>
    Args &read_or_set(const char *keyword, int flags, T &x, const V &default_value) {
        args_base_read_or_set(this, keyword, flags, x, default_value);
        return *this;
    }
 
    Args &validate(const char *keyword, bool present=false) {
        Slot *slot_status;
        String str = find(keyword, 0, slot_status);
        if (str && !present) {
            printf("A value was given for %s, but it was not given at time of devirtualization.\n", keyword);
            assert(false);
        }
        return *this;
    }
 
    template <typename T>
    Args &validate(const char *keyword, T &x, const char *static_value) {
        DefaultArg<T> p = DefaultArg<T>();
        T v;
        p.parse(static_value, v);
        return validate(keyword, x, v);
    }
 
    template <typename T, typename V>
    Args &validate(const char *keyword, T &x, const V &static_value) {
        Slot *slot_status;
        String str = find(keyword, 0, slot_status);
        if (!str) {
            x = static_value;
            return *this;
        } else {
            T *s = Args_parse_helper<DefaultArg<T> >::slot(x, *this);
            postparse(s && (str ? Args_parse_helper<DefaultArg<T> >::parse(DefaultArg<T>(), str, *s, *this) : (*s = static_value, true)), slot_status);
            if (*s != static_value) {
                click_chatter("%s is not the expected value", keyword);
                if (std::is_convertible<T,char *>::value) {
                    click_chatter("Given %s", x);
                }
                if (std::is_convertible<V,char *>::value) {
                    click_chatter("Given %s", static_value);
                }
                assert(*s == static_value);
            }
        }
        return *this;
    }
 
 
    template <typename T, typename V>
    Args &validate_f(const char *keyword, T &x, int flags, const V &static_value) {
        //Todo : cleaner
        Slot *slot_status;
        String str = find(keyword, flags, slot_status);
        if (!str) {
            return *this;
        } else {
            T *s = Args_parse_helper<DefaultArg<T> >::slot(x, *this);
            postparse(s && (str ? Args_parse_helper<DefaultArg<T> >::parse(DefaultArg<T>(), str, *s, *this) : (*s = static_value, true)), slot_status);
            assert(*s == static_value);
        }
        return *this;
    }
 
    template <typename T, typename V>
    Args &validate_p(const char *keyword, T &x, const V &static_value) {
        return validate_f(keyword, x, positional, static_value);
    }
 
    template <typename T, typename V>
    Args &validate_mp(const char *keyword, T &x, const V &static_value) {
        return validate_f(keyword, x, positional | mandatory, static_value);
    }
 
    template <typename T>
    Args &validate_p(const char *keyword, T &x, const char *static_value) {
        DefaultArg<T> p = DefaultArg<T>();
        T v;
        p.parse(static_value, v);
        return validate_f(keyword, x, positional, v);
    }
 
    template <typename T>
    Args &validate_mp(const char *keyword, T &x, const char *static_value) {
        DefaultArg<T> p = DefaultArg<T>();
        T v;
        p.parse(static_value, v);
        return validate_f(keyword, x, positional | mandatory, v);
    }
 
 
    template <typename P, typename T>
    Args &read(const char *keyword, P parser, T &x) {
        return read(keyword, 0, parser, x);
    }
    template <typename P, typename T>
    Args &read_m(const char *keyword, P parser, T &x) {
        return read(keyword, mandatory, parser, x);
    }
    template <typename P, typename T>
    Args &read_p(const char *keyword, P parser, T &x) {
        return read(keyword, positional, parser, x);
    }
    template <typename P, typename T>
    Args &read_mp(const char *keyword, P parser, T &x) {
        return read(keyword, mandatory | positional, parser, x);
    }
    template <typename P, typename T>
    Args &read(const char *keyword, int flags, P parser, T &x) {
        args_base_read(this, keyword, flags, parser, x);
        return *this;
    }
 
    template <typename P, typename T, typename V>
    Args &read_or_set(const char *keyword, P parser, T &x, const V &default_value) {
        return read_or_set(keyword, 0, parser, x, default_value);
    }
    template <typename P, typename T, typename V>
    Args &read_or_set_p(const char *keyword, P parser, T &x, const V &default_value) {
        return read_or_set(keyword, positional, parser, x, default_value);
    }
    template <typename P, typename T, typename V>
    Args &read_or_set(const char *keyword, int flags, P parser, T &x, const V &default_value) {
        args_base_read_or_set(this, keyword, flags, parser, x, default_value);
        return *this;
    }
 
    template<typename P, typename T1, typename T2>
    Args &read(const char *keyword, P parser, T1 &x1, T2 &x2) {
        return read(keyword, 0, parser, x1, x2);
    }
    template<typename P, typename T1, typename T2>
    Args &read_m(const char *keyword, P parser, T1 &x1, T2 &x2) {
        return read(keyword, mandatory, parser, x1, x2);
    }
    template<typename P, typename T1, typename T2>
    Args &read_p(const char *keyword, P parser, T1 &x1, T2 &x2) {
        return read(keyword, positional, parser, x1, x2);
    }
    template<typename P, typename T1, typename T2>
    Args &read_mp(const char *keyword, P parser, T1 &x1, T2 &x2) {
        return read(keyword, mandatory | positional, parser, x1, x2);
    }
    template<typename P, typename T1, typename T2>
    Args &read(const char *keyword, int flags, P parser, T1 &x1, T2 &x2) {
        args_base_read(this, keyword, flags, parser, x1, x2);
        return *this;
    }
 
    template <typename P>
    Args &read_with(const char *keyword, P parser) {
        return read_with(keyword, 0, parser);
    }
    template <typename P>
    Args &read_m_with(const char *keyword, P parser) {
        return read_with(keyword, mandatory, parser);
    }
    template <typename P>
    Args &read_p_with(const char *keyword, P parser) {
        return read_with(keyword, positional, parser);
    }
    template <typename P>
    Args &read_mp_with(const char *keyword, P parser) {
        return read_with(keyword, mandatory | positional, parser);
    }
    template <typename P>
    Args &read_with(const char *keyword, int flags, P parser) {
        args_base_read_with(this, keyword, flags, parser);
        return *this;
    }
 
    template <typename P, typename T>
    Args &read_with(const char *keyword, P parser, T &x) {
        return read(keyword, parser, x);
    }
    template <typename P, typename T>
    Args &read_m_with(const char *keyword, P parser, T &x) {
        return read_m(keyword, parser, x);
    }
    template <typename P, typename T>
    Args &read_p_with(const char *keyword, P parser, T &x) {
        return read_p(keyword, parser, x);
    }
    template <typename P, typename T>
    Args &read_mp_with(const char *keyword, P parser, T &x) {
        return read_mp(keyword, parser, x);
    }
    template <typename P, typename T>
    Args &read_with(const char *keyword, int flags, P parser, T &x) {
        return read(keyword, flags, parser, x);
    }
 
    template <typename P>
    Args &read_all_with(const char *keyword, P parser) {
        return read_all_with(keyword, 0, parser);
    }
    template <typename P>
    Args &read_all_with(const char *keyword, int flags, P parser) {
        args_base_read_all_with(this, keyword, flags | firstmatch, parser);
        return *this;
    }
 
    template <typename P, typename T>
    Args &read_all_with(const char *keyword, P parser, T &x) {
        return read_all_with(keyword, 0, parser, x);
    }
    template <typename P, typename T>
    Args &read_all_with(const char *keyword, int flags, P parser, T &x) {
        args_base_read_all_with(this, keyword, flags | firstmatch, parser, x);
        return *this;
    }
 
    template <typename P, typename T>
    Args &read_all(const char *keyword, P parser, Vector<T> &x) {
        return read_all(keyword, 0, parser, x);
    }
    template <typename T>
    Args &read_all(const char *keyword, Vector<T> &x) {
        return read_all(keyword, 0, DefaultArg<T>(), x);
    }
    template <typename P, typename T>
    Args &read_all(const char *keyword, int flags, P parser, Vector<T> &x) {
        args_base_read_all(this, keyword, flags | firstmatch, parser, x);
        return *this;
    }
    template <typename P, typename T>
    Args &read_all(const char *keyword, int flags, Vector<T> &x) {
        return read_all(keyword, flags, DefaultArg<T>(), x);
    }
 
 
    bool status() const {
        return _status;
    }
    Args &status(bool &x) {
        x = _status;
        return *this;
    }
    const Args &status(bool &x) const {
        x = _status;
        return *this;
    }
 
    bool read_status() const {
        return _read_status;
    }
    Args &read_status(bool &x) {
        x = _read_status;
        return *this;
    }
    const Args &read_status(bool &x) const {
        x = _read_status;
        return *this;
    }
 
 
    Args &strip();
 
    int execute();
 
    int consume();
 
    int complete();
 
 
    template <typename T>
    T *slot(T &x) {
        if (has_trivial_copy<T>::value)
            return reinterpret_cast<T *>(simple_slot(&x, sizeof(T)));
        else
            return complex_slot(x);
    }
 
    template <typename T>
    T *initialized_slot(T &x) {
        T *s = slot(x);
        if (has_trivial_copy<T>::value)
            *s = T();
        return s;
    }
 
    template <typename T, typename V>
    Args &set(T &x, const V &value) {
        if (T *s = slot(x))
            *s = value;
        return *this;
    }
 
 
    template<typename T>
    void base_read(const char *keyword, int flags, T &variable) {
        Slot *slot_status;
        if (String str = find(keyword, flags, slot_status)) {
            T *s = Args_parse_helper<DefaultArg<T> >::slot(variable, *this);
            postparse(s && Args_parse_helper<DefaultArg<T> >::parse(DefaultArg<T>(), str, *s, *this), slot_status);
        }
    }
 
    template<typename T, typename V>
    void base_read_or_set(const char *keyword, int flags, T &variable, const V &value) {
        Slot *slot_status;
        String str = find(keyword, flags, slot_status);
        T *s = Args_parse_helper<DefaultArg<T> >::slot(variable, *this);
        postparse(s && (str ? Args_parse_helper<DefaultArg<T> >::parse(DefaultArg<T>(), str, *s, *this) : (*s = value, true)), slot_status);
    }
 
    template<typename P, typename T>
    void base_read(const char *keyword, int flags, P parser, T &variable) {
        Slot *slot_status;
        if (String str = find(keyword, flags, slot_status)) {
            T *s = Args_parse_helper<P>::slot(variable, *this);
            postparse(s && Args_parse_helper<P>::parse(parser, str, *s, *this), slot_status);
        }
    }
 
    template<typename T, typename P, typename V>
    void base_read_or_set(const char *keyword, int flags, P parser, T &variable, const V &value) {
        Slot *slot_status;
        String str = find(keyword, flags, slot_status);
        T *s = Args_parse_helper<P>::slot(variable, *this);
        postparse(s && (str ? Args_parse_helper<P>::parse(parser, str, *s, *this) : (*s = value, true)), slot_status);
    }
 
    template<typename P, typename T1, typename T2>
    void base_read(const char *keyword, int flags,
                   P parser, T1 &variable1, T2 &variable2) {
        Slot *slot_status;
        if (String str = find(keyword, flags, slot_status)) {
            T1 *s1 = Args_parse_helper<P>::slot(variable1, *this);
            T2 *s2 = Args_parse_helper<P>::slot(variable2, *this);
            postparse(s1 && s2 && Args_parse_helper<P>::parse(parser, str, *s1, *s2, *this), slot_status);
        }
    }
 
    template<typename P>
    void base_read_with(const char *keyword, int flags, P parser) {
        Slot *slot_status;
        if (String str = find(keyword, flags, slot_status))
            postparse(parser.parse(str, *this), slot_status);
    }
 
    template<typename P>
    void base_read_all_with(const char *keyword, int flags, P parser) {
        Slot *slot_status;
        int read_status = -1;
        while (String str = find(keyword, flags, slot_status)) {
            postparse(parser.parse(str, *this), slot_status);
            read_status = (read_status != 0) && _read_status;
            flags &= ~mandatory;
        }
        _read_status = (read_status == 1);
    }
 
    template<typename P, typename T>
    void base_read_all_with(const char *keyword, int flags, P parser, T &variable) {
        Slot *slot_status;
        int read_status = -1;
        T *s = Args_parse_helper<P>::initialized_slot(variable, *this);
        while (String str = find(keyword, flags, slot_status)) {
            postparse(s && Args_parse_helper<P>::parse(parser, str, *s, *this), slot_status);
            read_status = (read_status != 0) && _read_status;
            flags &= ~mandatory;
        }
        _read_status = (read_status == 1);
    }
 
    template<typename P, typename T>
    void base_read_all(const char *keyword, int flags, P parser, Vector<T> &variable) {
        Slot *slot_status;
        int read_status = -1;
        Vector<T> *s = slot(variable);
        while (String str = find(keyword, flags, slot_status)) {
            T sx = T();
            postparse(parser.parse(str, sx, *this), slot_status);
            if (_read_status)
                s->push_back(sx);
            read_status = (read_status != 0) && _read_status;
            flags &= ~mandatory;
        }
        _read_status = (read_status == 1);
    }
  private:
 
    struct Slot {
        Slot() {
        }
        virtual ~Slot() {
        }
        virtual void store() = 0;
        Slot *_next;
    };
 
    struct BytesSlot : public Slot {
        BytesSlot(void *ptr, size_t size)
            : _ptr(ptr), _slot(new char[size]), _size(size) {
        }
        ~BytesSlot() {
            delete[] _slot;
        }
        void store() {
            memcpy(_ptr, _slot, _size);
        }
        void *_ptr;
        char *_slot;
        size_t _size;
    };
 
    template<typename T>
    struct SlotT : public Slot {
        SlotT(T *ptr)
            : _ptr(ptr) {
        }
        void store() {
            assign_consume(*_ptr, _slot);
        }
        T *_ptr;
        T _slot;
    };
 
    enum {
#if SIZEOF_VOID_P == 4
        simple_slotbuf_size = 24
#else
        simple_slotbuf_size = 48
#endif
    };
 
#if !CLICK_DEBUG_ARGS_USAGE
    bool _my_conf;
#else
    bool _my_conf : 1;
    bool _consumed : 1;
#endif
    bool _status;
    uint8_t _simple_slotpos;
 
    Vector<String> *_conf;
    Vector<int> _kwpos;
 
    Slot *_slots;
    uint8_t _simple_slotbuf[simple_slotbuf_size];
 
    inline void initialize(const Vector<String> *conf);
    void reset_from(int i);
 
    String find(const char *keyword, int flags, Slot *&slot_status);
    void postparse(bool ok, Slot *slot_status);
    void check_complete();
 
    static inline int simple_slot_size(int size);
    inline void simple_slot_info(int offset, int size,
                                 void *&slot, void **&pointer);
    void *simple_slot(void *data, size_t size);
    template<typename T> T *complex_slot(T &variable);
 
};
 
extern const ArgContext blank_args;
 
 
template<typename T>
struct DefaultArg {
};
 
template<typename T>
T *Args::complex_slot(T &variable)
{
    if (SlotT<T> *s = new SlotT<T>(&variable)) {
        s->_next = _slots;
        _slots = s;
        return &s->_slot;
    } else {
        error("out of memory");
        return 0;
    }
}
 
 
/* These functions are here because some GCC versions ignore noinline
   attributes on member function templates. */
template<typename T>
void args_base_read(Args *args, const char *keyword, int flags, T &variable)
    CLICK_NOINLINE;
template<typename T>
void args_base_read(Args *args, const char *keyword, int flags, T &variable)
{
    args->base_read(keyword, flags, variable);
}
 
template<typename T, typename V>
void args_base_read_or_set(Args *args, const char *keyword, int flags,
                           T &variable, const V &value) CLICK_NOINLINE;
template<typename T, typename V>
void args_base_read_or_set(Args *args, const char *keyword, int flags,
                           T &variable, const V &value)
{
    args->base_read_or_set(keyword, flags, variable, value);
}
 
template<typename P, typename T>
void args_base_read(Args *args, const char *keyword, int flags,
                    P parser, T &variable) CLICK_NOINLINE;
template<typename P, typename T>
void args_base_read(Args *args, const char *keyword, int flags,
                    P parser, T &variable)
{
    args->base_read(keyword, flags, parser, variable);
}
 
template<typename P, typename T, typename V>
void args_base_read_or_set(Args *args, const char *keyword, int flags,
                           P parser, T &variable, const V &value) CLICK_NOINLINE;
template<typename P, typename T, typename V>
void args_base_read_or_set(Args *args, const char *keyword, int flags,
                           P parser, T &variable, const V &value)
{
    args->base_read_or_set(keyword, flags, parser, variable, value);
}
 
template<typename P, typename T1, typename T2>
void args_base_read(Args *args, const char *keyword, int flags,
                    P parser, T1 &variable1, T2 &variable2) CLICK_NOINLINE;
template<typename P, typename T1, typename T2>
void args_base_read(Args *args, const char *keyword, int flags,
                    P parser, T1 &variable1, T2 &variable2)
{
    args->base_read(keyword, flags, parser, variable1, variable2);
}
 
template<typename P>
void args_base_read_with(Args *args, const char *keyword, int flags, P parser)
    CLICK_NOINLINE;
template<typename P>
void args_base_read_with(Args *args, const char *keyword, int flags, P parser)
{
    args->base_read_with(keyword, flags, parser);
}
 
template<typename P>
void args_base_read_all_with(Args *args, const char *keyword, int flags, P parser)
    CLICK_NOINLINE;
template<typename P>
void args_base_read_all_with(Args *args, const char *keyword, int flags, P parser)
{
    args->base_read_all_with(keyword, flags, parser);
}
 
template<typename P, typename T>
void args_base_read_all_with(Args *args, const char *keyword, int flags,
                             P parser, T &variable) CLICK_NOINLINE;
template<typename P, typename T>
void args_base_read_all_with(Args *args, const char *keyword, int flags,
                             P parser, T &variable)
{
    args->base_read_all_with(keyword, flags, parser, variable);
}
 
template <typename P, typename T>
void args_base_read_all(Args *args, const char *keyword, int flags,
                        P parser, Vector<T> &variable) CLICK_NOINLINE;
template <typename P, typename T>
void args_base_read_all(Args *args, const char *keyword, int flags,
                        P parser, Vector<T> &variable)
{
    args->base_read_all(keyword, flags, parser, variable);
}
class NumArg { public:
    enum {
        status_ok = 0,
        status_inval = EINVAL,
        status_range = ERANGE,
#if defined(ENOTSUP)
        status_notsup = ENOTSUP,
#elif defined(ENOTSUPP)
        status_notsup = ENOTSUPP,
#else
        status_notsup,
#endif
        status_unitless
    };
};
 
 
class IntArg : public NumArg { public:
 
    typedef uint32_t limb_type;
 
    IntArg(int b = 0)
        : base(b) {
    }
 
    const char *parse(const char *begin, const char *end,
                      bool is_signed, int size,
                      limb_type *value, int nlimb);
 
    template<typename V>
    bool parse_saturating(const String &str, V &result, const ArgContext &args = blank_args) {
        constexpr bool is_signed = integer_traits<V>::is_signed;
        constexpr int nlimb = int((sizeof(V) + sizeof(limb_type) - 1) / sizeof(limb_type));
        limb_type x[nlimb];
        if (parse(str.begin(), str.end(), is_signed, int(sizeof(V)), x, nlimb)
            != str.end())
            status = status_inval;
        if (status && status != status_range) {
            args.error("invalid number");
            return false;
        }
        typedef typename make_unsigned<V>::type unsigned_v_type;
        extract_integer(x, reinterpret_cast<unsigned_v_type &>(result));
        return true;
    }
 
    template<typename V>
    String unparse(const V &v) {
        return String(v);
    }
    template<typename V>
    bool parse(const String &str, V &result, const ArgContext &args = blank_args) {
        V x;
        if (!parse_saturating(str, x, args)
            || (status && status != status_range))
            return false;
        else if (status == status_range) {
            range_error(args, integer_traits<V>::is_signed,
                        click_int_large_t(x));
            return false;
        } else {
            result = x;
            return true;
        }
    }
 
    int base;
    int status;
 
  protected:
 
    static const char *span(const char *begin, const char *end,
                            bool is_signed, int &b);
    void range_error(const ArgContext &args, bool is_signed,
                     click_int_large_t value);
 
};
 
class SaturatingIntArg : public IntArg { public:
    SaturatingIntArg(int b = 0)
        : IntArg(b) {
    }
 
    template<typename V>
    bool parse(const String &str, V &result, const ArgContext &args = blank_args) {
        return parse_saturating(str, result, args);
    }
};
 
class BoundedIntArg : public IntArg { public:
    template <typename T>
    BoundedIntArg(T min_value, T max_value, int b = 0)
        : IntArg(b), min_value(min_value), max_value(max_value) {
        static_assert(integer_traits<T>::is_integral, "BoundedIntArg argument must be integral");
        is_signed = integer_traits<T>::is_signed;
    }
 
    template <typename V>
    bool parse(const String &str, V &result, const ArgContext &args = blank_args) {
        V x;
        if (!IntArg::parse(str, x, args))
            return false;
        else if (!check_min(typename integer_traits<V>::max_type(x))) {
            range_error(args, is_signed, min_value);
            return false;
        } else if (!check_max(typename integer_traits<V>::max_type(x))) {
            range_error(args, is_signed, max_value);
            return false;
        } else {
            result = x;
            return true;
        }
    }
 
    inline bool check_min(click_int_large_t x) const {
        if (is_signed)
            return x >= min_value;
        else
            return x >= 0 && click_uint_large_t(x) >= click_uint_large_t(min_value);
    }
    inline bool check_min(click_uint_large_t x) const {
        if (is_signed)
            return min_value < 0 || x >= click_uint_large_t(min_value);
        else
            return click_uint_large_t(x) >= click_uint_large_t(min_value);
    }
    inline bool check_max(click_int_large_t x) const {
        if (is_signed)
            return x <= max_value;
        else
            return x >= 0 && click_uint_large_t(x) <= click_uint_large_t(max_value);
    }
    inline bool check_max(click_uint_large_t x) const {
        if (is_signed)
            return max_value >= 0 && x <= click_uint_large_t(max_value);
        else
            return click_uint_large_t(x) <= click_uint_large_t(max_value);
    }
 
    click_intmax_t min_value;
    click_intmax_t max_value;
    bool is_signed;
};
 
template<> struct DefaultArg<unsigned char> : public IntArg {};
template<> struct DefaultArg<signed char> : public IntArg {};
template<> struct DefaultArg<char> : public IntArg {};
template<> struct DefaultArg<unsigned short> : public IntArg {};
template<> struct DefaultArg<short> : public IntArg {};
template<> struct DefaultArg<unsigned int> : public IntArg {};
template<> struct DefaultArg<int> : public IntArg {};
template<> struct DefaultArg<unsigned long> : public IntArg {};
template<> struct DefaultArg<long> : public IntArg {};
#if HAVE_LONG_LONG
template<> struct DefaultArg<unsigned long long> : public IntArg {};
template<> struct DefaultArg<long long> : public IntArg {};
#endif
 
 
class FixedPointArg : public NumArg { public:
    explicit FixedPointArg(int b, int exponent = 0)
        : fraction_bits(b), exponent_delta(exponent) {
    }
    inline bool parse_saturating(const String &str, uint32_t &result, const ArgContext &args = blank_args);
    bool parse(const String &str, uint32_t &result, const ArgContext &args = blank_args);
    bool parse_saturating(const String &str, int32_t &result, const ArgContext &args = blank_args);
    bool parse(const String &str, int32_t &result, const ArgContext &args = blank_args);
    int fraction_bits;
    int exponent_delta;
    int status;
  private:
    bool underparse(const String &str, bool is_signed, uint32_t &result);
};
 
inline bool
FixedPointArg::parse_saturating(const String &str, uint32_t &result, const ArgContext &)
{
    return underparse(str, false, result);
}
 
class DecimalFixedPointArg : public NumArg { public:
    DecimalFixedPointArg(int d, int exponent = 0)
        : fraction_digits(d), exponent_delta(exponent) {
    }
    inline bool parse_saturating(const String &str, uint32_t &result, const ArgContext &args = blank_args);
    bool parse(const String &str, uint32_t &result, const ArgContext &args = blank_args);
    bool parse_saturating(const String &str, int32_t &result, const ArgContext &args = blank_args);
    bool parse(const String &str, int32_t &result, const ArgContext &args = blank_args);
    bool parse_saturating(const String &str, uint32_t &iresult, uint32_t &fresult, const ArgContext &args = blank_args);
    bool parse(const String &str, uint32_t &iresult, uint32_t &fresult, const ArgContext &args = blank_args);
    int fraction_digits;
    int exponent_delta;
    int status;
  private:
    bool underparse(const String &str, bool is_signed, uint32_t &result);
};
 
inline bool
DecimalFixedPointArg::parse_saturating(const String &str, uint32_t &result, const ArgContext &)
{
    return underparse(str, false, result);
}
 
 
#if HAVE_FLOAT_TYPES
class DoubleArg : public NumArg { public:
    DoubleArg() {
    }
    bool parse(const String &str, double &result, const ArgContext &args = blank_args);
    int status;
};
 
template<> struct DefaultArg<double> : public DoubleArg {};
#endif
 
 
class BoolArg { public:
    static bool parse(const String &str, bool &result, const ArgContext &args = blank_args);
    static String unparse(bool x) {
        return String(x);
    }
};
 
template<> struct DefaultArg<bool> : public BoolArg {};
 
 
class UnitArg { public:
    explicit UnitArg(const char *unit_def, const char *prefix_chars_def)
        : units_(reinterpret_cast<const unsigned char *>(unit_def)),
          prefix_chars_(reinterpret_cast<const unsigned char *>(prefix_chars_def)) {
    }
    const char *parse(const char *begin, const char *end, int &power, int &factor) const;
  private:
    const unsigned char *units_;
    const unsigned char *prefix_chars_;
    void check_units();
};
 
 
class BandwidthArg : public NumArg { public:
    bool parse(const String &str, uint64_t &result, const ArgContext & = blank_args);
    static String unparse(uint32_t x);
    int status;
};
 
 
class BitvectorArg { public:
    static bool parse(const String &str, Bitvector &result, const ArgContext & = blank_args) {
        if (!result.parse(str, 0, 64)) {
            blank_args.error("%s is not a bitvecotr",str.c_str());
            return false;
        }
        return true;
    }
};
 
template<> struct DefaultArg<Bitvector> : public BitvectorArg {};
 
 
 
#if !CLICK_TOOL
class AnnoArg { public:
    AnnoArg(int s)
        : size(s) {
    }
    bool parse(const String &str, int &result, const ArgContext &args = blank_args);
  private:
    int size;
};
#endif
 
 
class SecondsArg : public NumArg { public:
    SecondsArg(int d = 0)
        : fraction_digits(d) {
    }
    bool parse_saturating(const String &str, uint32_t &result, const ArgContext &args = blank_args);
    bool parse(const String &str, uint32_t &result, const ArgContext &args = blank_args);
#if HAVE_FLOAT_TYPES
    bool parse(const String &str, double &result, const ArgContext &args = blank_args);
#endif
    int fraction_digits;
    int status;
};
 
 
class AnyArg { public:
    static bool parse(const String &, const ArgContext & = blank_args) {
        return true;
    }
    static bool parse(const String &str, String &result, const ArgContext & = blank_args) {
        result = str;
        return true;
    }
    static bool parse(const String &str, Vector<String> &result, const ArgContext & = blank_args) {
        result.push_back(str);
        return true;
    }
};
 
 
bool cp_string(const String &str, String *result, String *rest);
 
class StringArg { public:
    static bool parse(const String &str, String &result, const ArgContext & = blank_args) {
        return cp_string(str, &result, 0);
    }
};
 
template<> struct DefaultArg<String> : public StringArg {};
 
 
bool cp_keyword(const String &str, String *result, String *rest);
 
class KeywordArg { public:
    static bool parse(const String &str, String &result, const ArgContext & = blank_args) {
        return cp_keyword(str, &result, 0);
    }
};
 
 
bool cp_word(const String &str, String *result, String *rest);
 
class WordArg { public:
    static bool parse(const String &str, String &result, const ArgContext & = blank_args) {
        return cp_word(str, &result, 0);
    }
};
 
 
#if CLICK_USERLEVEL || CLICK_TOOL
class FilenameArg { public:
    static bool parse(const String &str, String &result, const ArgContext &args = blank_args);
};
#endif
 
 
#if !CLICK_TOOL
class ElementArg { public:
    static bool parse(const String &str, Element *&result, const ArgContext &args);
};
 
template<> struct DefaultArg<Element *> : public ElementArg {};
 
class ElementCastArg { public:
    ElementCastArg(const char *t)
        : type(t) {
    }
    bool parse(const String &str, Element *&result, const ArgContext &args);
    template<typename T> bool parse(const String &str, T *&result, const ArgContext &args) {
        return parse(str, reinterpret_cast<Element *&>(result), args);
    }
    const char *type;
};
#endif
 
CLICK_ENDDECLS
#endif