C++ Lines::push_back方法代码示例

void Context::splitLines()
{
    for (auto line = lines.begin(); line != lines.end(); ++line)
    {
        auto &text = line->text;
        auto p = text.find('\n');
        if (p == text.npos)
            continue;

        size_t old_pos = 0;
        Lines ls;
        while (1)
        {
            ls.push_back(Line{text.substr(old_pos, p - old_pos), line->n_indents});
            p++;
            old_pos = p;
            p = text.find('\n', p);
            if (p == text.npos)
            {
                ls.push_back(Line{ text.substr(old_pos), line->n_indents });
                break;
            }
        }
        lines.insert(line, ls.begin(), ls.end());
        line = lines.erase(line);
        line--;
    }
}

inline Lines to_lines(const Polygon &poly) 
{
    Lines lines;
    lines.reserve(poly.points.size());
    for (Points::const_iterator it = poly.points.begin(); it != poly.points.end()-1; ++it)
        lines.push_back(Line(*it, *(it + 1)));
    lines.push_back(Line(poly.points.back(), poly.points.front()));
    return lines;
}

Lines
Polygon::lines() const
{
    Lines lines;
    for (int i = 0; i < this->points.size()-1; i++) {
        lines.push_back(Line(this->points[i], this->points[i+1]));
    }
    lines.push_back(Line(this->points.back(), this->points.front()));
    return lines;
}

Lines
Polygon::lines() const
{
    Lines lines;
    lines.reserve(this->points.size());
    for (Points::const_iterator it = this->points.begin(); it != this->points.end()-1; ++it) {
        lines.push_back(Line(*it, *(it + 1)));
    }
    lines.push_back(Line(this->points.back(), this->points.front()));
    return lines;
}

inline Lines to_lines(const ExPolygon &src) 
{
    size_t n_lines = src.contour.points.size();
    for (size_t i = 0; i < src.holes.size(); ++ i)
        n_lines += src.holes[i].points.size();
    Lines lines;
    lines.reserve(n_lines);
    for (size_t i = 0; i <= src.holes.size(); ++ i) {
        const Polygon &poly = (i == 0) ? src.contour : src.holes[i - 1];
        for (Points::const_iterator it = poly.points.begin(); it != poly.points.end()-1; ++it)
            lines.push_back(Line(*it, *(it + 1)));
        lines.push_back(Line(poly.points.back(), poly.points.front()));
    }
    return lines;
}

void
Parser::write(std::list<string>& args)
{
    DirectoryPrx dir = _dirs.front();
    string name = args.front();
    args.pop_front();
    NodeDesc d;
    try
    {
        d = dir->find(name);
    }
    catch(const NoSuchName&)
    {
        cout << "`" << name << "': no such file" << endl;
        return;
    }
    if(d.type == DirType)
    {
        cout << "`" << name << "': not a file" << endl;
        return;
    }
    FilePrx f = FilePrx::uncheckedCast(d.proxy);

    Lines l;
    for(std::list<string>::const_iterator i = args.begin(); i != args.end(); ++i)
    {
        l.push_back(*i);
    }
    f->write(l);
}

Lines NewlineFilter::FlushLinesFromTerminatedProcess(DWORD pid, HANDLE handle)
{
    Lines lines;
    if (m_lineBuffers.find(pid) != m_lineBuffers.end())
    {
        if (!m_lineBuffers[pid].empty())
        {
            // timestamp not filled, this will be done by the loopback source
            lines.push_back(Line(0, FILETIME(), pid, "<flush>", m_lineBuffers[pid], nullptr));
        }
        m_lineBuffers.erase(pid);
    }
    auto processName = Str(ProcessInfo::GetProcessName(handle)).str();
    auto info = ProcessInfo::GetProcessInfo(handle);
    std::string infoStr = stringbuilder() << "<process started at " << info << " has now terminated>";
    lines.push_back(Line(0, FILETIME(), pid, processName, infoStr, nullptr));
    return lines;
}

