673 lines
21 KiB
C++
673 lines
21 KiB
C++
// -*- 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 &);
|
|
int __map_element_name(const String &name, int new_eindex);
|
|
void assign_element_names();
|
|
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
|
|
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 find_connections_touching(int eindex, int port, bool isoutput) const;
|
|
inline conn_iterator find_connections_touching(const PortT &port, bool isoutput) const;
|
|
inline conn_iterator find_connections_touching(ElementT *e, bool isoutput) const;
|
|
inline conn_iterator find_connections_touching(ElementT *e, int port, bool isoutput) const;
|
|
|
|
inline conn_iterator find_connections_from(const PortT &port) const;
|
|
inline conn_iterator find_connections_from(ElementT *e) const;
|
|
inline conn_iterator find_connections_from(ElementT *e, int port) const;
|
|
inline conn_iterator find_connections_to(const PortT &port) const;
|
|
inline conn_iterator find_connections_to(ElementT *e) const;
|
|
inline conn_iterator find_connections_to(ElementT *e, int port) const;
|
|
|
|
bool has_connection(const PortT &from, const PortT &to) const;
|
|
|
|
void find_connections_touching(const PortT &port, bool isoutput, Vector<PortT> &v, bool clear = true) const;
|
|
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_to(const PortT &input, Vector<PortT> &v) const {
|
|
find_connections_touching(input, end_to, v);
|
|
}
|
|
|
|
void find_connection_vector_touching(const ElementT *e, bool isoutput, Vector<conn_iterator> &x) const;
|
|
inline void find_connection_vector_from(const ElementT *e, Vector<conn_iterator> &x) const {
|
|
find_connection_vector_touching(e, end_from, x);
|
|
}
|
|
inline void find_connection_vector_to(const ElementT *e, Vector<conn_iterator> &x) const {
|
|
find_connection_vector_touching(e, end_to, x);
|
|
}
|
|
|
|
void add_tunnel(const String &namein, const String &nameout, const LandmarkT &landmark, ErrorHandler *errh);
|
|
|
|
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());
|
|
conn_iterator erase(conn_iterator it);
|
|
void kill_bad_connections();
|
|
|
|
conn_iterator change_connection_to(conn_iterator it, PortT new_to);
|
|
conn_iterator change_connection_from(conn_iterator it, PortT new_from);
|
|
|
|
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 &type, const String &value);
|
|
void remove_requirement(const String &type, const String &value);
|
|
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();
|
|
|
|
void remove_compound_elements(ErrorHandler *, bool expand_vars);
|
|
void remove_tunnels(ErrorHandler *errh = 0);
|
|
void compact();
|
|
|
|
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;
|
|
|
|
inline bool defines(const String &name) const;
|
|
|
|
int nformals() const { return _formals.size(); }
|
|
inline bool add_formal(const String &name, const String &type);
|
|
const String &formal_name(int i) const { return _formals[i]; }
|
|
const String &formal_type(int i) const { return _formal_types[i]; }
|
|
|
|
const VariableEnvironment &scope() const { return _scope; }
|
|
inline bool define(const String &name, const String &value);
|
|
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 check_pseudoelement(const ElementT *e, bool isoutput, const char *name, ErrorHandler *errh) const;
|
|
int finish_type(ErrorHandler *errh);
|
|
|
|
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 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 &);
|
|
};
|
|
|
|
enum { end_all = 2 };
|
|
|
|
struct ConnectionX : public ConnectionT {
|
|
ConnectionX **_pprev;
|
|
ConnectionX *_next[3];
|
|
ConnectionX(const PortT &from, const PortT &to,
|
|
const LandmarkT &landmark)
|
|
: ConnectionT(from, to, landmark) {
|
|
}
|
|
ConnectionX *next_from() const {
|
|
return _next[end_from];
|
|
}
|
|
ConnectionX *next_to() const {
|
|
return _next[end_to];
|
|
}
|
|
};
|
|
|
|
struct ConnectionSet {
|
|
ConnectionSet *next;
|
|
ConnectionX c[1];
|
|
};
|
|
|
|
struct Pair {
|
|
ConnectionX *end[2];
|
|
Pair() { end[0] = end[1] = 0; }
|
|
Pair(ConnectionX *from, ConnectionX *to) { end[end_from] = from; end[end_to] = to; }
|
|
ConnectionX *&operator[](int i) { assert(i >= 0 && i <= 1); return end[i]; }
|
|
ConnectionX *operator[](int i) const { assert(i >= 0 && i <= 1); return end[i]; }
|
|
};
|
|
|
|
StringMap _element_name_map;
|
|
Vector<ElementT *> _elements;
|
|
ElementT *_free_element;
|
|
int _n_live_elements;
|
|
Vector<int> *_new_eindex_collector;
|
|
|
|
ConnectionSet *_connsets;
|
|
int _nconnx;
|
|
Vector<Pair> _first_conn;
|
|
ConnectionX *_conn_head;
|
|
ConnectionX **_conn_tail;
|
|
ConnectionX *_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;
|
|
Vector<String> _formals;
|
|
Vector<String> _formal_types;
|
|
int _ninputs;
|
|
int _noutputs;
|
|
bool _scope_order_error;
|
|
bool _circularity_flag;
|
|
bool _potential_duplicate_connections;
|
|
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(ConnectionX *c);
|
|
void unlink_connection_from(ConnectionX *c);
|
|
void unlink_connection_to(ConnectionX *c);
|
|
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:
|
|
typedef int (const_iterator::*unspecified_bool_type)() const;
|
|
operator unspecified_bool_type() const { return _e ? &const_iterator::eindex : 0; }
|
|
int eindex() const { return _e->eindex(); }
|
|
void operator++() { if (_e) step(_e->router(), eindex()+1);}
|
|
void operator++(int) { ++(*this); }
|
|
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:
|
|
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:
|
|
typedef int (const_type_iterator::*unspecified_bool_type)() const;
|
|
operator unspecified_bool_type() const { return _e ? &const_type_iterator::eindex : 0; }
|
|
int eindex() const { return _e->eindex(); }
|
|
inline void operator++();
|
|
inline void operator++(int);
|
|
const ElementT *operator->() const { return _e; }
|
|
const ElementT *get() const { return _e; }
|
|
const ElementT &operator*() const { return *_e; }
|
|
private:
|
|
const ElementT *_e;
|
|
ElementClassT *_t;
|
|
const_type_iterator() : _e(0), _t(0) { }
|
|
const_type_iterator(const RouterT *r, ElementClassT *t, int i) : _t(t) { step(r, i); }
|
|
void step(const RouterT *, int);
|
|
friend class RouterT;
|
|
friend class RouterT::type_iterator;
|
|
};
|
|
|
|
class RouterT::type_iterator : public RouterT::const_type_iterator { public:
|
|
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:
|
|
type_iterator() : const_type_iterator() { }
|
|
type_iterator(RouterT *r, ElementClassT *t, int ei) : const_type_iterator(r, t, ei) { }
|
|
friend class RouterT;
|
|
};
|
|
|
|
class RouterT::conn_iterator { public:
|
|
inline conn_iterator() : _conn(0), _by(0) { }
|
|
typedef bool (conn_iterator::*unspecified_bool_type)() const;
|
|
operator unspecified_bool_type() const { return _conn ? &conn_iterator::empty : 0; }
|
|
inline bool empty() const { return !_conn; }
|
|
inline bool is_back() const;
|
|
inline conn_iterator &operator++();
|
|
inline void operator++(int);
|
|
const ConnectionT *operator->() const { return _conn; }
|
|
const ConnectionT *get() const { return _conn; }
|
|
const ConnectionT &operator*() const { return *_conn; }
|
|
private:
|
|
const ConnectionX *_conn;
|
|
int _by;
|
|
inline conn_iterator(const ConnectionX *conn, int by);
|
|
void assign(const ConnectionX *conn, int by) {
|
|
_conn = conn;
|
|
_by = by;
|
|
}
|
|
void complex_step();
|
|
friend class RouterT;
|
|
};
|
|
|
|
|
|
inline RouterT::iterator
|
|
RouterT::begin_elements()
|
|
{
|
|
return iterator(this, 0);
|
|
}
|
|
|
|
inline RouterT::const_iterator
|
|
RouterT::begin_elements() const
|
|
{
|
|
return const_iterator(this, 0);
|
|
}
|
|
|
|
inline RouterT::type_iterator
|
|
RouterT::begin_elements(ElementClassT *t)
|
|
{
|
|
return type_iterator(this, t, 0);
|
|
}
|
|
|
|
inline RouterT::const_type_iterator
|
|
RouterT::begin_elements(ElementClassT *t) const
|
|
{
|
|
return const_type_iterator(this, t, 0);
|
|
}
|
|
|
|
inline RouterT::const_iterator
|
|
RouterT::end_elements() const
|
|
{
|
|
return const_iterator();
|
|
}
|
|
|
|
inline RouterT::iterator
|
|
RouterT::end_elements()
|
|
{
|
|
return iterator();
|
|
}
|
|
|
|
inline void
|
|
RouterT::const_type_iterator::operator++()
|
|
{
|
|
if (_e)
|
|
step(_e->router(), _e->eindex() + 1);
|
|
}
|
|
|
|
inline void
|
|
RouterT::const_type_iterator::operator++(int)
|
|
{
|
|
++(*this);
|
|
}
|
|
|
|
inline
|
|
RouterT::conn_iterator::conn_iterator(const ConnectionX *conn, int by)
|
|
: _conn(conn), _by(by)
|
|
{
|
|
}
|
|
|
|
inline RouterT::conn_iterator
|
|
RouterT::begin_connections() const
|
|
{
|
|
return conn_iterator(_conn_head, end_all);
|
|
}
|
|
|
|
inline RouterT::conn_iterator
|
|
RouterT::end_connections() const
|
|
{
|
|
return conn_iterator();
|
|
}
|
|
|
|
inline RouterT::conn_iterator RouterT::find_connections_touching(const PortT &port, bool isoutput) const
|
|
{
|
|
assert(port.router() == this);
|
|
return find_connections_touching(port.eindex(), port.port, isoutput);
|
|
}
|
|
|
|
inline RouterT::conn_iterator RouterT::find_connections_touching(ElementT *e, bool isoutput) const
|
|
{
|
|
assert(e->router() == this);
|
|
return find_connections_touching(e->eindex(), -1, isoutput);
|
|
}
|
|
|
|
inline RouterT::conn_iterator RouterT::find_connections_touching(ElementT *e, int port, bool isoutput) const
|
|
{
|
|
assert(e->router() == this);
|
|
return find_connections_touching(e->eindex(), port, isoutput);
|
|
}
|
|
|
|
inline RouterT::conn_iterator RouterT::find_connections_from(const PortT &port) const
|
|
{
|
|
return find_connections_touching(port, end_from);
|
|
}
|
|
|
|
inline RouterT::conn_iterator RouterT::find_connections_from(ElementT *e) const
|
|
{
|
|
return find_connections_touching(e, end_from);
|
|
}
|
|
|
|
inline RouterT::conn_iterator RouterT::find_connections_from(ElementT *e, int port) const
|
|
{
|
|
return find_connections_touching(e, port, end_from);
|
|
}
|
|
|
|
inline RouterT::conn_iterator RouterT::find_connections_to(const PortT &port) const
|
|
{
|
|
return find_connections_touching(port, end_to);
|
|
}
|
|
|
|
inline RouterT::conn_iterator RouterT::find_connections_to(ElementT *e) const
|
|
{
|
|
return find_connections_touching(e, end_to);
|
|
}
|
|
|
|
inline RouterT::conn_iterator RouterT::find_connections_to(ElementT *e, int port) const
|
|
{
|
|
return find_connections_touching(e, port, end_to);
|
|
}
|
|
|
|
inline RouterT::conn_iterator &
|
|
RouterT::conn_iterator::operator++()
|
|
{
|
|
if (_conn && unsigned(_by) <= end_all)
|
|
_conn = _conn->_next[_by];
|
|
else
|
|
complex_step();
|
|
return *this;
|
|
}
|
|
|
|
inline void
|
|
RouterT::conn_iterator::operator++(int)
|
|
{
|
|
++(*this);
|
|
}
|
|
|
|
inline bool
|
|
RouterT::conn_iterator::is_back() const
|
|
{
|
|
conn_iterator x(*this);
|
|
return x && !++x;
|
|
}
|
|
|
|
inline const ElementT *
|
|
RouterT::element(const String &s) const
|
|
{
|
|
int i = _element_name_map[s];
|
|
return (i >= 0 ? _elements[i] : 0);
|
|
}
|
|
|
|
inline ElementT *
|
|
RouterT::element(const String &s)
|
|
{
|
|
int i = _element_name_map.get(s);
|
|
return (i >= 0 ? _elements[i] : 0);
|
|
}
|
|
|
|
inline String
|
|
RouterT::ename(int e) const
|
|
{
|
|
return _elements[e]->name();
|
|
}
|
|
|
|
inline ElementClassT *
|
|
RouterT::etype(int e) const
|
|
{
|
|
return _elements[e]->type();
|
|
}
|
|
|
|
inline String
|
|
RouterT::etype_name(int e) const
|
|
{
|
|
return _elements[e]->type()->name();
|
|
}
|
|
|
|
inline ElementClassT *
|
|
RouterT::declared_type(const String &name) const
|
|
{
|
|
return declared_type(name, 0x7FFFFFFF);
|
|
}
|
|
|
|
inline bool
|
|
RouterT::add_connection(ElementT *from_elt, int from_port, ElementT *to_elt,
|
|
int to_port, const LandmarkT &landmark)
|
|
{
|
|
return add_connection(PortT(from_elt, from_port), PortT(to_elt, to_port), landmark);
|
|
}
|
|
|
|
inline bool
|
|
RouterT::insert_before(ElementT *e, const PortT &h)
|
|
{
|
|
return insert_before(PortT(e, 0), h);
|
|
}
|
|
|
|
inline bool
|
|
RouterT::insert_after(ElementT *e, const PortT &h)
|
|
{
|
|
return insert_after(PortT(e, 0), h);
|
|
}
|
|
|
|
inline bool
|
|
RouterT::defines(const String &name) const
|
|
{
|
|
for (const String *f = _formals.begin(); f != _formals.end(); ++f)
|
|
if (*f == name)
|
|
return true;
|
|
return _scope.defines(name);
|
|
}
|
|
|
|
inline bool
|
|
RouterT::add_formal(const String &name, const String &type)
|
|
{
|
|
if (defines(name))
|
|
return false;
|
|
_formals.push_back(name);
|
|
_formal_types.push_back(type);
|
|
return true;
|
|
}
|
|
|
|
inline bool
|
|
RouterT::define(const String &name, const String &value)
|
|
{
|
|
if (defines(name))
|
|
return false;
|
|
return _scope.define(name, value, false);
|
|
}
|
|
|
|
inline void
|
|
RouterT::redefine(const VariableEnvironment &ve)
|
|
{
|
|
for (int i = 0; i < ve.size(); i++)
|
|
_scope.define(ve.name(i), ve.value(i), true);
|
|
}
|
|
|
|
inline ArchiveElement &
|
|
RouterT::archive(const String &name)
|
|
{
|
|
return _archive[_archive_map.get(name)];
|
|
}
|
|
|
|
inline const ArchiveElement &
|
|
RouterT::archive(const String &name) const
|
|
{
|
|
return _archive[_archive_map[name]];
|
|
}
|
|
|
|
inline bool
|
|
operator==(const RouterT::const_iterator &i, const RouterT::const_iterator &j)
|
|
{
|
|
return i.get() == j.get();
|
|
}
|
|
|
|
inline bool
|
|
operator!=(const RouterT::const_iterator &i, const RouterT::const_iterator &j)
|
|
{
|
|
return i.get() != j.get();
|
|
}
|
|
|
|
inline bool
|
|
operator==(const RouterT::const_type_iterator &i, const RouterT::const_type_iterator &j)
|
|
{
|
|
return i.get() == j.get();
|
|
}
|
|
|
|
inline bool
|
|
operator!=(const RouterT::const_type_iterator &i, const RouterT::const_type_iterator &j)
|
|
{
|
|
return i.get() != j.get();
|
|
}
|
|
|
|
inline bool
|
|
operator==(const RouterT::const_type_iterator &i, const RouterT::const_iterator &j)
|
|
{
|
|
return i.get() == j.get();
|
|
}
|
|
|
|
inline bool
|
|
operator!=(const RouterT::const_type_iterator &i, const RouterT::const_iterator &j)
|
|
{
|
|
return i.get() != j.get();
|
|
}
|
|
|
|
inline bool
|
|
operator==(const RouterT::conn_iterator &i, const RouterT::conn_iterator &j)
|
|
{
|
|
return i.get() == j.get();
|
|
}
|
|
|
|
inline bool
|
|
operator!=(const RouterT::conn_iterator &i, const RouterT::conn_iterator &j)
|
|
{
|
|
return i.get() != j.get();
|
|
}
|
|
|
|
inline RouterT::conn_iterator
|
|
operator+(RouterT::conn_iterator it, int x)
|
|
{
|
|
while (x-- > 0)
|
|
++it;
|
|
return it;
|
|
}
|
|
|
|
#endif
|