ospf_xif.cc

来自「BCAST Implementation for NS2」· CC 代码 · 共 2,721 行 · 第 1/5 页

	a->get("cost", cost);
    } catch (const XrlArgs::XrlAtomNotFound&) {
	XLOG_ERROR("Atom not found");
	cb->dispatch(XrlError::BAD_ARGS(), 0);
	return;
    }
    cb->dispatch(e, &cost);
}

bool
XrlOspfV0p1Client::send_interface_set_mtu(
	const char*	the_tgt, 
	const string&	identifier, 
	const uint32_t&	mtu, 
	const InterfaceSetMtuCB&	cb
)
{
    Xrl x(the_tgt, "ospf/0.1/interface_set_mtu");
    x.args().add("identifier", identifier);
    x.args().add("mtu", mtu);
    return _sender->send(x, callback(this, &XrlOspfV0p1Client::unmarshall_interface_set_mtu, cb));
}


/* Unmarshall interface_set_mtu */
void
XrlOspfV0p1Client::unmarshall_interface_set_mtu(
	const XrlError&	e, 
	XrlArgs*	a, 
	InterfaceSetMtuCB		cb
)
{
    if (e != XrlError::OKAY()) {
	cb->dispatch(e);
	return;
    } else if (a && a->size() != 0) {
	XLOG_ERROR("Wrong number of arguments (%u != 0)", (uint32_t)a->size());
	cb->dispatch(XrlError::BAD_ARGS());
	return;
    }
    cb->dispatch(e);
}

bool
XrlOspfV0p1Client::send_interface_get_mtu(
	const char*	the_tgt, 
	const string&	identifier, 
	const InterfaceGetMtuCB&	cb
)
{
    Xrl x(the_tgt, "ospf/0.1/interface_get_mtu");
    x.args().add("identifier", identifier);
    return _sender->send(x, callback(this, &XrlOspfV0p1Client::unmarshall_interface_get_mtu, cb));
}


/* Unmarshall interface_get_mtu */
void
XrlOspfV0p1Client::unmarshall_interface_get_mtu(
	const XrlError&	e, 
	XrlArgs*	a, 
	InterfaceGetMtuCB		cb
)
{
    if (e != XrlError::OKAY()) {
	cb->dispatch(e, 0);
	return;
    } else if (a && a->size() != 1) {
	XLOG_ERROR("Wrong number of arguments (%u != 1)", (uint32_t)a->size());
	cb->dispatch(XrlError::BAD_ARGS(), 0);
	return;
    }
    uint32_t mtu;
    try {
	a->get("mtu", mtu);
    } catch (const XrlArgs::XrlAtomNotFound&) {
	XLOG_ERROR("Atom not found");
	cb->dispatch(XrlError::BAD_ARGS(), 0);
	return;
    }
    cb->dispatch(e, &mtu);
}

bool
XrlOspfV0p1Client::send_interface_set_type(
	const char*	the_tgt, 
	const string&	identifier, 
	const string&	type, 
	const InterfaceSetTypeCB&	cb
)
{
    Xrl x(the_tgt, "ospf/0.1/interface_set_type");
    x.args().add("identifier", identifier);
    x.args().add("type", type);
    return _sender->send(x, callback(this, &XrlOspfV0p1Client::unmarshall_interface_set_type, cb));
}


/* Unmarshall interface_set_type */
void
XrlOspfV0p1Client::unmarshall_interface_set_type(
	const XrlError&	e, 
	XrlArgs*	a, 
	InterfaceSetTypeCB		cb
)
{
    if (e != XrlError::OKAY()) {
	cb->dispatch(e);
	return;
    } else if (a && a->size() != 0) {
	XLOG_ERROR("Wrong number of arguments (%u != 0)", (uint32_t)a->size());
	cb->dispatch(XrlError::BAD_ARGS());
	return;
    }
    cb->dispatch(e);
}

bool
XrlOspfV0p1Client::send_interface_get_type(
	const char*	the_tgt, 
	const string&	identifier, 
	const InterfaceGetTypeCB&	cb
)
{
    Xrl x(the_tgt, "ospf/0.1/interface_get_type");
    x.args().add("identifier", identifier);
    return _sender->send(x, callback(this, &XrlOspfV0p1Client::unmarshall_interface_get_type, cb));
}


