handler.hh

Go to the documentation of this file.

#ifndef CLICK_HANDLER_HH
#define CLICK_HANDLER_HH 1
#include <click/string.hh>
CLICK_DECLS
class Element;
class ErrorHandler;
class Handler;
 
typedef int (*HandlerCallback)(int operation, String &data, Element *element,
                               const Handler *handler, ErrorHandler *errh);
typedef String (*ReadHandlerCallback)(Element *handler, void *user_data);
typedef int (*WriteHandlerCallback)(const String &data, Element *element,
                                    void *user_data, ErrorHandler *errh);
 
class Handler { public:
 
    enum Flags {
        f_read = 0x0001,        
        f_write = 0x0002,       
        f_read_param = 0x0004,  
        f_exclusive = 0,        
        f_nonexclusive = 0x0020,
        f_raw = 0x0040,         
        f_read_private = 0x0080,
        f_write_private = 0x0100,
        f_deprecated = 0x0200,  
        f_uncommon = 0x0400,    
        f_calm = 0x0800,        
        f_expensive = 0x1000,   
        f_button = 0x2000,      
        f_checkbox = 0x4000,    
        f_driver0 = 1U << 26,
        f_driver1 = 1U << 27,   
        f_user_shift = 28,
        f_user0 = 1U << f_user_shift,
 
        f_read_comprehensive = 0x0008,
        f_write_comprehensive = 0x0010,
        f_special = f_read | f_write | f_read_param | f_read_comprehensive | f_write_comprehensive
    };
 
    inline const String &name() const {
        return _name;
    }
 
    inline uint32_t flags() const {
        return _flags;
    }
 
    inline void *user_data(int op) const {
        return op == f_write ? _write_user_data : _read_user_data;
    }
 
    inline void *read_user_data() const {
        return _read_user_data;
    }
 
    inline void *write_user_data() const {
        return _write_user_data;
    }
 
    inline void *user_data1() const CLICK_DEPRECATED;
    inline void *user_data2() const CLICK_DEPRECATED;
    inline bool readable() const {
        return _flags & f_read;
    }
 
    inline bool read_param() const {
        return _flags & f_read_param;
    }
 
    inline bool read_visible() const {
        return (_flags & (f_read | f_read_private)) == f_read;
    }
 
    inline bool writable() const {
        return _flags & f_write;
    }
 
    inline bool write_visible() const {
        return (_flags & (f_write | f_write_private)) == f_write;
    }
 
    inline bool visible() const {
        return read_visible() || write_visible();
    }
 
    inline bool allow_concurrent_handlers() const {
        return (_flags & f_nonexclusive);
    }
 
    inline bool allow_concurrent_threads() const {
        return (_flags & f_nonexclusive);
    }
 
    inline bool raw() const {
        return _flags & f_raw;
    }
 
 
    String call_read(Element *e, const String &param, ErrorHandler *errh) const;
 
    inline String call_read(Element *e, ErrorHandler *errh = 0) const {
        return call_read(e, String(), errh);
    }
 
    int call_write(const String &value, Element *e, ErrorHandler *errh) const;
 
 
    String unparse_name(Element *e) const;
 
    static String unparse_name(Element *e, const String &hname);
 
 
    static inline const Handler *blank_handler() {
        return the_blank_handler;
    }
 
 
    enum {
        h_read = f_read,
        h_write = f_write,
        h_read_param = f_read_param,
        h_exclusive = f_exclusive,
        h_nonexclusive = f_nonexclusive,
        h_raw = f_raw,
        h_read_private = f_read_private,
        h_write_private = f_write_private,
        h_deprecated = f_deprecated,
        h_uncommon = f_uncommon,
        h_calm = f_calm,
        h_expensive = f_expensive,
        h_button = f_button,
        h_checkbox = f_checkbox,
        h_driver_flag_0 = f_driver0,
        h_driver_flag_1 = f_driver1,
        h_user_flag_shift = f_user_shift,
        h_user_flag_0 = f_user0,
        h_read_comprehensive = f_read_comprehensive,
        h_write_comprehensive = f_write_comprehensive,
        h_special_flags = f_special
    };
    enum DeprecatedFlags {
        OP_READ = f_read,
        OP_WRITE = f_write,
        READ_PARAM = f_read_param,
        RAW = f_raw,
        // READ_PRIVATE = f_read_private,
        // WRITE_PRIVATE = f_write_private,
        // DEPRECATED = f_deprecated,
        // UNCOMMON = f_uncommon,
        CALM = f_calm,
        EXPENSIVE = f_expensive,
        BUTTON = f_button,
        CHECKBOX = f_checkbox,
        USER_FLAG_SHIFT = f_user_shift,
        USER_FLAG_0 = f_user0
    };
    enum CLICK_DEPRECATED {
        EXCLUSIVE = f_exclusive,
        NONEXCLUSIVE = f_nonexclusive
    };
    inline String __call_read(Element *e, void *new_user_data) const {
        assert((_flags & (f_read | f_read_comprehensive)) == f_read);
        return _read_hook.r(e, new_user_data);
    }
  private:
 
    String _name;
    union {
        HandlerCallback h;
        ReadHandlerCallback r;
    } _read_hook;
    union {
        HandlerCallback h;
        WriteHandlerCallback w;
    } _write_hook;
    void *_read_user_data;
    void *_write_user_data;
    uint32_t _flags;
    int _use_count;
    int _next_by_name;
 
    static const Handler *the_blank_handler;
 
    Handler(const String & = String());
 
    inline void combine(const Handler &x);
    inline bool compatible(const Handler &x) const;
 
    friend class Router;
 
};
 
/* The largest size a write handler is allowed to have. */
#define LARGEST_HANDLER_WRITE 65536
 
typedef HandlerCallback HandlerHook CLICK_DEPRECATED;
typedef ReadHandlerCallback ReadHandlerHook CLICK_DEPRECATED;
typedef WriteHandlerCallback WriteHandlerHook CLICK_DEPRECATED;
 
inline void *
Handler::user_data1() const
{
    return _read_user_data;
}
 
inline void *
Handler::user_data2() const
{
    return _write_user_data;
}
CLICK_ENDDECLS
#endif