nameinfo.hh

Go to the documentation of this file.

// -*- c-basic-offset: 4; related-file-name: "../../lib/nameinfo.cc" -*-
#ifndef CLICK_NAMEINFO_HH
#define CLICK_NAMEINFO_HH
#include <click/args.hh>
#include <click/straccum.hh>
CLICK_DECLS
class Element;
class NameDB;
class ErrorHandler;
 
class NameInfo { public:
 
    NameInfo();
 
    ~NameInfo();
 
    static void static_initialize();
 
    static void static_cleanup();
 
    enum DBType {
        T_NONE = 0,                     
        T_SCHEDULEINFO = 0x00000001,    
        T_ANNOTATION = 0x00000002,      
        T_SCRIPT_INSN = 0x00000003,     
        T_SIGNO = 0x00000004,           
        T_SPINLOCK = 0x00000005,        
        T_ETHERNET_ADDR = 0x01000001,   
        T_IP_ADDR = 0x04000001,         
        T_IP_PREFIX = 0x04000002,       
        T_IP_PROTO = 0x04000003,        
        T_IPFILTER_TYPE = 0x04000004,   
        T_TCP_OPT = 0x04000005,         
        T_IPREWRITER_PATTERN = 0x04000006, 
        T_ICMP_TYPE = 0x04010000,       
        T_ICMP_CODE = 0x04010100,       
        T_IP_PORT = 0x04020000,         
        T_TCP_PORT = 0x04020006,        
        T_UDP_PORT = 0x04020011,        
        T_IP_FIELDNAME = 0x04030000,    
        T_ICMP_FIELDNAME = 0x04030001,  
        T_TCP_FIELDNAME = 0x04030006,   
        T_UDP_FIELDNAME = 0x04030011,   
        T_IP6_ADDR = 0x06000001,        
        T_IP6_PREFIX = 0x06000002       
    };
 
    static NameDB *getdb(uint32_t type, const Element *context,
                         size_t value_size, bool create);
 
    static void installdb(NameDB *db, const Element *context);
 
    static void uninstalldb(NameDB *db);
 
    static bool query(uint32_t type, const Element *context,
                      const String &name, void *value_store, size_t value_size);
 
    static bool query_int(uint32_t type, const Element *context,
                          const String &name, int32_t *value_store);
 
    static bool query_int(uint32_t type, const Element *context,
                          const String &name, uint32_t *value_store);
 
    static String revquery(uint32_t type, const Element *context,
                           const void *value, size_t value_size);
 
    static inline String revquery_int(uint32_t type, const Element *context,
                                      int32_t value);
 
    static inline bool define(uint32_t type, const Element *context,
                              const String &name, const void *value, size_t value_size);
 
    static inline bool define_int(uint32_t type, const Element *context,
                                  const String &name, int32_t value);
 
#if CLICK_NAMEDB_CHECK
    void check(ErrorHandler *);
    static void check(const Element *, ErrorHandler *);
#endif
 
  private:
 
    Vector<NameDB *> _namedb_roots;
    Vector<NameDB *> _namedbs;
 
    inline NameDB *install_dynamic_sentinel() { return (NameDB *) this; }
    NameDB *namedb(uint32_t type, size_t size, const String &prefix, NameDB *installer);
 
#if CLICK_NAMEDB_CHECK
    uintptr_t _check_generation;
    void checkdb(NameDB *db, NameDB *parent, ErrorHandler *errh);
#endif
 
};
 
class NameDB { public:
 
    inline NameDB(uint32_t type, const String &context, size_t value_size);
 
    virtual ~NameDB() {
        NameInfo::uninstalldb(this);
    }
 
    uint32_t type() const {
        return _type;
    }
 
    const String &context() const {
        return _context;
    }
 
    NameDB *context_parent() const {
        return _context_parent;
    }
 
    size_t value_size() const {
        return _value_size;
    }
 
    virtual bool query(const String &name, void *value, size_t value_size) = 0;
 
    virtual String revquery(const void *value, size_t value_size);
 
    virtual bool define(const String &name, const void *value, size_t value_size);
 
    inline bool define_int(const String &name, int32_t value);
 
#if CLICK_NAMEDB_CHECK
    virtual void check(ErrorHandler *);
#endif
 
  private:
 
    uint32_t _type;
    String _context;
    size_t _value_size;
    NameDB *_context_parent;
    NameDB *_context_sibling;
    NameDB *_context_child;
    NameInfo *_installed;
 
#if CLICK_NAMEDB_CHECK
    uintptr_t _check_generation;
#endif
 
    friend class NameInfo;
 
};
 
class StaticNameDB : public NameDB { public:
 
    struct Entry {
        const char *name;
        uint32_t value;
    };
 
    inline StaticNameDB(uint32_t type, const String &context,
                        const Entry *entry, size_t nentry);
 
    bool query(const String &name, void *value, size_t value_size);
 
    String revquery(const void *value, size_t value_size);
 
#if CLICK_NAMEDB_CHECK
    void check(ErrorHandler *);
#endif
 
  private:
 
    const Entry *_entries;
    size_t _nentries;
 
};
 
class DynamicNameDB : public NameDB { public:
 
    inline DynamicNameDB(uint32_t type, const String &context, size_t value_size);
 
    bool query(const String &name, void *value, size_t value_size);
 
    String revquery(const void *value, size_t value_size);
 
    bool define(const String &name, const void *value, size_t value_size);
 
#if CLICK_NAMEDB_CHECK
    void check(ErrorHandler *);
#endif
 
  private:
 
    Vector<String> _names;
    StringAccum _values;
    int _sorted;
 
    void *find(const String &name, bool create);
    void sort();
 
};
 
 
inline
NameDB::NameDB(uint32_t type, const String &context, size_t vsize)
    : _type(type), _context(context), _value_size(vsize),
      _context_parent(0), _context_sibling(0), _context_child(0), _installed(0)
{
#if CLICK_NAMEDB_CHECK
    _check_generation = 0;
#endif
    assert(_value_size > 0);
}
 
inline
StaticNameDB::StaticNameDB(uint32_t type, const String &context, const Entry *entry, size_t nentry)
    : NameDB(type, context, sizeof(entry->value)), _entries(entry), _nentries(nentry)
{
}
 
inline
DynamicNameDB::DynamicNameDB(uint32_t type, const String &context, size_t vsize)
    : NameDB(type, context, vsize), _sorted(0)
{
}
 
inline String
NameInfo::revquery_int(uint32_t type, const Element *e, int32_t value)
{
    return revquery(type, e, &value, sizeof(value));
}
 
inline bool
NameInfo::define(uint32_t type, const Element *e, const String &name, const void *value, size_t vsize)
{
    if (NameDB *db = getdb(type, e, vsize, true))
        return db->define(name, value, vsize);
    else
        return false;
}
 
inline bool
NameInfo::define_int(uint32_t type, const Element *e, const String &name, const int32_t value)
{
    if (NameDB *db = getdb(type, e, sizeof(value), true))
        return db->define(name, &value, sizeof(value));
    else
        return false;
}
 
inline bool
NameDB::define_int(const String &name, const int32_t value)
{
    return define(name, &value, sizeof(value));
}
 
 
struct NamedIntArg {
    NamedIntArg(uint32_t type)
        : _type(type) {
    }
    bool parse(const String &str, int &value, const ArgContext &args) {
        return NameInfo::query(_type, args.context(), str,
                               &value, sizeof(value))
            || IntArg().parse(str, value, args);
    }
    int _type;
};
 
CLICK_ENDDECLS
#endif