You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@thrift.apache.org by hc...@apache.org on 2014/11/18 10:02:33 UTC

[05/37] thrift git commit: THRIFT-2729: C++ - .clang-format created and applied

http://git-wip-us.apache.org/repos/asf/thrift/blob/74260aa9/lib/cpp/src/thrift/transport/TSocket.cpp
----------------------------------------------------------------------
diff --git a/lib/cpp/src/thrift/transport/TSocket.cpp b/lib/cpp/src/thrift/transport/TSocket.cpp
index af7240a..ea85bfb 100644
--- a/lib/cpp/src/thrift/transport/TSocket.cpp
+++ b/lib/cpp/src/thrift/transport/TSocket.cpp
@@ -46,24 +46,26 @@
 #include <thrift/transport/PlatformSocket.h>
 
 #ifndef SOCKOPT_CAST_T
-#   ifndef _WIN32
-#       define SOCKOPT_CAST_T void
-#   else
-#       define SOCKOPT_CAST_T char
-#   endif // _WIN32
+#ifndef _WIN32
+#define SOCKOPT_CAST_T void
+#else
+#define SOCKOPT_CAST_T char
+#endif // _WIN32
 #endif
 
-template<class T>
+template <class T>
 inline const SOCKOPT_CAST_T* const_cast_sockopt(const T* v) {
-    return reinterpret_cast<const SOCKOPT_CAST_T*>(v);
+  return reinterpret_cast<const SOCKOPT_CAST_T*>(v);
 }
 
-template<class T>
+template <class T>
 inline SOCKOPT_CAST_T* cast_sockopt(T* v) {
-    return reinterpret_cast<SOCKOPT_CAST_T*>(v);
+  return reinterpret_cast<SOCKOPT_CAST_T*>(v);
 }
 
