routert.hh

Click is a modular router toolkit. To use it you ll need to know how to compile and install the sof

// -*- c-basic-offset: 4 -*-
#ifndef CLICK_ROUTERT_HH
#define CLICK_ROUTERT_HH
#include "elementt.hh"
#include "eclasst.hh"
#include <click/error.hh>
#include <click/hashtable.hh>
#include <click/archive.hh>
#include <click/variableenv.hh>
typedef HashTable<String, int> StringMap;

class RouterT : public ElementClassT { public:

    RouterT();
    RouterT(const String &name, const LandmarkT &landmark, RouterT *declaration_scope = 0);
    virtual ~RouterT();

    // ELEMENTS
    int nelements() const		{ return _elements.size(); }
    int n_live_elements() const		{ return _n_live_elements; }

    inline const ElementT *element(const String &) const;
    inline ElementT *element(const String &);
    int eindex(const String &name) const { return _element_name_map[name]; }

    const ElementT *element(int i) const{ return _elements[i]; }
    ElementT *element(int i)		{ return _elements[i]; }

    class iterator;
    class const_iterator;
    class type_iterator;
    class const_type_iterator;
    inline iterator begin_elements();
    inline const_iterator begin_elements() const;
    inline type_iterator begin_elements(ElementClassT *);
    inline const_type_iterator begin_elements(ElementClassT *) const;
    inline iterator end_elements();
    inline const_iterator end_elements() const;

    bool elive(int i) const		{ return _elements[i]->live(); }
    bool edead(int i) const		{ return _elements[i]->dead(); }
    inline String ename(int) const;
    inline ElementClassT *etype(int) const;
    inline String etype_name(int) const;

    ElementT *get_element(const String &name, ElementClassT *eclass, const String &configuration, const LandmarkT &landmark);
    ElementT *add_anon_element(ElementClassT *eclass, const String &configuration = String(), const LandmarkT &landmark = LandmarkT::empty_landmark());
    void change_ename(int, const String &);
    void deanonymize_elements();
    void free_element(ElementT *);
    void free_dead_elements();

    void set_new_eindex_collector(Vector<int> *v) { _new_eindex_collector=v; }

    // TYPES
    ElementClassT *locally_declared_type(const String &) const;
    inline ElementClassT *declared_type(const String &) const;
    void add_declared_type(ElementClassT *, bool anonymous);

    void collect_types(HashTable<ElementClassT *, int> &) const;
    void collect_locally_declared_types(Vector<ElementClassT *> &) const;
    void collect_overloads(Vector<ElementClassT *> &) const;

    // CONNECTIONS
    int nconnections() const			{ return _conn.size(); }
    const Vector<ConnectionT> &connections() const { return _conn; }
    const ConnectionT &connection(int cid) const {
	return _conn[cid];
    }
    bool connection_live(int cid) const {
	return _conn[cid].live();
    }

    enum { end_to = ConnectionT::end_to, end_from = ConnectionT::end_from };

    class conn_iterator;
    inline conn_iterator begin_connections() const;
    inline conn_iterator end_connections() const;
    conn_iterator begin_connections_touching(int eindex, int port, bool isoutput) const;
    inline conn_iterator begin_connections_touching(const PortT &port, bool isoutput) const;
    inline conn_iterator begin_connections_touching(ElementT *e, bool isoutput) const;

    inline conn_iterator begin_connections_from(const PortT &port) const;
    inline conn_iterator begin_connections_from(ElementT *e) const;
    inline conn_iterator begin_connections_to(const PortT &port) const;
    inline conn_iterator begin_connections_to(ElementT *e) const;
    inline conn_iterator find_connection(int ci) const;

    void add_tunnel(const String &namein, const String &nameout, const LandmarkT &, ErrorHandler *);

    bool add_connection(const PortT &, const PortT &, const LandmarkT &landmark = LandmarkT::empty_landmark());
    inline bool add_connection(ElementT *, int, ElementT *, int, const LandmarkT &landmark = LandmarkT::empty_landmark());
    void kill_connection(const conn_iterator &);
    void kill_bad_connections();
    void compact_connections();

    void change_connection_to(int, PortT);
    void change_connection_from(int, PortT);

    inline bool has_connection(const PortT &from, const PortT &to) const;
    int find_connection(const PortT &from, const PortT &to) const;
    void find_connections_touching(ElementT *e, bool isoutput, Vector<int> &v) const;

    /** @brief Return the ID of unique connection touching port @a port.
     * @a port port specification
     * @a isoutput true if @a port is an output port
     *
     * Returns -1 if there is no connection touching the port, or -2 if there
     * is more than one.
     * @sa connection() */
    int find_connection_id_touching(const PortT &port, bool isoutput) const;