/* Unmarshall interface_get_type */
void
XrlOspfV0p1Client::unmarshall_interface_get_type(
	const XrlError&	e, 
	XrlArgs*	a, 
	InterfaceGetTypeCB		cb
)
{
    if (e != XrlError::OKAY()) {
	cb->dispatch(e, 0);
	return;
    } else if (a && a->size() != 1) {
	XLOG_ERROR("Wrong number of arguments (%u != 1)", (uint32_t)a->size());
	cb->dispatch(XrlError::BAD_ARGS(), 0);
	return;
    }
    string type;
    try {
	a->get("type", type);
    } catch (const XrlArgs::XrlAtomNotFound&) {
	XLOG_ERROR("Atom not found");
	cb->dispatch(XrlError::BAD_ARGS(), 0);
	return;
    }
    cb->dispatch(e, &type);
}

bool
XrlOspfV0p1Client::send_interface_set_dr_priority(
	const char*	the_tgt, 
	const string&	identifier, 
	const uint32_t&	dr_priority, 
	const InterfaceSetDrPriorityCB&	cb
)
{
    Xrl x(the_tgt, "ospf/0.1/interface_set_dr_priority");
    x.args().add("identifier", identifier);
    x.args().add("dr_priority", dr_priority);
    return _sender->send(x, callback(this, &XrlOspfV0p1Client::unmarshall_interface_set_dr_priority, cb));
}


/* Unmarshall interface_set_dr_priority */
void
XrlOspfV0p1Client::unmarshall_interface_set_dr_priority(
	const XrlError&	e, 
	XrlArgs*	a, 
	InterfaceSetDrPriorityCB		cb
)
{
    if (e != XrlError::OKAY()) {
	cb->dispatch(e);
	return;
    } else if (a && a->size() != 0) {
	XLOG_ERROR("Wrong number of arguments (%u != 0)", (uint32_t)a->size());
	cb->dispatch(XrlError::BAD_ARGS());
	return;
    }
    cb->dispatch(e);
}

bool
XrlOspfV0p1Client::send_interface_get_dr_priority(
	const char*	the_tgt, 
	const string&	identifier, 
	const InterfaceGetDrPriorityCB&	cb
)
{
    Xrl x(the_tgt, "ospf/0.1/interface_get_dr_priority");
    x.args().add("identifier", identifier);
    return _sender->send(x, callback(this, &XrlOspfV0p1Client::unmarshall_interface_get_dr_priority, cb));
}


/* Unmarshall interface_get_dr_priority */
void
XrlOspfV0p1Client::unmarshall_interface_get_dr_priority(
	const XrlError&	e, 
	XrlArgs*	a, 
	InterfaceGetDrPriorityCB		cb
)
{
    if (e != XrlError::OKAY()) {
	cb->dispatch(e, 0);
	return;
    } else if (a && a->size() != 1) {
	XLOG_ERROR("Wrong number of arguments (%u != 1)", (uint32_t)a->size());
	cb->dispatch(XrlError::BAD_ARGS(), 0);
	return;
    }
    uint32_t dr_priority;
    try {
	a->get("dr_priority", dr_priority);
    } catch (const XrlArgs::XrlAtomNotFound&) {
	XLOG_ERROR("Atom not found");
	cb->dispatch(XrlError::BAD_ARGS(), 0);
	return;
    }
    cb->dispatch(e, &dr_priority);
}

bool
XrlOspfV0p1Client::send_interface_set_transit_delay(
	const char*	the_tgt, 
	const string&	identifier, 
	const uint32_t&	delay_secs, 
	const InterfaceSetTransitDelayCB&	cb
)
{
    Xrl x(the_tgt, "ospf/0.1/interface_set_transit_delay");
    x.args().add("identifier", identifier);
    x.args().add("delay_secs", delay_secs);
    return _sender->send(x, callback(this, &XrlOspfV0p1Client::unmarshall_interface_set_transit_delay, cb));
}


/* Unmarshall interface_set_transit_delay */
void
XrlOspfV0p1Client::unmarshall_interface_set_transit_delay(
	const XrlError&	e, 
	XrlArgs*	a, 
	InterfaceSetTransitDelayCB		cb
)
{
    if (e != XrlError::OKAY()) {
	cb->dispatch(e);
	return;
    } else if (a && a->size() != 0) {
	XLOG_ERROR("Wrong number of arguments (%u != 0)", (uint32_t)a->size());
	cb->dispatch(XrlError::BAD_ARGS());
	return;
    }
    cb->dispatch(e);
}

bool
XrlOspfV0p1Client::send_interface_get_transit_delay(
	const char*	the_tgt, 
	const string&	identifier, 
	const InterfaceGetTransitDelayCB&	cb
)
{
    Xrl x(the_tgt, "ospf/0.1/interface_get_transit_delay");
    x.args().add("identifier", identifier);
    return _sender->send(x, callback(this, &XrlOspfV0p1Client::unmarshall_interface_get_transit_delay, cb));
}


