1.boost::bind boost::function boost::shared_ptr 等boost库使用C++ 11标准库替代

2.缺少某些第三方库就不进行相应模块的编译，比如缺少mysql connector就不编译orm

Cpp/Cmake/FindMono.cmake

@@ -1,6 +1,5 @@
 FIND_PROGRAM(MONO_EXECUTABLE mono)
-FIND_PROGRAM(MONO_GMCS_EXECUTABLE gmcs)
-FIND_PROGRAM(MONO_GACUTIL_EXECUTABLE gacutil)
+FIND_PROGRAM(MONO_MCS_EXECUTABLE dmcs)
 
 IF(WIN32)
 	FIND_PATH(MONO_INCLUDE_DIR mono/jit/jit.h)
@@ -19,6 +18,6 @@ SET(MONO_LIBRARIES ${MONO_LIBRARY})
 
 INCLUDE(FindPackageHandleStandardArgs)
 FIND_PACKAGE_HANDLE_STANDARD_ARGS(MONO DEFAULT_MSG
-		MONO_EXECUTABLE MONO_GMCS_EXECUTABLE MONO_GACUTIL_EXECUTABLE MONO_INCLUDE_DIR MONO_LIBRARY)
+		MONO_EXECUTABLE MONO_MCS_EXECUTABLE MONO_INCLUDE_DIR MONO_LIBRARY)
 
-MARK_AS_ADVANCED(MONO_EXECUTABLE MONO_GMCS_EXECUTABLE MONO_GACUTIL_EXECUTABLE MONO_INCLUDE_DIR MONO_LIBRARY)
+MARK_AS_ADVANCED(MONO_EXECUTABLE MONO_MCS_EXECUTABLE MONO_INCLUDE_DIR MONO_LIBRARY)

Cpp/Cmake/FindMysqlConnector.cmake

@@ -16,4 +16,4 @@ IF(MYSQL_CONNECTOR_FOUND)
 	SET(MYSQL_CONNECTOR_LIBRARIES    ${MYSQL_CONNECTOR_LIBRARY})
 ENDIF()
 
-MARK_AS_ADVANCED(GTEST_INCLUDE_DIR GTEST_LIBRARY)
+MARK_AS_ADVANCED(MYSQL_CONNECTOR_INCLUDE_DIR MYSQL_CONNECTOR_LIBRARY)

Cpp/Platform/Base/Typedef.h

@@ -1,7 +1,8 @@
 #ifndef BASE_TYPEDEFS_H
 #define BASE_TYPEDEFS_H
+
+#include <memory>
 #include <boost/cstdint.hpp>
-#include <boost/shared_ptr.hpp>
 #include <google/protobuf/service.h>
 #include <google/protobuf/message.h>
 
@@ -18,12 +19,12 @@ typedef boost::uint64_t uint64;
 
 // smart_ptr typedef
 
-typedef boost::shared_ptr<int> IntPtr;
-typedef boost::shared_ptr<std::string> StringPtr;
+typedef std::shared_ptr<int> IntPtr;
+typedef std::shared_ptr<std::string> StringPtr;
 
 // google
-typedef boost::shared_ptr<google::protobuf::Service> ProtobufServicePtr;
-typedef boost::shared_ptr<google::protobuf::Message> ProtobufMessagePtr;
+typedef std::shared_ptr<google::protobuf::Service> ProtobufServicePtr;
+typedef std::shared_ptr<google::protobuf::Message> ProtobufMessagePtr;
 
 } // namespace Egametang
 

Cpp/Platform/CMakeLists.txt

@@ -1,5 +1,14 @@
 ADD_SUBDIRECTORY(Thread)
 ADD_SUBDIRECTORY(Rpc)
-ADD_SUBDIRECTORY(Mono)
-ADD_SUBDIRECTORY(Orm)
-ADD_SUBDIRECTORY(Log)
+
+IF(MONO_FOUND)
+	ADD_SUBDIRECTORY(Mono)
+ENDIF()
+
+IF(MYSQL_CONNECTOR_FOUND)
+	ADD_SUBDIRECTORY(Orm)
+ENDIF()
+
+IF(Boost_Log_FOUND)
+	ADD_SUBDIRECTORY(Log)
+ENDIF()

Cpp/Platform/Log/Log.cc

@@ -3,8 +3,7 @@
 
 #include <fstream>
 #include <iostream>
-#include <boost/shared_ptr.hpp>
-#include <boost/make_shared.hpp>
+#include <memory>
 #include <boost/date_time/posix_time/posix_time_types.hpp>
 #include <boost/log/common.hpp>
 #include <boost/log/filters.hpp>
@@ -43,9 +42,9 @@ void ELog::Init(const char* fileName)
 
 	auto core = core::get();
 	typedef sinks::synchronous_sink<sinks::text_ostream_backend> text_sink;
-	auto pSink = boost::make_shared<text_sink>();
+	auto pSink = std::make_shared<text_sink>();
 	std::string logFileName = FileName(fileName) + ".log";
-	auto logStream = boost::make_shared<std::ofstream>(logFileName.c_str());
+	auto logStream = std::make_shared<std::ofstream>(logFileName.c_str());
 	if (!logStream->good())
 	{
 		throw std::runtime_error("Failed to open a log file");
@@ -56,7 +55,7 @@ void ELog::Init(const char* fileName)
 	if (FLAGS_logtoconsole)
 	{
 		pSink->locked_backend()->add_stream(
-		        boost::shared_ptr<std::ostream>(&std::clog, boost::log::empty_deleter()));
+		        std::shared_ptr<std::ostream>(&std::clog, boost::log::empty_deleter()));
 	}
 
 	pSink->locked_backend()->set_formatter(
@@ -69,9 +68,9 @@ void ELog::Init(const char* fileName)
 
 	pSink->set_filter(boost::log::filters::attr<SeverityLevel>("Severity", std::nothrow) >= INFO);
 
-    core->add_global_attribute("Line #", boost::make_shared<attributes::counter<unsigned int>>());
-    core->add_global_attribute("TimeStamp", boost::make_shared<attributes::local_clock>());
-    core->add_global_attribute("ThreadID", boost::make_shared<attributes::current_thread_id>());
+    core->add_global_attribute("Line #", std::make_shared<attributes::counter<unsigned int>>());
+    core->add_global_attribute("TimeStamp", std::make_shared<attributes::local_clock>());
+    core->add_global_attribute("ThreadID", std::make_shared<attributes::current_thread_id>());
 
 	core->add_sink(pSink);
 }