    void find_connections_touching(const PortT &port, bool isoutput, Vector<PortT> &v, bool clear = true) const;
    void find_connections_touching(const PortT &port, bool isoutput, Vector<int> &v) const;
    void find_connection_vector_touching(ElementT *e, bool isoutput, Vector<int> &v) const;

    inline int find_connection_id_from(const PortT &output) const {
	return find_connection_id_touching(output, end_from);
    }
    inline const PortT &find_connection_from(const PortT &output) const;
    inline void find_connections_from(ElementT *e, Vector<int> &v) const {
	find_connections_touching(e, end_from, v);
    }
    inline void find_connections_from(const PortT &output, Vector<PortT> &v, bool clear = true) const {
	find_connections_touching(output, end_from, v, clear);
    }
    void find_connections_from(const PortT &output, Vector<int> &v) const {
	find_connections_touching(output, end_from, v);
    }
    void find_connection_vector_from(ElementT *e, Vector<int> &v) const {
	find_connection_vector_touching(e, end_from, v);
    }

    inline int find_connection_id_to(const PortT &input) const {
	return find_connection_id_touching(input, end_to);
    }
    inline const PortT &find_connection_to(const PortT &input) const;
    void find_connections_to(ElementT *e, Vector<int> &v) const {
	find_connections_touching(e, end_to, v);
    }
    void find_connections_to(const PortT &input, Vector<PortT> &v) const {
	find_connections_touching(input, end_to, v);
    }
    void find_connections_to(const PortT &input, Vector<int> &v) const {
	find_connections_touching(input, end_to, v);
    }
    void find_connection_vector_to(ElementT *e, Vector<int> &v) const {
	find_connection_vector_touching(e, end_to, v);
    }

    bool insert_before(const PortT &, const PortT &);
    bool insert_after(const PortT &, const PortT &);
    inline bool insert_before(ElementT *, const PortT &);
    inline bool insert_after(ElementT *, const PortT &);

    // REQUIREMENTS
    void add_requirement(const String &);
    void remove_requirement(const String &);
    const Vector<String> &requirements() const	{ return _requirements; }

    // ARCHIVE
    void add_archive(const ArchiveElement &);
    int narchive() const			{ return _archive.size(); }
    int archive_index(const String &s) const	{ return _archive_map[s]; }
    const Vector<ArchiveElement> &archive() const{ return _archive; }
    ArchiveElement &archive(int i)		{ return _archive[i]; }
    const ArchiveElement &archive(int i) const	{ return _archive[i]; }
    inline ArchiveElement &archive(const String &s);
    inline const ArchiveElement &archive(const String &s) const;

    void add_components_to(RouterT *, const String &prefix = String()) const;

    // CHECKING, FLATTENING AND EXPANDING
    void check() const;

    void remove_duplicate_connections();
    void remove_dead_elements(ErrorHandler * = 0);

    void remove_compound_elements(ErrorHandler *, bool expand_vars);
    void remove_tunnels(ErrorHandler * = 0);

    void expand_into(RouterT *dest, const String &prefix, VariableEnvironment &env, ErrorHandler *errh);
    void flatten(ErrorHandler *errh, bool expand_vars = false);

    // UNPARSING
    void unparse(StringAccum &, const String & = String()) const;
    void unparse_requirements(StringAccum &, const String & = String()) const;
    void unparse_defines(StringAccum &, const String & = String()) const;
    void unparse_declarations(StringAccum &, const String & = String()) const;
    void unparse_connections(StringAccum &, const String & = String()) const;
    String configuration_string() const;

    // COMPOUND ELEMENTS
    String landmark() const		{ return _type_landmark.str(); }
    String decorated_landmark() const	{ return _type_landmark.decorated_str(); }
    void set_landmarkt(const LandmarkT &l) { _type_landmark = l; }
    const ElementTraits *find_traits(ElementMap *emap) const;

    bool primitive() const		{ return false; }
    bool overloaded() const;

    int nformals() const		{ return _nformals; }
    const VariableEnvironment &scope() const { return _scope; }
    inline bool define(const String &name, const String &value, bool isformal);
    inline void redefine(const VariableEnvironment &);
    int ninputs() const			{ return _ninputs; }
    int noutputs() const		{ return _noutputs; }

    RouterT *declaration_scope() const	{ return _declaration_scope; }
    ElementClassT *overload_type() const { return _overload_type; }
    void set_overload_type(ElementClassT *);

