C++ boost::make_tuple方法代码示例

int main()
{
    using boost::assign::tuple_list_of;
    using boost::make_tuple;
    using boost::geometry::append;

    typedef boost::geometry::model::polygon<boost::tuple<int, int> > polygon;

    polygon poly;

    // Append a range
    append(poly, tuple_list_of(0, 0)(0, 10)(11, 11)(10, 0)); /*< tuple_list_of delivers a range and can therefore be used in boost::geometry::append >*/
    // Append a point (in this case the closing point)
    append(poly, make_tuple(0, 0));

    // Create an interior ring (append does not do this automatically)
    boost::geometry::interior_rings(poly).resize(1);

    // Append a range to the interior ring
    append(poly, tuple_list_of(2, 2)(2, 5)(6, 6)(5, 2), 0); /*< The last parameter ring_index 0 denotes the first interior ring >*/
    // Append a point to the first interior ring
    append(poly, make_tuple(2, 2), 0);

    std::cout << boost::geometry::dsv(poly) << std::endl;

    return 0;
}

// void TCPSocket::HandleTcpSend(const boost::asio::error& err, size_t bytes_transferred, MyBuffer b)
void TCPClientSocket::HandleTcpSend(const boost::system::error_code& err, size_t bytes_transferred)
{
	if ( m_SendQueue.empty() )
	{
		//TRACE("HandleTcpSend %lu %d\n", GetCurrentThreadId(), m_Socket->GetSocket().native());
		APP_ERROR("TCPClientSocket::HandleTcpSend invalid empty buffer " << make_tuple( err.value(), bytes_transferred, m_SendQueue.size() ));
		assert(false == m_Socket->GetSocket().is_open());
		return;
	}
	m_SendQueue.pop_front();
	if ( err )
	{
		// ·¢ËÍʧ°Ü
		APP_ERROR("TCPClientSocket::HandleTcpSend error " << make_tuple( err.value(), bytes_transferred, m_SendQueue.size() ));
		this->GetListener()->OnSocketReceiveFailed(this, err.value());
	}
	else
	{
		if ( m_SendQueue.empty() )
		{
			return;
		}
		else
		{
			this->DoAsyncSend(m_SendQueue.front());
		}
	}
}

tuple<int, int, bool> feed_bytes(http_parser& parser, char const* str)
{
	tuple<int, int, bool> ret(0, 0, false);
	tuple<int, int, bool> prev(0, 0, false);
	for (int chunks = 1; chunks < 70; ++chunks)
	{
		ret = make_tuple(0, 0, false);
		parser.reset();
		buffer::const_interval recv_buf(str, str);
		for (; *str;)
		{
			int chunk_size = (std::min)(chunks, int(strlen(recv_buf.end)));
			if (chunk_size == 0) break;
			recv_buf.end += chunk_size;
			int payload, protocol;
			bool error = false;
			tie(payload, protocol) = parser.incoming(recv_buf, error);
			ret.get<0>() += payload;
			ret.get<1>() += protocol;
			ret.get<2>() |= error;
//			std::cerr << payload << ", " << protocol << ", " << chunk_size << std::endl;
			TORRENT_ASSERT(payload + protocol == chunk_size || ret.get<2>());
		}
		TEST_CHECK(prev == make_tuple(0, 0, false) || ret == prev || ret.get<2>());
		if (!ret.get<2>())
		{
			TEST_EQUAL(ret.get<0>() + ret.get<1>(), strlen(str));
		}

		prev = ret;
	}
	return ret;
}

    iteration_stats do_iteration()
    {
        using namespace boost::chrono;
        using boost::make_tuple;

        // Zero the counters (to be set during advance() by our slot)
        tree_time_ = particle_time_ = 0.0;
        particles_visited_ = pparticles_visited_ = 0;

        // Get the number of acceleration evals before advancing
        const int init_neval = particle_pusher_.num_acceleval();

        // Get the current time
        const steady_clock::time_point start_time = steady_clock::now();

        // Advance the system
        particle_pusher_.advance();

        // Determine how much time has elapsed
        const duration<double> net_push_time = steady_clock::now() - start_time;

        // Generate the iteration statistics; see accel_timings_slot
        return make_tuple(tree_time_,
                          particle_time_,
                          net_push_time.count() - tree_time_ - particle_time_,
                          particles_visited_,
                          pparticles_visited_,
                          particle_pusher_.num_acceleval() - init_neval);
    }

