C++ base_stream类代码示例

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 aggr_source_discovery::dump_cache(base_stream &out) const {
	out.writeline("Source cache");

	out.inc_level();

	dump_cache(out, m_cache);

	out.dec_level();
}

static void output(base_stream &out, const std::vector<interface *> &ifs) {
	out.write("{ ");
	for (std::vector<interface *>::const_iterator i = ifs.begin();
						i != ifs.end(); ++i) {
		if (i != ifs.begin())
			out.write(", ");
		out.write((*i)->name());
	}
	out.write(" }");
}

bool group::output_info(base_stream &_out, bool detailed) const {
	_out.xprintf("Group %{Addr}\n", id());

	_out.inc_level();

	node::output_info(_out, std::vector<std::string>());

	_out.dec_level();

	return true;
}

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;
}

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;
}

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;
}

void propval_enum::output_value(base_stream &os) const {
	for (entry *i = entries; i->name; i++) {
		if (value == i->value) {
			os.write(i->name);
			return;
		}
	}
}

static void _draw_sep(base_stream &ctx, int n) {
	char buf[64];

	buf[0] = '+';
	memset(buf + 1, '-', n+2);
	buf[n+3] = 0;

	ctx.xprintf("%s+--------------+------------+----------+\n", buf);
}

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;
}

bool timermgr::output_info(base_stream &ctx, bool extended) const {
	size_t namelen = 20;

	for (tq_def::const_iterator i = tq.begin();
			namelen < 50 && i != tq.end(); ++i) {
		timer_base *h = *i;
		if (h->name.size() > namelen)
			namelen = h->name.size();
	}

	if (namelen > 50)
		namelen = 50;

	char fmt[64];
	snprintf(fmt, sizeof(fmt), "| %%%is | %%12s | %%10s | %%8s |", (int)namelen);

	_draw_sep(ctx, namelen);
	ctx.printf(fmt, "timer name", "time left", "interval", "repeat").newl();
	_draw_sep(ctx, namelen);

	char buf1[64], buf2[64];

	for (tq_def::const_iterator i = tq.begin(); i != tq.end(); ++i) {
		timer_base *h = *i;

		_prettyprint(buf1, sizeof(buf1), h->time_left());
		_prettyprint(buf2, sizeof(buf2), h->_interval);

		ctx.printf(fmt, h->name.c_str(), buf1, buf2,
			   h->_repeat ? "true" : "false").newl();
	}

	_draw_sep(ctx, namelen);

	return true;
}

bool node::call_method(int id, base_stream &out,
		       const std::vector<std::string> &args) {
	switch (id) {
	case node_method_enable:
	case node_method_disable:
		return enable_several(args, id == node_method_enable);
	case node_method_no:
		return exec_negate(out, args);
	case node_method_show_properties:
		{
			std::string fname = m_parent ? full_name() : std::string();
			for (properties::const_iterator i = m_properties.begin();
					i != m_properties.end(); ++i) {
				if (!fname.empty())
					out.write(fname.c_str()).write(".");
				out.write(i->first.c_str()).write(" = ");
				if (i->second.is_property()) {
					i->second.output_value(out);
					if (i->second.is_readonly())
						out.write(" [readonly]");
				} else if (i->second.is_child()) {
					out.xprintf("<node %s>", i->second.get_node()->name());
				} else if (i->second.is_method()) {
					if (i->second.is_readonly())
						out.write("<info-method ");
					else
						out.write("<method ");
					out.xprintf("%s>", i->second.get_method_info()->name);
				}

				out.newl();
			}

			return true;
		}
	}

	return false;
}

bool linux_unicast_router::filter_routes(base_stream &out,
        const std::vector<std::string> &args) {
    std::map<int, std::string> pmap = parse_rt_protos();
    std::map<std::string, int> proto_map;

    for (std::map<int, std::string>::const_iterator i = pmap.begin();
            i != pmap.end(); ++i)
        proto_map[i->second] = i->first;

    std::set<int> new_filter;

    for (std::vector<std::string>::const_iterator i = args.begin();
            i != args.end(); ++i) {
        int value = -1;

        if (isdigit(*i->c_str())) {
            char *endp;
            value = strtol(i->c_str(), &endp, 10);
            if (*endp)
                value = -1;
        } else {
            std::map<std::string, int>::const_iterator j = proto_map.find(*i);
            if (j != proto_map.end())
                value = j->second;
        }

        if (value < 0) {
            out.xprintf("Invalid argument `%s`.\n", i->c_str());
            return true;
        }

        new_filter.insert(value);
    }

    filter_protos = new_filter;

    return true;
}

void base_ptree::dump_internal_tree(base_stream &os, const ptree_node *node,
				    const char *desc) const {
	if (!node)
		return;
	os.xprintf("%s ", desc);
	if (node->_t_color == ptree_node::BLACK)
		write_prefix(os, node);
	else
		os.write("white");
	os.xprintf(" at %i", (int)node->_t_bit);
	os.newl();

	os.inc_level();

	dump_internal_tree(os, node->_t_left, "left");
	dump_internal_tree(os, node->_t_right, "right");

	os.dec_level();
}

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());
	}
}