    int finish_type(ErrorHandler *);

    bool need_resolve() const;
    ElementClassT *resolve(int, int, Vector<String> &, ErrorHandler *, const LandmarkT &landmark);
    void create_scope(const Vector<String> &args, const VariableEnvironment &env, VariableEnvironment &new_env);
    ElementT *complex_expand_element(ElementT *, const Vector<String> &, RouterT *, const String &prefix, const VariableEnvironment &, ErrorHandler *);

    String unparse_signature() const;
    void unparse_declaration(StringAccum &, const String &, UnparseKind, ElementClassT *);

    RouterT *cast_router()		{ return this; }

  private:

    struct Pair {
	int end[2];
	Pair() { end[0] = end[1] = -1; }
	Pair(int from, int to) { end[end_from] = from; end[end_to] = to; }
	int &operator[](int i) { assert(i >= 0 && i <= 1); return end[i]; }
	int operator[](int i) const { assert(i >= 0 && i <= 1); return end[i]; }
    };

    struct ElementType {
	ElementClassT * const type;
	int scope_cookie;
	int prev_name;
	ElementType(ElementClassT *c, int sc, int pn) : type(c), scope_cookie(sc), prev_name(pn) { assert(type); type->use(); }
	ElementType(const ElementType &o) : type(o.type), scope_cookie(o.scope_cookie), prev_name(o.prev_name) { type->use(); }
	~ElementType()			{ type->unuse(); }
	const String &name() const	{ return type->name(); }
      private:
	ElementType &operator=(const ElementType &);
    };

    StringMap _element_name_map;
    Vector<ElementT *> _elements;
    ElementT *_free_element;
    int _n_live_elements;
    Vector<int> *_new_eindex_collector;

    Vector<ConnectionT> _conn;
    Vector<Pair> _first_conn;
    int _free_conn;

    StringMap _declared_type_map;
    Vector<ElementType> _declared_types;

    Vector<String> _requirements;

    StringMap _archive_map;
    Vector<ArchiveElement> _archive;

    RouterT *_declaration_scope;
    int _declaration_scope_cookie;
    int _scope_cookie;

    VariableEnvironment _scope;
    int _nformals;
    int _ninputs;
    int _noutputs;
    bool _scope_order_error;
    bool _circularity_flag;
    ElementClassT *_overload_type;
    LandmarkT _type_landmark;
    mutable ElementTraits _traits;

    RouterT(const RouterT &);
    RouterT &operator=(const RouterT &);

    ElementClassT *declared_type(const String &, int scope_cookie) const;
    void update_noutputs(int);
    void update_ninputs(int);
    ElementT *add_element(const ElementT &);
    void assign_element_name(int);
    void free_connection(int ci);
    void unlink_connection_from(int ci);
    void unlink_connection_to(int ci);
    void expand_tunnel(Vector<PortT> *port_expansions, const Vector<PortT> &ports, bool is_output, int which, ErrorHandler *) const;
    int assign_arguments(const Vector<String> &, Vector<String> *) const;

    friend class RouterUnparserT;
    friend class conn_iterator;

};

class RouterT::const_iterator { public:
    operator bool() const		{ return _e; }
    int eindex() const			{ return _e->eindex(); }
    void operator++()			{ if (_e) step(_e->router(), eindex()+1);}
    void operator++(int)		{ ++(*this); }
    operator const ElementT *() const	{ return _e; }
    const ElementT *operator->() const	{ return _e; }
    const ElementT *get() const		{ return _e; }
    const ElementT &operator*() const	{ return *_e; }
  private:
    const ElementT *_e;
    const_iterator()			: _e(0) { }
    const_iterator(const RouterT *r, int ei) { step(r, ei); }
    void step(const RouterT *, int);
    friend class RouterT;
    friend class RouterT::iterator;
};

class RouterT::iterator : public RouterT::const_iterator { public:
    operator ElementT *() const		{ return const_cast<ElementT *>(_e); }
    ElementT *operator->() const	{ return const_cast<ElementT *>(_e); }
    ElementT *get() const		{ return const_cast<ElementT *>(_e); }
    ElementT &operator*() const		{ return const_cast<ElementT &>(*_e); }
  private:
    iterator()				: const_iterator() { }
    iterator(RouterT *r, int ei)	: const_iterator(r, ei) { }
    friend class RouterT;
};

class RouterT::const_type_iterator { public:
    operator bool() const		{ return _e; }
    int eindex() const			{ return _e->eindex(); }
    inline void operator++();
    inline void operator++(int);
    operator const ElementT *() const	{ return _e; }