/* Unmarshall interface_get_transit_delay */
void
XrlOspfV0p1Client::unmarshall_interface_get_transit_delay(
	const XrlError&	e, 
	XrlArgs*	a, 
	InterfaceGetTransitDelayCB		cb
)
{
    if (e != XrlError::OKAY()) {
	cb->dispatch(e, 0);
	return;
    } else if (a && a->size() != 1) {
	XLOG_ERROR("Wrong number of arguments (%u != 1)", (uint32_t)a->size());
	cb->dispatch(XrlError::BAD_ARGS(), 0);
	return;
    }
    uint32_t delay_secs;
    try {
	a->get("delay_secs", delay_secs);
    } catch (const XrlArgs::XrlAtomNotFound&) {
	XLOG_ERROR("Atom not found");
	cb->dispatch(XrlError::BAD_ARGS(), 0);
	return;
    }
    cb->dispatch(e, &delay_secs);
}

bool
XrlOspfV0p1Client::send_interface_set_retransmit_interval(
	const char*	the_tgt, 
	const string&	identifier, 
	const uint32_t&	interval_secs, 
	const InterfaceSetRetransmitIntervalCB&	cb
)
{
    Xrl x(the_tgt, "ospf/0.1/interface_set_retransmit_interval");
    x.args().add("identifier", identifier);
    x.args().add("interval_secs", interval_secs);
    return _sender->send(x, callback(this, &XrlOspfV0p1Client::unmarshall_interface_set_retransmit_interval, cb));
}


/* Unmarshall interface_set_retransmit_interval */
void
XrlOspfV0p1Client::unmarshall_interface_set_retransmit_interval(
	const XrlError&	e, 
	XrlArgs*	a, 
	InterfaceSetRetransmitIntervalCB		cb
)
{
    if (e != XrlError::OKAY()) {
	cb->dispatch(e);
	return;
    } else if (a && a->size() != 0) {
	XLOG_ERROR("Wrong number of arguments (%u != 0)", (uint32_t)a->size());
	cb->dispatch(XrlError::BAD_ARGS());
	return;
    }
    cb->dispatch(e);
}

bool
XrlOspfV0p1Client::send_interface_get_retransmit_interval(
	const char*	the_tgt, 
	const string&	identifier, 
	const InterfaceGetRetransmitIntervalCB&	cb
)
{
    Xrl x(the_tgt, "ospf/0.1/interface_get_retransmit_interval");
    x.args().add("identifier", identifier);
    return _sender->send(x, callback(this, &XrlOspfV0p1Client::unmarshall_interface_get_retransmit_interval, cb));
}


/* Unmarshall interface_get_retransmit_interval */
void
XrlOspfV0p1Client::unmarshall_interface_get_retransmit_interval(
	const XrlError&	e, 
	XrlArgs*	a, 
	InterfaceGetRetransmitIntervalCB		cb
)
{
    if (e != XrlError::OKAY()) {
	cb->dispatch(e, 0);
	return;
    } else if (a && a->size() != 1) {
	XLOG_ERROR("Wrong number of arguments (%u != 1)", (uint32_t)a->size());
	cb->dispatch(XrlError::BAD_ARGS(), 0);
	return;
    }
    uint32_t interval_secs;
    try {
	a->get("interval_secs", interval_secs);
    } catch (const XrlArgs::XrlAtomNotFound&) {
	XLOG_ERROR("Atom not found");
	cb->dispatch(XrlError::BAD_ARGS(), 0);
	return;
    }
    cb->dispatch(e, &interval_secs);
}

bool
XrlOspfV0p1Client::send_interface_set_router_dead_interval(
	const char*	the_tgt, 
	const string&	identifier, 
	const uint32_t&	interval_secs, 
	const InterfaceSetRouterDeadIntervalCB&	cb
)
{
    Xrl x(the_tgt, "ospf/0.1/interface_set_router_dead_interval");
    x.args().add("identifier", identifier);
    x.args().add("interval_secs", interval_secs);
    return _sender->send(x, callback(this, &XrlOspfV0p1Client::unmarshall_interface_set_router_dead_interval, cb));
}


/* Unmarshall interface_set_router_dead_interval */
void
XrlOspfV0p1Client::unmarshall_interface_set_router_dead_interval(
	const XrlError&	e, 
	XrlArgs*	a, 
	InterfaceSetRouterDeadIntervalCB		cb
)
{
    if (e != XrlError::OKAY()) {
	cb->dispatch(e);
	return;
    } else if (a && a->size() != 0) {
	XLOG_ERROR("Wrong number of arguments (%u != 0)", (uint32_t)a->size());
	cb->dispatch(XrlError::BAD_ARGS());
	return;
    }
    cb->dispatch(e);
}