-namespace apache { namespace thrift { namespace transport {
+namespace apache {
+namespace thrift {
+namespace transport {
 
 using namespace std;
 
@@ -75,66 +77,66 @@ uint32_t g_socket_syscalls = 0;
  *
  */
 
-TSocket::TSocket(string host, int port) :
-  host_(host),
-  port_(port),
-  path_(""),
-  socket_(THRIFT_INVALID_SOCKET),
-  connTimeout_(0),
-  sendTimeout_(0),
-  recvTimeout_(0),
-  keepAlive_(false),
-  lingerOn_(1),
-  lingerVal_(0),
-  noDelay_(1),
-  maxRecvRetries_(5) {
-}
-
-TSocket::TSocket(string path) :
-  host_(""),
-  port_(0),
-  path_(path),
-  socket_(THRIFT_INVALID_SOCKET),
-  connTimeout_(0),
-  sendTimeout_(0),
-  recvTimeout_(0),
-  keepAlive_(false),
-  lingerOn_(1),
-  lingerVal_(0),
-  noDelay_(1),
-  maxRecvRetries_(5) {
+TSocket::TSocket(string host, int port)
+  : host_(host),
+    port_(port),
+    path_(""),
+    socket_(THRIFT_INVALID_SOCKET),
+    connTimeout_(0),
+    sendTimeout_(0),
+    recvTimeout_(0),
+    keepAlive_(false),
+    lingerOn_(1),
+    lingerVal_(0),
+    noDelay_(1),
+    maxRecvRetries_(5) {
+}
+
+TSocket::TSocket(string path)
+  : host_(""),
+    port_(0),
+    path_(path),
+    socket_(THRIFT_INVALID_SOCKET),
+    connTimeout_(0),
+    sendTimeout_(0),
+    recvTimeout_(0),
+    keepAlive_(false),
+    lingerOn_(1),
+    lingerVal_(0),
+    noDelay_(1),
+    maxRecvRetries_(5) {
   cachedPeerAddr_.ipv4.sin_family = AF_UNSPEC;
 }
 
-TSocket::TSocket() :
-  host_(""),
-  port_(0),
-  path_(""),
-  socket_(THRIFT_INVALID_SOCKET),
-  connTimeout_(0),
-  sendTimeout_(0),
-  recvTimeout_(0),
-  keepAlive_(false),
-  lingerOn_(1),
-  lingerVal_(0),
-  noDelay_(1),
-  maxRecvRetries_(5) {
+TSocket::TSocket()
+  : host_(""),
+    port_(0),
+    path_(""),
+    socket_(THRIFT_INVALID_SOCKET),
+    connTimeout_(0),
+    sendTimeout_(0),
+    recvTimeout_(0),
+    keepAlive_(false),
+    lingerOn_(1),
+    lingerVal_(0),
+    noDelay_(1),
+    maxRecvRetries_(5) {
   cachedPeerAddr_.ipv4.sin_family = AF_UNSPEC;
 }
 
-TSocket::TSocket(THRIFT_SOCKET socket) :
-  host_(""),
-  port_(0),
-  path_(""),
-  socket_(socket),
-  connTimeout_(0),
-  sendTimeout_(0),
-  recvTimeout_(0),
-  keepAlive_(false),
-  lingerOn_(1),
-  lingerVal_(0),
-  noDelay_(1),
-  maxRecvRetries_(5) {
+TSocket::TSocket(THRIFT_SOCKET socket)
+  : host_(""),
+    port_(0),
+    path_(""),
+    socket_(socket),
+    connTimeout_(0),
+    sendTimeout_(0),
+    recvTimeout_(0),
+    keepAlive_(false),
+    lingerOn_(1),
+    lingerVal_(0),
+    noDelay_(1),
+    maxRecvRetries_(5) {
   cachedPeerAddr_.ipv4.sin_family = AF_UNSPEC;
 #ifdef SO_NOSIGPIPE
   {
@@ -160,30 +162,29 @@ bool TSocket::peek() {
   int r = static_cast<int>(recv(socket_, cast_sockopt(&buf), 1, MSG_PEEK));
   if (r == -1) {
     int errno_copy = THRIFT_GET_SOCKET_ERROR;
-    #if defined __FreeBSD__ || defined __MACH__
+#if defined __FreeBSD__ || defined __MACH__
     /* shigin:
      * freebsd returns -1 and THRIFT_ECONNRESET if socket was closed by
      * the other side
      */
-    if (errno_copy == THRIFT_ECONNRESET)
-    {
+    if (errno_copy == THRIFT_ECONNRESET) {
       close();
       return false;
     }
-    #endif
+#endif
     GlobalOutput.perror("TSocket::peek() recv() " + getSocketInfo(), errno_copy);
     throw TTransportException(TTransportException::UNKNOWN, "recv()", errno_copy);
   }
   return (r > 0);
 }
 
-void TSocket::openConnection(struct addrinfo *res) {
+void TSocket::openConnection(struct addrinfo* res) {
 
   if (isOpen()) {
     return;
   }
 
-  if (! path_.empty()) {
+  if (!path_.empty()) {
     socket_ = socket(PF_UNIX, SOCK_STREAM, IPPROTO_IP);
   } else {
     socket_ = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
@@ -205,7 +206,7 @@ void TSocket::openConnection(struct addrinfo *res) {
     setRecvTimeout(recvTimeout_);
   }
 
-  if(keepAlive_) {
+  if (keepAlive_) {
     setKeepAlive(keepAlive_);
   }
 
@@ -222,7 +223,7 @@ void TSocket::openConnection(struct addrinfo *res) {
   }
 #endif
 
-  // Uses a low min RTO if asked to.
+// Uses a low min RTO if asked to.
 #ifdef TCP_LOW_MIN_RTO
   if (getUseLowMinRto()) {
     int one = 1;
@@ -230,7 +231,6 @@ void TSocket::openConnection(struct addrinfo *res) {
   }
 #endif
 
-
   // Set the socket to be non blocking for connect if a timeout exists
   int flags = THRIFT_FCNTL(socket_, THRIFT_F_GETFL, 0);
   if (connTimeout_ > 0) {
@@ -249,7 +249,7 @@ void TSocket::openConnection(struct addrinfo *res) {
 
   // Connect the socket
   int ret;
-  if (! path_.empty()) {
+  if (!path_.empty()) {
 
 #ifndef _WIN32
     size_t len = path_.size() + 1;
@@ -263,10 +263,11 @@ void TSocket::openConnection(struct addrinfo *res) {
     address.sun_family = AF_UNIX;
     memcpy(address.sun_path, path_.c_str(), len);
     socklen_t structlen = static_cast<socklen_t>(sizeof(address));
-    ret = connect(socket_, (struct sockaddr *) &address, structlen);
+    ret = connect(socket_, (struct sockaddr*)&address, structlen);
 #else
-      GlobalOutput.perror("TSocket::open() Unix Domain socket path not supported on windows", -99);
-      throw TTransportException(TTransportException::NOT_OPEN, " Unix Domain socket path not supported");
+    GlobalOutput.perror("TSocket::open() Unix Domain socket path not supported on windows", -99);
+    throw TTransportException(TTransportException::NOT_OPEN,
+                              " Unix Domain socket path not supported");
 #endif
 
   } else {
@@ -278,15 +279,15 @@ void TSocket::openConnection(struct addrinfo *res) {
     goto done;
   }
 
-  if ((THRIFT_GET_SOCKET_ERROR != THRIFT_EINPROGRESS) && (THRIFT_GET_SOCKET_ERROR != THRIFT_EWOULDBLOCK)) {
+  if ((THRIFT_GET_SOCKET_ERROR != THRIFT_EINPROGRESS)
+      && (THRIFT_GET_SOCKET_ERROR != THRIFT_EWOULDBLOCK)) {
     int errno_copy = THRIFT_GET_SOCKET_ERROR;
     GlobalOutput.perror("TSocket::open() connect() " + getSocketInfo(), errno_copy);
     throw TTransportException(TTransportException::NOT_OPEN, "connect() failed", errno_copy);
   }
 
-
   struct THRIFT_POLLFD fds[1];
-  std::memset(fds, 0 , sizeof(fds));
+  std::memset(fds, 0, sizeof(fds));
   fds[0].fd = socket_;
   fds[0].events = THRIFT_POLLOUT;
   ret = THRIFT_POLL(fds, 1, connTimeout_);
@@ -306,7 +307,8 @@ void TSocket::openConnection(struct addrinfo *res) {
     if (val == 0) {
       goto done;
     }
-    GlobalOutput.perror("TSocket::open() error on socket (after THRIFT_POLL) " + getSocketInfo(), val);
+    GlobalOutput.perror("TSocket::open() error on socket (after THRIFT_POLL) " + getSocketInfo(),
+                        val);
     throw TTransportException(TTransportException::NOT_OPEN, "socket open() error", val);
   } else if (ret == 0) {
     // socket timed out
@@ -320,7 +322,7 @@ void TSocket::openConnection(struct addrinfo *res) {
     throw TTransportException(TTransportException::NOT_OPEN, "THRIFT_POLL() failed", errno_copy);
   }
 
- done:
+done:
   // Set socket back to normal mode (blocking)
   THRIFT_FCNTL(socket_, THRIFT_F_SETFL, flags);
 
@@ -333,24 +335,24 @@ void TSocket::open() {
   if (isOpen()) {
     return;
   }
-  if (! path_.empty()) {
+  if (!path_.empty()) {
     unix_open();
   } else {
     local_open();
   }
 }
 
-void TSocket::unix_open(){
-  if (! path_.empty()) {
+void TSocket::unix_open() {
+  if (!path_.empty()) {
     // Unix Domain SOcket does not need addrinfo struct, so we pass NULL
     openConnection(NULL);
   }
 }
 
-void TSocket::local_open(){
+void TSocket::local_open() {
 
 #ifdef _WIN32
-    TWinsockSingleton::create();
+  TWinsockSingleton::create();
 #endif // _WIN32
 
   if (isOpen()) {
@@ -383,10 +385,12 @@ void TSocket::local_open(){
 #endif
 
   if (error) {
-    string errStr = "TSocket::open() getaddrinfo() " + getSocketInfo() + string(THRIFT_GAI_STRERROR(error));
+    string errStr = "TSocket::open() getaddrinfo() " + getSocketInfo()
+                    + string(THRIFT_GAI_STRERROR(error));
     GlobalOutput(errStr.c_str());
     close();
-    throw TTransportException(TTransportException::NOT_OPEN, "Could not resolve host for client socket.");
+    throw TTransportException(TTransportException::NOT_OPEN,
+                              "Could not resolve host for client socket.");
   }
 
   // Cycle through all the returned addresses until one
@@ -441,10 +445,10 @@ uint32_t TSocket::read(uint8_t* buf, uint32_t len) {
     // if a readTimeout is specified along with a max number of recv retries, then
     // the threshold will ensure that the read timeout is not exceeded even in the
     // case of resource errors
-    eagainThresholdMicros = (recvTimeout_*1000)/ ((maxRecvRetries_>0) ? maxRecvRetries_ : 2);
+    eagainThresholdMicros = (recvTimeout_ * 1000) / ((maxRecvRetries_ > 0) ? maxRecvRetries_ : 2);
   }
 
- try_again:
+try_again:
   // Read from the socket
   struct timeval begin;
   if (recvTimeout_ > 0) {
@@ -455,7 +459,8 @@ uint32_t TSocket::read(uint8_t* buf, uint32_t len) {
     begin.tv_sec = begin.tv_usec = 0;
   }
   int got = static_cast<int>(recv(socket_, cast_sockopt(buf), len, 0));
-  int errno_copy = THRIFT_GET_SOCKET_ERROR; //THRIFT_GETTIMEOFDAY can change THRIFT_GET_SOCKET_ERROR
+  int errno_copy = THRIFT_GET_SOCKET_ERROR; // THRIFT_GETTIMEOFDAY can change
+                                            // THRIFT_GET_SOCKET_ERROR
   ++g_socket_syscalls;
 
   // Check for error on read
@@ -464,14 +469,14 @@ uint32_t TSocket::read(uint8_t* buf, uint32_t len) {
       // if no timeout we can assume that resource exhaustion has occurred.
       if (recvTimeout_ == 0) {
         throw TTransportException(TTransportException::TIMED_OUT,
-                                    "THRIFT_EAGAIN (unavailable resources)");
+                                  "THRIFT_EAGAIN (unavailable resources)");
       }
       // check if this is the lack of resources or timeout case
       struct timeval end;
       THRIFT_GETTIMEOFDAY(&end, NULL);
-      uint32_t readElapsedMicros =  static_cast<uint32_t>(
-         ((end.tv_sec - begin.tv_sec) * 1000 * 1000)
-         + (((uint64_t)(end.tv_usec - begin.tv_usec))));
+      uint32_t readElapsedMicros
+          = static_cast<uint32_t>(((end.tv_sec - begin.tv_sec) * 1000 * 1000)
+                                  + (((uint64_t)(end.tv_usec - begin.tv_usec))));
 
       if (!eagainThresholdMicros || (readElapsedMicros < eagainThresholdMicros)) {
         if (retries++ < maxRecvRetries_) {
@@ -483,8 +488,7 @@ uint32_t TSocket::read(uint8_t* buf, uint32_t len) {
         }
       } else {
         // infer that timeout has been hit
-        throw TTransportException(TTransportException::TIMED_OUT,
-                                  "THRIFT_EAGAIN (timed out)");
+        throw TTransportException(TTransportException::TIMED_OUT, "THRIFT_EAGAIN (timed out)");
       }
     }
 
@@ -493,7 +497,7 @@ uint32_t TSocket::read(uint8_t* buf, uint32_t len) {
       goto try_again;
     }
 
-    #if defined __FreeBSD__ || defined __MACH__
+#if defined __FreeBSD__ || defined __MACH__
     if (errno_copy == THRIFT_ECONNRESET) {
       /* shigin: freebsd doesn't follow POSIX semantic of recv and fails with
        * THRIFT_ECONNRESET if peer performed shutdown
@@ -501,10 +505,10 @@ uint32_t TSocket::read(uint8_t* buf, uint32_t len) {
        */
       return 0;
     }
-    #endif
+#endif
 
 #ifdef _WIN32
-    if(errno_copy == WSAECONNRESET) {
+    if (errno_copy == WSAECONNRESET) {
       return 0; // EOF
     }
 #endif
@@ -550,8 +554,7 @@ void TSocket::write(const uint8_t* buf, uint32_t len) {
     if (b == 0) {
       // This should only happen if the timeout set with SO_SNDTIMEO expired.
       // Raise an exception.
-      throw TTransportException(TTransportException::TIMED_OUT,
-                                "send timeout expired");
+      throw TTransportException(TTransportException::TIMED_OUT, "send timeout expired");
     }
     sent += b;
   }
@@ -582,7 +585,8 @@ uint32_t TSocket::write_partial(const uint8_t* buf, uint32_t len) {
     int errno_copy = THRIFT_GET_SOCKET_ERROR;
     GlobalOutput.perror("TSocket::write_partial() send() " + getSocketInfo(), errno_copy);
 
-    if (errno_copy == THRIFT_EPIPE || errno_copy == THRIFT_ECONNRESET || errno_copy == THRIFT_ENOTCONN) {
+    if (errno_copy == THRIFT_EPIPE || errno_copy == THRIFT_ECONNRESET
+        || errno_copy == THRIFT_ENOTCONN) {
       close();
       throw TTransportException(TTransportException::NOT_OPEN, "write() send()", errno_copy);
     }
@@ -628,7 +632,8 @@ void TSocket::setLinger(bool on, int linger) {
 
   int ret = setsockopt(socket_, SOL_SOCKET, SO_LINGER, cast_sockopt(&l), sizeof(l));
   if (ret == -1) {
-    int errno_copy = THRIFT_GET_SOCKET_ERROR;  // Copy THRIFT_GET_SOCKET_ERROR because we're allocating memory.
+    int errno_copy
+        = THRIFT_GET_SOCKET_ERROR; // Copy THRIFT_GET_SOCKET_ERROR because we're allocating memory.
     GlobalOutput.perror("TSocket::setLinger() setsockopt() " + getSocketInfo(), errno_copy);
   }
 }
@@ -643,7 +648,8 @@ void TSocket::setNoDelay(bool noDelay) {
   int v = noDelay_ ? 1 : 0;
   int ret = setsockopt(socket_, IPPROTO_TCP, TCP_NODELAY, cast_sockopt(&v), sizeof(v));
   if (ret == -1) {
-    int errno_copy = THRIFT_GET_SOCKET_ERROR;  // Copy THRIFT_GET_SOCKET_ERROR because we're allocating memory.
+    int errno_copy
+        = THRIFT_GET_SOCKET_ERROR; // Copy THRIFT_GET_SOCKET_ERROR because we're allocating memory.
     GlobalOutput.perror("TSocket::setNoDelay() setsockopt() " + getSocketInfo(), errno_copy);
   }
 }
@@ -652,8 +658,7 @@ void TSocket::setConnTimeout(int ms) {
   connTimeout_ = ms;
 }
 
-void setGenericTimeout(THRIFT_SOCKET s, int timeout_ms, int optname)
-{
+void setGenericTimeout(THRIFT_SOCKET s, int timeout_ms, int optname) {
   if (timeout_ms < 0) {
     char errBuf[512];
     sprintf(errBuf, "TSocket::setGenericTimeout with negative input: %d\n", timeout_ms);
@@ -665,17 +670,16 @@ void setGenericTimeout(THRIFT_SOCKET s, int timeout_ms, int optname)
     return;
   }
 
-  #ifdef _WIN32
+#ifdef _WIN32
   DWORD platform_time = static_cast<DWORD>(timeout_ms);
-  #else
-  struct timeval platform_time = {
-    (int)(timeout_ms/1000),
-    (int)((timeout_ms%1000)*1000)};
-  #endif
+#else
+  struct timeval platform_time = {(int)(timeout_ms / 1000), (int)((timeout_ms % 1000) * 1000)};
+#endif
 
   int ret = setsockopt(s, SOL_SOCKET, optname, cast_sockopt(&platform_time), sizeof(platform_time));
   if (ret == -1) {
-    int errno_copy = THRIFT_GET_SOCKET_ERROR;  // Copy THRIFT_GET_SOCKET_ERROR because we're allocating memory.
+    int errno_copy
+        = THRIFT_GET_SOCKET_ERROR; // Copy THRIFT_GET_SOCKET_ERROR because we're allocating memory.
     GlobalOutput.perror("TSocket::setGenericTimeout() setsockopt() ", errno_copy);
   }
 }
@@ -698,10 +702,12 @@ void TSocket::setKeepAlive(bool keepAlive) {
   }
 
   int value = keepAlive_;
-  int ret = setsockopt(socket_, SOL_SOCKET, SO_KEEPALIVE, const_cast_sockopt(&value), sizeof(value));
+  int ret
+      = setsockopt(socket_, SOL_SOCKET, SO_KEEPALIVE, const_cast_sockopt(&value), sizeof(value));
 
   if (ret == -1) {
-    int errno_copy = THRIFT_GET_SOCKET_ERROR;  // Copy THRIFT_GET_SOCKET_ERROR because we're allocating memory.
+    int errno_copy
+        = THRIFT_GET_SOCKET_ERROR; // Copy THRIFT_GET_SOCKET_ERROR because we're allocating memory.
     GlobalOutput.perror("TSocket::setKeepAlive() setsockopt() " + getSocketInfo(), errno_copy);
   }
 }
@@ -735,7 +741,7 @@ std::string TSocket::getPeerHost() {
 
     if (addrPtr == NULL) {
       addrLen = sizeof(addr);
-      if (getpeername(socket_, (sockaddr*) &addr, &addrLen) != 0) {
+      if (getpeername(socket_, (sockaddr*)&addr, &addrLen) != 0) {
         return peerHost_;
       }
       addrPtr = (sockaddr*)&addr;
@@ -746,9 +752,13 @@ std::string TSocket::getPeerHost() {
     char clienthost[NI_MAXHOST];
     char clientservice[NI_MAXSERV];
 
-    getnameinfo((sockaddr*) addrPtr, addrLen,
-                clienthost, sizeof(clienthost),
-                clientservice, sizeof(clientservice), 0);
+    getnameinfo((sockaddr*)addrPtr,
+                addrLen,
+                clienthost,
+                sizeof(clienthost),
+                clientservice,
+                sizeof(clientservice),
+                0);
 
     peerHost_ = clienthost;
   }
@@ -769,7 +779,7 @@ std::string TSocket::getPeerAddress() {
 
     if (addrPtr == NULL) {
       addrLen = sizeof(addr);
-      if (getpeername(socket_, (sockaddr*) &addr, &addrLen) != 0) {
+      if (getpeername(socket_, (sockaddr*)&addr, &addrLen) != 0) {
         return peerAddress_;
       }
       addrPtr = (sockaddr*)&addr;
@@ -780,10 +790,13 @@ std::string TSocket::getPeerAddress() {
     char clienthost[NI_MAXHOST];
     char clientservice[NI_MAXSERV];
 
-    getnameinfo(addrPtr, addrLen,
-                clienthost, sizeof(clienthost),
-                clientservice, sizeof(clientservice),
-                NI_NUMERICHOST|NI_NUMERICSERV);
+    getnameinfo(addrPtr,
+                addrLen,
+                clienthost,
+                sizeof(clienthost),
+                clientservice,
+                sizeof(clientservice),
+                NI_NUMERICHOST | NI_NUMERICSERV);
 
     peerAddress_ = clienthost;
     peerPort_ = std::atoi(clientservice);
@@ -820,11 +833,11 @@ sockaddr* TSocket::getCachedAddress(socklen_t* len) const {
   switch (cachedPeerAddr_.ipv4.sin_family) {
   case AF_INET:
     *len = sizeof(sockaddr_in);
-    return (sockaddr*) &cachedPeerAddr_.ipv4;
+    return (sockaddr*)&cachedPeerAddr_.ipv4;
 
   case AF_INET6:
     *len = sizeof(sockaddr_in6);
-    return (sockaddr*) &cachedPeerAddr_.ipv6;
+    return (sockaddr*)&cachedPeerAddr_.ipv6;
 
   default:
     return NULL;
@@ -844,5 +857,6 @@ const std::string TSocket::getOrigin() {
   oss << getPeerHost() << ":" << getPeerPort();
   return oss.str();
 }
-
-}}} // apache::thrift::transport
+}
+}
+} // apache::thrift::transport

http://git-wip-us.apache.org/repos/asf/thrift/blob/74260aa9/lib/cpp/src/thrift/transport/TSocket.h
----------------------------------------------------------------------
diff --git a/lib/cpp/src/thrift/transport/TSocket.h b/lib/cpp/src/thrift/transport/TSocket.h
index c873218..38bd789 100644
--- a/lib/cpp/src/thrift/transport/TSocket.h
+++ b/lib/cpp/src/thrift/transport/TSocket.h
@@ -37,14 +37,16 @@
 #include <netdb.h>
 #endif
 
-namespace apache { namespace thrift { namespace transport {
+namespace apache {
+namespace thrift {
+namespace transport {
 
 /**
  * TCP Socket implementation of the TTransport interface.
  *
  */
 class TSocket : public TVirtualTransport<TSocket> {
- public:
+public:
   /**
    * Constructs a new socket. Note that this does NOT actually connect the
    * socket.
@@ -206,9 +208,7 @@ class TSocket : public TVirtualTransport<TSocket> {
   /**
    * Returns the underlying socket file descriptor.
    */
-  THRIFT_SOCKET getSocketFD() {
-    return socket_;
-  }
+  THRIFT_SOCKET getSocketFD() { return socket_; }
 
   /**
    * (Re-)initialize a TSocket for the supplied descriptor.  This is only
@@ -252,9 +252,9 @@ class TSocket : public TVirtualTransport<TSocket> {
    */
   void setCachedAddress(const sockaddr* addr, socklen_t len);
 
- protected:
+protected:
   /** connect, called by open */
-  void openConnection(struct addrinfo *res);
+  void openConnection(struct addrinfo* res);
 
   /** Host to connect to */
   std::string host_;
@@ -310,12 +310,12 @@ class TSocket : public TVirtualTransport<TSocket> {
   /** Whether to use low minimum TCP retransmission timeout */
   static bool useLowMinRto_;
 
- private:
+private:
   void unix_open();
   void local_open();
 };
-
-}}} // apache::thrift::transport
+}
+}
+} // apache::thrift::transport
 
 #endif // #ifndef _THRIFT_TRANSPORT_TSOCKET_H_
-

http://git-wip-us.apache.org/repos/asf/thrift/blob/74260aa9/lib/cpp/src/thrift/transport/TSocketPool.cpp
----------------------------------------------------------------------
diff --git a/lib/cpp/src/thrift/transport/TSocketPool.cpp b/lib/cpp/src/thrift/transport/TSocketPool.cpp
index e0b286a..ccab258 100644
--- a/lib/cpp/src/thrift/transport/TSocketPool.cpp
+++ b/lib/cpp/src/thrift/transport/TSocketPool.cpp
@@ -24,7 +24,9 @@
 
 #include <thrift/transport/TSocketPool.h>
 
-namespace apache { namespace thrift { namespace transport {
+namespace apache {
+namespace thrift {
+namespace transport {
 
 using namespace std;
 
@@ -35,43 +37,41 @@ using boost::shared_ptr;
  *
  */
 TSocketPoolServer::TSocketPoolServer()
-  : host_(""),
-    port_(0),
-    socket_(THRIFT_INVALID_SOCKET),
-    lastFailTime_(0),
-    consecutiveFailures_(0) {}
+  : host_(""), port_(0), socket_(THRIFT_INVALID_SOCKET), lastFailTime_(0), consecutiveFailures_(0) {
+}
 
 /**
  * Constructor for TSocketPool server
  */
-TSocketPoolServer::TSocketPoolServer(const string &host, int port)
+TSocketPoolServer::TSocketPoolServer(const string& host, int port)
   : host_(host),
     port_(port),
     socket_(THRIFT_INVALID_SOCKET),
     lastFailTime_(0),
-    consecutiveFailures_(0) {}
+    consecutiveFailures_(0) {
+}
 
 /**
  * TSocketPool implementation.
  *
  */
 
-TSocketPool::TSocketPool() : TSocket(),
-  numRetries_(1),
-  retryInterval_(60),
-  maxConsecutiveFailures_(1),
-  randomize_(true),
-  alwaysTryLast_(true) {
-}
-
-TSocketPool::TSocketPool(const vector<string> &hosts,
-                         const vector<int> &ports) : TSocket(),
-  numRetries_(1),
-  retryInterval_(60),
-  maxConsecutiveFailures_(1),
-  randomize_(true),
-  alwaysTryLast_(true)
-{
+TSocketPool::TSocketPool()
+  : TSocket(),
+    numRetries_(1),
+    retryInterval_(60),
+    maxConsecutiveFailures_(1),
+    randomize_(true),
+    alwaysTryLast_(true) {
+}
+
+TSocketPool::TSocketPool(const vector<string>& hosts, const vector<int>& ports)
+  : TSocket(),
+    numRetries_(1),
+    retryInterval_(60),
+    maxConsecutiveFailures_(1),
+    randomize_(true),
+    alwaysTryLast_(true) {
   if (hosts.size() != ports.size()) {
     GlobalOutput("TSocketPool::TSocketPool: hosts.size != ports.size");
     throw TTransportException(TTransportException::BAD_ARGS);
@@ -82,41 +82,41 @@ TSocketPool::TSocketPool(const vector<string> &hosts,
   }
 }
 
-TSocketPool::TSocketPool(const vector<pair<string, int> >& servers) : TSocket(),
-  numRetries_(1),
-  retryInterval_(60),
-  maxConsecutiveFailures_(1),
-  randomize_(true),
-  alwaysTryLast_(true)
-{
+TSocketPool::TSocketPool(const vector<pair<string, int> >& servers)
+  : TSocket(),
+    numRetries_(1),
+    retryInterval_(60),
+    maxConsecutiveFailures_(1),
+    randomize_(true),
+    alwaysTryLast_(true) {
   for (unsigned i = 0; i < servers.size(); ++i) {
     addServer(servers[i].first, servers[i].second);
   }
 }
 
-TSocketPool::TSocketPool(const vector< shared_ptr<TSocketPoolServer> >& servers) : TSocket(),
-  servers_(servers),
-  numRetries_(1),
-  retryInterval_(60),
-  maxConsecutiveFailures_(1),
-  randomize_(true),
-  alwaysTryLast_(true)
-{
+TSocketPool::TSocketPool(const vector<shared_ptr<TSocketPoolServer> >& servers)
+  : TSocket(),
+    servers_(servers),
+    numRetries_(1),
+    retryInterval_(60),
+    maxConsecutiveFailures_(1),
+    randomize_(true),
+    alwaysTryLast_(true) {
 }
 
-TSocketPool::TSocketPool(const string& host, int port) : TSocket(),
-  numRetries_(1),
-  retryInterval_(60),
-  maxConsecutiveFailures_(1),
-  randomize_(true),
-  alwaysTryLast_(true)
-{
+TSocketPool::TSocketPool(const string& host, int port)
+  : TSocket(),
+    numRetries_(1),
+    retryInterval_(60),
+    maxConsecutiveFailures_(1),
+    randomize_(true),
+    alwaysTryLast_(true) {
   addServer(host, port);
 }
 
 TSocketPool::~TSocketPool() {
-  vector< shared_ptr<TSocketPoolServer> >::const_iterator iter = servers_.begin();
-  vector< shared_ptr<TSocketPoolServer> >::const_iterator iterEnd = servers_.end();
+  vector<shared_ptr<TSocketPoolServer> >::const_iterator iter = servers_.begin();
+  vector<shared_ptr<TSocketPoolServer> >::const_iterator iterEnd = servers_.end();
   for (; iter != iterEnd; ++iter) {
     setCurrentServer(*iter);
     TSocketPool::close();
@@ -127,17 +127,17 @@ void TSocketPool::addServer(const string& host, int port) {
   servers_.push_back(shared_ptr<TSocketPoolServer>(new TSocketPoolServer(host, port)));
 }
 
-void TSocketPool::addServer(shared_ptr<TSocketPoolServer> &server) {
+void TSocketPool::addServer(shared_ptr<TSocketPoolServer>& server) {
   if (server) {
     servers_.push_back(server);
   }
 }
 
-void TSocketPool::setServers(const vector< shared_ptr<TSocketPoolServer> >& servers) {
+void TSocketPool::setServers(const vector<shared_ptr<TSocketPoolServer> >& servers) {
   servers_ = servers;
 }
 
-void TSocketPool::getServers(vector< shared_ptr<TSocketPoolServer> >& servers) {
+void TSocketPool::getServers(vector<shared_ptr<TSocketPoolServer> >& servers) {
   servers = servers_;
 }
 
@@ -149,7 +149,6 @@ void TSocketPool::setRetryInterval(int retryInterval) {
   retryInterval_ = retryInterval;
 }
 
-
 void TSocketPool::setMaxConsecutiveFailures(int maxConsecutiveFailures) {
   maxConsecutiveFailures_ = maxConsecutiveFailures;
 }
@@ -162,7 +161,7 @@ void TSocketPool::setAlwaysTryLast(bool alwaysTryLast) {
   alwaysTryLast_ = alwaysTryLast;
 }
 
-void TSocketPool::setCurrentServer(const shared_ptr<TSocketPoolServer> &server) {
+void TSocketPool::setCurrentServer(const shared_ptr<TSocketPoolServer>& server) {
   currentServer_ = server;
   host_ = server->host_;
   port_ = server->port_;
@@ -192,7 +191,7 @@ void TSocketPool::open() {
 
   for (size_t i = 0; i < numServers; ++i) {
 
-    shared_ptr<TSocketPoolServer> &server = servers_[i];
+    shared_ptr<TSocketPoolServer>& server = servers_[i];
     // Impersonate the server socket
     setCurrentServer(server);
 
@@ -217,7 +216,7 @@ void TSocketPool::open() {
         try {
           TSocket::open();
         } catch (TException e) {
-          string errStr = "TSocketPool::open failed "+getSocketInfo()+": "+e.what();
+          string errStr = "TSocketPool::open failed " + getSocketInfo() + ": " + e.what();
           GlobalOutput(errStr.c_str());
           socket_ = THRIFT_INVALID_SOCKET;
           continue;
@@ -250,5 +249,6 @@ void TSocketPool::close() {
     currentServer_->socket_ = THRIFT_INVALID_SOCKET;
   }
 }
-
-}}} // apache::thrift::transport
+}
+}
+} // apache::thrift::transport

http://git-wip-us.apache.org/repos/asf/thrift/blob/74260aa9/lib/cpp/src/thrift/transport/TSocketPool.h
----------------------------------------------------------------------
diff --git a/lib/cpp/src/thrift/transport/TSocketPool.h b/lib/cpp/src/thrift/transport/TSocketPool.h
index 7728257..78f0ebf 100644
--- a/lib/cpp/src/thrift/transport/TSocketPool.h
+++ b/lib/cpp/src/thrift/transport/TSocketPool.h
@@ -23,15 +23,17 @@
 #include <vector>
 #include <thrift/transport/TSocket.h>
 
-namespace apache { namespace thrift { namespace transport {
+namespace apache {
+namespace thrift {
+namespace transport {
 
- /**
-  * Class to hold server information for TSocketPool
-  *
-  */
+/**
+ * Class to hold server information for TSocketPool
+ *
+ */
 class TSocketPoolServer {
 
-  public:
+public:
   /**
    * Default constructor for server info
    */
@@ -40,7 +42,7 @@ class TSocketPoolServer {
   /**
    * Constructor for TSocketPool server
    */
-  TSocketPoolServer(const std::string &host, int port);
+  TSocketPoolServer(const std::string& host, int port);
 
   // Host name
   std::string host_;
@@ -64,133 +66,130 @@ class TSocketPoolServer {
  */
 class TSocketPool : public TSocket {
 
- public:
-
-   /**
-    * Socket pool constructor
-    */
-   TSocketPool();
-
-   /**
-    * Socket pool constructor
-    *
-    * @param hosts list of host names
-    * @param ports list of port names
-    */
-   TSocketPool(const std::vector<std::string> &hosts,
-               const std::vector<int> &ports);
-
-   /**
-    * Socket pool constructor
-    *
-    * @param servers list of pairs of host name and port
-    */
-   TSocketPool(const std::vector<std::pair<std::string, int> >& servers);
-
-   /**
-    * Socket pool constructor
-    *
-    * @param servers list of TSocketPoolServers
-    */
-  TSocketPool(const std::vector< boost::shared_ptr<TSocketPoolServer> >& servers);
-
-   /**
-    * Socket pool constructor
-    *
-    * @param host single host
-    * @param port single port
-    */
-   TSocketPool(const std::string& host, int port);
-
-   /**
-    * Destroyes the socket object, closing it if necessary.
-    */
-   virtual ~TSocketPool();
-
-   /**
-    * Add a server to the pool
-    */
-   void addServer(const std::string& host, int port);
-
-   /**
-    * Add a server to the pool
-    */
-  void addServer(boost::shared_ptr<TSocketPoolServer> &server);
-
-   /**
-    * Set list of servers in this pool
-    */
-  void setServers(const std::vector< boost::shared_ptr<TSocketPoolServer> >& servers);
-
-   /**
-    * Get list of servers in this pool
-    */
-  void getServers(std::vector< boost::shared_ptr<TSocketPoolServer> >& servers);
-
-   /**
-    * Sets how many times to keep retrying a host in the connect function.
-    */
-   void setNumRetries(int numRetries);
-
-   /**
-    * Sets how long to wait until retrying a host if it was marked down
-    */
-   void setRetryInterval(int retryInterval);
-
-   /**
-    * Sets how many times to keep retrying a host before marking it as down.
-    */
-   void setMaxConsecutiveFailures(int maxConsecutiveFailures);
-
-   /**
-    * Turns randomization in connect order on or off.
-    */
-   void setRandomize(bool randomize);
-
-   /**
-    * Whether to always try the last server.
-    */
-   void setAlwaysTryLast(bool alwaysTryLast);
-
-   /**
-    * Creates and opens the UNIX socket.
-    */
-   void open();
-
-   /*
-    * Closes the UNIX socket
-    */
-   void close();
-
- protected:
-
-  void setCurrentServer(const boost::shared_ptr<TSocketPoolServer> &server);
-
-   /** List of servers to connect to */
-  std::vector< boost::shared_ptr<TSocketPoolServer> > servers_;
+public:
+  /**
+   * Socket pool constructor
+   */
+  TSocketPool();
+
+  /**
+   * Socket pool constructor
+   *
+   * @param hosts list of host names
+   * @param ports list of port names
+   */
+  TSocketPool(const std::vector<std::string>& hosts, const std::vector<int>& ports);
+
+  /**
+   * Socket pool constructor
+   *
+   * @param servers list of pairs of host name and port
+   */
+  TSocketPool(const std::vector<std::pair<std::string, int> >& servers);
+
+  /**
+   * Socket pool constructor
+   *
+   * @param servers list of TSocketPoolServers
+   */
+  TSocketPool(const std::vector<boost::shared_ptr<TSocketPoolServer> >& servers);
+
+  /**
+   * Socket pool constructor
+   *
+   * @param host single host
+   * @param port single port
+   */
+  TSocketPool(const std::string& host, int port);
+
+  /**
+   * Destroyes the socket object, closing it if necessary.
+   */
+  virtual ~TSocketPool();
+
+  /**
+   * Add a server to the pool
+   */
+  void addServer(const std::string& host, int port);
+
+  /**
+   * Add a server to the pool
+   */
+  void addServer(boost::shared_ptr<TSocketPoolServer>& server);
+
+  /**
+   * Set list of servers in this pool
+   */
+  void setServers(const std::vector<boost::shared_ptr<TSocketPoolServer> >& servers);
+
+  /**
+   * Get list of servers in this pool
+   */
+  void getServers(std::vector<boost::shared_ptr<TSocketPoolServer> >& servers);
+
+  /**
+   * Sets how many times to keep retrying a host in the connect function.
+   */
+  void setNumRetries(int numRetries);
+
+  /**
+   * Sets how long to wait until retrying a host if it was marked down
+   */
+  void setRetryInterval(int retryInterval);
+
+  /**
+   * Sets how many times to keep retrying a host before marking it as down.
+   */
+  void setMaxConsecutiveFailures(int maxConsecutiveFailures);
+
+  /**
+   * Turns randomization in connect order on or off.
+   */
+  void setRandomize(bool randomize);
+
+  /**
+   * Whether to always try the last server.
+   */
+  void setAlwaysTryLast(bool alwaysTryLast);
+
+  /**
+   * Creates and opens the UNIX socket.
+   */
+  void open();
+
+  /*
+   * Closes the UNIX socket
+   */
+  void close();
+
+protected:
+  void setCurrentServer(const boost::shared_ptr<TSocketPoolServer>& server);
+
+  /** List of servers to connect to */
+  std::vector<boost::shared_ptr<TSocketPoolServer> > servers_;
 
   /** Current server */
   boost::shared_ptr<TSocketPoolServer> currentServer_;
 
-   /** How many times to retry each host in connect */
-   int numRetries_;
+  /** How many times to retry each host in connect */
+  int numRetries_;
 
-   /** Retry interval in seconds, how long to not try a host if it has been
-    * marked as down.
-    */
-   time_t retryInterval_;
+  /** Retry interval in seconds, how long to not try a host if it has been
+   * marked as down.
+   */
+  time_t retryInterval_;
 
-   /** Max consecutive failures before marking a host down. */
-   int maxConsecutiveFailures_;
+  /** Max consecutive failures before marking a host down. */
+  int maxConsecutiveFailures_;
 
-   /** Try hosts in order? or Randomized? */
-   bool randomize_;
+  /** Try hosts in order? or Randomized? */
+  bool randomize_;
 
-   /** Always try last host, even if marked down? */
-   bool alwaysTryLast_;
+  /** Always try last host, even if marked down? */
+  bool alwaysTryLast_;
 };
-
-}}} // apache::thrift::transport
+}
+}
+} // apache::thrift::transport
 
 #endif // #ifndef _THRIFT_TRANSPORT_TSOCKETPOOL_H_
-

http://git-wip-us.apache.org/repos/asf/thrift/blob/74260aa9/lib/cpp/src/thrift/transport/TTransport.h
----------------------------------------------------------------------
diff --git a/lib/cpp/src/thrift/transport/TTransport.h b/lib/cpp/src/thrift/transport/TTransport.h
index 6e9a698..d06b0f8 100644
--- a/lib/cpp/src/thrift/transport/TTransport.h
+++ b/lib/cpp/src/thrift/transport/TTransport.h
@@ -25,21 +25,22 @@
 #include <thrift/transport/TTransportException.h>
 #include <string>
 
-namespace apache { namespace thrift { namespace transport {
+namespace apache {
+namespace thrift {
+namespace transport {
 
 /**
  * Helper template to hoist readAll implementation out of TTransport
  */
 template <class Transport_>
-uint32_t readAll(Transport_ &trans, uint8_t* buf, uint32_t len) {
+uint32_t readAll(Transport_& trans, uint8_t* buf, uint32_t len) {
   uint32_t have = 0;
   uint32_t get = 0;
 
   while (have < len) {
-    get = trans.read(buf+have, len-have);
+    get = trans.read(buf + have, len - have);
     if (get <= 0) {
-      throw TTransportException(TTransportException::END_OF_FILE,
-                                "No more data to read.");
+      throw TTransportException(TTransportException::END_OF_FILE, "No more data to read.");
     }
     have += get;
   }
@@ -47,14 +48,13 @@ uint32_t readAll(Transport_ &trans, uint8_t* buf, uint32_t len) {
   return have;
 }
 
-
 /**
  * Generic interface for a method of transporting data. A TTransport may be
  * capable of either reading or writing, but not necessarily both.
  *
  */
 class TTransport {
- public:
+public:
   /**
    * Virtual deconstructor.
    */
@@ -63,9 +63,7 @@ class TTransport {
   /**
    * Whether this transport is open.
    */
-  virtual bool isOpen() {
-    return false;
-  }
+  virtual bool isOpen() { return false; }
 
   /**
    * Tests whether there is more data to read or if the remote side is
@@ -75,9 +73,7 @@ class TTransport {
    * This is used by a server to check if it should listen for another
    * request.
    */
-  virtual bool peek() {
-    return isOpen();
-  }
+  virtual bool peek() { return isOpen(); }
 
   /**
    * Opens the transport for communications.
@@ -109,8 +105,7 @@ class TTransport {
     return read_virt(buf, len);
   }
   virtual uint32_t read_virt(uint8_t* /* buf */, uint32_t /* len */) {
-    throw TTransportException(TTransportException::NOT_OPEN,
-                              "Base TTransport cannot read.");
+    throw TTransportException(TTransportException::NOT_OPEN, "Base TTransport cannot read.");
   }
 
   /**
@@ -158,8 +153,7 @@ class TTransport {
     write_virt(buf, len);
   }
   virtual void write_virt(const uint8_t* /* buf */, uint32_t /* len */) {
-    throw TTransportException(TTransportException::NOT_OPEN,
-                              "Base TTransport cannot write.");
+    throw TTransportException(TTransportException::NOT_OPEN, "Base TTransport cannot write.");
   }
 
   /**
@@ -215,9 +209,7 @@ class TTransport {
     T_VIRTUAL_CALL();
     return borrow_virt(buf, len);
   }
-  virtual const uint8_t* borrow_virt(uint8_t* /* buf */, uint32_t* /* len */) {
-    return NULL;
-  }
+  virtual const uint8_t* borrow_virt(uint8_t* /* buf */, uint32_t* /* len */) { return NULL; }
 
   /**
    * Remove len bytes from the transport.  This should always follow a borrow
@@ -233,8 +225,7 @@ class TTransport {
     consume_virt(len);
   }
   virtual void consume_virt(uint32_t /* len */) {
-    throw TTransportException(TTransportException::NOT_OPEN,
-                              "Base TTransport cannot consume.");
+    throw TTransportException(TTransportException::NOT_OPEN, "Base TTransport cannot consume.");
   }
 
   /**
@@ -245,11 +236,9 @@ class TTransport {
    *
    * The returned value can be used in a log message for example
    */
-  virtual const std::string getOrigin() {
-    return "Unknown";
-  }
+  virtual const std::string getOrigin() { return "Unknown"; }
 
- protected:
+protected:
   /**
    * Simple constructor.
    */
@@ -263,7 +252,7 @@ class TTransport {
  *
  */
 class TTransportFactory {
- public:
+public:
   TTransportFactory() {}
 
   virtual ~TTransportFactory() {}
@@ -274,9 +263,9 @@ class TTransportFactory {
   virtual boost::shared_ptr<TTransport> getTransport(boost::shared_ptr<TTransport> trans) {
     return trans;
   }
-
 };
-
-}}} // apache::thrift::transport
+}
+}
+} // apache::thrift::transport
 
 #endif // #ifndef _THRIFT_TRANSPORT_TTRANSPORT_H_

http://git-wip-us.apache.org/repos/asf/thrift/blob/74260aa9/lib/cpp/src/thrift/transport/TTransportException.cpp
----------------------------------------------------------------------
diff --git a/lib/cpp/src/thrift/transport/TTransportException.cpp b/lib/cpp/src/thrift/transport/TTransportException.cpp
index 2b1430c..612e7b7 100644
--- a/lib/cpp/src/thrift/transport/TTransportException.cpp
+++ b/lib/cpp/src/thrift/transport/TTransportException.cpp
@@ -26,25 +26,36 @@
 using std::string;
 using boost::lexical_cast;
 
-namespace apache { namespace thrift { namespace transport {
+namespace apache {
+namespace thrift {
+namespace transport {
 
-  const char* TTransportException::what() const throw() {
-    if (message_.empty()) {
-      switch (type_) {
-        case UNKNOWN        : return "TTransportException: Unknown transport exception";
-        case NOT_OPEN       : return "TTransportException: Transport not open";
-        case TIMED_OUT      : return "TTransportException: Timed out";
-        case END_OF_FILE    : return "TTransportException: End of file";
-        case INTERRUPTED    : return "TTransportException: Interrupted";
-        case BAD_ARGS       : return "TTransportException: Invalid arguments";
-        case CORRUPTED_DATA : return "TTransportException: Corrupted Data";
-        case INTERNAL_ERROR : return "TTransportException: Internal error";
-        default             : return "TTransportException: (Invalid exception type)";
-      }
-    } else {
-      return message_.c_str();
+const char* TTransportException::what() const throw() {
+  if (message_.empty()) {
+    switch (type_) {
+    case UNKNOWN:
+      return "TTransportException: Unknown transport exception";
+    case NOT_OPEN:
+      return "TTransportException: Transport not open";
+    case TIMED_OUT:
+      return "TTransportException: Timed out";
+    case END_OF_FILE:
+      return "TTransportException: End of file";
+    case INTERRUPTED:
+      return "TTransportException: Interrupted";
+    case BAD_ARGS:
+      return "TTransportException: Invalid arguments";
+    case CORRUPTED_DATA:
+      return "TTransportException: Corrupted Data";
+    case INTERNAL_ERROR:
+      return "TTransportException: Internal error";
+    default:
+      return "TTransportException: (Invalid exception type)";
     }
+  } else {
+    return message_.c_str();
   }
-
-
-}}} // apache::thrift::transport
+}
+}
+}
+} // apache::thrift::transport

http://git-wip-us.apache.org/repos/asf/thrift/blob/74260aa9/lib/cpp/src/thrift/transport/TTransportException.h
----------------------------------------------------------------------
diff --git a/lib/cpp/src/thrift/transport/TTransportException.h b/lib/cpp/src/thrift/transport/TTransportException.h
index 8558837..83e876a 100644
--- a/lib/cpp/src/thrift/transport/TTransportException.h
+++ b/lib/cpp/src/thrift/transport/TTransportException.h
@@ -23,7 +23,9 @@
 #include <string>
 #include <thrift/Thrift.h>
 
-namespace apache { namespace thrift { namespace transport {
+namespace apache {
+namespace thrift {
+namespace transport {
 
 /**
  * Class to encapsulate all the possible types of transport errors that may
@@ -34,42 +36,33 @@ namespace apache { namespace thrift { namespace transport {
  *
  */
 class TTransportException : public apache::thrift::TException {
- public:
+public:
   /**
    * Error codes for the various types of exceptions.
    */
-  enum TTransportExceptionType
-  { UNKNOWN = 0
-  , NOT_OPEN = 1
-  , TIMED_OUT = 2
-  , END_OF_FILE = 3
-  , INTERRUPTED = 4
-  , BAD_ARGS = 5
-  , CORRUPTED_DATA = 6
-  , INTERNAL_ERROR = 7
+  enum TTransportExceptionType {
+    UNKNOWN = 0,
+    NOT_OPEN = 1,
+    TIMED_OUT = 2,
+    END_OF_FILE = 3,
+    INTERRUPTED = 4,
+    BAD_ARGS = 5,
+    CORRUPTED_DATA = 6,
+    INTERNAL_ERROR = 7
   };
 
-  TTransportException() :
-    apache::thrift::TException(),
-    type_(UNKNOWN) {}
+  TTransportException() : apache::thrift::TException(), type_(UNKNOWN) {}
 
-  TTransportException(TTransportExceptionType type) :
-    apache::thrift::TException(),
-    type_(type) {}
+  TTransportException(TTransportExceptionType type) : apache::thrift::TException(), type_(type) {}
 
-  TTransportException(const std::string& message) :
-    apache::thrift::TException(message),
-    type_(UNKNOWN) {}
+  TTransportException(const std::string& message)
+    : apache::thrift::TException(message), type_(UNKNOWN) {}
 
-  TTransportException(TTransportExceptionType type, const std::string& message) :
-    apache::thrift::TException(message),
-    type_(type) {}
+  TTransportException(TTransportExceptionType type, const std::string& message)
+    : apache::thrift::TException(message), type_(type) {}
 
-  TTransportException(TTransportExceptionType type,
-                      const std::string& message,
-                      int errno_copy) :
-    apache::thrift::TException(message + ": " + TOutput::strerror_s(errno_copy)),
-    type_(type) {}
+  TTransportException(TTransportExceptionType type, const std::string& message, int errno_copy)
+    : apache::thrift::TException(message + ": " + TOutput::strerror_s(errno_copy)), type_(type) {}
 
   virtual ~TTransportException() throw() {}
 
@@ -79,21 +72,19 @@ class TTransportException : public apache::thrift::TException {
    *
    * @return Error code
    */
-  TTransportExceptionType getType() const throw() {
-    return type_;
-  }
+  TTransportExceptionType getType() const throw() { return type_; }
 
   virtual const char* what() const throw();
 
- protected:
+protected:
   /** Just like strerror_r but returns a C++ string object. */
   std::string strerror_s(int errno_copy);
 
   /** Error code */
   TTransportExceptionType type_;
-
 };
-
-}}} // apache::thrift::transport
+}
+}
+} // apache::thrift::transport
 
 #endif // #ifndef _THRIFT_TRANSPORT_TTRANSPORTEXCEPTION_H_

http://git-wip-us.apache.org/repos/asf/thrift/blob/74260aa9/lib/cpp/src/thrift/transport/TTransportUtils.cpp
----------------------------------------------------------------------
diff --git a/lib/cpp/src/thrift/transport/TTransportUtils.cpp b/lib/cpp/src/thrift/transport/TTransportUtils.cpp
index 44f6101..0f24c95 100644
--- a/lib/cpp/src/thrift/transport/TTransportUtils.cpp
+++ b/lib/cpp/src/thrift/transport/TTransportUtils.cpp
@@ -21,39 +21,40 @@
 
 using std::string;
 
-namespace apache { namespace thrift { namespace transport {
+namespace apache {
+namespace thrift {
+namespace transport {
 
 uint32_t TPipedTransport::read(uint8_t* buf, uint32_t len) {
   uint32_t need = len;
 
   // We don't have enough data yet
-  if (rLen_-rPos_ < need) {
+  if (rLen_ - rPos_ < need) {
     // Copy out whatever we have
-    if (rLen_-rPos_ > 0) {
-      memcpy(buf, rBuf_+rPos_, rLen_-rPos_);
-      need -= rLen_-rPos_;
-      buf += rLen_-rPos_;
+    if (rLen_ - rPos_ > 0) {
+      memcpy(buf, rBuf_ + rPos_, rLen_ - rPos_);
+      need -= rLen_ - rPos_;
+      buf += rLen_ - rPos_;
       rPos_ = rLen_;
     }
 
     // Double the size of the underlying buffer if it is full
     if (rLen_ == rBufSize_) {
-      rBufSize_ *=2;
-      rBuf_ = (uint8_t *)std::realloc(rBuf_, sizeof(uint8_t) * rBufSize_);
+      rBufSize_ *= 2;
+      rBuf_ = (uint8_t*)std::realloc(rBuf_, sizeof(uint8_t) * rBufSize_);
     }
 
     // try to fill up the buffer
-    rLen_ += srcTrans_->read(rBuf_+rPos_, rBufSize_ - rPos_);
+    rLen_ += srcTrans_->read(rBuf_ + rPos_, rBufSize_ - rPos_);
   }
 
-
   // Hand over whatever we have
   uint32_t give = need;
-  if (rLen_-rPos_ < give) {
-    give = rLen_-rPos_;
+  if (rLen_ - rPos_ < give) {
+    give = rLen_ - rPos_;
   }
   if (give > 0) {
-    memcpy(buf, rBuf_+rPos_, give);
+    memcpy(buf, rBuf_ + rPos_, give);
     rPos_ += give;
     need -= give;
   }
@@ -68,11 +69,11 @@ void TPipedTransport::write(const uint8_t* buf, uint32_t len) {
 
   // Make the buffer as big as it needs to be
   if ((len + wLen_) >= wBufSize_) {
-    uint32_t newBufSize = wBufSize_*2;
+    uint32_t newBufSize = wBufSize_ * 2;
     while ((len + wLen_) >= newBufSize) {
       newBufSize *= 2;
     }
-    wBuf_ = (uint8_t *)std::realloc(wBuf_, sizeof(uint8_t) * newBufSize);
+    wBuf_ = (uint8_t*)std::realloc(wBuf_, sizeof(uint8_t) * newBufSize);
     wBufSize_ = newBufSize;
   }
 
@@ -81,7 +82,7 @@ void TPipedTransport::write(const uint8_t* buf, uint32_t len) {
   wLen_ += len;
 }
 
-void TPipedTransport::flush()  {
+void TPipedTransport::flush() {
   // Write out any data waiting in the write buffer
   if (wLen_ > 0) {
     srcTrans_->write(wBuf_, wLen_);
@@ -92,9 +93,10 @@ void TPipedTransport::flush()  {
   srcTrans_->flush();
 }
 
-TPipedFileReaderTransport::TPipedFileReaderTransport(boost::shared_ptr<TFileReaderTransport> srcTrans, boost::shared_ptr<TTransport> dstTrans)
-  : TPipedTransport(srcTrans, dstTrans),
-    srcTrans_(srcTrans) {
+TPipedFileReaderTransport::TPipedFileReaderTransport(
+    boost::shared_ptr<TFileReaderTransport> srcTrans,
+    boost::shared_ptr<TTransport> dstTrans)
+  : TPipedTransport(srcTrans, dstTrans), srcTrans_(srcTrans) {
 }
 
 TPipedFileReaderTransport::~TPipedFileReaderTransport() {
@@ -125,7 +127,7 @@ uint32_t TPipedFileReaderTransport::readAll(uint8_t* buf, uint32_t len) {
   uint32_t get = 0;
 
   while (have < len) {
-    get = read(buf+have, len-have);
+    get = read(buf + have, len - have);
     if (get <= 0) {
       throw TEOFException();
     }
@@ -174,5 +176,6 @@ void TPipedFileReaderTransport::seekToChunk(int32_t chunk) {
 void TPipedFileReaderTransport::seekToEnd() {
   srcTrans_->seekToEnd();
 }
-
-}}} // apache::thrift::transport
+}
+}
+} // apache::thrift::transport

http://git-wip-us.apache.org/repos/asf/thrift/blob/74260aa9/lib/cpp/src/thrift/transport/TTransportUtils.h
----------------------------------------------------------------------
diff --git a/lib/cpp/src/thrift/transport/TTransportUtils.h b/lib/cpp/src/thrift/transport/TTransportUtils.h
index aa294b4..c221836 100644
--- a/lib/cpp/src/thrift/transport/TTransportUtils.h
+++ b/lib/cpp/src/thrift/transport/TTransportUtils.h
@@ -29,7 +29,9 @@
 #include <thrift/transport/TBufferTransports.h>
 #include <thrift/transport/TFileTransport.h>
 
-namespace apache { namespace thrift { namespace transport {
+namespace apache {
+namespace thrift {
+namespace transport {
 
 /**
  * The null transport is a dummy transport that doesn't actually do anything.
@@ -39,24 +41,18 @@ namespace apache { namespace thrift { namespace transport {
  *
  */
 class TNullTransport : public TVirtualTransport<TNullTransport> {
- public:
+public:
   TNullTransport() {}
 
   ~TNullTransport() {}
 
-  bool isOpen() {
-    return true;
-  }
+  bool isOpen() { return true; }
 
   void open() {}
 
-  void write(const uint8_t* /* buf */, uint32_t /* len */) {
-    return;
-  }
-
+  void write(const uint8_t* /* buf */, uint32_t /* len */) { return; }
 };
 
-
 /**
  * TPipedTransport. This transport allows piping of a request from one
  * transport to another either when readEnd() or writeEnd(). The typical
@@ -66,23 +62,25 @@ class TNullTransport : public TVirtualTransport<TNullTransport> {
  *
  */
 class TPipedTransport : virtual public TTransport {
- public:
-  TPipedTransport(boost::shared_ptr<TTransport> srcTrans,
-                  boost::shared_ptr<TTransport> dstTrans) :
-    srcTrans_(srcTrans),
-    dstTrans_(dstTrans),
-    rBufSize_(512), rPos_(0), rLen_(0),
-    wBufSize_(512), wLen_(0) {
+public:
+  TPipedTransport(boost::shared_ptr<TTransport> srcTrans, boost::shared_ptr<TTransport> dstTrans)
+    : srcTrans_(srcTrans),
+      dstTrans_(dstTrans),
+      rBufSize_(512),
+      rPos_(0),
+      rLen_(0),
+      wBufSize_(512),
+      wLen_(0) {
 
     // default is to to pipe the request when readEnd() is called
     pipeOnRead_ = true;
     pipeOnWrite_ = false;
 
-    rBuf_ = (uint8_t*) std::malloc(sizeof(uint8_t) * rBufSize_);
+    rBuf_ = (uint8_t*)std::malloc(sizeof(uint8_t) * rBufSize_);
     if (rBuf_ == NULL) {
       throw std::bad_alloc();
     }
-    wBuf_ = (uint8_t*) std::malloc(sizeof(uint8_t) * wBufSize_);
+    wBuf_ = (uint8_t*)std::malloc(sizeof(uint8_t) * wBufSize_);
     if (wBuf_ == NULL) {
       throw std::bad_alloc();
     }
@@ -90,17 +88,20 @@ class TPipedTransport : virtual public TTransport {
 
   TPipedTransport(boost::shared_ptr<TTransport> srcTrans,
                   boost::shared_ptr<TTransport> dstTrans,
-                  uint32_t sz) :
-    srcTrans_(srcTrans),
-    dstTrans_(dstTrans),
-    rBufSize_(512), rPos_(0), rLen_(0),
-    wBufSize_(sz), wLen_(0) {
-
-    rBuf_ = (uint8_t*) std::malloc(sizeof(uint8_t) * rBufSize_);
+                  uint32_t sz)
+    : srcTrans_(srcTrans),
+      dstTrans_(dstTrans),
+      rBufSize_(512),
+      rPos_(0),
+      rLen_(0),
+      wBufSize_(sz),
+      wLen_(0) {
+
+    rBuf_ = (uint8_t*)std::malloc(sizeof(uint8_t) * rBufSize_);
     if (rBuf_ == NULL) {
       throw std::bad_alloc();
     }
-    wBuf_ = (uint8_t*) std::malloc(sizeof(uint8_t) * wBufSize_);
+    wBuf_ = (uint8_t*)std::malloc(sizeof(uint8_t) * wBufSize_);
     if (wBuf_ == NULL) {
       throw std::bad_alloc();
     }
@@ -111,40 +112,29 @@ class TPipedTransport : virtual public TTransport {
     std::free(wBuf_);
   }
 
-  bool isOpen() {
-    return srcTrans_->isOpen();
-  }
+  bool isOpen() { return srcTrans_->isOpen(); }
 
   bool peek() {
     if (rPos_ >= rLen_) {
       // Double the size of the underlying buffer if it is full
       if (rLen_ == rBufSize_) {
-        rBufSize_ *=2;
-        rBuf_ = (uint8_t *)std::realloc(rBuf_, sizeof(uint8_t) * rBufSize_);
+        rBufSize_ *= 2;
+        rBuf_ = (uint8_t*)std::realloc(rBuf_, sizeof(uint8_t) * rBufSize_);
       }
 
       // try to fill up the buffer
-      rLen_ += srcTrans_->read(rBuf_+rPos_, rBufSize_ - rPos_);
+      rLen_ += srcTrans_->read(rBuf_ + rPos_, rBufSize_ - rPos_);
     }
     return (rLen_ > rPos_);
   }
 
+  void open() { srcTrans_->open(); }
 
-  void open() {
-    srcTrans_->open();
-  }
-
-  void close() {
-    srcTrans_->close();
-  }
+  void close() { srcTrans_->close(); }
 
-  void setPipeOnRead(bool pipeVal) {
-    pipeOnRead_ = pipeVal;
-  }
+  void setPipeOnRead(bool pipeVal) { pipeOnRead_ = pipeVal; }
 
-  void setPipeOnWrite(bool pipeVal) {
-    pipeOnWrite_ = pipeVal;
-  }
+  void setPipeOnWrite(bool pipeVal) { pipeOnWrite_ = pipeVal; }
 
   uint32_t read(uint8_t* buf, uint32_t len);
 
@@ -180,23 +170,17 @@ class TPipedTransport : virtual public TTransport {
 
   void flush();
 
-  boost::shared_ptr<TTransport> getTargetTransport() {
-    return dstTrans_;
-  }
+  boost::shared_ptr<TTransport> getTargetTransport() { return dstTrans_; }
 
   /*
    * Override TTransport *_virt() functions to invoke our implementations.
    * We cannot use TVirtualTransport to provide these, since we need to inherit
    * virtually from TTransport.
    */
-  virtual uint32_t read_virt(uint8_t* buf, uint32_t len) {
-    return this->read(buf, len);
-  }
-  virtual void write_virt(const uint8_t* buf, uint32_t len) {
-    this->write(buf, len);
-  }
+  virtual uint32_t read_virt(uint8_t* buf, uint32_t len) { return this->read(buf, len); }
+  virtual void write_virt(const uint8_t* buf, uint32_t len) { this->write(buf, len); }
 
- protected:
+protected:
   boost::shared_ptr<TTransport> srcTrans_;
   boost::shared_ptr<TTransport> dstTrans_;
 
@@ -213,13 +197,12 @@ class TPipedTransport : virtual public TTransport {
   bool pipeOnWrite_;
 };
 
-
 /**
  * Wraps a transport into a pipedTransport instance.
  *
  */
 class TPipedTransportFactory : public TTransportFactory {
- public:
+public:
   TPipedTransportFactory() {}
   TPipedTransportFactory(boost::shared_ptr<TTransport> dstTrans) {
     initializeTargetTransport(dstTrans);
@@ -241,7 +224,7 @@ class TPipedTransportFactory : public TTransportFactory {
     }
   }
 
- protected:
+protected:
   boost::shared_ptr<TTransport> dstTrans_;
 };
 
@@ -251,10 +234,10 @@ class TPipedTransportFactory : public TTransportFactory {
  * TTransport can still access the original transport.
  *
  */
-class TPipedFileReaderTransport : public TPipedTransport,
-                                  public TFileReaderTransport {
- public:
-  TPipedFileReaderTransport(boost::shared_ptr<TFileReaderTransport> srcTrans, boost::shared_ptr<TTransport> dstTrans);
+class TPipedFileReaderTransport : public TPipedTransport, public TFileReaderTransport {
+public:
+  TPipedFileReaderTransport(boost::shared_ptr<TFileReaderTransport> srcTrans,
+                            boost::shared_ptr<TTransport> dstTrans);
 
   ~TPipedFileReaderTransport();
 
@@ -283,17 +266,11 @@ class TPipedFileReaderTransport : public TPipedTransport,
    * We cannot use TVirtualTransport to provide these, since we need to inherit
    * virtually from TTransport.
    */
-  virtual uint32_t read_virt(uint8_t* buf, uint32_t len) {
-    return this->read(buf, len);
-  }
-  virtual uint32_t readAll_virt(uint8_t* buf, uint32_t len) {
-    return this->readAll(buf, len);
-  }
-  virtual void write_virt(const uint8_t* buf, uint32_t len) {
-    this->write(buf, len);
-  }
+  virtual uint32_t read_virt(uint8_t* buf, uint32_t len) { return this->read(buf, len); }
+  virtual uint32_t readAll_virt(uint8_t* buf, uint32_t len) { return this->readAll(buf, len); }
+  virtual void write_virt(const uint8_t* buf, uint32_t len) { this->write(buf, len); }
 
- protected:
+protected:
   // shouldn't be used
   TPipedFileReaderTransport();
   boost::shared_ptr<TFileReaderTransport> srcTrans_;
@@ -304,15 +281,15 @@ class TPipedFileReaderTransport : public TPipedTransport,
  *
  */
 class TPipedFileReaderTransportFactory : public TPipedTransportFactory {
- public:
+public:
   TPipedFileReaderTransportFactory() {}
   TPipedFileReaderTransportFactory(boost::shared_ptr<TTransport> dstTrans)
-    : TPipedTransportFactory(dstTrans)
-  {}
+    : TPipedTransportFactory(dstTrans) {}
   virtual ~TPipedFileReaderTransportFactory() {}
 
   boost::shared_ptr<TTransport> getTransport(boost::shared_ptr<TTransport> srcTrans) {
-    boost::shared_ptr<TFileReaderTransport> pFileReaderTransport = boost::dynamic_pointer_cast<TFileReaderTransport>(srcTrans);
+    boost::shared_ptr<TFileReaderTransport> pFileReaderTransport
+        = boost::dynamic_pointer_cast<TFileReaderTransport>(srcTrans);
     if (pFileReaderTransport.get() != NULL) {
       return getFileReaderTransport(pFileReaderTransport);
     } else {
@@ -320,11 +297,14 @@ class TPipedFileReaderTransportFactory : public TPipedTransportFactory {
     }
   }
 
-  boost::shared_ptr<TFileReaderTransport> getFileReaderTransport(boost::shared_ptr<TFileReaderTransport> srcTrans) {
-    return boost::shared_ptr<TFileReaderTransport>(new TPipedFileReaderTransport(srcTrans, dstTrans_));
+  boost::shared_ptr<TFileReaderTransport> getFileReaderTransport(
+      boost::shared_ptr<TFileReaderTransport> srcTrans) {
+    return boost::shared_ptr<TFileReaderTransport>(
+        new TPipedFileReaderTransport(srcTrans, dstTrans_));
   }
 };
-
-}}} // apache::thrift::transport
+}
+}
+} // apache::thrift::transport
 
 #endif // #ifndef _THRIFT_TRANSPORT_TTRANSPORTUTILS_H_

http://git-wip-us.apache.org/repos/asf/thrift/blob/74260aa9/lib/cpp/src/thrift/transport/TVirtualTransport.h
----------------------------------------------------------------------
diff --git a/lib/cpp/src/thrift/transport/TVirtualTransport.h b/lib/cpp/src/thrift/transport/TVirtualTransport.h
index 575f547..0cacf61 100644
--- a/lib/cpp/src/thrift/transport/TVirtualTransport.h
+++ b/lib/cpp/src/thrift/transport/TVirtualTransport.h
@@ -22,8 +22,9 @@
 
 #include <thrift/transport/TTransport.h>
 
-namespace apache { namespace thrift { namespace transport {
-
+namespace apache {
+namespace thrift {
+namespace transport {
 
 /**
  * Helper class that provides default implementations of TTransport methods.
@@ -42,28 +43,20 @@ namespace apache { namespace thrift { namespace transport {
  * read_virt().)
  */
 class TTransportDefaults : public TTransport {
- public:
+public:
   /*
    * TTransport *_virt() methods provide reasonable default implementations.
    * Invoke them non-virtually.
    */
-  uint32_t read(uint8_t* buf, uint32_t len) {
-    return this->TTransport::read_virt(buf, len);
-  }
-  uint32_t readAll(uint8_t* buf, uint32_t len) {
-    return this->TTransport::readAll_virt(buf, len);
-  }
-  void write(const uint8_t* buf, uint32_t len) {
-    this->TTransport::write_virt(buf, len);
-  }
+  uint32_t read(uint8_t* buf, uint32_t len) { return this->TTransport::read_virt(buf, len); }
+  uint32_t readAll(uint8_t* buf, uint32_t len) { return this->TTransport::readAll_virt(buf, len); }
+  void write(const uint8_t* buf, uint32_t len) { this->TTransport::write_virt(buf, len); }
   const uint8_t* borrow(uint8_t* buf, uint32_t* len) {
     return this->TTransport::borrow_virt(buf, len);
   }
-  void consume(uint32_t len) {
-    this->TTransport::consume_virt(len);
-  }
+  void consume(uint32_t len) { this->TTransport::consume_virt(len); }
 
- protected:
+protected:
   TTransportDefaults() {}
 };
 
@@ -84,9 +77,9 @@ class TTransportDefaults : public TTransport {
  *
  * @author Chad Walters <ch...@powerset.com>
  */
-template <class Transport_, class Super_=TTransportDefaults>
+template <class Transport_, class Super_ = TTransportDefaults>
 class TVirtualTransport : public Super_ {
- public:
+public:
   /*
    * Implementations of the *_virt() functions, to call the subclass's
    * non-virtual implementation function.
@@ -107,9 +100,7 @@ class TVirtualTransport : public Super_ {
     return static_cast<Transport_*>(this)->borrow(buf, len);
   }
 
-  virtual void consume_virt(uint32_t len) {
-    static_cast<Transport_*>(this)->consume(len);
-  }
+  virtual void consume_virt(uint32_t len) { static_cast<Transport_*>(this)->consume(len); }
 
   /*
    * Provide a default readAll() implementation that invokes
@@ -126,7 +117,7 @@ class TVirtualTransport : public Super_ {
     return ::apache::thrift::transport::readAll(*trans, buf, len);
   }
 
- protected:
+protected:
   TVirtualTransport() {}
 
   /*
@@ -135,12 +126,15 @@ class TVirtualTransport : public Super_ {
    * additional versions can be added as needed.
    */
   template <typename Arg_>
-  TVirtualTransport(Arg_ const& arg) : Super_(arg) { }
+  TVirtualTransport(Arg_ const& arg)
+    : Super_(arg) {}
 
   template <typename Arg1_, typename Arg2_>
-  TVirtualTransport(Arg1_ const& a1, Arg2_ const& a2) : Super_(a1, a2) { }
+  TVirtualTransport(Arg1_ const& a1, Arg2_ const& a2)
+    : Super_(a1, a2) {}
 };
-
-}}} // apache::thrift::transport
+}
+}
+} // apache::thrift::transport
 
 #endif // #ifndef _THRIFT_TRANSPORT_TVIRTUALTRANSPORT_H_

http://git-wip-us.apache.org/repos/asf/thrift/blob/74260aa9/lib/cpp/src/thrift/transport/TZlibTransport.cpp
----------------------------------------------------------------------
diff --git a/lib/cpp/src/thrift/transport/TZlibTransport.cpp b/lib/cpp/src/thrift/transport/TZlibTransport.cpp
index cdde7c3..fb5cc5d 100644
--- a/lib/cpp/src/thrift/transport/TZlibTransport.cpp
+++ b/lib/cpp/src/thrift/transport/TZlibTransport.cpp
@@ -24,7 +24,9 @@
 
 using std::string;
 
-namespace apache { namespace thrift { namespace transport {
+namespace apache {
+namespace thrift {
+namespace transport {
 
 // Don't call this outside of the constructor.
 void TZlibTransport::initZlib() {
@@ -36,17 +38,17 @@ void TZlibTransport::initZlib() {
 
     rstream_->zalloc = Z_NULL;
     wstream_->zalloc = Z_NULL;
-    rstream_->zfree  = Z_NULL;
-    wstream_->zfree  = Z_NULL;
+    rstream_->zfree = Z_NULL;
+    wstream_->zfree = Z_NULL;
     rstream_->opaque = Z_NULL;
     wstream_->opaque = Z_NULL;
 
-    rstream_->next_in   = crbuf_;
-    wstream_->next_in   = uwbuf_;
-    rstream_->next_out  = urbuf_;
-    wstream_->next_out  = cwbuf_;
-    rstream_->avail_in  = 0;
-    wstream_->avail_in  = 0;
+    rstream_->next_in = crbuf_;
+    wstream_->next_in = uwbuf_;
+    rstream_->next_out = urbuf_;
+    wstream_->next_out = cwbuf_;
+    rstream_->avail_in = 0;
+    wstream_->avail_in = 0;
     rstream_->avail_out = urbuf_size_;
     wstream_->avail_out = cwbuf_size_;
 
@@ -79,8 +81,8 @@ inline void TZlibTransport::checkZlibRv(int status, const char* message) {
 
 inline void TZlibTransport::checkZlibRvNothrow(int status, const char* message) {
   if (status != Z_OK) {
-    string output = "TZlibTransport: zlib failure in destructor: " +
-      TZlibTransportException::errorMessage(status, message);
+    string output = "TZlibTransport: zlib failure in destructor: "
+                    + TZlibTransportException::errorMessage(status, message);
     GlobalOutput(output.c_str());
   }
 }
@@ -116,8 +118,6 @@ bool TZlibTransport::peek() {
   return (readAvail() > 0) || (rstream_->avail_in > 0) || transport_->peek();
 }
 
-
-
 // READING STRATEGY
 //
 // We have two buffers for reading: one containing the compressed data (crbuf_)
@@ -143,7 +143,7 @@ uint32_t TZlibTransport::read(uint8_t* buf, uint32_t len) {
   while (true) {
     // Copy out whatever we have available, then give them the min of
     // what we have and what they want, then advance indices.
-    int give = (std::min)((uint32_t) readAvail(), need);
+    int give = (std::min)((uint32_t)readAvail(), need);
     memcpy(buf, urbuf_ + urpos_, give);
     need -= give;
     buf += give;
@@ -170,7 +170,7 @@ uint32_t TZlibTransport::read(uint8_t* buf, uint32_t len) {
     }
 
     // The uncompressed read buffer is empty, so reset the stream fields.
-    rstream_->next_out  = urbuf_;
+    rstream_->next_out = urbuf_;
     rstream_->avail_out = urbuf_size_;
     urpos_ = 0;
 
@@ -195,7 +195,7 @@ bool TZlibTransport::readFromZlib() {
     if (got == 0) {
       return false;
     }
-    rstream_->next_in  = crbuf_;
+    rstream_->next_in = crbuf_;
     rstream_->avail_in = got;
   }
 
@@ -211,7 +211,6 @@ bool TZlibTransport::readFromZlib() {
   return true;
 }
 
-
 // WRITING STRATEGY
 //
 // We buffer up small writes before sending them to zlib, so our logic is:
@@ -232,8 +231,7 @@ bool TZlibTransport::readFromZlib() {
 
 void TZlibTransport::write(const uint8_t* buf, uint32_t len) {
   if (output_finished_) {
-    throw TTransportException(TTransportException::BAD_ARGS,
-                              "write() called after finish()");
+    throw TTransportException(TTransportException::BAD_ARGS, "write() called after finish()");
   }
 
   // zlib's "deflate" function has enough logic in it that I think
@@ -252,25 +250,23 @@ void TZlibTransport::write(const uint8_t* buf, uint32_t len) {
   }
 }
 
-void TZlibTransport::flush()  {
+void TZlibTransport::flush() {
   if (output_finished_) {
-    throw TTransportException(TTransportException::BAD_ARGS,
-                              "flush() called after finish()");
+    throw TTransportException(TTransportException::BAD_ARGS, "flush() called after finish()");
   }
 
   flushToTransport(Z_FULL_FLUSH);
 }
 
-void TZlibTransport::finish()  {
+void TZlibTransport::finish() {
   if (output_finished_) {
-    throw TTransportException(TTransportException::BAD_ARGS,
-                              "finish() called more than once");
+    throw TTransportException(TTransportException::BAD_ARGS, "finish() called more than once");
   }
 
   flushToTransport(Z_FINISH);
 }
 
-void TZlibTransport::flushToTransport(int flush)  {
+void TZlibTransport::flushToTransport(int flush) {
   // write pending data in uwbuf_ to zlib
   flushToZlib(uwbuf_, uwpos_, flush);
   uwpos_ = 0;
@@ -285,7 +281,7 @@ void TZlibTransport::flushToTransport(int flush)  {
 }
 
 void TZlibTransport::flushToZlib(const uint8_t* buf, int len, int flush) {
-  wstream_->next_in  = const_cast<uint8_t*>(buf);
+  wstream_->next_in = const_cast<uint8_t*>(buf);
   wstream_->avail_in = len;
 
   while (true) {
@@ -296,7 +292,7 @@ void TZlibTransport::flushToZlib(const uint8_t* buf, int len, int flush) {
     // If our ouput buffer is full, flush to the underlying transport.
     if (wstream_->avail_out == 0) {
       transport_->write(cwbuf_, cwbuf_size_);
-      wstream_->next_out  = cwbuf_;
+      wstream_->next_out = cwbuf_;
       wstream_->avail_out = cwbuf_size_;
     }
 
@@ -310,15 +306,15 @@ void TZlibTransport::flushToZlib(const uint8_t* buf, int len, int flush) {
 
     checkZlibRv(zlib_rv, wstream_->msg);
 
-    if ((flush == Z_SYNC_FLUSH || flush == Z_FULL_FLUSH) &&
-        wstream_->avail_in == 0 && wstream_->avail_out != 0) {
+    if ((flush == Z_SYNC_FLUSH || flush == Z_FULL_FLUSH) && wstream_->avail_in == 0
+        && wstream_->avail_out != 0) {
       break;
     }
   }
 }
 
 const uint8_t* TZlibTransport::borrow(uint8_t* buf, uint32_t* len) {
-  (void) buf;
+  (void)buf;
   // Don't try to be clever with shifting buffers.
   // If we have enough data, give a pointer to it,
   // otherwise let the protcol use its slow path.
@@ -333,8 +329,7 @@ void TZlibTransport::consume(uint32_t len) {
   if (readAvail() >= (int)len) {
     urpos_ += len;
   } else {
-    throw TTransportException(TTransportException::BAD_ARGS,
-                              "consume did not follow a borrow.");
+    throw TTransportException(TTransportException::BAD_ARGS, "consume did not follow a borrow.");
   }
 }
 
@@ -348,14 +343,13 @@ void TZlibTransport::verifyChecksum() {
   // This should only be called when reading is complete.
   // If the caller still has unread data, throw an exception.
   if (readAvail() > 0) {
-    throw TTransportException(
-        TTransportException::CORRUPTED_DATA,
-        "verifyChecksum() called before end of zlib stream");
+    throw TTransportException(TTransportException::CORRUPTED_DATA,
+                              "verifyChecksum() called before end of zlib stream");
   }
 
   // Reset the rstream fields, in case avail_out is 0.
   // (Since readAvail() is 0, we know there is no unread data in urbuf_)
-  rstream_->next_out  = urbuf_;
+  rstream_->next_out = urbuf_;
   rstream_->avail_out = urbuf_size_;
   urpos_ = 0;
 
@@ -394,6 +388,6 @@ void TZlibTransport::verifyChecksum() {
                             "verifyChecksum() called before end of "
                             "zlib stream");
 }
-
-
-}}} // apache::thrift::transport
+}
+}
+} // apache::thrift::transport

http://git-wip-us.apache.org/repos/asf/thrift/blob/74260aa9/lib/cpp/src/thrift/transport/TZlibTransport.h
----------------------------------------------------------------------
diff --git a/lib/cpp/src/thrift/transport/TZlibTransport.h b/lib/cpp/src/thrift/transport/TZlibTransport.h
index 565ecaa..1e7b5ec 100644
--- a/lib/cpp/src/thrift/transport/TZlibTransport.h
+++ b/lib/cpp/src/thrift/transport/TZlibTransport.h
@@ -27,15 +27,16 @@
 
 struct z_stream_s;
 
-namespace apache { namespace thrift { namespace transport {
+namespace apache {
+namespace thrift {
+namespace transport {
 
 class TZlibTransportException : public TTransportException {
- public:
-  TZlibTransportException(int status, const char* msg) :
-    TTransportException(TTransportException::INTERNAL_ERROR,
-                        errorMessage(status, msg)),
-    zlib_status_(status),
-    zlib_msg_(msg == NULL ? "(null)" : msg) {}
+public:
+  TZlibTransportException(int status, const char* msg)
+    : TTransportException(TTransportException::INTERNAL_ERROR, errorMessage(status, msg)),
+      zlib_status_(status),
+      zlib_msg_(msg == NULL ? "(null)" : msg) {}
 
   virtual ~TZlibTransportException() throw() {}
 
@@ -67,8 +68,7 @@ class TZlibTransportException : public TTransportException {
  *
  */
 class TZlibTransport : public TVirtualTransport<TZlibTransport> {
- public:
-
+public:
   /**
    * @param transport    The transport to read compressed data from
    *                     and write compressed data to.
@@ -83,31 +83,29 @@ class TZlibTransport : public TVirtualTransport<TZlibTransport> {
                  int crbuf_size = DEFAULT_CRBUF_SIZE,
                  int uwbuf_size = DEFAULT_UWBUF_SIZE,
                  int cwbuf_size = DEFAULT_CWBUF_SIZE,
-                 int16_t comp_level = Z_DEFAULT_COMPRESSION) :
-    transport_(transport),
-    urpos_(0),
-    uwpos_(0),
-    input_ended_(false),
-    output_finished_(false),
-    urbuf_size_(urbuf_size),
-    crbuf_size_(crbuf_size),
-    uwbuf_size_(uwbuf_size),
-    cwbuf_size_(cwbuf_size),
-    urbuf_(NULL),
-    crbuf_(NULL),
-    uwbuf_(NULL),
-    cwbuf_(NULL),
-    rstream_(NULL),
-    wstream_(NULL),
-    comp_level_(comp_level)
-  {
+                 int16_t comp_level = Z_DEFAULT_COMPRESSION)
+    : transport_(transport),
+      urpos_(0),
+      uwpos_(0),
+      input_ended_(false),
+      output_finished_(false),
+      urbuf_size_(urbuf_size),
+      crbuf_size_(crbuf_size),
+      uwbuf_size_(uwbuf_size),
+      cwbuf_size_(cwbuf_size),
+      urbuf_(NULL),
+      crbuf_(NULL),
+      uwbuf_(NULL),
+      cwbuf_(NULL),
+      rstream_(NULL),
+      wstream_(NULL),
+      comp_level_(comp_level) {
     if (uwbuf_size_ < MIN_DIRECT_DEFLATE_SIZE) {
       // Have to copy this into a local because of a linking issue.
       int minimum = MIN_DIRECT_DEFLATE_SIZE;
-      throw TTransportException(
-          TTransportException::BAD_ARGS,
-          "TZLibTransport: uncompressed write buffer must be at least"
-          + boost::lexical_cast<std::string>(minimum) + ".");
+      throw TTransportException(TTransportException::BAD_ARGS,
+                                "TZLibTransport: uncompressed write buffer must be at least"
+                                + boost::lexical_cast<std::string>(minimum) + ".");
     }
 
     try {
@@ -143,13 +141,9 @@ class TZlibTransport : public TVirtualTransport<TZlibTransport> {
   bool isOpen();
   bool peek();
 
-  void open() {
-    transport_->open();
-  }
+  void open() { transport_->open(); }
 
-  void close() {
-    transport_->close();
-  }
+  void close() { transport_->close(); }
 
   uint32_t read(uint8_t* buf, uint32_t len);
 
@@ -178,16 +172,15 @@ class TZlibTransport : public TVirtualTransport<TZlibTransport> {
    */
   void verifyChecksum();
 
-   /**
-    * TODO(someone_smart): Choose smart defaults.
-    */
+  /**
+   * TODO(someone_smart): Choose smart defaults.
+   */
   static const int DEFAULT_URBUF_SIZE = 128;
   static const int DEFAULT_CRBUF_SIZE = 1024;
   static const int DEFAULT_UWBUF_SIZE = 128;
   static const int DEFAULT_CWBUF_SIZE = 1024;
 
- protected:
-
+protected:
   inline void checkZlibRv(int status, const char* msg);
   inline void checkZlibRvNothrow(int status, const char* msg);
   inline int readAvail();
@@ -195,7 +188,7 @@ class TZlibTransport : public TVirtualTransport<TZlibTransport> {
   void flushToZlib(const uint8_t* buf, int len, int flush);
   bool readFromZlib();
 
- protected:
+protected:
   // Writes smaller than this are buffered up.
   // Larger (or equal) writes are dumped straight to zlib.
   static const uint32_t MIN_DIRECT_DEFLATE_SIZE = 32;
@@ -226,24 +219,22 @@ class TZlibTransport : public TVirtualTransport<TZlibTransport> {
   const int comp_level_;
 };
 
-
 /**
  * Wraps a transport into a zlibbed one.
  *
  */
 class TZlibTransportFactory : public TTransportFactory {
- public:
+public:
   TZlibTransportFactory() {}
 
   virtual ~TZlibTransportFactory() {}
 
-  virtual boost::shared_ptr<TTransport> getTransport(
-                                         boost::shared_ptr<TTransport> trans) {
+  virtual boost::shared_ptr<TTransport> getTransport(boost::shared_ptr<TTransport> trans) {
     return boost::shared_ptr<TTransport>(new TZlibTransport(trans));
   }
 };
-
-
-}}} // apache::thrift::transport
+}
+}
+} // apache::thrift::transport
 
 #endif // #ifndef _THRIFT_TRANSPORT_TZLIBTRANSPORT_H_

http://git-wip-us.apache.org/repos/asf/thrift/blob/74260aa9/lib/cpp/src/thrift/windows/GetTimeOfDay.cpp
----------------------------------------------------------------------
diff --git a/lib/cpp/src/thrift/windows/GetTimeOfDay.cpp b/lib/cpp/src/thrift/windows/GetTimeOfDay.cpp
index c5667e4..654d005 100644
--- a/lib/cpp/src/thrift/windows/GetTimeOfDay.cpp
+++ b/lib/cpp/src/thrift/windows/GetTimeOfDay.cpp
@@ -24,89 +24,73 @@
 #include <time.h>
 
 #if defined(_MSC_VER) || defined(_MSC_EXTENSIONS)
-#   define DELTA_EPOCH_IN_MICROSECS  11644473600000000Ui64
+#define DELTA_EPOCH_IN_MICROSECS 11644473600000000Ui64
 #else
-#   define DELTA_EPOCH_IN_MICROSECS  11644473600000000ULL
+#define DELTA_EPOCH_IN_MICROSECS 11644473600000000ULL
 #endif
 
-struct timezone
-{
-    int  tz_minuteswest; /* minutes W of Greenwich */
-    int  tz_dsttime;     /* type of dst correction */
+struct timezone {
+  int tz_minuteswest; /* minutes W of Greenwich */
+  int tz_dsttime;     /* type of dst correction */
 };
 
-int thrift_gettimeofday(struct timeval * tv, struct timezone * tz)
-{
-    FILETIME         ft;
-    unsigned __int64 tmpres(0);
-    static int       tzflag;
-
-    if (NULL != tv)
-    {
-        GetSystemTimeAsFileTime(&ft);
-
-        tmpres |= ft.dwHighDateTime;
-        tmpres <<= 32;
-        tmpres |= ft.dwLowDateTime;
-
-        /*converting file time to unix epoch*/
-        tmpres -= DELTA_EPOCH_IN_MICROSECS;
-        tmpres /= 10;  /*convert into microseconds*/
-        tv->tv_sec = (long)(tmpres / 1000000UL);
-        tv->tv_usec = (long)(tmpres % 1000000UL);
+int thrift_gettimeofday(struct timeval* tv, struct timezone* tz) {
+  FILETIME ft;
+  unsigned __int64 tmpres(0);
+  static int tzflag;
+
+  if (NULL != tv) {
+    GetSystemTimeAsFileTime(&ft);
+
+    tmpres |= ft.dwHighDateTime;
+    tmpres <<= 32;
+    tmpres |= ft.dwLowDateTime;
+
+    /*converting file time to unix epoch*/
+    tmpres -= DELTA_EPOCH_IN_MICROSECS;
+    tmpres /= 10; /*convert into microseconds*/
+    tv->tv_sec = (long)(tmpres / 1000000UL);
+    tv->tv_usec = (long)(tmpres % 1000000UL);
+  }
+
+  if (NULL != tz) {
+    if (!tzflag) {
+      _tzset();
+      tzflag++;
     }
 
-    if (NULL != tz)
-    {
-        if (!tzflag)
-        {
-            _tzset();
-            tzflag++;
-        }
-
-        long time_zone(0);
-        errno_t err(_get_timezone(&time_zone));
-        if (err == NO_ERROR)
-        {
-            tz->tz_minuteswest = time_zone / 60;
-        }
-        else
-        {
-            return -1;
-        }
+    long time_zone(0);
+    errno_t err(_get_timezone(&time_zone));
+    if (err == NO_ERROR) {
+      tz->tz_minuteswest = time_zone / 60;
+    } else {
+      return -1;
+    }
 
-        int day_light(0);
-        err = (_get_daylight(&day_light));
-        if (err == NO_ERROR)
-        {
-            tz->tz_dsttime = day_light;
-            return 0;
-        }
-        else
-        {
-            return -1;
-        }
+    int day_light(0);
+    err = (_get_daylight(&day_light));
+    if (err == NO_ERROR) {
+      tz->tz_dsttime = day_light;
+      return 0;
+    } else {
+      return -1;
     }
+  }
 
-    return 0;
+  return 0;
 }
 
-int thrift_sleep(unsigned int seconds)
-{
+int thrift_sleep(unsigned int seconds) {
   ::Sleep(seconds * 1000);
   return 0;
 }
-int thrift_usleep(unsigned int microseconds)
-{
-  unsigned int milliseconds = (microseconds + 999)/ 1000;
+int thrift_usleep(unsigned int microseconds) {
+  unsigned int milliseconds = (microseconds + 999) / 1000;
   ::Sleep(milliseconds);
   return 0;
 }
 
-char *thrift_ctime_r(const time_t *_clock, char *_buf)
-{
-   strcpy(_buf, ctime(_clock));
-   return _buf;
+char* thrift_ctime_r(const time_t* _clock, char* _buf) {
+  strcpy(_buf, ctime(_clock));
+  return _buf;
 }
-
-

http://git-wip-us.apache.org/repos/asf/thrift/blob/74260aa9/lib/cpp/src/thrift/windows/GetTimeOfDay.h
----------------------------------------------------------------------
diff --git a/lib/cpp/src/thrift/windows/GetTimeOfDay.h b/lib/cpp/src/thrift/windows/GetTimeOfDay.h
index 27b8a84..6e90ba1 100644
--- a/lib/cpp/src/thrift/windows/GetTimeOfDay.h
+++ b/lib/cpp/src/thrift/windows/GetTimeOfDay.h
@@ -35,9 +35,9 @@ struct thrift_timespec {
   int64_t tv_nsec;
 };
 
-int thrift_gettimeofday(struct timeval * tv, struct timezone * tz);
+int thrift_gettimeofday(struct timeval* tv, struct timezone* tz);
 int thrift_sleep(unsigned int seconds);
 int thrift_usleep(unsigned int micro_seconds);
-char *thrift_ctime_r(const time_t *_clock, char *_buf);
+char* thrift_ctime_r(const time_t* _clock, char* _buf);
 
 #endif // _THRIFT_WINDOWS_GETTIMEOFDAY_H_

http://git-wip-us.apache.org/repos/asf/thrift/blob/74260aa9/lib/cpp/src/thrift/windows/Operators.h
----------------------------------------------------------------------
diff --git a/lib/cpp/src/thrift/windows/Operators.h b/lib/cpp/src/thrift/windows/Operators.h
index 95d8e3e..9b86096 100644
--- a/lib/cpp/src/thrift/windows/Operators.h
+++ b/lib/cpp/src/thrift/windows/Operators.h
@@ -24,17 +24,17 @@
 #pragma once
 #endif // _MSC_VER
 
-namespace apache { namespace thrift {
+namespace apache {
+namespace thrift {
 
 class TEnumIterator;
 
-inline bool operator == (const TEnumIterator&, const TEnumIterator&)
-{
-    // Not entirely sure what the test should be here. It is only to enable
-    // iterator debugging and is not used in release mode.
-    return true;
+inline bool operator==(const TEnumIterator&, const TEnumIterator&) {
+  // Not entirely sure what the test should be here. It is only to enable
+  // iterator debugging and is not used in release mode.
+  return true;
 }
-
-}} // apache::thrift
+}
+} // apache::thrift
 
 #endif // _THRIFT_WINDOWS_OPERATORS_H_

http://git-wip-us.apache.org/repos/asf/thrift/blob/74260aa9/lib/cpp/src/thrift/windows/OverlappedSubmissionThread.cpp
----------------------------------------------------------------------
diff --git a/lib/cpp/src/thrift/windows/OverlappedSubmissionThread.cpp b/lib/cpp/src/thrift/windows/OverlappedSubmissionThread.cpp
index 5dec390..5ac6fe0 100644
--- a/lib/cpp/src/thrift/windows/OverlappedSubmissionThread.cpp
+++ b/lib/cpp/src/thrift/windows/OverlappedSubmissionThread.cpp
@@ -23,21 +23,23 @@
 #include <boost/scope_exit.hpp>
 #include <process.h>
 
-namespace apache { namespace thrift { namespace transport {
-
-TOverlappedWorkItem::TOverlappedWorkItem() :
-  SLIST_ENTRY(),
-  action(UNKNOWN),
-  h(INVALID_HANDLE_VALUE),
-  buffer(NULL),
-  buffer_len(0),
-  overlap(),
-  last_error(0),
-  success(TRUE)
-{}
+namespace apache {
+namespace thrift {
+namespace transport {
+
+TOverlappedWorkItem::TOverlappedWorkItem()
+  : SLIST_ENTRY(),
+    action(UNKNOWN),
+    h(INVALID_HANDLE_VALUE),
+    buffer(NULL),
+    buffer_len(0),
+    overlap(),
+    last_error(0),
+    success(TRUE) {
+}
 
-void TOverlappedWorkItem::reset(uint8_t *buf, uint32_t len, HANDLE event) {
-  memset( &overlap, 0, sizeof(overlap));
+void TOverlappedWorkItem::reset(uint8_t* buf, uint32_t len, HANDLE event) {
+  memset(&overlap, 0, sizeof(overlap));
   overlap.hEvent = event;
   buffer = buf;
   buffer_len = len;
@@ -48,7 +50,7 @@ void TOverlappedWorkItem::reset(uint8_t *buf, uint32_t len, HANDLE event) {
 uint32_t TOverlappedWorkItem::overlappedResults(bool signal_failure) {
   DWORD bytes = 0;
   BOOL result = ::GetOverlappedResult(h, &overlap, &bytes, TRUE);
-  if(signal_failure && !result) //get overlapped error case
+  if (signal_failure && !result) // get overlapped error case
   {
     GlobalOutput.perror("TPipe ::GetOverlappedResult errored GLE=", ::GetLastError());
     throw TTransportException(TTransportException::UNKNOWN, "TPipe: GetOverlappedResult failed");
@@ -57,42 +59,40 @@ uint32_t TOverlappedWorkItem::overlappedResults(bool signal_failure) {
 }
 
 bool TOverlappedWorkItem::process() {
-  BOOST_SCOPE_EXIT( (&doneSubmittingEvent) ) {
-    SetEvent(doneSubmittingEvent.h);
-  } BOOST_SCOPE_EXIT_END
+  BOOST_SCOPE_EXIT((&doneSubmittingEvent)) { SetEvent(doneSubmittingEvent.h); }
+  BOOST_SCOPE_EXIT_END
 
-  switch(action) {
-  case(CONNECT):
+  switch (action) {
+  case (CONNECT):
     success = ::ConnectNamedPipe(h, &overlap);
-    if(success == FALSE)
+    if (success == FALSE)
       last_error = ::GetLastError();
     return true;
-  case(READ):
+  case (READ):
     success = ::ReadFile(h, buffer, buffer_len, NULL, &overlap);
-    if(success == FALSE)
+    if (success == FALSE)
       last_error = ::GetLastError();
     return true;
-  case(CANCELIO):
+  case (CANCELIO):
     success = ::CancelIo(h);
-    if(success == FALSE)
+    if (success == FALSE)
       last_error = ::GetLastError();
     return true;
-  case(STOP):
+  case (STOP):
   default:
     return false;
   }
 }
 
-void TOverlappedSubmissionThread::addWorkItem(TOverlappedWorkItem *item) {
+void TOverlappedSubmissionThread::addWorkItem(TOverlappedWorkItem* item) {
   InterlockedPushEntrySList(&workList_, item);
   SetEvent(workAvailableEvent_.h);
   WaitForSingleObject(item->doneSubmittingEvent.h, INFINITE);
 }
 
-TOverlappedSubmissionThread *TOverlappedSubmissionThread::acquire_instance() {
+TOverlappedSubmissionThread* TOverlappedSubmissionThread::acquire_instance() {
   TAutoCrit lock(instanceGuard_);
-  if(instance_ == NULL)
-  {
+  if (instance_ == NULL) {
     assert(instanceRefCount_ == 0);
     instance_ = new TOverlappedSubmissionThread;
   }
@@ -101,8 +101,7 @@ TOverlappedSubmissionThread *TOverlappedSubmissionThread::acquire_instance() {
 }
 void TOverlappedSubmissionThread::release_instance() {
   TAutoCrit lock(instanceGuard_);
-  if(--instanceRefCount_ == 0)
-  {
+  if (--instanceRefCount_ == 0) {
     delete instance_;
     instance_ = NULL;
   }
@@ -112,16 +111,11 @@ TOverlappedSubmissionThread::TOverlappedSubmissionThread() {
   stopItem_.action = TOverlappedWorkItem::STOP;
 
   InitializeSListHead(&workList_);
-  thread_ = (HANDLE)_beginthreadex(
-    NULL,
-    0,
-    thread_proc,
-    this,
-    0,
-    NULL);
-  if(thread_ == 0) {
+  thread_ = (HANDLE)_beginthreadex(NULL, 0, thread_proc, this, 0, NULL);
+  if (thread_ == 0) {
     GlobalOutput.perror("TOverlappedSubmissionThread unable to create thread, errno=", errno);
-    throw TTransportException(TTransportException::NOT_OPEN, " TOverlappedSubmissionThread unable to create thread");
+    throw TTransportException(TTransportException::NOT_OPEN,
+                              " TOverlappedSubmissionThread unable to create thread");
   }
 }
 
@@ -132,25 +126,26 @@ TOverlappedSubmissionThread::~TOverlappedSubmissionThread() {
 }
 
 void TOverlappedSubmissionThread::run() {
-  for(;;) {
+  for (;;) {
     WaitForSingleObject(workAvailableEvent_.h, INFINITE);
-    //todo check result
-    SLIST_ENTRY *entry = NULL;
-    while( (entry = InterlockedPopEntrySList(&workList_)) != NULL) {
-      TOverlappedWorkItem &item = *static_cast<TOverlappedWorkItem *>(entry);
-      if(!item.process())
+    // todo check result
+    SLIST_ENTRY* entry = NULL;
+    while ((entry = InterlockedPopEntrySList(&workList_)) != NULL) {
+      TOverlappedWorkItem& item = *static_cast<TOverlappedWorkItem*>(entry);
+      if (!item.process())
         return;
     }
   }
 }
 
-unsigned __stdcall TOverlappedSubmissionThread::thread_proc(void *addr) {
-  static_cast<TOverlappedSubmissionThread *>(addr)->run();
+unsigned __stdcall TOverlappedSubmissionThread::thread_proc(void* addr) {
+  static_cast<TOverlappedSubmissionThread*>(addr)->run();
   return 0;
 }
 
 TCriticalSection TOverlappedSubmissionThread::instanceGuard_;
 TOverlappedSubmissionThread* TOverlappedSubmissionThread::instance_;
-uint32_t TOverlappedSubmissionThread::instanceRefCount_=0;
-
-}}} //apach::thrift::transport
+uint32_t TOverlappedSubmissionThread::instanceRefCount_ = 0;
+}
+}
+} // apach::thrift::transport

http://git-wip-us.apache.org/repos/asf/thrift/blob/74260aa9/lib/cpp/src/thrift/windows/OverlappedSubmissionThread.h
----------------------------------------------------------------------
diff --git a/lib/cpp/src/thrift/windows/OverlappedSubmissionThread.h b/lib/cpp/src/thrift/windows/OverlappedSubmissionThread.h
index 16b7e24..56684bb 100644
--- a/lib/cpp/src/thrift/windows/OverlappedSubmissionThread.h
+++ b/lib/cpp/src/thrift/windows/OverlappedSubmissionThread.h
@@ -59,13 +59,15 @@
   until the operation has completed.
 */
 
-namespace apache { namespace thrift { namespace transport {
+namespace apache {
+namespace thrift {
+namespace transport {
 
 DECLSPEC_ALIGN(MEMORY_ALLOCATION_ALIGNMENT) struct TOverlappedWorkItem : public SLIST_ENTRY {
   TOverlappedWorkItem();
 
   enum action_t {
-    UNKNOWN  = 3000,
+    UNKNOWN = 3000,
     CONNECT,
     READ,
     CANCELIO,
@@ -75,38 +77,38 @@ DECLSPEC_ALIGN(MEMORY_ALLOCATION_ALIGNMENT) struct TOverlappedWorkItem : public
   TAutoResetEvent doneSubmittingEvent;
   action_t action;
   HANDLE h;
-  uint8_t *buffer;
+  uint8_t* buffer;
   uint32_t buffer_len;
   OVERLAPPED overlap;
 
   DWORD last_error;
   BOOL success;
 
-  void reset(uint8_t *buf, uint32_t len, HANDLE event);
+  void reset(uint8_t* buf, uint32_t len, HANDLE event);
   uint32_t overlappedResults(bool signal_failure = true);
   bool process();
 };
 
-class TOverlappedSubmissionThread : boost::noncopyable
-{
+class TOverlappedSubmissionThread : boost::noncopyable {
 public:
-  void addWorkItem(TOverlappedWorkItem *item);
+  void addWorkItem(TOverlappedWorkItem* item);
 
-//singleton stuff
+  // singleton stuff
 public:
-  static TOverlappedSubmissionThread *acquire_instance();
+  static TOverlappedSubmissionThread* acquire_instance();
   static void release_instance();
+
 private:
   static TCriticalSection instanceGuard_;
-  static TOverlappedSubmissionThread *instance_;
+  static TOverlappedSubmissionThread* instance_;
   static uint32_t instanceRefCount_;
 
-//thread details
+  // thread details
 private:
   TOverlappedSubmissionThread();
   ~TOverlappedSubmissionThread();
   void run();
-  static unsigned __stdcall thread_proc(void *addr);
+  static unsigned __stdcall thread_proc(void* addr);
 
 private:
   DECLSPEC_ALIGN(MEMORY_ALLOCATION_ALIGNMENT) SLIST_HEADER workList_;
@@ -117,13 +119,15 @@ private:
 
 class TAutoOverlapThread : boost::noncopyable {
 private:
-  TOverlappedSubmissionThread *p;
+  TOverlappedSubmissionThread* p;
+
 public:
   TAutoOverlapThread() : p(TOverlappedSubmissionThread::acquire_instance()) {}
-  ~TAutoOverlapThread() {TOverlappedSubmissionThread::release_instance();}
-  TOverlappedSubmissionThread *operator->() {return p;}
+  ~TAutoOverlapThread() { TOverlappedSubmissionThread::release_instance(); }
+  TOverlappedSubmissionThread* operator->() { return p; }
 };
-
-}}} //apache::thrift::transport
+}
+}
+} // apache::thrift::transport
 
 #endif