libxorp Globals


Annotated List
Files
Globals
Hierarchy
Index

c_format.hh

debug.h

ether_compat.h

exceptions.hh

ipnet.hh

ipv4net.hh

ipv6net.hh

ipvx.hh

ipvxnet.hh

mac.hh

nexthop.hh

selector.hh

timer.hh

timeval.hh

token.hh

utils.hh

xorp.h

Global member Documentation

inline int  arg_count ()

arg_count

#include <c_format.hh>

template <class A> inline int  arg_count (A)

arg_count

#include <c_format.hh>

template <class A, class B> inline int  arg_count (A,B)

arg_count

#include <c_format.hh>

template <class A, class B, class C> inline int  arg_count (A,B,C)

arg_count

#include <c_format.hh>

template <class A, class B, class C, class D> inline int  arg_count (A,B,C,D)

arg_count

#include <c_format.hh>

template <class A, class B, class C, class D, class E> inline int  arg_count (A,B,C,D,E)

arg_count

#include <c_format.hh>

template <class A, class B, class C,class D, class E, class F> inline int  arg_count (A,B,C,D,E,F)

arg_count

#include <c_format.hh>

template <class A, class B, class C, class D, class E, class F, class G> inline int  arg_count (A,B,C,D,E,F,G)

arg_count

#include <c_format.hh>

template <class A, class B, class C, class D, class E, class F, class G, class H> inline int  arg_count (A,B,C,D,E,F,G,H)

arg_count

#include <c_format.hh>

template <class A, class B, class C, class D, class E, class F, class G, class H, class I> inline int  arg_count (A,B,C,D,E,F,G,H,I)

arg_count

#include <c_format.hh>

template <class A, class B, class C, class D, class E, class F, class G, class H, class I, class J> inline int  arg_count (A,B,C,D,E,F,G,H,I,J)

arg_count

#include <c_format.hh>

template <class A, class B, class C, class D, class E, class F, class G, class H, class I, class J, class K> inline int  arg_count (A,B,C,D,E,F,G,H,I,J,K)

arg_count

#include <c_format.hh>

template <class A, class B, class C, class D, class E, class F, class G, class H, class I, class J, class K, class L> inline int  arg_count (A,B,C,D,E,F,G,H,I,J,K,L)

arg_count

#include <c_format.hh>

template <class A, class B, class C, class D, class E, class F, class G, class H, class I, class J, class K, class L, class M> inline int  arg_count (A,B,C,D,E,F,G,H,I,J,K,L,M)

arg_count

#include <c_format.hh>

template <class A, class B, class C, class D, class E, class F, class G, class H, class I, class J, class K, class L, class M, class N> inline int  arg_count (A,B,C,D,E,F,G,H,I,J,K,L,M,N)

arg_count

#include <c_format.hh>

void  c_format_validate (const char* fmt, int n)

c_format_validate

#include <c_format.hh>

inline void  swallow_args (const char*)

swallow_args

#include <debug.h>

template <class A> inline void  swallow_args (const char*, A)

swallow_args

#include <debug.h>

template <class A, class B> inline void  swallow_args (const char*, A, B)

swallow_args

#include <debug.h>

template <class A, class B, class C> inline void  swallow_args (const char*, A, B, C)

swallow_args

#include <debug.h>

template <class A, class B, class C, class D> inline void  swallow_args (const char*, A, B, C, D)

swallow_args

#include <debug.h>

template <class A, class B, class C, class D, class E> inline void  swallow_args (const char*, A, B, C, D, E)

swallow_args

#include <debug.h>

template <class A, class B, class C, class D, class E, class F> inline void  swallow_args (const char*, A, B, C, D, E, F)

swallow_args

#include <debug.h>

template <class A, class B, class C, class D, class E, class F, class G> inline void  swallow_args (const char*, A, B, C, D, E, F, G)

swallow_args

#include <debug.h>

template <class A, class B, class C, class D, class E, class F, class G, class H> inline void  swallow_args (const char*, A, B, C, D, E, F, G, H)

swallow_args

#include <debug.h>

inline void  check_args (const char*, ...)

check_args

#include <debug.h>

struct ether_addr*  ether_aton (const char *a)

ether_aton

#include <ether_compat.h>

const char*  ether_ntoa (const struct ether_addr* ea)

ether_ntoa

#include <ether_compat.h>

void  xorp_catch_standard_exceptions ()

xorp_catch_standard_exceptions

#include <exceptions.hh>

Print diagnostic message if exception is derived from XorpException or from standard exceptions, and terminate the program.

void  xorp_print_standard_exceptions ()

xorp_print_standard_exceptions

#include <exceptions.hh>

Print diagnostic message if exception is derived from XorpException or from standard exceptions.

Note that unlike xorp_catch_standard_exceptions(), the program does NOT terminate.

void  xorp_unexpected_handler ()

xorp_unexpected_handler

#include <exceptions.hh>

Unexpected exceptions are programming errors and this handler can be installed with XorpUnexpectedHandler to print out as much information as possible. The default behaviour is just to dump core, but it very hard to detect what happened.

template <class A> size_t  overlap (const IPNet<A>& a1, const IPNet<A>& a2)