bool
XrlOspfV0p1Client::send_interface_get_router_dead_interval(
	const char*	the_tgt, 
	const string&	identifier, 
	const InterfaceGetRouterDeadIntervalCB&	cb
)
{
    Xrl x(the_tgt, "ospf/0.1/interface_get_router_dead_interval");
    x.args().add("identifier", identifier);
    return _sender->send(x, callback(this, &XrlOspfV0p1Client::unmarshall_interface_get_router_dead_interval, cb));
}


/* Unmarshall interface_get_router_dead_interval */
void
XrlOspfV0p1Client::unmarshall_interface_get_router_dead_interval(
	const XrlError&	e, 
	XrlArgs*	a, 
	InterfaceGetRouterDeadIntervalCB		cb
)
{
    if (e != XrlError::OKAY()) {
	cb->dispatch(e, 0);
	return;
    } else if (a && a->size() != 1) {
	XLOG_ERROR("Wrong number of arguments (%u != 1)", (uint32_t)a->size());
	cb->dispatch(XrlError::BAD_ARGS(), 0);
	return;
    }
    uint32_t interval_secs;
    try {
	a->get("interval_secs", interval_secs);
    } catch (const XrlArgs::XrlAtomNotFound&) {
	XLOG_ERROR("Atom not found");
	cb->dispatch(XrlError::BAD_ARGS(), 0);
	return;
    }
    cb->dispatch(e, &interval_secs);
}

bool
XrlOspfV0p1Client::send_interface_set_poll_interval(
	const char*	the_tgt, 
	const string&	identifier, 
	const uint32_t&	interval_secs, 
	const InterfaceSetPollIntervalCB&	cb
)
{
    Xrl x(the_tgt, "ospf/0.1/interface_set_poll_interval");
    x.args().add("identifier", identifier);
    x.args().add("interval_secs", interval_secs);
    return _sender->send(x, callback(this, &XrlOspfV0p1Client::unmarshall_interface_set_poll_interval, cb));
}


/* Unmarshall interface_set_poll_interval */
void
XrlOspfV0p1Client::unmarshall_interface_set_poll_interval(
	const XrlError&	e, 
	XrlArgs*	a, 
	InterfaceSetPollIntervalCB		cb
)
{
    if (e != XrlError::OKAY()) {
	cb->dispatch(e);
	return;
    } else if (a && a->size() != 0) {
	XLOG_ERROR("Wrong number of arguments (%u != 0)", (uint32_t)a->size());
	cb->dispatch(XrlError::BAD_ARGS());
	return;
    }
    cb->dispatch(e);
}

bool
XrlOspfV0p1Client::send_interface_get_poll_interval(
	const char*	the_tgt, 
	const string&	identifier, 
	const InterfaceGetPollIntervalCB&	cb
)
{
    Xrl x(the_tgt, "ospf/0.1/interface_get_poll_interval");
    x.args().add("identifier", identifier);
    return _sender->send(x, callback(this, &XrlOspfV0p1Client::unmarshall_interface_get_poll_interval, cb));
}


/* Unmarshall interface_get_poll_interval */
void
XrlOspfV0p1Client::unmarshall_interface_get_poll_interval(
	const XrlError&	e, 
	XrlArgs*	a, 
	InterfaceGetPollIntervalCB		cb
)
{
    if (e != XrlError::OKAY()) {
	cb->dispatch(e, 0);
	return;
    } else if (a && a->size() != 1) {
	XLOG_ERROR("Wrong number of arguments (%u != 1)", (uint32_t)a->size());
	cb->dispatch(XrlError::BAD_ARGS(), 0);
	return;
    }
    uint32_t interval_secs;
    try {
	a->get("interval_secs", interval_secs);
    } catch (const XrlArgs::XrlAtomNotFound&) {
	XLOG_ERROR("Atom not found");
	cb->dispatch(XrlError::BAD_ARGS(), 0);
	return;
    }
    cb->dispatch(e, &interval_secs);
}

bool
XrlOspfV0p1Client::send_interface_set_authentication(
	const char*	the_tgt, 
	const string&	identifier, 
	const string&	type, 
	const string&	key, 
	const InterfaceSetAuthenticationCB&	cb
)
{
    Xrl x(the_tgt, "ospf/0.1/interface_set_authentication");
    x.args().add("identifier", identifier);
    x.args().add("type", type);
    x.args().add("key", key);
    return