int main()
{
    tuple<int, double> a, b, c;
    a = tuple<int, double>();
    b = tuple<int, double>(1);
    c = tuple<int, double>(1, 3.14);
    a = make_tuple(1, 2.57);

    int i;
    double d;
    tie(i, d) = a;
    i = a.get<0>();
    d = a.get<1>();

    std::cout << "version=" << BOOST_VERSION/100000 << "."
              << ((BOOST_VERSION / 100) % 100) << "."
              << BOOST_VERSION % 100 << std::endl;

    return 0;
}

int test_main()
{
	// HTTP request parser
	http_parser parser;
	boost::tuple<int, int, bool> received;

	received = feed_bytes(parser
		, "HTTP/1.1 200 OK\r\n"
		"Content-Length: 4\r\n"
		"Content-Type: text/plain\r\n"
		"\r\n"
		"test");

	TEST_CHECK(received == make_tuple(4, 64, false));
	TEST_CHECK(parser.finished());
	TEST_CHECK(std::equal(parser.get_body().begin, parser.get_body().end, "test"));
	TEST_CHECK(parser.header("content-type") == "text/plain");
	TEST_CHECK(atoi(parser.header("content-length").c_str()) == 4);

	parser.reset();

	TEST_CHECK(!parser.finished());

	char const* upnp_response =
		"HTTP/1.1 200 OK\r\n"
		"ST:upnp:rootdevice\r\n"
		"USN:uuid:000f-66d6-7296000099dc::upnp:rootdevice\r\n"
		"Location: http://192.168.1.1:5431/dyndev/uuid:000f-66d6-7296000099dc\r\n"
		"Server: Custom/1.0 UPnP/1.0 Proc/Ver\r\n"
		"EXT:\r\n"
		"Cache-Control:max-age=180\r\n"
		"DATE: Fri, 02 Jan 1970 08:10:38 GMT\r\n\r\n";

	received = feed_bytes(parser, upnp_response);

	TEST_CHECK(received == make_tuple(0, int(strlen(upnp_response)), false));
	TEST_CHECK(parser.get_body().left() == 0);
	TEST_CHECK(parser.header("st") == "upnp:rootdevice");
	TEST_CHECK(parser.header("location")
		== "http://192.168.1.1:5431/dyndev/uuid:000f-66d6-7296000099dc");
	TEST_CHECK(parser.header("ext") == "");
	TEST_CHECK(parser.header("date") == "Fri, 02 Jan 1970 08:10:38 GMT");
	TEST_EQUAL(parser.connection_close(), false);

	// test connection close
	parser.reset();

	TEST_CHECK(!parser.finished());

	char const* http1_response =
		"HTTP/1.0 200 OK\r\n"
		"Cache-Control: max-age=180\r\n"
		"DATE: Fri, 02 Jan 1970 08:10:38 GMT\r\n\r\n";

	received = feed_bytes(parser, http1_response);

	TEST_CHECK(received == make_tuple(0, int(strlen(http1_response)), false));
	TEST_CHECK(parser.get_body().left() == 0);
	TEST_CHECK(parser.header("date") == "Fri, 02 Jan 1970 08:10:38 GMT");
	TEST_EQUAL(parser.connection_close(), true);

	parser.reset();

	TEST_CHECK(!parser.finished());

	char const* close_response =
		"HTTP/1.1 200 OK\r\n"
		"Connection: close\r\n"
		"DATE: Fri, 02 Jan 1970 08:10:38 GMT\r\n\r\n";

	received = feed_bytes(parser, close_response);

	TEST_CHECK(received == make_tuple(0, int(strlen(close_response)), false));
	TEST_CHECK(parser.get_body().left() == 0);
	TEST_CHECK(parser.header("date") == "Fri, 02 Jan 1970 08:10:38 GMT");
	TEST_EQUAL(parser.connection_close(), true);

	parser.reset();

	TEST_CHECK(!parser.finished());

	char const* keep_alive_response =
		"HTTP/1.1 200 OK\r\n"
		"Connection: keep-alive\r\n"
		"DATE: Fri, 02 Jan 1970 08:10:38 GMT\r\n\r\n";

	received = feed_bytes(parser, keep_alive_response);

	TEST_CHECK(received == make_tuple(0, int(strlen(keep_alive_response)), false));
	TEST_CHECK(parser.get_body().left() == 0);
	TEST_CHECK(parser.header("date") == "Fri, 02 Jan 1970 08:10:38 GMT");
	TEST_EQUAL(parser.connection_close(), false);

	parser.reset();
	TEST_CHECK(!parser.finished());

	char const* upnp_notify =
		"NOTIFY * HTTP/1.1\r\n"
		"Host:239.255.255.250:1900\r\n"
		"NT:urn:schemas-upnp-org:device:MediaServer:1\r\n"
//.........这里部分代码省略.........

void GuideSemantics::CreateGuideMapping()
{
    m_GuideTypeMapping[ GuideSemantics::Cover ]
        = make_tuple(QString("cover"),           QObject::tr("Cover"));
    m_GuideTypeMapping[ GuideSemantics::TitlePage ]
        = make_tuple(QString("title-page"),      QObject::tr("Title Page"));
    m_GuideTypeMapping[ GuideSemantics::TableOfContents ]
        = make_tuple(QString("toc"),             QObject::tr("Table Of Contents"));
    m_GuideTypeMapping[ GuideSemantics::Index ]
        = make_tuple(QString("index"),           QObject::tr("Index"));
    m_GuideTypeMapping[ GuideSemantics::Glossary ]
        = make_tuple(QString("glossary"),        QObject::tr("Glossary"));
    m_GuideTypeMapping[ GuideSemantics::Acknowledgements ]
        = make_tuple(QString("acknowledgements"), QObject::tr("Acknowledgements"));
    m_GuideTypeMapping[ GuideSemantics::Bibliography ]
        = make_tuple(QString("bibliography"),    QObject::tr("Bibliography"));
    m_GuideTypeMapping[ GuideSemantics::Colophon ]
        = make_tuple(QString("colophon"),        QObject::tr("Colophon"));
    m_GuideTypeMapping[ GuideSemantics::CopyrightPage ]
        = make_tuple(QString("copyright-page"),  QObject::tr("Copyright Page"));
    m_GuideTypeMapping[ GuideSemantics::Dedication ]
        = make_tuple(QString("dedication"),      QObject::tr("Dedication"));
    m_GuideTypeMapping[ GuideSemantics::Epigraph ]
        = make_tuple(QString("epigraph"),        QObject::tr("Epigraph"));
    m_GuideTypeMapping[ GuideSemantics::Foreword ]
        = make_tuple(QString("foreword"),        QObject::tr("Foreword"));
    m_GuideTypeMapping[ GuideSemantics::ListOfIllustrations ]
        = make_tuple(QString("loi"),             QObject::tr("List Of Illustrations"));
    m_GuideTypeMapping[ GuideSemantics::ListOfTables ]
        = make_tuple(QString("lot"),             QObject::tr("List Of Tables"));
    m_GuideTypeMapping[ GuideSemantics::Notes ]
        = make_tuple(QString("notes"),           QObject::tr("Notes"));
    m_GuideTypeMapping[ GuideSemantics::Preface ]
        = make_tuple(QString("preface"),         QObject::tr("Preface"));
    m_GuideTypeMapping[ GuideSemantics::Text ]
        = make_tuple(QString("text"),            QObject::tr("Text"));
}