overlap

#include <ipnet.hh>

Determine the number of the most significant bits overlapping between two subnets.

Parameters:
a1the first subnet.
a2the subnet.

Returns: the number of bits overlapping between a1 and a2.

typedef IPNet<IPv4> IPv4Net

IPv4Net

#include <ipv4net.hh>

typedef IPNet<IPv6> IPv6Net

IPv6Net

#include <ipv6net.hh>

inline size_t  family2addr_size (const int family)

family2addr_size

#include <ipvx.hh>

inline size_t  family2addr_bitlen (const int family)

family2addr_bitlen

#include <ipvx.hh>

typedef IPNet<IPvX> BaseIPvXNet

BaseIPvXNet

#include <ipvxnet.hh>

Base IPvXNet just has IPNet methods. IPvXNet is derived from BaseIPvXNet and has IPvX specific functions such as whether contained type is an IPv4 network or an IPv6 network.

See IPNet for available methods.

inline bool  operator== (const Mac& m1, const Mac& m2)

operator==

#include <mac.hh>

typedef IPNextHop<IPv4> IPv4NextHop

IPv4NextHop

#include <nexthop.hh>

typedef IPNextHop<IPv6> IPv6NextHop

IPv6NextHop

#include <nexthop.hh>

typedef IPNextHop<IPvX> IPvXNextHop

IPvXNextHop

#include <nexthop.hh>

typedef IPPeerNextHop<IPv4> IPv4PeerNextHop

IPv4PeerNextHop

#include <nexthop.hh>

typedef IPPeerNextHop<IPv6> IPv6PeerNextHop

IPv6PeerNextHop

#include <nexthop.hh>

typedef IPPeerNextHop<IPvX> IPvXPeerNextHop

IPvXPeerNextHop

#include <nexthop.hh>

typedef IPEncapsNextHop<IPv4> IPv4EncapsNextHop

IPv4EncapsNextHop

#include <nexthop.hh>

typedef IPEncapsNextHop<IPv6> IPv6EncapsNextHop

IPv6EncapsNextHop

#include <nexthop.hh>

typedef IPEncapsNextHop<IPvX> IPvXEncapsNextHop

IPvXEncapsNextHop

#include <nexthop.hh>

typedef IPExternalNextHop<IPv4> IPv4ExternalNextHop

IPv4ExternalNextHop

#include <nexthop.hh>

typedef IPExternalNextHop<IPv6> IPv6ExternalNextHop

IPv6ExternalNextHop

#include <nexthop.hh>

typedef IPExternalNextHop<IPvX> IPvXExternalNextHop

IPvXExternalNextHop

#include <nexthop.hh>

enum SelectorMask { SEL_RD = 0x01, SEL_WR = 0x02, SEL_EX = 0x04, SEL_ALL = SEL_RD | SEL_WR | SEL_EX }

SelectorMask

#include <selector.hh>

Selector event type masks.

typedef void  (*SelectorHook) (int fd, SelectorMask mask, void* cookie)

(*SelectorHook)

#include <selector.hh>

SelectorList event hook type.

typedef XorpCallback2<void,int,SelectorMask>::RefPtr SelectorCallback

SelectorCallback

#include <selector.hh>

typedef ref_ptr<SelectorTag> Selector

Selector

#include <selector.hh>

typedef XorpCallback0<void>::RefPtr OneoffTimerCallback

OneoffTimerCallback

#include <timer.hh>

typedef XorpCallback0<bool>::RefPtr PeriodicTimerCallback

PeriodicTimerCallback

#include <timer.hh>

typedef XorpCallback1<void, XorpTimer&>::RefPtr BasicTimerCallback

BasicTimerCallback

#include <timer.hh>

typedef void  (*OneoffTimerHook) (void*)

(*OneoffTimerHook)

#include <timer.hh>

Deprecated callback types - use OneoffTimerCallback/PeriodicTimerCallback instead.

typedef bool  (*PeriodicTimerHook) (void*)

(*PeriodicTimerHook)

#include <timer.hh>

typedef void  (*query_current_time) (timeval*)

(*query_current_time)

#include <timer.hh>

inline timeval  mk_timeval (int sec, int usec)

mk_timeval

[static]

#include <timeval.hh>

Make a timeval value.

Parameters:
secthe number of seconds.
usecthe number of microseconds.

Returns: the timeval value of sec and usec.

inline timeval&  round (timeval& t)

round

[static]

#include <timeval.hh>

Adjust the timeval value so it is valid.

A timeval value is valid if the number of microseconds is not negative, and is smaller than 1000000 (i.e., one million).

Parameters:
tthe timeval value to adjust.

Returns: the adjusted timeval value. Note that the original t value is also adjusted.

inline double  timeval_to_double (const timeval& t)

timeval_to_double

[static]

#include <timeval.hh>

Convert a timeval value to a double-float value.

Parameters:
tthe timeval value to convert to a double-float value.

Returns: the double-float value of t.

inline timeval  double_to_timeval (const double& d)

double_to_timeval

[static]

#include <timeval.hh>

Convert a double-float value to a timeval value.

