C++ base_stream::writeline方法代码示例

bool mld_interface::output_info(base_stream &ctx, const std::vector<std::string> &) const {
	ctx.xprintf("MLD, version %i", (int)mif_mld_version);

	if (owner()->linklocals().empty()) {
		ctx.writeline(", not running");
		return true;
	}

	ctx.newl();

	ctx.inc_level();

	if (!mif_isquerier) {
		if (mif_querier_addr.is_any()) {
			ctx.writeline("Querier: None");
		} else {
			ctx.xprintf("Querier: %{Addr} for %{duration}\n",
				    mif_querier_addr,
				    mif_other_querier_present_timer_id.time_left_d());
		}
	} else {
		ctx.writeline("Querier: self");
	}

	ctx.dec_level();

	return true;
}

void base_ptree::dump_internal_tree_graphviz(base_stream &os) const {
	os.writeline("graph ptree {");
	os.inc_level();
	dump_internal_tree_graphviz(os, head, "black");
	dump_internal_tree_graphviz(os, head, 0);
	os.dec_level();
	os.writeline("}");
}

void us_mfa_group::output_info(base_stream &out, bool counters, bool noempty) const {
	if (counters) {
		out.writeline("Aggregate activity statistics:");
		out.inc_level();

		if (stat_packet_count60s) {
			const char *format = "%.2f %s";
			double rate = 8 * stat_octet_count60s / 60000.;
			const char *unit = "Kb/s";

			if (rate > 1000) {
				rate /= 1000.;
				unit = "Mb/s";
			}

			out.write("Current rate: ");
			out.printf(format, rate, unit);
			out.printf(" (%.2f pkt/s)", stat_packet_count60s / 60.f);
			out.newl();
			out.printf("Last 60 secs: %llu bytes (%llu packets, %.2lf bytes/packet)",
					stat_octet_count60s, stat_packet_count60s,
					stat_octet_count60s / (double)stat_packet_count60s);
			out.newl();
		} else {
			out.writeline("No available statistics");
		}

		out.dec_level();
	}

	/* no active sources */
	if (counters && noempty && !stat_packet_count60s)
		return;

	out.writeline("Sources:");

	out.inc_level();

	if (m_sources.empty()) {
		out.writeline("(None)");
	} else {
		for (sources::const_iterator i = m_sources.begin();
					i != m_sources.end(); ++i) {
			i->second->output_info(out, counters, noempty);
		}
	}

	out.dec_level();
}

bool pim_interface::flap_neighbour(base_stream &out,
				   const std::vector<std::string> &args,
				   bool remove) {
	if (args.empty())
		return false;

	inet6_addr addr;
	if (!addr.set(args[0]))
		return false;

	pim_neighbour *neigh = 0;
	neighbours_def::iterator i;

	for (i = neighbours.begin(); i != neighbours.end(); i++) {
		if ((*i)->has_address(addr)) {
			neigh = *i;
			break;
		}
	}

	if (!neigh) {
		out.writeline("No such neighbour.");
	} else {
		if (remove) {
			neighbour_timed_out(neigh);
		} else {
			neighbours.erase(i);
			pim->lost_neighbour(neigh);
			neighbours.push_back(neigh);
			pim->found_new_neighbour(neigh);
		}
	}

	return true;
}

void aggr_source_discovery::dump_cache(base_stream &out) const {
	out.writeline("Source cache");

	out.inc_level();

	dump_cache(out, m_cache);

	out.dec_level();
}

bool console_module::output_info(base_stream &ctx, const std::vector<std::string> &args) const {
	if (!args.empty())
		return false;

	ctx.writeline("Console");

	ctx.inc_level();

	ctx.writeline("Allowed:");

	ctx.inc_level();

	if (acl.empty()) {
		ctx.writeline("(None)");
	} else {
		for (allow_local_def::const_iterator i = acl.begin();
				i != acl.end(); i++) {
			for (std::list<auth_desc>::const_iterator j =
				i->second.begin(); j != i->second.end(); j++) {
				if (j->username.empty() || j->username == "*")
					ctx.write("Any");
				else
					ctx.write(j->username.c_str());
				if (j->password.empty() || j->password == "*")
					ctx.write(" with no password");

				ctx.xprintf(" from %{Addr}\n", i->first);
			}
		}
	}

	ctx.dec_level();

	ctx.dec_level();

	return true;
}