Cpp/Platform/Log/Log.h

@@ -5,7 +5,7 @@
 #define BASE_LOG_H
 
 #include <string>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 #include <boost/log/trivial.hpp>
 #include <boost/log/sources/severity_logger.hpp>
 

Cpp/Platform/Mono/MonoInit.h

@@ -5,7 +5,7 @@
 #define MONO_MONOINIT_H
 
 #include <string>
-#include <boost/unordered_map.hpp>
+#include <unordered_map>
 #include <mono/jit/jit.h>
 #include <mono/metadata/assembly.h>
 
@@ -15,7 +15,7 @@ class MonoInit
 {
 private:
 	MonoDomain *domain;
-	boost::unordered_map<std::string, MonoImage*> imageMap;
+	std::unordered_map<std::string, MonoImage*> imageMap;
 
 public:
 	MonoInit(const std::string& domainName);

Cpp/Platform/Orm/DbHelper.h

@@ -4,8 +4,6 @@
 #ifndef ORM_SQLHELPER_H
 #define ORM_SQLHELPER_H
 
-#include <boost/scoped_ptr.hpp>
-#include <boost/make_shared.hpp>
 #include <cppconn/driver.h>
 #include <cppconn/exception.h>
 #include <cppconn/resultset.h>
@@ -21,8 +19,8 @@ namespace Egametang {
 class DbHelper
 {
 private:
-	boost::scoped_ptr<sql::Connection> connection;
-	boost::scoped_ptr<sql::Statement> statement;
+	std::unique_ptr<sql::Connection> connection;
+	std::unique_ptr<sql::Statement> statement;
 
 public:
 	DbHelper(std::string url, std::string username, std::string password);
@@ -34,7 +32,7 @@ public:
 		std::string sql = select.ToString();
 		VLOG(2) << "execute sql: " << sql;
 		ResultSetPtr resultSet(statement->executeQuery(sql));
-		auto dbResult = boost::make_shared<DbResult>(resultSet);
+		auto dbResult = std::make_shared<DbResult>(resultSet);
 		return dbResult;
 	}
 };

Cpp/Platform/Orm/DbResult.h

@@ -26,7 +26,7 @@ public:
 	std::size_t Count();
 
 	template <typename Table>
-	void All(std::vector<boost::shared_ptr<Table> >& messages)
+	void All(std::vector<std::shared_ptr<Table> >& messages)
 	{
 		for (std::size_t i = 0; i < messages.size(); ++i)
 		{

Cpp/Platform/Orm/DbResultTest.cc

@@ -1,7 +1,7 @@
 // Copyright: All Rights Reserved
 // Author: egametang@gmail.com (tanghai)
 
-#include <boost/make_shared.hpp>
+#include <memory>
 #include <gtest/gtest.h>
 #include <gflags/gflags.h>
 #include <glog/logging.h>
@@ -28,7 +28,7 @@ TEST_F(DbResultTest, One)
 				Where(Column("age") > 10)
 			);
 
-		auto person = boost::make_shared<Person>();
+		auto person = std::make_shared<Person>();
 		result->One(person);
 		ASSERT_EQ(26, person->age());
 	}

Cpp/Platform/Orm/Expr.h

@@ -6,7 +6,7 @@
 
 #include <list>
 #include <string>
-#include <boost/unordered_set.hpp>
+#include <unordered_set>
 #include <google/protobuf/message.h>
 
 namespace Egametang {

Cpp/Platform/Orm/MessageFieldTest.cc

@@ -2,7 +2,7 @@
 // Author: egametang@gmail.com (tanghai)
 
 #include <sstream>
-#include <boost/make_shared.hpp>
+#include <memory>
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
 #include <glog/logging.h>
@@ -14,7 +14,6 @@
 
 namespace Egametang {
 
-using namespace boost;
 using testing::_;
 using testing::Invoke;
 using testing::Return;
@@ -173,7 +172,7 @@ TEST_F(MessageFieldTest, GetField_FieldIsMessage)
 
 TEST_F(MessageFieldTest, SetField_FieldIsBool)
 {
-	ResultSetMockPtr resultSetMock = make_shared<ResultSetMock>();
+	auto resultSetMock = std::make_shared<ResultSetMock>();
 	EXPECT_CALL(*resultSetMock, getBoolean(8))
 		.WillOnce(Return(true))
 		.WillOnce(Return(false));
@@ -192,7 +191,7 @@ TEST_F(MessageFieldTest, SetField_FieldIsBool)
 
 TEST_F(MessageFieldTest, SetField_FieldIsDouble)
 {
-	ResultSetMockPtr resultSetMock = make_shared<ResultSetMock>();
+	auto resultSetMock = std::make_shared<ResultSetMock>();
 	EXPECT_CALL(*resultSetMock, getDouble(6))
 		.WillOnce(Return(1.00))
 		.WillOnce(Return(12345.6789));
@@ -211,7 +210,7 @@ TEST_F(MessageFieldTest, SetField_FieldIsDouble)
 
 TEST_F(MessageFieldTest, SetField_FieldIsInt32)
 {
-	ResultSetMockPtr resultSetMock = make_shared<ResultSetMock>();
+	auto resultSetMock = std::make_shared<ResultSetMock>();
 	EXPECT_CALL(*resultSetMock, getInt(2))
 		.WillOnce(Return(1))
 		.WillOnce(Return(0xFFFFFFFF));
@@ -230,7 +229,7 @@ TEST_F(MessageFieldTest, SetField_FieldIsInt32)
 
 TEST_F(MessageFieldTest, SetField_FieldIsInt64)
 {
-	ResultSetMockPtr resultSetMock = make_shared<ResultSetMock>();
+	auto resultSetMock = std::make_shared<ResultSetMock>();
 	EXPECT_CALL(*resultSetMock, getInt64(1))
 		.WillOnce(Return(1))
 		.WillOnce(Return(0xFFFFFFFFFFFFFFFF));
@@ -249,7 +248,7 @@ TEST_F(MessageFieldTest, SetField_FieldIsInt64)
 
 TEST_F(MessageFieldTest, SetField_FieldIsUInt32)
 {
-	ResultSetMockPtr resultSetMock = make_shared<ResultSetMock>();
+	auto resultSetMock = std::make_shared<ResultSetMock>();
 	EXPECT_CALL(*resultSetMock, getUInt(3))
 		.WillOnce(Return(1))
 		.WillOnce(Return(0xFFFFFFFF));
@@ -268,7 +267,7 @@ TEST_F(MessageFieldTest, SetField_FieldIsUInt32)
 
 TEST_F(MessageFieldTest, SetField_FieldIsUInt64)
 {
-	ResultSetMockPtr resultSetMock = make_shared<ResultSetMock>();
+	auto resultSetMock = std::make_shared<ResultSetMock>();
 	EXPECT_CALL(*resultSetMock, getUInt64(4))
 		.WillOnce(Return(1))
 		.WillOnce(Return(0xFFFFFFFFFFFFFFFF));
@@ -287,7 +286,7 @@ TEST_F(MessageFieldTest, SetField_FieldIsUInt64)
 
 TEST_F(MessageFieldTest, SetField_FieldIsString)
 {
-	ResultSetMockPtr resultSetMock = make_shared<ResultSetMock>();
+	auto resultSetMock = std::make_shared<ResultSetMock>();
 	EXPECT_CALL(*resultSetMock, getString(5))
 		.WillOnce(Return("1"))
 		.WillOnce(Return("tanghai"));
@@ -306,7 +305,7 @@ TEST_F(MessageFieldTest, SetField_FieldIsString)
 
 TEST_F(MessageFieldTest, SetField_FieldIsBytes)
 {
-	ResultSetMockPtr resultSetMock = make_shared<ResultSetMock>();
+	auto resultSetMock = std::make_shared<ResultSetMock>();
 	EXPECT_CALL(*resultSetMock, getString(7))
 		.WillOnce(Return("1"))
 		.WillOnce(Return("tanghai is a good student"));
@@ -327,7 +326,7 @@ TEST_F(MessageFieldTest, SetField_FieldIsMessage)
 {
 	std::istringstream is;
 	is.str("id: 123 name: \"pen\"");
-	ResultSetMockPtr resultSetMock = make_shared<ResultSetMock>();
+	auto resultSetMock = std::make_shared<ResultSetMock>();
 	EXPECT_CALL(*resultSetMock, getBlob(9))
 		.WillOnce(Return(&is));
 	Person person;

Cpp/Platform/Orm/Select.h

@@ -6,7 +6,6 @@
 
 #include <string>
 #include <vector>
-#include <boost/foreach.hpp>
 #include <boost/lexical_cast.hpp>
 #include <google/protobuf/descriptor.h>
 #include "Base/Marcos.h"

Cpp/Platform/Orm/Typedef.h

@@ -4,7 +4,7 @@
 #ifndef ORM_TYPEDEF_H
 #define ORM_TYPEDEF_H
 
-#include <boost/shared_ptr.hpp>
+#include <memory>
 #include <cppconn/resultset.h>
 
 namespace Egametang {
@@ -12,10 +12,10 @@ namespace Egametang {
 class DbResult;
 class ResultSetMock;
 
-typedef boost::shared_ptr<sql::ResultSet> ResultSetPtr;
-typedef boost::shared_ptr<sql::Statement> StatementPtr;
-typedef boost::shared_ptr<DbResult> DbResultPtr;
-typedef boost::shared_ptr<ResultSetMock> ResultSetMockPtr;
+typedef std::shared_ptr<sql::ResultSet> ResultSetPtr;
+typedef std::shared_ptr<sql::Statement> StatementPtr;
+typedef std::shared_ptr<DbResult> DbResultPtr;
+typedef std::shared_ptr<ResultSetMock> ResultSetMockPtr;
 
 } // namespace Egametang
 

Cpp/Platform/Python/PythonInterpreter.h

@@ -2,7 +2,7 @@
 #define PYTHON_PYTHONINTERPRETER_H
 
 #include <boost/noncopyable.hpp>
-#include <boost/unordered_set.hpp>
+#include <unordered_set>
 #include <boost/shared_ptr.hpp>
 #include "Base/Marcos.h"
 #include "Python/PythonInit.h"
@@ -14,8 +14,8 @@ class PythonInterpreter: private boost::noncopyable
 private:
 	PythonInit python;
 	boost::python::object mainNS;
-	boost::unordered_set<std::string> paths;
-	boost::unordered_set<std::string> modules;
+	std::unordered_set<std::string> paths;
+	std::unordered_set<std::string> modules;
 
 private:
 	bool GetExecString(const std::string& main_fun, std::string& exec_string);
@@ -28,7 +28,7 @@ public:
 	void ImportModule(std::string module);
 
 	template <typename T>
-	void RegisterObjectPtr(std::string name, boost::shared_ptr<T> object_ptr)
+	void RegisterObjectPtr(std::string name, std::shared_ptr<T> object_ptr)
 	{
 		mainNS[name.c_str()] = object_ptr;
 	}

Cpp/Platform/Python/PythonInterpreterTest.cc

@@ -1,5 +1,5 @@
 #include <boost/python.hpp>
-#include <boost/make_shared.hpp>
+#include <memory>
 #include <gtest/gtest.h>
 #include <glog/logging.h>
 #include <gflags/gflags.h>
@@ -53,7 +53,7 @@ public:
 	}
 };
 
-typedef boost::shared_ptr<PersonTest> PersonTestPtr;
+typedef std::shared_ptr<PersonTest> PersonTestPtr;
 
 BOOST_PYTHON_MODULE(PersonTest)
 {
@@ -72,7 +72,7 @@ TEST_F(PythonInterpreterTest, EnterPythonScript)
 	interpreter.ImportPath("../../../Cpp/Platform/Python/");
 	interpreter.ImportModule("PythonInterpreterTest");
 
-	auto person = boost::make_shared<PersonTest>();
+	auto person = std::make_shared<PersonTest>();
 	interpreter.RegisterObjectPtr("person", person);
 
 	ASSERT_EQ(0, person->Guid());

Cpp/Platform/Rpc/ResponseHandler.cc

@@ -1,4 +1,4 @@
-#include <boost/make_shared.hpp>
+#include <memory>
 #include <glog/logging.h>
 #include "Rpc/MethodInfo.h"
 #include "Rpc/ResponseHandler.h"
@@ -40,8 +40,8 @@ google::protobuf::Message* ResponseHandler::Response()
 
 void ResponseHandler::Run()
 {
-	auto meta = boost::make_shared<RpcMeta>();
-	auto message = boost::make_shared<std::string>();
+	auto meta = std::make_shared<RpcMeta>();
+	auto message = std::make_shared<std::string>();
 	response->SerializeToString(message.get());
 	meta->id = id;
 	meta->size = message->size();

Cpp/Platform/Rpc/ResponseHandler.h

@@ -1,7 +1,6 @@
 #ifndef RPC_RESPONSEHANDLER_H
 #define RPC_RESPONSEHANDLER_H
 
-#include <boost/function.hpp>
 #include <google/protobuf/service.h>
 #include <google/protobuf/message.h>
 #include "Base/Typedef.h"

Cpp/Platform/Rpc/RpcClient.cc

@@ -1,6 +1,5 @@
+#include <functional>
 #include <boost/asio.hpp>
-#include <boost/bind.hpp>
-#include <boost/make_shared.hpp>
 #include <google/protobuf/message.h>
 #include <google/protobuf/descriptor.h>
 #include <glog/logging.h>
@@ -18,8 +17,8 @@ RpcClient::RpcClient(boost::asio::io_service& ioService, std::string host, int p
 	address.from_string(host);
 	boost::asio::ip::tcp::endpoint endpoint(address, port);
 	socket.async_connect(endpoint,
-			boost::bind(&RpcClient::OnAsyncConnect, this,
-					boost::asio::placeholders::error));
+			std::bind(&RpcClient::OnAsyncConnect, this,
+					std::placeholders::_1));
 }
 
 RpcClient::~RpcClient()
@@ -32,8 +31,8 @@ void RpcClient::OnAsyncConnect(const boost::system::error_code& err)
 	{
 		return;
 	}
-	auto recvMeta = boost::make_shared<RpcMeta>();
-	auto recvMessage = boost::make_shared<std::string>();
+	auto recvMeta = std::make_shared<RpcMeta>();
+	auto recvMessage = std::make_shared<std::string>();
 	RecvMeta(recvMeta, recvMessage);
 }
 
@@ -72,13 +71,13 @@ void RpcClient::CallMethod(
 {
 	if (done)
 	{
-		auto request_handler = boost::make_shared<RequestHandler>(response, done);
+		auto request_handler = std::make_shared<RequestHandler>(response, done);
 		requestHandlers[++id] = request_handler;
 	}
-	boost::hash<std::string> stringHash;
-	auto message = boost::make_shared<std::string>();
+	std::hash<std::string> stringHash;
+	auto message = std::make_shared<std::string>();
 	request->SerializePartialToString(message.get());
-	auto meta = boost::make_shared<RpcMeta>();
+	auto meta = std::make_shared<RpcMeta>();
 	meta->size = message->size();
 	meta->id = id;
 	meta->method = stringHash(method->full_name());

Cpp/Platform/Rpc/RpcClient.h

@@ -1,7 +1,7 @@
 #ifndef RPC_RPCCLIENT_H
 #define RPC_RPCCLIENT_H
 
-#include <boost/unordered_map.hpp>
+#include <unordered_map>
 #include <boost/enable_shared_from_this.hpp>
 #include <boost/asio.hpp>
 #include <boost/thread.hpp>
@@ -19,7 +19,7 @@ class RpcClient:
 	public boost::enable_shared_from_this<RpcClient>
 {
 private:
-	typedef boost::unordered_map<std::size_t, RequestHandlerPtr> RequestHandlerMap;
+	typedef std::unordered_map<std::size_t, RequestHandlerPtr> RequestHandlerMap;
 
 	std::size_t id;
 	RequestHandlerMap requestHandlers;

Cpp/Platform/Rpc/RpcClientTest.cc

@@ -31,8 +31,8 @@ public:
 		acceptor.bind(endpoint);
 		acceptor.listen();
 		acceptor.async_accept(socket,
-				boost::bind(&RpcServerTest::OnAsyncAccept, this,
-						boost::asio::placeholders::error));
+				std::bind(&RpcServerTest::OnAsyncAccept, this,
+						std::placeholders::_1));
 	}
 	~RpcServerTest()
 	{
@@ -46,8 +46,8 @@ public:
 		{
 			return;
 		}
-		auto meta = boost::make_shared<RpcMeta>();
-		auto message = boost::make_shared<std::string>();
+		auto meta = std::make_shared<RpcMeta>();
+		auto message = std::make_shared<std::string>();
 		RecvMeta(meta, message);
 	}
 
@@ -61,9 +61,9 @@ public:
 		EchoResponse response;
 		response.set_num(num);
 
-		auto responseMessage = boost::make_shared<std::string>();
+		auto responseMessage = std::make_shared<std::string>();
 		response.SerializeToString(responseMessage.get());
-		auto responseMeta = boost::make_shared<RpcMeta>();
+		auto responseMeta = std::make_shared<RpcMeta>();
 		responseMeta->id = meta->id;
 		responseMeta->size = responseMessage->size();
 		SendMeta(responseMeta, responseMessage);
@@ -91,14 +91,14 @@ TEST_F(RpcClientTest, Echo)
 
 	CountBarrier barrier(2);
 	RpcServerTest server(ioServer, globalPort, barrier);
-	auto client = boost::make_shared<RpcClient>(ioClient, "127.0.0.1", globalPort);
+	auto client = std::make_shared<RpcClient>(ioClient, "127.0.0.1", globalPort);
 	EchoService_Stub service(client.get());
 
 	boost::threadpool::fifo_pool threadPool(2);
-	threadPool.schedule(boost::bind(&IOServiceRun, &ioServer));
+	threadPool.schedule(std::bind(&IOServiceRun, &ioServer));
 
 	boost::this_thread::sleep(boost::posix_time::milliseconds(500));
-	threadPool.schedule(boost::bind(&IOServiceRun, &ioClient));
+	threadPool.schedule(std::bind(&IOServiceRun, &ioClient));
 
 	EchoRequest request;
 	request.set_num(100);
@@ -111,8 +111,8 @@ TEST_F(RpcClientTest, Echo)
 	barrier.Wait();
 
 	// 加入任务队列,等client和server stop,io_service才stop
-	ioClient.post(boost::bind(&boost::asio::io_service::stop, &ioClient));
-	ioServer.post(boost::bind(&boost::asio::io_service::stop, &ioServer));
+	ioClient.post(std::bind(&boost::asio::io_service::stop, &ioClient));
+	ioServer.post(std::bind(&boost::asio::io_service::stop, &ioServer));
 	ASSERT_EQ(100, response.num());
 }
 

Cpp/Platform/Rpc/RpcCommunicator.cc

@@ -1,4 +1,4 @@
-#include <boost/bind.hpp>
+#include <functional>
 #include <boost/asio.hpp>
 #include <boost/lexical_cast.hpp>
 #include "Rpc/RpcCommunicator.h"
@@ -29,8 +29,8 @@ void RpcCommunicator::RecvMeta(RpcMetaPtr meta, StringPtr message)
 {
 	boost::asio::async_read(socket,
 			boost::asio::buffer(reinterpret_cast<char*>(meta.get()), sizeof(*meta)),
-			boost::bind(&RpcCommunicator::RecvMessage, this,
-					meta, message, boost::asio::placeholders::error));
+			std::bind(&RpcCommunicator::RecvMessage, this,
+					meta, message, std::placeholders::_1));
 }
 
 void RpcCommunicator::RecvMessage(RpcMetaPtr meta, StringPtr message,
@@ -44,8 +44,8 @@ void RpcCommunicator::RecvMessage(RpcMetaPtr meta, StringPtr message,
 	message->resize(meta->size, 0);
 	boost::asio::async_read(socket,
 			boost::asio::buffer(reinterpret_cast<char*>(&message->at(0)), meta->size),
-			boost::bind(&RpcCommunicator::RecvDone, this,
-					meta, message, boost::asio::placeholders::error));
+			std::bind(&RpcCommunicator::RecvDone, this,
+					meta, message, std::placeholders::_1));
 }
 
 void RpcCommunicator::RecvDone(RpcMetaPtr meta, StringPtr message,
@@ -68,8 +68,8 @@ void RpcCommunicator::SendMeta(RpcMetaPtr meta, StringPtr message)
 {
 	boost::asio::async_write(socket,
 			boost::asio::buffer(reinterpret_cast<char*>(meta.get()), sizeof(*meta)),
-			boost::bind(&RpcCommunicator::SendMessage, this,
-					meta, message, boost::asio::placeholders::error));
+			std::bind(&RpcCommunicator::SendMessage, this,
+					meta, message, std::placeholders::_1));
 }
 
 void RpcCommunicator::SendMessage(RpcMetaPtr meta, StringPtr message,
@@ -81,8 +81,8 @@ void RpcCommunicator::SendMessage(RpcMetaPtr meta, StringPtr message,
 		return;
 	}
 	boost::asio::async_write(socket, boost::asio::buffer(*message),
-			boost::bind(&RpcCommunicator::SendDone, this,
-					meta, message, boost::asio::placeholders::error));
+			std::bind(&RpcCommunicator::SendDone, this,
+					meta, message, std::placeholders::_1));
 }
 
 void RpcCommunicator::SendDone(RpcMetaPtr meta, StringPtr message,

Cpp/Platform/Rpc/RpcCommunicator.h

@@ -2,7 +2,7 @@
 #define RPC_RPCCOMMUNICATOR_H
 
 #include <google/protobuf/service.h>
-#include <boost/unordered_map.hpp>
+#include <unordered_map>
 #include <boost/asio.hpp>
 #include <boost/format.hpp>
 #include <boost/noncopyable.hpp>

Cpp/Platform/Rpc/RpcCommunicatorTest.cc

@@ -1,7 +1,6 @@
-#include <boost/bind.hpp>
 #include <boost/asio.hpp>
 #include <boost/threadpool.hpp>
-#include <boost/make_shared.hpp>
+#include <memory>
 #include <gtest/gtest.h>
 #include <glog/logging.h>
 #include <gflags/gflags.h>
@@ -33,8 +32,8 @@ public:
 		acceptor.bind(endpoint);
 		acceptor.listen();
 		acceptor.async_accept(socket,
-				boost::bind(&RpcServerTest::OnAsyncAccept, this,
-						boost::asio::placeholders::error));
+				std::bind(&RpcServerTest::OnAsyncAccept, this,
+						std::placeholders::_1));
 	}
 
 	void OnAsyncAccept(const boost::system::error_code& err)
@@ -44,8 +43,8 @@ public:
 			return;
 		}
 
-		auto meta = boost::make_shared<RpcMeta>();
-		auto message = boost::make_shared<std::string>();
+		auto meta = std::make_shared<RpcMeta>();
+		auto message = std::make_shared<std::string>();
 		RecvMeta(meta, message);
 	}
 
@@ -65,8 +64,8 @@ public:
 		recvMessage = *message;
 		recvMeta = *meta;
 
-		auto responseMeta = boost::make_shared<RpcMeta>();
-		auto response_message = boost::make_shared<std::string>(
+		auto responseMeta = std::make_shared<RpcMeta>();
+		auto response_message = std::make_shared<std::string>(
 				"response test rpc communicator string");
 		responseMeta->size = response_message->size();
 		responseMeta->method = 123456;
@@ -93,8 +92,8 @@ public:
 		boost::asio::ip::tcp::endpoint endpoint(address, port);
 		VLOG(2) << "port: " << port;
 		socket.async_connect(endpoint,
-				boost::bind(&RpcClientTest::OnAsyncConnect, this,
-						boost::asio::placeholders::error));
+				std::bind(&RpcClientTest::OnAsyncConnect, this,
+						std::placeholders::_1));
 	}
 
 	void Start()
@@ -114,15 +113,15 @@ public:
 			return;
 		}
 
-		auto sendMeta = boost::make_shared<RpcMeta>();
-		auto sendMessage = boost::make_shared<std::string>(
+		auto sendMeta = std::make_shared<RpcMeta>();
+		auto sendMessage = std::make_shared<std::string>(
 				"send test rpc communicator string");
 		sendMeta->size = sendMessage->size();
 		sendMeta->method = 654321;
 		SendMeta(sendMeta, sendMessage);
 
-		auto meta = boost::make_shared<RpcMeta>();
-		auto message = boost::make_shared<std::string>();
+		auto meta = std::make_shared<RpcMeta>();
+		auto message = std::make_shared<std::string>();
 		RecvMeta(meta, message);
 	}
 
@@ -148,15 +147,15 @@ TEST_F(RpcCommunicatorTest, SendAndRecvString)
 	RpcClientTest rpcClient(ioClient, globalPort, barrier);
 
 	boost::threadpool::fifo_pool threadPool(2);
-	threadPool.schedule(boost::bind(&RpcServerTest::Start, &rpcServer));
+	threadPool.schedule(std::bind(&RpcServerTest::Start, &rpcServer));
 
 	boost::this_thread::sleep(boost::posix_time::milliseconds(500));
-	threadPool.schedule(boost::bind(&RpcClientTest::Start, &rpcClient));
+	threadPool.schedule(std::bind(&RpcClientTest::Start, &rpcClient));
 	barrier.Wait();
 	threadPool.wait();
 
-	ioClient.post(boost::bind(&boost::asio::io_service::stop, &ioClient));
-	ioServer.post(boost::bind(&boost::asio::io_service::stop, &ioServer));
+	ioClient.post(std::bind(&boost::asio::io_service::stop, &ioClient));
+	ioServer.post(std::bind(&boost::asio::io_service::stop, &ioServer));
 
 	ASSERT_EQ(std::string("send test rpc communicator string"), rpcServer.recvMessage);
 	ASSERT_EQ(rpcServer.recvMeta.size, rpcServer.recvMessage.size());

Cpp/Platform/Rpc/RpcServer.cc

@@ -1,6 +1,6 @@
+#include <functional>
+#include <memory>
 #include <boost/asio.hpp>
-#include <boost/bind.hpp>
-#include <boost/make_shared.hpp>
 #include <google/protobuf/service.h>
 #include <google/protobuf/descriptor.h>
 #include "Base/Marcos.h"
@@ -24,10 +24,10 @@ RpcServer::RpcServer(boost::asio::io_service& service, int port):
 	acceptor.set_option(boost::asio::ip::tcp::acceptor::reuse_address(true));
 	acceptor.bind(endpoint);
 	acceptor.listen();
-	auto newSession = boost::make_shared<RpcSession>(ioService, *this);
+	auto newSession = std::make_shared<RpcSession>(ioService, *this);
 	acceptor.async_accept(newSession->Socket(),
-			boost::bind(&RpcServer::OnAsyncAccept, this,
-					newSession, boost::asio::placeholders::error));
+			std::bind(&RpcServer::OnAsyncAccept, this,
+					newSession, std::placeholders::_1));
 }
 
 RpcServer::~RpcServer()
@@ -44,17 +44,17 @@ void RpcServer::OnAsyncAccept(RpcSessionPtr session, const boost::system::error_
 	}
 	session->Start();
 	sessions.insert(session);
-	auto newSession = boost::make_shared<RpcSession>(ioService, *this);
+	auto newSession = std::make_shared<RpcSession>(ioService, *this);
 	acceptor.async_accept(newSession->Socket(),
-			boost::bind(&RpcServer::OnAsyncAccept, this,
-					newSession, boost::asio::placeholders::error));
+			std::bind(&RpcServer::OnAsyncAccept, this,
+					newSession, std::placeholders::_1));
 }
 
 void RpcServer::OnCallMethod(RpcSessionPtr session, ResponseHandlerPtr responseHandler)
 {
 	// 调度到网络线
 	session->Socket().get_io_service().post(
-			boost::bind(&ResponseHandler::Run, responseHandler));
+			std::bind(&ResponseHandler::Run, responseHandler));
 }
 
 void RpcServer::RunService(
@@ -64,13 +64,13 @@ void RpcServer::RunService(
 	MethodInfoPtr methodInfo = methods[meta->method];
 
 	auto responseHandler =
-			boost::make_shared<ResponseHandler>(meta, message, methodInfo, messageHandler);
+			std::make_shared<ResponseHandler>(meta, message, methodInfo, messageHandler);
 
 	google::protobuf::Closure* done = google::protobuf::NewCallback(
 			this, &RpcServer::OnCallMethod, session, responseHandler);
 
 	threadPool.schedule(
-			boost::bind(&google::protobuf::Service::CallMethod, methodInfo->GetService(),
+			std::bind(&google::protobuf::Service::CallMethod, methodInfo->GetService(),
 					&responseHandler->Method(), (google::protobuf::RpcController*)(nullptr),
 					responseHandler->Request(), responseHandler->Response(),
 					done));
@@ -78,14 +78,14 @@ void RpcServer::RunService(
 
 void RpcServer::Register(ProtobufServicePtr service)
 {
-	boost::hash<std::string> stringHash;
+	std::hash<std::string> stringHash;
 	const google::protobuf::ServiceDescriptor* serviceDescriptor = service->GetDescriptor();
 	for (int i = 0; i < serviceDescriptor->method_count(); ++i)
 	{
 		const google::protobuf::MethodDescriptor* methodDescriptor =
 				serviceDescriptor->method(i);
 		std::size_t methodHash = stringHash(methodDescriptor->full_name());
-		auto methodInfo = boost::make_shared<MethodInfo>(service, methodDescriptor);
+		auto methodInfo = std::make_shared<MethodInfo>(service, methodDescriptor);
 		methods[methodHash] = methodInfo;
 	}
 }

Cpp/Platform/Rpc/RpcServer.h

@@ -1,9 +1,10 @@
 #ifndef RPC_RPCSERVER_H
 #define RPC_RPCSERVER_H
+
+#include <functional>
+#include <unordered_set>
+#include <unordered_map>
 #include <boost/asio.hpp>
-#include <boost/function.hpp>
-#include <boost/unordered_set.hpp>
-#include <boost/unordered_map.hpp>
 #include <boost/enable_shared_from_this.hpp>
 #include <boost/threadpool.hpp>
 #include <google/protobuf/service.h>
@@ -12,8 +13,8 @@
 
 namespace Egametang {
 
-typedef boost::unordered_set<RpcSessionPtr> RpcSessionSet;
-typedef boost::unordered_map<std::size_t, MethodInfoPtr> MethodMap;
+typedef std::unordered_set<RpcSessionPtr> RpcSessionSet;
+typedef std::unordered_map<std::size_t, MethodInfoPtr> MethodMap;
 
 class RpcServer: public boost::noncopyable, public boost::enable_shared_from_this<RpcServer>
 {

Cpp/Platform/Rpc/RpcServerMock.h

@@ -1,10 +1,10 @@
 #ifndef RPC_RPCSERVERMOCK_H
 #define RPC_RPCSERVERMOCK_H
 
+#include <functional>
+#include <unordered_set>
+#include <unordered_map>
 #include <boost/asio.hpp>
-#include <boost/function.hpp>
-#include <boost/unordered_set.hpp>
-#include <boost/unordered_map.hpp>
 #include <google/protobuf/service.h>
 #include <gmock/gmock.h>
 #include "Rpc/RpcServer.h"

Cpp/Platform/Rpc/RpcServerTest.cc

@@ -1,8 +1,7 @@
-#include <boost/bind.hpp>
+#include <functional>
+#include <memory>
 #include <boost/asio.hpp>
-#include <boost/function.hpp>
 #include <boost/threadpool.hpp>
-#include <boost/make_shared.hpp>
 #include <gtest/gtest.h>
 #include <glog/logging.h>
 #include <gflags/gflags.h>
@@ -57,14 +56,14 @@ TEST_F(RpcServerTest, ClientAndServer)
 
 	boost::threadpool::fifo_pool threadPool(2);
 
-	auto echoSevice = boost::make_shared<MyEcho>();
+	auto echoSevice = std::make_shared<MyEcho>();
 
-	auto server = boost::make_shared<RpcServer>(ioServer, globalPort);
+	auto server = std::make_shared<RpcServer>(ioServer, globalPort);
 	// 注册service
 	server->Register(echoSevice);
 	ASSERT_EQ(1U, GetMethodMap(server).size());
 
-	auto client = boost::make_shared<RpcClient>(ioClient, "127.0.0.1", globalPort);
+	auto client = std::make_shared<RpcClient>(ioClient, "127.0.0.1", globalPort);
 	EchoService_Stub service(client.get());
 
 	// 定义消息
@@ -74,10 +73,10 @@ TEST_F(RpcServerTest, ClientAndServer)
 	ASSERT_EQ(0U, response.num());
 
 	// server和client分别在两个不同的线程
-	threadPool.schedule(boost::bind(&IOServiceRun, &ioServer));
+	threadPool.schedule(std::bind(&IOServiceRun, &ioServer));
 	// 等待server OK
 	boost::this_thread::sleep(boost::posix_time::milliseconds(100));
-	threadPool.schedule(boost::bind(&IOServiceRun, &ioClient));
+	threadPool.schedule(std::bind(&IOServiceRun, &ioClient));
 
 	CountBarrier barrier;
 	service.Echo(nullptr, &request, &response,
@@ -85,8 +84,8 @@ TEST_F(RpcServerTest, ClientAndServer)
 	barrier.Wait();
 
 	// 加入任务队列,等client和server stop,io_service才stop
-	ioClient.post(boost::bind(&boost::asio::io_service::stop, &ioClient));
-	ioServer.post(boost::bind(&boost::asio::io_service::stop, &ioServer));
+	ioClient.post(std::bind(&boost::asio::io_service::stop, &ioClient));
+	ioServer.post(std::bind(&boost::asio::io_service::stop, &ioServer));
 
 	// 必须主动让client和server stop才能wait线程
 	threadPool.wait();

Cpp/Platform/Rpc/RpcSession.cc

@@ -1,5 +1,5 @@
-#include <boost/bind.hpp>
-#include <boost/make_shared.hpp>
+#include <memory>
+#include <functional>
 #include "Rpc/RpcSession.h"
 #include "Rpc/RpcServer.h"
 
@@ -16,9 +16,10 @@ RpcSession::~RpcSession()
 
 void RpcSession::OnRecvMessage(RpcMetaPtr meta, StringPtr message)
 {
-	RpcSessionPtr session = shared_from_this();
+	auto session = shared_from_this();
 	rpcServer.RunService(session, meta, message,
-			boost::bind(&RpcSession::SendMeta, session, _1, _2));
+			std::bind(&RpcSession::SendMeta, session,
+					std::placeholders::_1, std::placeholders::_2));
 
 	// RunService函数里读完就不使用了,可以循环利用
 	RecvMeta(meta, message);
@@ -30,8 +31,8 @@ void RpcSession::OnSendMessage(RpcMetaPtr meta, StringPtr message)
 
 void RpcSession::Start()
 {
-	auto meta = boost::make_shared<RpcMeta>();
-	auto message = boost::make_shared<std::string>();
+	auto meta = std::make_shared<RpcMeta>();
+	auto message = std::make_shared<std::string>();
 	RecvMeta(meta, message);
 }
 
@@ -44,7 +45,7 @@ void RpcSession::Stop()
 	isStopped = true;
 	// 延迟删除,必须等所有的bind执行完成后才能remove,
 	// 否则会出现this指针失效的问题
-	ioService.post(boost::bind(&RpcServer::Remove, &rpcServer, shared_from_this()));
+	ioService.post(std::bind(&RpcServer::Remove, &rpcServer, shared_from_this()));
 }
 
 } // namespace Egametang

Cpp/Platform/Rpc/RpcSession.h

@@ -11,7 +11,7 @@ namespace Egametang {
 
 class RpcServer;
 
-class RpcSession: public RpcCommunicator, public boost::enable_shared_from_this<RpcSession>
+class RpcSession: public RpcCommunicator, public std::enable_shared_from_this<RpcSession>
 {
 private:
 	RpcServer& rpcServer;

Cpp/Platform/Rpc/RpcSessionTest.cc

@@ -1,4 +1,3 @@
-#include <boost/bind.hpp>
 #include <boost/asio.hpp>
 #include <gtest/gtest.h>
 #include <glog/logging.h>

Cpp/Platform/Rpc/Typedef.h

@@ -1,8 +1,8 @@
 #ifndef RPC_TYPEDEF_H
 #define RPC_TYPEDEF_H
 
-#include <boost/shared_ptr.hpp>
-#include <boost/function.hpp>
+#include <memory>
+#include <functional>
 #include "Base/Typedef.h"
 
 namespace Egametang {
@@ -15,16 +15,15 @@ class MethodInfo;
 class RpcMeta;
 class ResponseHandler;
 
-typedef boost::shared_ptr<RpcServer> 	              RpcServerPtr;
-typedef boost::shared_ptr<RpcSession>                 RpcSessionPtr;
-typedef boost::shared_ptr<RpcClient>                  RpcClientPtr;
-typedef boost::shared_ptr<MethodInfo>                 MethodInfoPtr;
-typedef boost::shared_ptr<RpcMeta> 	                  RpcMetaPtr;
-typedef boost::shared_ptr<RequestHandler>             RequestHandlerPtr;
-typedef boost::shared_ptr<ResponseHandler>            ResponseHandlerPtr;
+typedef std::shared_ptr<RpcServer> 	                RpcServerPtr;
+typedef std::shared_ptr<RpcSession>                 RpcSessionPtr;
+typedef std::shared_ptr<RpcClient>                  RpcClientPtr;
+typedef std::shared_ptr<MethodInfo>                 MethodInfoPtr;
+typedef std::shared_ptr<RpcMeta> 	                RpcMetaPtr;
+typedef std::shared_ptr<RequestHandler>             RequestHandlerPtr;
+typedef std::shared_ptr<ResponseHandler>            ResponseHandlerPtr;
 
-typedef boost::weak_ptr<RpcServer>                    RpcServerWPtr;
-typedef boost::function<void (RpcMetaPtr, StringPtr)> MessageHandler;
+typedef std::function<void (RpcMetaPtr, StringPtr)> MessageHandler;
 
 } // namespace Egametang
 

Cpp/Platform/Thread/CountBarrierTest.cc

@@ -1,5 +1,3 @@
-#include <boost/bind.hpp>
-#include <boost/ref.hpp>
 #include <boost/detail/atomic_count.hpp>
 #include <boost/date_time.hpp>
 #include <boost/threadpool.hpp>
@@ -47,8 +45,8 @@ TEST_F(CountBarrierTest, WaitAndSignal)
 	for (int i = 0; i < 10; ++i)
 	{
 		pool.schedule(
-				boost::bind(&CountBarrierTest::Signal,
-						this, boost::ref(barrier)));
+				std::bind(&CountBarrierTest::Signal,
+						this, std::ref(barrier)));
 	}
 	ASSERT_EQ(0, this->count);
 	barrier.Wait();

Cpp/Platform/Thread/ThreadPoolTest.cc

@@ -1,5 +1,4 @@
-#include <boost/function.hpp>
-#include <boost/bind.hpp>
+#include <functional>
 #include <boost/threadpool.hpp>
 #include <gtest/gtest.h>
 #include <glog/logging.h>
@@ -9,34 +8,22 @@ namespace Egametang {
 
 class ThreadPoolTest: public testing::Test
 {
-protected:
-	boost::threadpool::fifo_pool pool;
-
-public:
-	ThreadPoolTest() : pool(10)
-	{
-	}
-
-	virtual ~ThreadPoolTest()
-	{
-	}
-
-	void Max(int a, int b, int* z)
-	{
-		*z = a > b? a : b;
-	}
 };
 
+static void Max(int a, int b, int* z)
+{
+	*z = a > b? a : b;
+}
+
 TEST_F(ThreadPoolTest, Test1)
 {
+	boost::threadpool::fifo_pool pool(10);
 	std::vector<int> x(100, 8);
 	std::vector<int> y(100, 9);
 	std::vector<int> z(100, 0);
 	for (int i = 0; i < 100; ++i)
 	{
-		pool.schedule(
-				boost::bind(&ThreadPoolTest::Max,
-						this, x[i], y[i], &z[i]));
+		pool.schedule(std::bind(&Max, x[i], y[i], &z[i]));
 	}
 	pool.wait();
 	for (int i = 0; i < 100; ++i)