自学教程：C++ writeCString函数代码示例

void CollectAliases::dump(WriteBuffer & out) const{	/// For need of tests, we need to dump result in some fixed order.	std::vector<Aliases::const_iterator> vec;	vec.reserve(aliases.size());	for (auto it = aliases.begin(); it != aliases.end(); ++it)		vec.emplace_back(it);	std::sort(vec.begin(), vec.end(), [](const auto & a, const auto & b) { return a->first < b->first; });	for (const auto & it : vec)	{		writeProbablyBackQuotedString(it->first, out);		writeCString(" -> ", out);		switch (it->second.kind)		{			case Kind::Expression:				writeCString("(expression) ", out);				break;			case Kind::Table:				writeCString("(table) ", out);				break;			case Kind::ArrayJoin:				writeCString("(array join) ", out);				break;		}		std::stringstream formatted_ast;		formatAST(*it->second.node, formatted_ast, 0, false, true);		writeString(formatted_ast.str(), out);		writeChar('/n', out);	}}

voiddrawMenu(int option){	SDL_Rect a,b;	/* erase the screen */	SDL_FillRect(screen,NULL,SDL_MapRGB(screen->format,0,0,0));	/* BETA */	a.x=97;//77	a.y=20;	b.x=100;	b.y=46;	b.w=125;//166	b.h=15;	SDL_BlitSurface(gfx, &b, screen, &a);	/* options */	writeCString(gfx, screen, 105, 50,  "play", (option==1));//orig diff=17 now 26	writeCString(gfx, screen, 105, 76, "hall of fame", (option==2));//105, 94  option==3	writeCString(gfx, screen, 105, 102, "options", (option==3));//105, 111 option==4	writeCString(gfx, screen, 105, 128, "about", (option==4));//105, 138 option==5	writeCString(gfx, screen, 105, 154, "exit game", (option==5));//105, 155 option==6	/* some credit	a.x=154;	a.y=184;	b.x=268;	b.y=57;	b.w=166;	b.h=16;	SDL_BlitSurface(gfx, &b, screen, &a);*/	SDL_Flip(screen);}

voiddrawHiscores(int max){	int i;	SDL_Rect a,b;	/* erase the screen */	SDL_FillRect(screen,NULL,SDL_MapRGB(screen->format,0,0,0));	/* DD2 characters */	a.x=60;	a.y=5;	b.x=450;	b.y=43;	b.w=211;	b.h=190;	SDL_BlitSurface(gfx, &b, screen, &a);	/* header */	writeCString(gfx, screen, 80, 2, "the hall of fame", 1);	for(i=0;i<max;i++) {		writeNumber(gfx, screen, 10, 23+i*17, i+1, 2);		writeCString(gfx, screen, 30, 20+i*17, hiscore[i].name, 0);		writeCString(gfx, screen, 180, 20+i*17, "st",0);		writeNumber(gfx, screen, 200, 23+i*17, hiscore[i].stage,2);		writeCString(gfx, screen, 236, 20+i*17, "sc",0);		writeNumber(gfx, screen, 260, 23+i*17, hiscore[i].score,6);	}	SDL_Flip(screen);}

String ASTFunction::getColumnNameImpl() const{    WriteBufferFromOwnString wb;    writeString(name, wb);    if (parameters)    {        writeChar('(', wb);        for (ASTs::const_iterator it = parameters->children.begin(); it != parameters->children.end(); ++it)        {            if (it != parameters->children.begin())                writeCString(", ", wb);            writeString((*it)->getColumnName(), wb);        }        writeChar(')', wb);    }    writeChar('(', wb);    for (ASTs::const_iterator it = arguments->children.begin(); it != arguments->children.end(); ++it)    {        if (it != arguments->children.begin())            writeCString(", ", wb);        writeString((*it)->getColumnName(), wb);    }    writeChar(')', wb);    return wb.str();}

void VerticalRowOutputStream::writeSpecialRow(const Block & block, size_t row_num, const char * title){    writeCString("/n", ostr);    row_number = 0;    field_number = 0;    size_t columns = block.columns();    writeCString(title, ostr);    writeCString(":/n", ostr);    size_t width = strlen(title) + 1;    for (size_t i = 0; i < width; ++i)        writeCString("─", ostr);    writeChar('/n', ostr);    for (size_t i = 0; i < columns; ++i)    {        if (i != 0)            writeFieldDelimiter();        auto & col = block.getByPosition(i);        writeField(*col.column, *col.type, row_num);    }}

void JSONRowOutputStream::writeField(const IColumn & column, const IDataType & type, size_t row_num){    writeCString("/t/t/t", *ostr);    writeString(fields[field_number].name, *ostr);    writeCString(": ", *ostr);    type.serializeTextJSON(column, row_num, *ostr, force_quoting_64bit_integers);    ++field_number;}

void XMLRowOutputStream::writeRowsBeforeLimitAtLeast(){	if (applied_limit)	{		writeCString("/t<rows_before_limit_at_least>", *ostr);		writeIntText(rows_before_limit, *ostr);		writeCString("</rows_before_limit_at_least>/n", *ostr);	}}

void KoXmlWriter::addAttribute(const char* attrName, const QByteArray& value){    // Same as the const char* one, but here we know the size    writeChar(' ');    writeCString(attrName);    writeCString("=/"");    char* escaped = escapeForXML(value.constData(), value.size());    writeCString(escaped);    if (escaped != d->escapeBuffer)        delete[] escaped;    writeChar('"');}

void PrettySpaceBlockOutputStream::writeSuffix(){    if (total_rows >= max_rows)    {        writeCString("/nShowed first ", ostr);        writeIntText(max_rows, ostr);        writeCString("./n", ostr);    }    total_rows = 0;    writeTotals();    writeExtremes();}

void PrettyCompactMonoBlockOutputStream::writeSuffix(){	if (blocks.empty())		return;	Widths_t max_widths;	Widths_t name_widths;	for (size_t i = 0; i < blocks.size(); ++i)		calculateWidths(blocks[i], max_widths, name_widths);	writeHeader(blocks.front(), max_widths, name_widths);	size_t row_count = 0;	for (size_t block_id = 0; block_id < blocks.size() && row_count < max_rows; ++block_id)	{		const Block & block = blocks[block_id];		size_t rows = block.rows();		for (size_t i = 0; i < rows && row_count < max_rows; ++i)		{			writeRow(i, block, max_widths, name_widths);			++row_count;		}	}	writeBottom(max_widths);	if (total_rows >= max_rows)	{		writeCString("  Showed first ", ostr);		writeIntText(max_rows, ostr);		writeCString("./n", ostr);	}	total_rows = 0;	if (totals)	{		writeCString("/nTotals:/n", ostr);		PrettyCompactBlockOutputStream::write(totals);	}	if (extremes)	{		writeCString("/nExtremes:/n", ostr);		PrettyCompactBlockOutputStream::write(extremes);	}}

VerticalRowOutputStream::VerticalRowOutputStream(    WriteBuffer & ostr_, const Block & sample_, const FormatSettings & format_settings)    : ostr(ostr_), sample(sample_), format_settings(format_settings){    size_t columns = sample.columns();    using Widths = std::vector<size_t>;    Widths name_widths(columns);    size_t max_name_width = 0;    String serialized_value;    for (size_t i = 0; i < columns; ++i)    {        /// Note that number of code points is just a rough approximation of visible string width.        const String & name = sample.getByPosition(i).name;        name_widths[i] = UTF8::countCodePoints(reinterpret_cast<const UInt8 *>(name.data()), name.size());        if (name_widths[i] > max_name_width)            max_name_width = name_widths[i];    }    names_and_paddings.resize(columns);    for (size_t i = 0; i < columns; ++i)    {        WriteBufferFromString out(names_and_paddings[i]);        writeString(sample.getByPosition(i).name, out);        writeCString(": ", out);    }    for (size_t i = 0; i < columns; ++i)        names_and_paddings[i].resize(max_name_width + strlen(": "), ' ');}

void MergeTreePartition::serializeText(const MergeTreeData & storage, WriteBuffer & out, const FormatSettings & format_settings) const{    size_t key_size = storage.partition_key_sample.columns();    if (key_size == 0)    {        writeCString("tuple()", out);    }    else if (key_size == 1)    {        const DataTypePtr & type = storage.partition_key_sample.getByPosition(0).type;        auto column = type->createColumn();        column->insert(value[0]);        type->serializeAsText(*column, 0, out, format_settings);    }    else    {        DataTypes types;        Columns columns;        for (size_t i = 0; i < key_size; ++i)        {            const auto & type = storage.partition_key_sample.getByPosition(i).type;            types.push_back(type);            auto column = type->createColumn();            column->insert(value[i]);            columns.push_back(std::move(column));        }        DataTypeTuple tuple_type(types);        auto tuple_column = ColumnTuple::create(columns);        tuple_type.serializeText(*tuple_column, 0, out, format_settings);    }}

void JSONRowOutputStream::writeRowEndDelimiter(){    writeChar('/n', *ostr);    writeCString("/t/t}", *ostr);    field_number = 0;    ++row_count;}

void JSONCompactRowOutputStream::writeExtremes(){    if (extremes)    {        writeCString(",/n", *ostr);        writeChar('/n', *ostr);        writeCString("/t/"extremes/":/n", *ostr);        writeCString("/t{/n", *ostr);        writeExtremesElement("min", extremes, 0, *ostr, settings);        writeCString(",/n", *ostr);        writeExtremesElement("max", extremes, 1, *ostr, settings);        writeChar('/n', *ostr);        writeCString("/t}", *ostr);    }}

static void writeExtremesElement(const char * title, const Block & extremes, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings){    writeCString("/t/t/"", ostr);    writeCString(title, ostr);    writeCString("/": [", ostr);    size_t extremes_columns = extremes.columns();    for (size_t i = 0; i < extremes_columns; ++i)    {        if (i != 0)            writeChar(',', ostr);        const ColumnWithTypeAndName & column = extremes.safeGetByPosition(i);        column.type->serializeTextJSON(*column.column.get(), row_num, ostr, settings);    }    writeChar(']', ostr);}

void KoXmlWriter::addTextNode(const QByteArray& cstr){    // Same as the const char* version below, but here we know the size    prepareForTextNode();    char* escaped = escapeForXML(cstr.constData(), cstr.size());    writeCString(escaped);    if (escaped != d->escapeBuffer)        delete[] escaped;}