Parameters:
dthe double-float value to convert to a timeval value.

Returns: the timeval value of @ref.

inline bool  operator== (const timeval& t, const timeval& u)

operator==

[static]

#include <timeval.hh>

Timeval Equality Operator

Parameters:
tthe first timeval value to compare.
uthe second timeval value to compare.

Returns: true if t and u have same timeval value.

inline bool  operator< (const timeval& t, const timeval& u)

operator<

[static]

#include <timeval.hh>

Timeval Less-Than Operator

Parameters:
tthe first timeval value to compare.
uthe second timeval value to compare.

Returns: true if t has numerically smaller timeval value than u.

inline timeval&  operator+= (timeval& t, const timeval& delta)

operator+=

[static]

#include <timeval.hh>

Timeval Assign-Sum Operator

Parameters:
tthe timeval value to assign-sum.
deltathe timeval value to add to t.

Returns: the timeval value of adding delta to t.

inline timeval  operator+ (const timeval& t, const timeval& u)

operator+

[static]

#include <timeval.hh>

Timeval Addition Operator

Parameters:
tthe first timeval value to add.
uthe second timeval value to add.

Returns: the timeval value of adding t and u.

inline timeval&  operator-= (timeval& t, const timeval& delta)

operator-=

[static]

#include <timeval.hh>

Timeval Assign-Difference Operator

Parameters:
tthe timeval value to assign-difference.
deltathe timeval value to substract from t.

Returns: the timeval value of substracting delta from t.

inline timeval  operator- (const timeval& t, const timeval& u)

operator-

[static]

#include <timeval.hh>

Timeval Substraction Operator

Parameters:
tthe timeval value of the first operand (the one to substract from).
uthe timeval value of the second operand (the one to substract from t).

Returns: the timeval value of substracting u from t.

inline timeval  operator/ (const timeval & t, int n)

operator/

[static]

#include <timeval.hh>

Timeval Division Operator

Parameters:
tthe timeval value of the first operand (the one to be divided).
nthe integer value of the second operand (the one to divide t).

Returns: the timeval value of dividing t by n.

inline timeval  operator% (const timeval& t, const timeval& u)

operator%

[static]

#include <timeval.hh>

Timeval Modulo Operator

Parameters:
tthe timeval value of the first operand (the one to be divided).
uthe timeval value of the second operand (the one to divide t).

Returns: the timeval value of the remainder of dividing t by u.

inline double  operator/ (const timeval& t, const timeval& u)

operator/

[static]

#include <timeval.hh>

Timeval Division Operator

Parameters:
tthe timeval value of the first operand (the one to be divided).
uthe timeval value of the second operand (the one to divide t).

Returns: the timeval value of dividing t by u.

inline timeval  operator* (const timeval& t, int n)

operator*

[static]

#include <timeval.hh>

Timeval Multiplication Operator

Parameters:
tthe timeval value of the first operand to multiply.
nthe integer value of the second operand to multiply.

Returns: the timeval value of multiplying t and n.

string  copy_token (const string& token_org)

copy_token

#include <token.hh>

Copy a token.

If the token contains token separators, enclose it within quotations.

Parameters:
token_orgthe token to copy.

Returns: the copy of the token with token separators enclosed within quotations.

string  pop_token (string& token_line)

pop_token

#include <token.hh>

Pop a token from a token line.

Parameters:
token_linethe token line to pop a token from.

Returns: the first token from the front of the line. Also, token_line is modified to exlude that token.

bool  is_token_separator (const char c)

is_token_separator

#include <token.hh>

Test if a character is a token separator.

Currently, the is_space(3) characters and '|' are considered as token separators.

Parameters:
cthe character to test whether it is token separator.

Returns: true if c is a token separator, otherwise false.

bool  has_more_tokens (const string& token_line)

has_more_tokens

#include <token.hh>

Test if a token line contains more tokens.

Parameters:
token_linethe token line to test.

Returns: true if token_line contains more tokens, otherwise false.

string  char_line2token_line (const char *char_line)

char_line2token_line

#include <token.hh>

Create a copy of a token line.

Create a copy of a token line, but all tokens with a single space between.

Parameters:
char_lineC-style token line to copy.

Returns: C++ string copy of char_line, but with all tokens inside with a single space between.

template<class T> void  delete_pointers_list (list<T *>& delete_list)

delete_pointers_list

#include <utils.hh>

Template to delete a list of pointers, and the objects pointed to.

Parameters:
delete_listthe list of pointers to objects to delete.

template<class T> void  delete_pointers_vector (vector<T *>& delete_vector)

delete_pointers_vector

#include <utils.hh>

Template to delete an array of pointers, and the objects pointed to.

Parameters:
delete_vectorthe vector of pointers to objects to delete.

typedef enum --

--

#include <xorp.h>

The xlog functions provide a similar role to syslog. The log messages may be output to multiple output streams simulataneously.

enum -- { true = TRUE, false = FALSE }

--

#include <xorp.h>

typedef bool bool_t

bool_t

#include <xorp.h>


Generated by: pavlin on possum.icir.org on Mon Mar 10 19:34:43 2003, using kdoc 2.0a54+XORP.