Lines GetLines(const CEdges& edges)
{
	Lines res;

	for (CEdges::const_iterator it = edges.begin(); it != edges.end(); ++it)
	{
		res.push_back(it->GetLine());
	}

	return res;
}

Lines get_starts(TextIter Xi, TextIter Yi) {
    Lines lines;
    int C = Xi.compare(Yi);
    while (C < 0) {
        lines.push_back(Xi.get_offset());
        if (!Xi.forward_line())
            break;
        C = Xi.compare(Yi);
    }
    return lines;
}

Lines DBWinReader::ProcessLine(const Line& line)
{
	Lines lines;
	if (m_lineBuffers.find(line.pid) == m_lineBuffers.end())
	{
		std::string message;
		message.reserve(4000);
		m_lineBuffers[line.pid] = std::move(message);
	}
	std::string& message = m_lineBuffers[line.pid];

	Line outputLine = line;
	for (auto i = line.message.begin(); i != line.message.end(); i++)
	{
		if (*i == '\r')
			continue;

		if (*i == '\n')
		{
			outputLine.message = std::move(message);
			message.clear();
			lines.push_back(outputLine);
		}
		else
		{
			message.push_back(char(*i));
		}
	}

	if (message.empty())
	{
		m_lineBuffers.erase(line.pid);
	}
	else if (m_autoNewLine || message.size() > 8192)	// 8k line limit prevents stack overflow in handling code 
	{
		outputLine.message = std::move(message);
		message.clear();
		lines.push_back(outputLine);
	}
	return lines;
}

Lines
Polyline::lines() const
{
    Lines lines;
    if (this->points.size() >= 2) {
        lines.reserve(this->points.size() - 1);
        for (Points::const_iterator it = this->points.begin(); it != this->points.end()-1; ++it) {
            lines.push_back(Line(*it, *(it + 1)));
        }
    }
    return lines;
}

void GetIntersection(Triangle& t1,Triangle& t2,Lines& res,std::vector<LineConf>* lines_conf,float*perimeter)
{
	Line ll;
	LineConf cc;
	if(CrossTriangles(t1,t2,&ll,cc.v))
	{
		if(!vecs_near(ll.v[0],ll.v[1]))
		{
			res.push_back(ll);
			if(lines_conf)lines_conf->push_back(cc);
			if(perimeter)*perimeter += ll.v[0].length(ll.v[1]);
		}//else printf(" BL ");
	}
}

Lines NewlineFilter::Process(const Line& line)
{
    Lines lines;
    auto& message = m_lineBuffers[line.pid];
    message.reserve(4000);

    Line outputLine = line;
    for (auto it = line.message.begin(); it != line.message.end(); ++it)
    {
        if (*it == '\r')
            continue;

        if (*it == '\n')
        {
            outputLine.message = message;
            message.clear();
            lines.push_back(outputLine);
        }
        else
        {
            message.push_back(*it);
        }
    }

    if (message.empty())
    {
        m_lineBuffers.erase(line.pid);
    }
    else if (outputLine.pLogSource->GetAutoNewLine() || message.size() > 8192)	// 8k line limit prevents stack overflow in handling code
    {
        outputLine.message = message;
        message.clear();
        lines.push_back(outputLine);
    }
    return lines;
}

Lines GetLine(CvPoints2d& cvline)
{
	Lines res;

	for (auto it = cvline.begin(); it != cvline.end(); ++it)
	{
		Line li;

		for (auto it2 = it->begin(); it2 != it->end(); ++it2)
		{
			li.push_back(Vector2(it2->x, it2->y));
		}

		res.push_back(li);
	}

	return res;
}

bool FileHelper::open(const std::string file_name, Lines& lines)
{
    std::ifstream file(file_name.c_str(), std::ios::in);
    if (!file) 
    {
        return false;
    }

    lines.clear();
    char buffer[buffer_size];

    while (file.getline(buffer, buffer_size, '\n'))
    {
        lines.push_back(buffer);
    }
    
    return true;
}