handlercall.hh

Go to the documentation of this file.

// -*- c-basic-offset: 4; related-file-name: "../../lib/handlercall.cc" -*-
#ifndef CLICK_HANDLERCALL_HH
#define CLICK_HANDLERCALL_HH
#include <click/router.hh>
CLICK_DECLS
class VariableExpander;
 
class HandlerCall { public:
 
    static String call_read(Element *e, const String &hname,
                            ErrorHandler *errh = 0);
    static String call_read(const String &hdesc, const Element *context,
                            ErrorHandler *errh = 0);
    static int call_write(Element *e, const String &hname,
                          ErrorHandler *errh = 0);
    static int call_write(Element *e, const String &hname, const String &value,
                          ErrorHandler *errh = 0);
    static int call_write(const String &hdesc,
                          const Element *context, ErrorHandler *errh = 0);
    static int call_write(const String &hdesc, const String &value,
                          const Element *context, ErrorHandler *errh = 0);
 
 
 
    HandlerCall()
        : _e(0), _h(Handler::blank_handler()) {
    }
 
    HandlerCall(const String &hdesc)
        : _e(reinterpret_cast<Element *>(4)), _h(Handler::blank_handler()),
          _value(hdesc) {
    }
 
 
    enum Flags {
        readable = Handler::f_read,
        f_read = Handler::f_read,
        writable = Handler::f_write,
        f_write = Handler::f_write,
        f_preinitialize = 4,
        f_unquote_param = 8
    };
 
    int initialize(int flags, const Element *context, ErrorHandler *errh = 0);
 
    inline int initialize_read(const Element *context, ErrorHandler *errh = 0);
 
    inline int initialize_write(const Element *context, ErrorHandler *errh = 0);
 
 
    typedef bool (HandlerCall::*unspecified_bool_type)() const;
 
    operator unspecified_bool_type() const {
        return _h != Handler::blank_handler() || _e ? &HandlerCall::empty : 0;
    }
 
    bool empty() const {
        return _h == Handler::blank_handler() && !_e;
    }
 
    bool initialized() const {
        return _h != Handler::blank_handler();
    }
 
 
    inline String call_read(ErrorHandler *errh = 0) const;
 
    inline int call_write(ErrorHandler *errh = 0) const;
 
    inline int call_write(const VariableExpander &scope, ErrorHandler *errh = 0) const;
 
    inline int call_write(const String &value_ext, ErrorHandler *errh = 0) const;
 
 
    static int reset(HandlerCall *&hcall, const String &hdesc, int flags,
                     const Element *context, ErrorHandler *errh = 0);
 
    static int reset(HandlerCall *&hcall,
                     Element *e, const String &hname, const String &value,
                     int flags, ErrorHandler *errh = 0);
 
 
    static inline int reset_read(HandlerCall *&hcall, const String &hdesc,
                                 const Element *context, ErrorHandler *errh = 0);
 
    static inline int reset_read(HandlerCall *&hcall,
                                 Element *e, const String &hname,
                                 ErrorHandler *errh = 0);
 
    static inline int reset_write(HandlerCall *&hcall, const String &hdesc,
                                  const Element *context, ErrorHandler *errh = 0);
 
    static inline int reset_write(HandlerCall *&hcall,
                                  Element *e, const String &hname,
                                  const String &value = String(),
                                  ErrorHandler *errh = 0);
 
 
    Element *element() const {
        return _e;
    }
 
    const Handler *handler() const {
        return _h;
    }
 
    const String &value() const {
        return initialized() ? _value : String::make_empty();
    }
 
    void set_value(const String &value) {
        if (initialized())
            _value = value;
    }
 
    String unparse() const;
 
    void clear() {
        _e = 0;
        _h = Handler::blank_handler();
        _value = String();
    }
 
 
    enum {
        CHECK_READ = f_read, OP_READ = f_read, h_read = f_read,
        CHECK_WRITE = f_write, OP_WRITE = f_write, h_write = f_write,
        PREINITIALIZE = f_preinitialize, h_preinitialize = f_preinitialize,
        UNQUOTE_PARAM = f_unquote_param, h_unquote_param = f_unquote_param
    };
  private:
 
    Element *_e;
    const Handler *_h;
    String _value;
 
    int parse(int flags, Element*, ErrorHandler*);
    int assign(Element*, const String&, const String&, int flags, ErrorHandler*);
 
};
 
inline int
HandlerCall::reset_read(HandlerCall*& hcall, const String& hdesc, const Element* context, ErrorHandler* errh)
{
    return reset(hcall, hdesc, f_read, context, errh);
}
 
inline int
HandlerCall::reset_write(HandlerCall*& hcall, const String& hdesc, const Element* context, ErrorHandler* errh)
{
    return reset(hcall, hdesc, f_write, context, errh);
}
 
inline int
HandlerCall::reset_read(HandlerCall*& hcall, Element* e, const String& hname, ErrorHandler* errh)
{
    return reset(hcall, e, hname, String(), f_read, errh);
}
 
inline int
HandlerCall::reset_write(HandlerCall*& hcall, Element* e, const String& hname, const String& value, ErrorHandler* errh)
{
    return reset(hcall, e, hname, value, f_write, errh);
}
 
inline int
HandlerCall::initialize_read(const Element* context, ErrorHandler* errh)
{
    return initialize(f_read, context, errh);
}
 
inline int
HandlerCall::initialize_write(const Element* context, ErrorHandler* errh)
{
    return initialize(f_write, context, errh);
}
 
inline String
HandlerCall::call_read(ErrorHandler *errh) const
{
    return _h->call_read(_e, _value, errh);
}
 
inline int
HandlerCall::call_write(ErrorHandler *errh) const
{
    return _h->call_write(_value, _e, errh);
}
 
String cp_expand(const String &str, const VariableExpander &env, bool expand_quote, int depth);
 
inline int
HandlerCall::call_write(const VariableExpander &scope, ErrorHandler *errh) const
{
    return _h->call_write(cp_expand(_value, scope, false, 0), _e, errh);
}
 
inline int
HandlerCall::call_write(const String &value_ext, ErrorHandler *errh) const
{
    if (_value && value_ext)
        return _h->call_write(_value + " " + value_ext, _e, errh);
    else
        return _h->call_write(_value ? _value : value_ext, _e, errh);
}
 
inline int
HandlerCall::call_write(Element *e, const String &hname, ErrorHandler *errh)
{
    return call_write(e, hname, String(), errh);
}
 
 
struct HandlerCallArg {
    HandlerCallArg(int f)
        : flags(f) {
    }
    bool parse(const String &str, HandlerCall &result, const ArgContext &args);
    int flags;
};
 
CLICK_ENDDECLS
#endif