私有成员后缀用下划线

Src/Net/RpcChannel.cc

@@ -6,14 +6,14 @@
 namespace Hainan {
 
 RpcChannel::RpcChannel(
-		boost::asio::io_service& service, std::string& host, int port):
-		io_service(service)
+		boost::asio::io_service& io_service, std::string& host, int port):
+		io_service_(io_service)
 {
 	// another thread?
 	boost::asio::ip::address address;
 	address.from_string(host);
 	boost::asio::ip::tcp::endpoint endpoint(address, port);
-	socket.async_connect(endpoint,
+	socket_.async_connect(endpoint,
 			boost::bind(&RpcChannel::AsyncConnectHandler, this,
 					boost::asio::placeholders::error));
 }
@@ -31,7 +31,7 @@ void RpcChannel::AsyncConnectHandler(const boost::system::error_code& err)
 void RpcChannel::RecvMessegeSize()
 {
 	IntPtr size(new int);
-	boost::asio::async_read(socket,
+	boost::asio::async_read(socket_,
 			boost::asio::buffer(
 					reinterpret_cast<char*>(size.get()), sizeof(int)),
 			boost::bind(&RpcChannel::RecvMessage, this, size,
@@ -46,7 +46,7 @@ void RpcChannel::RecvMessage(IntPtr size, const boost::system::error_code& err)
 		return;
 	}
 	StringPtr ss;
-	boost::asio::async_read(socket,
+	boost::asio::async_read(socket_,
 			boost::asio::buffer(*ss, *size),
 			boost::bind(&RpcChannel::RecvMessageHandler, this, ss,
 					boost::asio::placeholders::error));
@@ -63,15 +63,15 @@ void RpcChannel::RecvMessageHandler(
 
 	RpcResponse response;
 	Response->ParseFromString(*ss);
-	RpcHandlerPtr handler = handlers[response.id()];
+	RpcHandlerPtr handler = handlers_[response.id()];
 	handler->GetResponse()->ParseFromString(response.response());
 
-	if (handler->done != NULL)
+	if (handler->done_ != NULL)
 	{
-		handler->done->Run();
+		handler->done_->Run();
 	}
 
-	handlers.erase(response.id());
+	handlers_.erase(response.id());
 
 	// read size
 	RecvMessegeSize();
@@ -85,7 +85,7 @@ void RpcChannel::SendMessageHandler(int32 id, RpcHandlerPtr handler,
 		LOG(ERROR) << "SendMessage error:";
 		return;
 	}
-	handlers[id] = handler;
+	handlers_[id] = handler;
 }
 
 void RpcChannel::SendMessage(const RpcRequestPtr request,
@@ -97,7 +97,7 @@ void RpcChannel::SendMessage(const RpcRequestPtr request,
 		return;
 	}
 	std::string ss = request->SerializeAsString();
-	boost::asio::async_write(socket, boost::asio::buffer(ss),
+	boost::asio::async_write(socket_, boost::asio::buffer(ss),
 			boost::bind(&RpcChannel::SendMessageHandler, this, request->id(),
 					handler, boost::asio::placeholders::error));
 }
@@ -107,7 +107,7 @@ void RpcChannel::SendMessageSize(
 {
 	int size = request->ByteSize();
 	std::string ss = boost::lexical_cast(size);
-	boost::asio::async_write(socket, boost::asio::buffer(ss),
+	boost::asio::async_write(socket_, boost::asio::buffer(ss),
 			boost::bind(&RpcChannel::SendMessage, this, request,
 					handler, boost::asio::placeholders::error));
 }
@@ -120,7 +120,7 @@ void RpcChannel::CallMethod(
 		google::protobuf::Closure* done)
 {
 	RpcRequestPtr req(new RpcRequest);
-	req->set_id(++id);
+	req->set_id(++id_);
 	req->set_method(method->full_name());
 	req->set_request(request->SerializeAsString());
 	RpcHandlerPtr handler(new RpcHandler(controller, response, done));

Src/Net/RpcChannel.h

@@ -15,10 +15,10 @@ class RpcChannel: public google::protobuf::RpcChannel
 private:
 	typedef boost::unordered_map<int32, RpcHandlerPtr> RpcCallbackMap;
 
-	int32 id;
-	RpcCallbackMap handlers;
-	boost::asio::io_service& io_service;
-	boost::asio::ip::tcp::socket socket;
+	int32 id_;
+	RpcCallbackMap handlers_;
+	boost::asio::io_service& io_service_;
+	boost::asio::ip::tcp::socket socket_;
 
 	void AsyncConnectHandler(const boost::system::error_code& err);
 

Src/Net/RpcChannelTest.cc

@@ -10,15 +10,15 @@ static int port = 10001;
 class RpcServerTest
 {
 public:
-	boost::asio::io_service io_service;
-	boost::asio::ip::tcp::acceptor acceptor;
-	boost::asio::ip::tcp::socket socket;
+	boost::asio::io_service io_service_;
+	boost::asio::ip::tcp::acceptor acceptor_;
+	boost::asio::ip::tcp::socket socket_;
 
 	int size;
 
 public:
 	RpcServerTest(boost::asio::io_service& service, int port):
-		io_service(service), size(0)
+		io_service_(service), size(0)
 	{
 		boost::asio::ip::address address;
 		address.from_string("localhost");
@@ -29,7 +29,7 @@ public:
 		boost::asio::ip::tcp::acceptor::reuse_address(true));
 		acceptor.bind(endpoint);
 		acceptor.listen();
-		acceptor.async_accept(socket);
+		acceptor.async_accept(socket_);
 	}
 	~RpcServerTest();
 
@@ -60,11 +60,11 @@ public:
 
 TEST_F(RpcChannelTest, CallMethod)
 {
-	RpcServerTest server(io_service, port);
+	RpcServerTest server(io_service_, port);
 	ASSERT_EQ(0, server.size);
 
-	RpcChannel channel(io_service, "localhost", port);
-	channel.CallMethod(NULL, NULL, request, response, done);
+	RpcChannel channel(io_service_, "localhost", port);
+	channel.CallMethod(NULL, NULL, request, response_, done_);
 
 	ASSERT_EQ(request.ByteSize(), server.size);
 }

Src/Net/RpcController.cc

@@ -2,44 +2,44 @@
 
 namespace Hainan {
 
-Hainan::RpcController::RpcController()
+RpcController::RpcController()
 {
 }
 
-Hainan::RpcController::~RpcController()
+RpcController::~RpcController()
 {
 }
 
-void Hainan::RpcController::Reset()
+void RpcController::Reset()
 {
-	failed = false;
-	reason = "";
-	canceled = false;
+	failed_ = false;
+	reason_ = "";
+	canceled_ = false;
 }
 
-bool Hainan::RpcController::Failed() const
+bool RpcController::Failed() const
 {
-	return failed;
+	return failed_;
 }
 
-std::string Hainan::RpcController::ErrorText() const
+std::string RpcController::ErrorText() const
 {
-	return reason;
+	return reason_;
 }
 
-void Hainan::RpcController::StartCancel()
+void RpcController::StartCancel()
 {
 }
 
-void Hainan::RpcController::SetFailed(const string & reason)
+void RpcController::SetFailed(const string & reason)
 {
 }
 
-bool Hainan::RpcController::IsCanceled() const
+bool RpcController::IsCanceled() const
 {
 }
 
-void Hainan::RpcController::NotifyOnCancel(Closure *callback)
+void RpcController::NotifyOnCancel(Closure *callback)
 {
 }
 

Src/Net/RpcController.h

@@ -8,9 +8,9 @@ namespace Hainan {
 class RpcController: public google::protobuf::RpcController
 {
 private:
-	bool failed;
-	std::string reason;
-	bool canceled;
+	bool failed_;
+	std::string reason_;
+	bool canceled_;
 
 public:
 	RpcController();

Src/Net/RpcHandler.cc

@@ -2,26 +2,26 @@
 
 namespace Hainan {
 
-RpcHandler::RpcHandler(google::protobuf::RpcController* p_controller,
-		google::protobuf::Message* p_response,
-		google::protobuf::Closure* p_done):
-		controller(p_controller), response(p_response), done(p_done)
+RpcHandler::RpcHandler(google::protobuf::RpcController* controller,
+		google::protobuf::Message* response,
+		google::protobuf::Closure* done):
+		controller_(controller), response_(response), done_(done)
 {
 }
 
 google::protobuf::RpcController *RpcHandler::GetController() const
 {
-    return controller;
+    return controller_;
 }
 
 google::protobuf::Closure *RpcHandler::GetDone() const
 {
-    return done;
+    return done_;
 }
 
 google::protobuf::Message *RpcHandler::GetResponse() const
 {
-    return response;
+    return response_;
 }
 
 } // namespace Hainan

Src/Net/RpcHandler.h

@@ -12,13 +12,13 @@ class google::protobuf::Closure;
 class RpcHandler
 {
 private:
-	google::protobuf::RpcController* controller;
-	google::protobuf::Message* response;
-	google::protobuf::Closure* done;
+	google::protobuf::RpcController* controller_;
+	google::protobuf::Message* response_;
+	google::protobuf::Closure* done_;
 public:
-	RpcHandler(google::protobuf::RpcController* p_controller,
-			google::protobuf::Message* p_response,
-			google::protobuf::Closure* p_done);
+	RpcHandler(google::protobuf::RpcController* controller,
+			google::protobuf::Message* response,
+			google::protobuf::Closure* done);
     google::protobuf::RpcController *GetController() const;
     google::protobuf::Closure *GetDone() const;
     google::protobuf::Message *GetResponse() const;

Src/Net/RpcServer.cc

@@ -9,17 +9,17 @@
 namespace Hainan {
 
 RpcServer::RpcServer(boost::asio::io_service& io_service, int port):
-		io_service(io_service), thread_pool()
+		io_service_(io_service), thread_pool_()
 {
 	boost::asio::ip::address address;
 	address.from_string("localhost");
 	boost::asio::ip::tcp::endpoint endpoint(address, port);
-	acceptor.open(endpoint.protocol());
-	acceptor.set_option(boost::asio::ip::tcp::acceptor::reuse_address(true));
-	acceptor.bind(endpoint);
-	acceptor.listen();
-	RpcSessionPtr new_session(new RpcSession(sessions));
-	acceptor.async_accept(new_session->socket(),
+	acceptor_.open(endpoint.protocol());
+	acceptor_.set_option(boost::asio::ip::tcp::acceptor::reuse_address(true));
+	acceptor_.bind(endpoint);
+	acceptor_.listen();
+	RpcSessionPtr new_session(new RpcSession(sessions_));
+	acceptor_.async_accept(new_session->socket(),
 			boost::bind(&RpcServer::HandleAsyncAccept, this,
 					boost::asio::placeholders::error));
 }
@@ -31,9 +31,9 @@ void RpcServer::HandleAsyncAccept(RpcSessionPtr session, const boost::system::er
 		return;
 	}
 	session->Start();
-	sessions.insert(session);
-	RpcSessionPtr new_session(new RpcSession(io_service, sessions));
-	acceptor.async_accept(new_session->socket(),
+	sessions_.insert(session);
+	RpcSessionPtr new_session(new RpcSession(io_service_, sessions_));
+	acceptor_.async_accept(new_session->socket(),
 			boost::bind(&RpcServer::HandleAsyncAccept, this,
 					boost::asio::placeholders::error));
 }
@@ -46,12 +46,12 @@ void RpcServer::Callback(RpcSessionPtr session,
 
 void RpcServer::Stop()
 {
-	acceptor.close();
-	foreach(RpcSessionPtr session, rpc_server->sessions)
+	acceptor_.close();
+	foreach(RpcSessionPtr session, rpc_server->sessions_)
 	{
 		session->Stop();
 	}
-	sessions.clear();
+	sessions_.clear();
 }
 
 void RpcServer::RunService(RpcSessionPtr session, RpcRequestPtr request,
@@ -59,8 +59,8 @@ void RpcServer::RunService(RpcSessionPtr session, RpcRequestPtr request,
 {
 	google::protobuf::Closure* done = google::protobuf::NewCallback(
 			this, &RpcServer::Callback, session, handler);
-	thread_pool.PushTask(
-			boost::bind(&google::protobuf::Service::CallMethod, &service,
+	thread_pool_.PushTask(
+			boost::bind(&google::protobuf::Service::CallMethod, &service_,
 					method, NULL, request.get(), done));
 }
 
@@ -71,7 +71,7 @@ void RpcServer::RegisterService(ProtobufServicePtr service)
 
 void RpcServer::Start()
 {
-	io_service.run();
+	io_service_.run();
 }
 
 } // namespace Hainan

Src/Net/RpcServer.h

@@ -10,11 +10,11 @@ class RpcServer: public boost::enable_shared_from_this<RpcServer>
 private:
 	typedef boost::unordered_set<RpcSessionPtr> RpcSessionSet;
 
-	google::protobuf::Service& service;
-	boost::asio::io_service& io_service;
-	boost::asio::ip::tcp::acceptor acceptor;
-	ThreadPool thread_pool;
-	RpcSessionSet sessions;
+	google::protobuf::Service& service_;
+	boost::asio::io_service& io_service_;
+	boost::asio::ip::tcp::acceptor acceptor_;
+	ThreadPool thread_pool_;
+	RpcSessionSet sessions_;
 
 	void HandleAsyncAccept(RpcSessionPtr session, const boost::system::error_code& err);
 	void Callback(RpcSessionPtr session,

Src/Net/RpcSession.cc

@@ -2,7 +2,7 @@
 
 namespace Hainan {
 
-RpcSession::RpcSession(RpcSessionSet& rpc_sessions): sessions(rpc_sessions)
+RpcSession::RpcSession(RpcSessionSet& rpc_sessions): sessions_(rpc_sessions)
 {
 }
 
@@ -19,7 +19,7 @@ void RpcSession::SendMessageHandler(int32 id, RpcHandlerPtr handler,
 		LOG(ERROR) << "SendMessage error:";
 		return;
 	}
-	handlers[id] = handler;
+	handlers_[id] = handler;
 }
 
 void RpcSession::SendMessage(const RpcResponsePtr response, const boost::system::error_code& err)
@@ -31,7 +31,7 @@ void RpcSession::SendMessage(const RpcResponsePtr response, const boost::system:
 	std::string ss = response->SerializeAsString();
 	boost::asio::async_write(socket, boost::asio::buffer(ss),
 			boost::bind(&RpcSession::SendMessageHandler, this,
-					response->id(), boost::asio::placeholders::error));
+					response->id_(), boost::asio::placeholders::error));
 }
 
 void RpcSession::SendMessageSize(RpcResponsePtr response)
@@ -80,7 +80,7 @@ void RpcSession::RecvMessageHandler(StringPtr ss, const boost::system::error_cod
 	request->ParseFromString(*ss);
 
 	RpcResponsePtr response(new RpcResponse);
-	response->set_id(request->id());
+	response->set_id(request->id_());
 
 	rpc_server.RunService(shared_from_this(), request,
 			boost::bind(&RpcSession::SendMessegeSize, shared_from_this(), response));
@@ -97,7 +97,7 @@ void RpcSession::Start()
 void RpcSession::Stop()
 {
 	socket.close();
-	sessions.erase(shared_from_this());
+	sessions_.erase(shared_from_this());
 }
 
 }

Src/Thread/ThreadPool.cc

@@ -4,11 +4,11 @@
 namespace Hainan {
 
 ThreadPool::ThreadPool(int num) :
-	thread_num(num), running(false), work_num(0)
+	thread_num_(num), running_(false), work_num_(0)
 {
 	if (num == 0)
 	{
-		thread_num = boost::thread::hardware_concurrency();
+		thread_num_ = boost::thread::hardware_concurrency();
 	}
 }
 
@@ -18,27 +18,27 @@ ThreadPool::~ThreadPool()
 
 void ThreadPool::Start()
 {
-	running = true;
-	for (int i = 0; i < thread_num; ++i)
+	running_ = true;
+	for (int i = 0; i < thread_num_; ++i)
 	{
 		ThreadPtr t(new boost::thread(
 				boost::bind(&ThreadPool::Runner, this)));
-		threads.push_back(t);
+		threads_.push_back(t);
 		t->detach();
-		++work_num;
+		++work_num_;
 	}
 }
 
 void ThreadPool::Stop()
 {
 	VLOG(3)<< "Stop";
-	boost::mutex::scoped_lock lock(mutex);
-	running = false;
-	cond.notify_all();
-	while (work_num > 0)
+	boost::mutex::scoped_lock lock(mutex_);
+	running_ = false;
+	cond_.notify_all();
+	while (work_num_ > 0)
 	{
-		VLOG(3) << "done tasks size = " << tasks.size();
-		done.wait(lock);
+		VLOG(3) << "done tasks size = " << tasks_.size();
+		done_.wait(lock);
 	}
 }
 
@@ -51,23 +51,23 @@ void ThreadPool::Runner()
 		boost::function<void (void)> task;
 		{
 			VLOG(3) << "loop lock";
-			boost::mutex::scoped_lock lock(mutex);
+			boost::mutex::scoped_lock lock(mutex_);
 			VLOG(3) << "loop lock ok";
-			while (running && tasks.empty())
+			while (running_ && tasks_.empty())
 			{
-				cond.wait(lock);
+				cond_.wait(lock);
 				VLOG(3) << "cond";
 			}
-			if (!tasks.empty())
+			if (!tasks_.empty())
 			{
 				VLOG(3) << "fetch task";
-				task = tasks.front();
-				tasks.pop_front();
+				task = tasks_.front();
+				tasks_.pop_front();
 			}
-			continued = running || !tasks.empty();
+			continued = running_ || !tasks_.empty();
 			VLOG(3) << "continued = " << continued
-			<< "running = " << running
-			<< " tasks size = " << tasks.size();
+			<< "running = " << running_
+			<< " tasks size = " << tasks_.size();
 			VLOG(3) << "loop unlock";
 		}
 
@@ -76,10 +76,10 @@ void ThreadPool::Runner()
 			task();
 		}
 	}
-	if (--work_num == 0)
+	if (--work_num_ == 0)
 	{
-		VLOG(3) << "work_num = " << work_num;
-		done.notify_one();
+		VLOG(3) << "work_num = " << work_num_;
+		done_.notify_one();
 	}
 }
 
@@ -87,15 +87,15 @@ bool ThreadPool::PushTask(boost::function<void (void)> task)
 {
 	VLOG(3) << "push task";
 	{
-		boost::mutex::scoped_lock lock(mutex);
-		if (!running)
+		boost::mutex::scoped_lock lock(mutex_);
+		if (!running_)
 		{
 			return false;
 		}
-		tasks.push_back(task);
+		tasks_.push_back(task);
 	}
 	VLOG(3) << "push task unlock";
-	cond.notify_one();
+	cond_.notify_one();
 	return true;
 }
 

Src/Thread/ThreadPool.h

@@ -12,14 +12,14 @@ namespace Hainan {
 class ThreadPool: private boost::noncopyable
 {
 private:
-	int thread_num;
-	boost::detail::atomic_count work_num;
-	volatile bool running;
-	boost::mutex mutex;
-	boost::condition_variable cond;
-	boost::condition_variable done;
-	std::list<ThreadPtr> threads;
-	std::list<boost::function<void (void)> > tasks;
+	int thread_num_;
+	boost::detail::atomic_count work_num_;
+	volatile bool running_;
+	boost::mutex mutex_;
+	boost::condition_variable cond_;
+	boost::condition_variable done_;
+	std::list<ThreadPtr> threads_;
+	std::list<boost::function<void (void)> > tasks_;
 
 	void Runner();
 public:

Src/Thread/ThreadPoolTest.cc

@@ -10,9 +10,9 @@ namespace Hainan {
 class ThreadPoolTest: public testing::Test
 {
 protected:
-	ThreadPool pool;
+	ThreadPool pool_;
 public:
-	ThreadPoolTest() : pool(10)
+	ThreadPoolTest() : pool_(10)
 	{
 	}
 	void Max(int a, int b, int* z)
@@ -23,16 +23,16 @@ public:
 
 TEST_F(ThreadPoolTest, Test1)
 {
-	pool.Start();
+	pool_.Start();
 	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.PushTask(
+		pool_.PushTask(
 				boost::bind(&ThreadPoolTest::Max, this, x[i], y[i], &z[i]));
 	}
-	pool.Stop();
+	pool_.Stop();
 	for (int i = 0; i < 100; ++i)
 	{
 		ASSERT_EQ(9, z[i])<< "i = " << i;