routert.hh

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

    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:
    operator ElementT *() const		{ return const_cast<ElementT *>(_e); }
    ElementT *operator->() 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) { }
    inline void operator++();
    inline void operator++(int);
    operator const ConnectionT &() const	{ return *_conn; }
    const ConnectionT *operator->() const	{ return _conn; }
    const ConnectionT &operator*() const	{ return *_conn; }
  private:
    const ConnectionT *_conn;
    int _by;
    inline conn_iterator(const ConnectionT *conn, int by);
    void complex_step(const RouterT *);
    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 ConnectionT *conn, int by)
    : _conn(conn), _by(by)
{
    if (_conn && _conn->dead())
	(*this)++;
}

inline RouterT::conn_iterator
RouterT::begin_connections() const
{
    if (_conn.size())
	return conn_iterator(_conn.begin(), 0);
    else
	return conn_iterator();
}

inline RouterT::conn_iterator
RouterT::end_connections() const
{
    return conn_iterator();
}

inline RouterT::conn_iterator RouterT::begin_connections_touching(const PortT &port, bool isoutput) const
{
    assert(port.router() == this);
    return begin_connections_touching(port.eindex(), port.port, isoutput);
}

inline RouterT::conn_iterator RouterT::begin_connections_touching(ElementT *e, bool isoutput) const
{
    assert(e->router() == this);
    return begin_connections_touching(e->eindex(), -1, isoutput);
}

inline RouterT::conn_iterator RouterT::begin_connections_from(const PortT &port) const
{
    return begin_connections_touching(port, end_from);
}

inline RouterT::conn_iterator RouterT::begin_connections_from(ElementT *e) const
{
    return begin_connections_touching(e, end_from);
}

inline RouterT::conn_iterator RouterT::begin_connections_to(const PortT &port) const
{
    return begin_connections_touching(port, end_to);
}

inline RouterT::conn_iterator RouterT::begin_connections_to(ElementT *e) const
{
    return begin_connections_touching(e, end_to);
}

inline RouterT::conn_iterator
RouterT::find_connection(int c) const
{
    if (c < 0 || c >= _conn.size())
	return end_connections();
    else
	return conn_iterator(&_conn[c], 0);
}

inline void
RouterT::conn_iterator::operator++()
{
    if (_conn) {
	const RouterT *r = _conn->router();
      again:
	if (_by == 0)
	    ++_conn;
	else
	    complex_step(r);
	if (_conn == r->_conn.end())
	    _conn = 0;
	else if (_conn && !_conn->live())
	    goto again;
    }
}

inline void
RouterT::conn_iterator::operator++(int)
{
    ++(*this);
}

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::has_connection(const PortT &hfrom, const PortT &hto) const
{
    return find_connection(hfrom, hto) >= 0;
}

inline const PortT &
RouterT::find_connection_from(const PortT &h) const
{
    int c = find_connection_id_from(h);
    return (c >= 0 ? _conn[c].to() : PortT::null_port);
}

inline const PortT &
RouterT::find_connection_to(const PortT &h) const
{
    int c = find_connection_id_to(h);
    return (c >= 0 ? _conn[c].from() : PortT::null_port);
}

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::define(const String &name, const String &value, bool isformal)
{
    assert(!isformal || _nformals == _scope.size());
    bool retval = _scope.define(name, value, false);
    if (isformal)
	_nformals = _scope.size();
    return retval;
}

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.operator->() == j.operator->();
}

inline bool
operator!=(const RouterT::const_iterator &i, const RouterT::const_iterator &j)
{
    return i.operator->() != j.operator->();
}

inline bool
operator==(const RouterT::const_type_iterator &i, const RouterT::const_type_iterator &j)
{
    return i.operator->() == j.operator->();
}

inline bool
operator!=(const RouterT::const_type_iterator &i, const RouterT::const_type_iterator &j)
{
    return i.operator->() != j.operator->();
}

inline bool
operator==(const RouterT::const_type_iterator &i, const RouterT::const_iterator &j)
{
    return i.operator->() == j.operator->();
}

inline bool
operator!=(const RouterT::const_type_iterator &i, const RouterT::const_iterator &j)
{
    return i.operator->() != j.operator->();
}

inline bool
operator==(const RouterT::conn_iterator &i, const RouterT::conn_iterator &j)
{
    return i.operator->() == j.operator->();
}

inline bool
operator!=(const RouterT::conn_iterator &i, const RouterT::conn_iterator &j)
{
    return i.operator->() != j.operator->();
}

#endif