bool pim_interface::output_info(base_stream &ctx, bool extended) const {
	if (get_state() == NOT_READY)
		return false;

	ctx.writeline("PIM");

	ctx.inc_level();

	ctx.xprintf("DR Priority: %u\n", conf()->dr_priority());
	ctx.xprintf("LAN Propagation Delay: %ums Override Interval: %ums\n",
		    conf()->propagation_delay(), conf()->override_interval());

	if (elected_dr)
		ctx.xprintf("DR: %{Addr}\n", elected_dr->localaddr());
	else
		ctx.writeline("DR: self");

	ctx.writeline("Neighbours:");

	ctx.inc_level();

	if (neighbours.empty()) {
		ctx.writeline("(None)");
	} else {
		for (neighbours_def::const_iterator j = neighbours.begin();
						j != neighbours.end(); j++) {
			(*j)->output_info(ctx, extended);
		}
	}

	ctx.dec_level();

	ctx.dec_level();

	return true;
}

bool pim_router::output_info(base_stream &ctx, const std::vector<std::string> &args) const {
	if (!args.empty())
		return false;

	ctx.writeline("PIM");

	ctx.inc_level();

#ifndef PIM_NO_BSR
	m_bsr.output_info(ctx);
#endif

	ctx.dec_level();

	return true;
}

bool linux_unicast_router::show_filter_routes(base_stream &out,
        const std::vector<std::string> &args) {
    if (!args.empty()) {
        out.writeline("This method accepts no arguments.");
        return true;
    }

    const std::map<int, std::string> pmap = parse_rt_protos();

    for (std::set<int>::const_iterator i = filter_protos.begin();
            i != filter_protos.end(); ++i) {
        std::map<int, std::string>::const_iterator j = pmap.find(*i);

        if (j == pmap.end())
            out.xprintf("? (%i)\n", *i);
        else
            out.xprintf("%s (%i)\n", j->second.c_str(), *i);
    }

    return true;
}

void telnet_console_connection::dump_history(base_stream &out) const {
	for (std::vector<std::string>::const_iterator i = history.begin();
			i != history.end(); ++i) {
		out.writeline(i->c_str());
	}
}

bool pim_router::call_method(int id, base_stream &out,
			     const std::vector<std::string> &args) {
	if (id == pim_router_method_rpf) {
		if (args.size() != 1)
			return false;

		inet6_addr addr;
		if (!addr.set(args[0].c_str()))
			return false;

		pim_neighbour *neigh = get_rpf_neighbour(addr);

		if (neigh) {
			neigh->output_info(out, false);
		} else {
			out.writeline("No RPF neighbor.");
		}

		return true;
	} else if (id == pim_router_method_group_rp) {
		if (args.size() != 1)
			return false;

		inet6_addr addr;
		if (!addr.set(args[0].c_str()))
			return false;

		pim_groupconf_node *pconf = 0;
		groupconf *conf = g_mrd->match_group_configuration(addr);
		while (conf && !pconf) {
			pconf = (pim_groupconf_node *)conf->get_child("pim");
			conf = g_mrd->get_similar_groupconf_node(conf);
		}

		if (!pconf) {
			out.writeline("No available configuration.");
			return true;
		}

		in6_addr rpaddr;
		rp_source src;
		if (pconf->rp_for_group(addr, rpaddr, src)) {
			out.xprintf("RP: %{addr} [", rpaddr);
			if (src == rps_static)
				out.write("static");
			else if (src == rps_embedded)
				out.write("embedded");
			else if (src == rps_rp_set)
				out.write("rp_set");
			else
				out.write("unknown");
			out.writeline("]");
		} else {
			out.writeline("No available RP");
		}

		return true;
	} else if (id == pim_router_method_group_summary) {
		if (args.size() > 1)
			return false;

		inet6_addr mask;
		if (!args.empty()) {
			if (!mask.set(args[0].c_str()))
				return false;
		}

		mrd::group_list::const_iterator i = g_mrd->group_table().begin();

		for (; i != g_mrd->group_table().end(); ++i) {
			if (!mask.matches(i->first))
				continue;

			pim_group_node *grp =
				(pim_group_node *)i->second->node_owned_by(this);
			if (!grp)
				continue;

			out.xprintf("%{Addr}\n", i->first);
			out.inc_level();

			if (grp->wildcard()) {
				out.xprintf("Wildcard present, RP is at %{addr}\n", grp->rpaddr());
			}

			int count = grp->source_state_set().size();

			out.xprintf("Has %i state%s.\n", count, count > 1 ? "s" : "");

			int local = grp->local_source_state_set().size();

			if (local > 0) {
				out.xprintf("Of which %i %s local.\n", local, local > 1 ? "are" : "is");
			}

			out.dec_level();
		}

		return true;
	}
//.........这里部分代码省略.........