Merge lp:~mzanetti/reminders-app/update-thrift into lp:reminders-app

[Michael Zanetti]

update libthrift to 0.9.2

I hoped this would increase the connection stability, but I'm afraid it doesn't. In any case, this is probably still good to have at it seems to have some security related fixes too.

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

FAILED: Continuous integration, rev:351
No commit message was specified in the merge proposal. Click on the following link and set the commit message (if you want a jenkins rebuild you need to trigger it yourself):
https://code.launchpad.net/~mzanetti/reminders-app/update-thrift/+merge/251027/+edit-commit-message

http://91.189.93.70:8080/job/reminders-app-ci/672/
Executed test runs:
    SUCCESS: http://91.189.93.70:8080/job/generic-mediumtests-utopic/2114
        deb: http://91.189.93.70:8080/job/generic-mediumtests-utopic/2114/artifact/work/output/*zip*/output.zip
    SUCCESS: http://91.189.93.70:8080/job/reminders-app-vivid-amd64-ci/93

Click here to trigger a rebuild:
http://91.189.93.70:8080/job/reminders-app-ci/672/rebuild

review: Needs Fixing (continuous-integration)

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

PASSED: Continuous integration, rev:351
http://91.189.93.70:8080/job/reminders-app-ci/673/
Executed test runs:
    SUCCESS: http://91.189.93.70:8080/job/generic-mediumtests-utopic/2123
        deb: http://91.189.93.70:8080/job/generic-mediumtests-utopic/2123/artifact/work/output/*zip*/output.zip
    SUCCESS: http://91.189.93.70:8080/job/reminders-app-vivid-amd64-ci/94

Click here to trigger a rebuild:
http://91.189.93.70:8080/job/reminders-app-ci/673/rebuild

review: Approve (continuous-integration)

[Riccardo Padovani (rpadovani)]

I see you dropped the edit you did in Washington to 3rdParty/libthrift/transport/TSSLSocket.cpp

Is something you want or you just forgot about it?

review: Needs Information

[Michael Zanetti (mzanetti)]

> I see you dropped the edit you did in Washington to
> 3rdParty/libthrift/transport/TSSLSocket.cpp
>
> Is something you want or you just forgot about it?

Yeah, I think that's not needed any more. I couldn't reproduce the issue any more.

[Riccardo Padovani (rpadovani)]

Then looks good :-)

review: Approve

=== removed file '3rdParty/libthrift/README'
--- 3rdParty/libthrift/README	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/README	1970-01-01 00:00:00 +0000
@@ -1,77 +0,0 @@
-Apache Thrift
-
-Last Modified: 2012-May-30
-
-License
-=======
-
-Licensed to the Apache Software Foundation (ASF) under one
-or more contributor license agreements. See the NOTICE file
-distributed with this work for additional information
-regarding copyright ownership. The ASF licenses this file
-to you under the Apache License, Version 2.0 (the
-"License"); you may not use this file except in compliance
-with the License. You may obtain a copy of the License at
-
-  http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing,
-software distributed under the License is distributed on an
-"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, either express or implied. See the License for the
-specific language governing permissions and limitations
-under the License.
-
-Introduction
-============
-
-Thrift is a lightweight, language-independent software stack with an
-associated code generation mechanism for RPC. Thrift provides clean
-abstractions for data transport, data serialization, and application
-level processing. The code generation system takes a simple definition
-language as its input and generates code across programming languages that
-uses the abstracted stack to build interoperable RPC clients and servers.
-
-Thrift is specifically designed to support non-atomic version changes
-across client and server code.
-
-For more details on Thrift's design and implementation, take a gander at
-the Thrift whitepaper included in this distribution or at the README files
-in your particular subdirectory of interest.
-
-Changes
-=======
-
-This repo builds up a small subset of the original Thrift C++ library.
-Source ready to compile on Linux, Android (at least android-5 platform with 
-exceptions and rtti enabled) and iOS.
-
-Hierarchy
-=========
-
-thrift/
-
-  lib/
-    Contains the Thrift software library implementation, subdivided by
-    language of implementation.
-
-    cpp/
-
-Requirements
-============
-
- - LibC
- - Boost (1.47 recommended)
-
-Resources
-=========
-
-More information about Thrift can be obtained on the Thrift webpage at:
-
-     http://thrift.apache.org
-
-Acknowledgments
-===============
-
-Thrift was inspired by pillar, a lightweight RPC tool written by Adam D'Angelo,
-and also by Google's protocol buffers.

=== modified file '3rdParty/libthrift/TApplicationException.h'
--- 3rdParty/libthrift/TApplicationException.h	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/TApplicationException.h	2015-02-26 01:00:39 +0000
@@ -22,6 +22,7 @@
 
 #include <Thrift.h>
 
+
 namespace apache { namespace thrift {
 
 namespace protocol {
@@ -42,7 +43,10 @@
     BAD_SEQUENCE_ID = 4,
     MISSING_RESULT = 5,
     INTERNAL_ERROR = 6,
-    PROTOCOL_ERROR = 7
+    PROTOCOL_ERROR = 7,
+    INVALID_TRANSFORM = 8,
+    INVALID_PROTOCOL = 9,
+    UNSUPPORTED_CLIENT_TYPE = 10
   };
 
   TApplicationException() :
@@ -77,13 +81,18 @@
   virtual const char* what() const throw() {
     if (message_.empty()) {
       switch (type_) {
-        case UNKNOWN              : return "TApplicationException: Unknown application exception";
-        case UNKNOWN_METHOD       : return "TApplicationException: Unknown method";
-        case INVALID_MESSAGE_TYPE : return "TApplicationException: Invalid message type";
-        case WRONG_METHOD_NAME    : return "TApplicationException: Wrong method name";
-        case BAD_SEQUENCE_ID      : return "TApplicationException: Bad sequence identifier";
-        case MISSING_RESULT       : return "TApplicationException: Missing result";
-        default                   : return "TApplicationException: (Invalid exception type)";
+        case UNKNOWN                 : return "TApplicationException: Unknown application exception";
+        case UNKNOWN_METHOD          : return "TApplicationException: Unknown method";
+        case INVALID_MESSAGE_TYPE    : return "TApplicationException: Invalid message type";
+        case WRONG_METHOD_NAME       : return "TApplicationException: Wrong method name";
+        case BAD_SEQUENCE_ID         : return "TApplicationException: Bad sequence identifier";
+        case MISSING_RESULT          : return "TApplicationException: Missing result";
+        case INTERNAL_ERROR          : return "TApplicationException: Internal error";
+        case PROTOCOL_ERROR          : return "TApplicationException: Protocol error";
+        case INVALID_TRANSFORM       : return "TApplicationException: Invalid transform";
+        case INVALID_PROTOCOL        : return "TApplicationException: Invalid protocol";
+        case UNSUPPORTED_CLIENT_TYPE : return "TApplicationException: Unsupported client type";
+        default                      : return "TApplicationException: (Invalid exception type)";
       };
     } else {
       return message_.c_str();

=== added file '3rdParty/libthrift/TDispatchProcessor.h'
--- 3rdParty/libthrift/TDispatchProcessor.h	1970-01-01 00:00:00 +0000
+++ 3rdParty/libthrift/TDispatchProcessor.h	2015-02-26 01:00:39 +0000
@@ -0,0 +1,142 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+#ifndef _THRIFT_TDISPATCHPROCESSOR_H_
+#define _THRIFT_TDISPATCHPROCESSOR_H_ 1
+
+#include <thrift/TProcessor.h>
+
+namespace apache { namespace thrift {
+
+/**
+ * TDispatchProcessor is a helper class to parse the message header then call
+ * another function to dispatch based on the function name.
+ *
+ * Subclasses must implement dispatchCall() to dispatch on the function name.
+ */
+template <class Protocol_>
+class TDispatchProcessorT : public TProcessor {
+ public:
+  virtual bool process(boost::shared_ptr<protocol::TProtocol> in,
+                       boost::shared_ptr<protocol::TProtocol> out,
+                       void* connectionContext) {
+    protocol::TProtocol* inRaw = in.get();
+    protocol::TProtocol* outRaw = out.get();
+
+    // Try to dynamic cast to the template protocol type
+    Protocol_* specificIn = dynamic_cast<Protocol_*>(inRaw);
+    Protocol_* specificOut = dynamic_cast<Protocol_*>(outRaw);
+    if (specificIn && specificOut) {
+      return processFast(specificIn, specificOut, connectionContext);
+    }
+
+    // Log the fact that we have to use the slow path
+    T_GENERIC_PROTOCOL(this, inRaw, specificIn);
+    T_GENERIC_PROTOCOL(this, outRaw, specificOut);
+
+    std::string fname;
+    protocol::TMessageType mtype;
+    int32_t seqid;
+    inRaw->readMessageBegin(fname, mtype, seqid);
+
+    // If this doesn't look like a valid call, log an error and return false so
+    // that the server will close the connection.
+    //
+    // (The old generated processor code used to try to skip a T_STRUCT and
+    // continue.  However, that seems unsafe.)
+    if (mtype != protocol::T_CALL && mtype != protocol::T_ONEWAY) {
+      GlobalOutput.printf("received invalid message type %d from client",
+                          mtype);
+      return false;
+    }
+
+    return this->dispatchCall(inRaw, outRaw, fname, seqid, connectionContext);
+  }
+
+ protected:
+  bool processFast(Protocol_* in, Protocol_* out, void* connectionContext) {
+    std::string fname;
+    protocol::TMessageType mtype;
+    int32_t seqid;
+    in->readMessageBegin(fname, mtype, seqid);
+
+    if (mtype != protocol::T_CALL && mtype != protocol::T_ONEWAY) {
+      GlobalOutput.printf("received invalid message type %d from client",
+                          mtype);
+      return false;
+    }
+
+    return this->dispatchCallTemplated(in, out, fname,
+                                       seqid, connectionContext);
+  }
+
+  /**
+   * dispatchCall() methods must be implemented by subclasses
+   */
+  virtual bool dispatchCall(apache::thrift::protocol::TProtocol* in,
+                            apache::thrift::protocol::TProtocol* out,
+                            const std::string& fname, int32_t seqid,
+                            void* callContext) = 0;
+
+  virtual bool dispatchCallTemplated(Protocol_* in, Protocol_* out,
+                                     const std::string& fname, int32_t seqid,
+                                     void* callContext) = 0;
+};
+
+/**
+ * Non-templatized version of TDispatchProcessor, that doesn't bother trying to
+ * perform a dynamic_cast.
+ */
+class TDispatchProcessor : public TProcessor {
+ public:
+  virtual bool process(boost::shared_ptr<protocol::TProtocol> in,
+                       boost::shared_ptr<protocol::TProtocol> out,
+                       void* connectionContext) {
+    std::string fname;
+    protocol::TMessageType mtype;
+    int32_t seqid;
+    in->readMessageBegin(fname, mtype, seqid);
+
+    if (mtype != protocol::T_CALL && mtype != protocol::T_ONEWAY) {
+      GlobalOutput.printf("received invalid message type %d from client",
+                          mtype);
+      return false;
+    }
+
+    return dispatchCall(in.get(), out.get(), fname, seqid, connectionContext);
+  }
+
+ protected:
+  virtual bool dispatchCall(apache::thrift::protocol::TProtocol* in,
+                            apache::thrift::protocol::TProtocol* out,
+                            const std::string& fname, int32_t seqid,
+                            void* callContext) = 0;
+};
+
+// Specialize TDispatchProcessorT for TProtocol and TDummyProtocol just to use
+// the generic TDispatchProcessor.
+template <>
+class TDispatchProcessorT<protocol::TDummyProtocol> :
+  public TDispatchProcessor {};
+template <>
+class TDispatchProcessorT<protocol::TProtocol> :
+  public TDispatchProcessor {};
+
+}} // apache::thrift
+
+#endif // _THRIFT_TDISPATCHPROCESSOR_H_

=== modified file '3rdParty/libthrift/TLogging.h'
--- 3rdParty/libthrift/TLogging.h	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/TLogging.h	2015-02-26 01:00:39 +0000
@@ -20,20 +20,14 @@
 #ifndef _THRIFT_TLOGGING_H_
 #define _THRIFT_TLOGGING_H_ 1
 
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
+#include <thrift-config.h>
 
 /**
  * Contains utility macros for debugging and logging.
  *
  */
 
-#ifndef HAVE_CLOCK_GETTIME
 #include <time.h>
-#else
-#include <sys/time.h>
-#endif
 
 #ifdef HAVE_STDINT_H
 #include <stdint.h>
@@ -82,7 +76,7 @@
         time_t now;                                                       \
         char dbgtime[26] ;                                                \
         time(&now);                                                       \
-        ctime_r(&now, dbgtime);                                           \
+        THRIFT_CTIME_R(&now, dbgtime);                                           \
         dbgtime[24] = '\0';                                               \
         fprintf(stderr,"[%s,%d] [%s] " format_string " \n", __FILE__, __LINE__,dbgtime,##__VA_ARGS__); \
       }                                                                   \
@@ -115,7 +109,7 @@
     time_t now;                                                         \
     char dbgtime[26] ;                                                  \
     time(&now);                                                         \
-    ctime_r(&now, dbgtime);                                             \
+    THRIFT_CTIME_R(&now, dbgtime);                                             \
     dbgtime[24] = '\0';                                                 \
     fprintf(stderr,"[%s,%d] [%s] ERROR: " format_string " \n", __FILE__, __LINE__,dbgtime,##__VA_ARGS__); \
   }
@@ -132,7 +126,7 @@
     time_t now;                                                         \
     char dbgtime[26] ;                                                  \
     time(&now);                                                         \
-    ctime_r(&now, dbgtime);                                             \
+    THRIFT_CTIME_R(&now, dbgtime);                                             \
     dbgtime[24] = '\0';                                                 \
     fprintf(stderr,"[%s,%d] [%s] ERROR: Going to abort " format_string " \n", __FILE__, __LINE__,dbgtime,##__VA_ARGS__); \
     exit(1);                                                            \
@@ -151,7 +145,7 @@
         time_t now;                                                           \
         char dbgtime[26] ;                                                    \
         time(&now);                                                           \
-        ctime_r(&now, dbgtime);                                               \
+        THRIFT_CTIME_R(&now, dbgtime);                                               \
         dbgtime[24] = '\0';                                                   \
         fprintf(stderr,"[%s] " format_string " \n", dbgtime,##__VA_ARGS__);  \
       }                                                                       \

=== modified file '3rdParty/libthrift/TReflectionLocal.h'
--- 3rdParty/libthrift/TReflectionLocal.h	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/TReflectionLocal.h	2015-02-26 01:00:39 +0000
@@ -22,7 +22,7 @@
 
 #include <stdint.h>
 #include <cstring>
-#include <protocol/TProtocol.h>
+#include <thrift/protocol/TProtocol.h>
 
 /**
  * Local Reflection is a blanket term referring to the the structure

=== added file '3rdParty/libthrift/TToString.h'
--- 3rdParty/libthrift/TToString.h	1970-01-01 00:00:00 +0000
+++ 3rdParty/libthrift/TToString.h	2015-02-26 01:00:39 +0000
@@ -0,0 +1,89 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#ifndef _THRIFT_TOSTRING_H_
+#define _THRIFT_TOSTRING_H_ 1
+
+#include <boost/lexical_cast.hpp>
+
+#include <vector>
+#include <map>
+#include <set>
+#include <string>
+#include <sstream>
+
+namespace apache { namespace thrift {
+
+template <typename T>
+std::string to_string(const T& t) {
+  return boost::lexical_cast<std::string>(t);
+}
+
+template <typename K, typename V>
+std::string to_string(const std::map<K, V>& m);
+
+template <typename T>
+std::string to_string(const std::set<T>& s);
+
+template <typename T>
+std::string to_string(const std::vector<T>& t);
+
+template <typename K, typename V>
+std::string to_string(const typename std::pair<K, V>& v) {
+  std::ostringstream o;
+  o << to_string(v.first) << ": " << to_string(v.second);
+  return o.str();
+}
+
+template <typename T>
+std::string to_string(const T& beg, const T& end)
+{
+  std::ostringstream o;
+  for (T it = beg; it != end; ++it) {
+    if (it != beg)
+      o << ", ";
+    o << to_string(*it);
+  }
+  return o.str();
+}
+
+template <typename T>
+std::string to_string(const std::vector<T>& t) {
+  std::ostringstream o;
+  o << "[" << to_string(t.begin(), t.end()) << "]";
+  return o.str();
+}
+
+template <typename K, typename V>
+std::string to_string(const std::map<K, V>& m) {
+  std::ostringstream o;
+  o << "{" << to_string(m.begin(), m.end()) << "}";
+  return o.str();
+}
+
+template <typename T>
+std::string to_string(const std::set<T>& s) {
+  std::ostringstream o;
+  o << "{" << to_string(s.begin(), s.end()) << "}";
+  return o.str();
+}
+
+}} // apache::thrift
+
+#endif // _THRIFT_TOSTRING_H_

=== modified file '3rdParty/libthrift/Thrift.cpp'
--- 3rdParty/libthrift/Thrift.cpp	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/Thrift.cpp	2015-02-26 01:00:39 +0000
@@ -29,11 +29,25 @@
 TOutput GlobalOutput;
 
 void TOutput::printf(const char *message, ...) {
+#ifndef THRIFT_SQUELCH_CONSOLE_OUTPUT
   // Try to reduce heap usage, even if printf is called rarely.
   static const int STACK_BUF_SIZE = 256;
   char stack_buf[STACK_BUF_SIZE];
   va_list ap;
 
+#ifdef _MSC_VER
+  va_start(ap, message);
+  int need = _vscprintf(message, ap);
+  va_end(ap);
+
+  if (need < STACK_BUF_SIZE) {
+    va_start(ap, message);
+    vsnprintf_s(stack_buf, STACK_BUF_SIZE, _TRUNCATE, message, ap);
+    va_end(ap);
+    f_(stack_buf);
+    return;
+  }
+#else
   va_start(ap, message);
   int need = vsnprintf(stack_buf, STACK_BUF_SIZE, message, ap);
   va_end(ap);
@@ -42,9 +56,15 @@
     f_(stack_buf);
     return;
   }
+#endif
 
   char *heap_buf = (char*)malloc((need+1) * sizeof(char));
   if (heap_buf == NULL) {
+#ifdef _MSC_VER
+    va_start(ap, message);
+    vsnprintf_s(stack_buf, STACK_BUF_SIZE, _TRUNCATE, message, ap);
+    va_end(ap);
+#endif
     // Malloc failed.  We might as well print the stack buffer.
     f_(stack_buf);
     return;
@@ -58,6 +78,18 @@
     f_(heap_buf);
   }
   free(heap_buf);
+#endif
+}
+
+void TOutput::errorTimeWrapper(const char* msg) {
+#ifndef THRIFT_SQUELCH_CONSOLE_OUTPUT
+  time_t now;
+  char dbgtime[26];
+  time(&now);
+  THRIFT_CTIME_R(&now, dbgtime);
+  dbgtime[24] = 0;
+  fprintf(stderr, "Thrift: %s %s\n", dbgtime, msg);
+#endif
 }
 
 void TOutput::perror(const char *message, int errno_copy) {

=== modified file '3rdParty/libthrift/Thrift.h'
--- 3rdParty/libthrift/Thrift.h	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/Thrift.h	2015-02-26 01:00:39 +0000
@@ -20,13 +20,10 @@
 #ifndef _THRIFT_THRIFT_H_
 #define _THRIFT_THRIFT_H_ 1
 
-#ifdef _WIN32
-#include "windows/config.h"
-#endif
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
+#include <transport/PlatformSocket.h>
+
+#include <thrift-config.h>
+
 #include <stdio.h>
 #include <assert.h>
 
@@ -48,7 +45,7 @@
 #include <boost/utility/enable_if.hpp>
 #include <boost/type_traits/is_convertible.hpp>
 
-#include "TLogging.h"
+#include <TLogging.h>
 
 /**
  * Helper macros to allow function overloading even when using
@@ -72,6 +69,8 @@
 #define THRIFT_OVERLOAD_IF(T, Y) \
   THRIFT_OVERLOAD_IF_DEFN(T, Y) = NULL
 
+#define THRIFT_UNUSED_VARIABLE(x) ((void)(x))
+
 namespace apache { namespace thrift {
 
 class TEnumIterator : public std::iterator<std::forward_iterator_tag, std::pair<int, const char*> > {
@@ -87,6 +86,7 @@
   }
 
   bool operator !=(const TEnumIterator& end) {
+    (void)end;  // avoid "unused" warning with NDEBUG
     assert(end.n_ == -1);
     return (ii_ != n_);
   }
@@ -125,14 +125,7 @@
 
   void printf(const char *message, ...);
 
-  inline static void errorTimeWrapper(const char* msg) {
-    time_t now;
-    char dbgtime[26];
-    time(&now);
-    ctime_r(&now, dbgtime);
-    dbgtime[24] = 0;
-    fprintf(stderr, "Thrift: %s %s\n", dbgtime, msg);
-  }
+  static void errorTimeWrapper(const char* msg);
 
   /** Just like strerror_r but returns a C++ string object. */
   static std::string strerror_s(int errno_copy);

=== modified file '3rdParty/libthrift/VirtualProfiling.cpp'
--- 3rdParty/libthrift/VirtualProfiling.cpp	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/VirtualProfiling.cpp	2015-02-26 01:00:39 +0000
@@ -17,7 +17,7 @@
  * under the License.
  */
 
-#include <Thrift.h>
+#include <thrift/Thrift.h>
 
 // Do nothing if virtual call profiling is not enabled
 #if T_GLOBAL_DEBUG_VIRTUAL > 1
@@ -36,7 +36,7 @@
 #endif // !__GLIBC__
 
 
-#include <concurrency/Mutex.h>
+#include <thrift/concurrency/Mutex.h>
 
 #include <ext/hash_map>
 #include <execinfo.h>

=== modified file '3rdParty/libthrift/async/TAsyncBufferProcessor.h'
--- 3rdParty/libthrift/async/TAsyncBufferProcessor.h	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/async/TAsyncBufferProcessor.h	2015-02-26 01:00:39 +0000
@@ -20,10 +20,10 @@
 #ifndef _THRIFT_TASYNC_BUFFER_PROCESSOR_H_
 #define _THRIFT_TASYNC_BUFFER_PROCESSOR_H_ 1
 
-#include <tr1/functional>
+#include <cxxfunctional.h>
 #include <boost/shared_ptr.hpp>
 
-#include "transport/TBufferTransports.h"
+#include <transport/TBufferTransports.h>
 
 namespace apache { namespace thrift { namespace async {
 
@@ -35,7 +35,7 @@
   // "in" and "out" should be TMemoryBuffer or similar,
   // not a wrapper around a socket.
   virtual void process(
-      std::tr1::function<void(bool healthy)> _return,
+      apache::thrift::stdcxx::function<void(bool healthy)> _return,
       boost::shared_ptr<apache::thrift::transport::TBufferBase> ibuf,
       boost::shared_ptr<apache::thrift::transport::TBufferBase> obuf) = 0;
   virtual ~TAsyncBufferProcessor() {}

=== modified file '3rdParty/libthrift/async/TAsyncChannel.cpp'
--- 3rdParty/libthrift/async/TAsyncChannel.cpp	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/async/TAsyncChannel.cpp	2015-02-26 01:00:39 +0000
@@ -18,15 +18,15 @@
  */
 
 #include <async/TAsyncChannel.h>
-#include <tr1/functional>
+#include <cxxfunctional.h>
 
 namespace apache { namespace thrift { namespace async {
 
 void TAsyncChannel::sendAndRecvMessage(const VoidCallback& cob,
                                        TMemoryBuffer* sendBuf,
                                        TMemoryBuffer* recvBuf) {
-  std::tr1::function<void()> send_done =
-    std::tr1::bind(&TAsyncChannel::recvMessage, this, cob, recvBuf);
+  apache::thrift::stdcxx::function<void()> send_done =
+    apache::thrift::stdcxx::bind(&TAsyncChannel::recvMessage, this, cob, recvBuf);
 
   sendMessage(send_done, sendBuf);
 }

=== modified file '3rdParty/libthrift/async/TAsyncChannel.h'
--- 3rdParty/libthrift/async/TAsyncChannel.h	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/async/TAsyncChannel.h	2015-02-26 01:00:39 +0000
@@ -20,7 +20,7 @@
 #ifndef _THRIFT_ASYNC_TASYNCCHANNEL_H_
 #define _THRIFT_ASYNC_TASYNCCHANNEL_H_ 1
 
-#include <tr1/functional>
+#include <cxxfunctional.h>
 #include <Thrift.h>
 
 namespace apache { namespace thrift { namespace transport {
@@ -32,7 +32,7 @@
 
 class TAsyncChannel {
  public:
-  typedef std::tr1::function<void()> VoidCallback;
+  typedef apache::thrift::stdcxx::function<void()> VoidCallback;
 
   virtual ~TAsyncChannel() {}
 

=== added file '3rdParty/libthrift/async/TAsyncDispatchProcessor.h'
--- 3rdParty/libthrift/async/TAsyncDispatchProcessor.h	1970-01-01 00:00:00 +0000
+++ 3rdParty/libthrift/async/TAsyncDispatchProcessor.h	2015-02-26 01:00:39 +0000
@@ -0,0 +1,149 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+#ifndef _THRIFT_ASYNC_TASYNCDISPATCHPROCESSOR_H_
+#define _THRIFT_ASYNC_TASYNCDISPATCHPROCESSOR_H_ 1
+
+#include <thrift/async/TAsyncProcessor.h>
+
+namespace apache { namespace thrift { namespace async {
+
+/**
+ * TAsyncDispatchProcessor is a helper class to parse the message header then
+ * call another function to dispatch based on the function name.
+ *
+ * Subclasses must implement dispatchCall() to dispatch on the function name.
+ */
+template <class Protocol_>
+class TAsyncDispatchProcessorT : public TAsyncProcessor {
+ public:
+  virtual void process(apache::thrift::stdcxx::function<void(bool success)> _return,
+                       boost::shared_ptr<protocol::TProtocol> in,
+                       boost::shared_ptr<protocol::TProtocol> out) {
+    protocol::TProtocol* inRaw = in.get();
+    protocol::TProtocol* outRaw = out.get();
+
+    // Try to dynamic cast to the template protocol type
+    Protocol_* specificIn = dynamic_cast<Protocol_*>(inRaw);
+    Protocol_* specificOut = dynamic_cast<Protocol_*>(outRaw);
+    if (specificIn && specificOut) {
+      return processFast(_return, specificIn, specificOut);
+    }
+
+    // Log the fact that we have to use the slow path
+    T_GENERIC_PROTOCOL(this, inRaw, specificIn);
+    T_GENERIC_PROTOCOL(this, outRaw, specificOut);
+
+    std::string fname;
+    protocol::TMessageType mtype;
+    int32_t seqid;
+    inRaw->readMessageBegin(fname, mtype, seqid);
+
+    // If this doesn't look like a valid call, log an error and return false so
+    // that the server will close the connection.
+    //
+    // (The old generated processor code used to try to skip a T_STRUCT and
+    // continue.  However, that seems unsafe.)
+    if (mtype != protocol::T_CALL && mtype != protocol::T_ONEWAY) {
+      GlobalOutput.printf("received invalid message type %d from client",
+                          mtype);
+      _return(false);
+      return;
+    }
+
+    return this->dispatchCall(_return, inRaw, outRaw, fname, seqid);
+  }
+
+  void processFast(apache::thrift::stdcxx::function<void(bool success)> _return,
+                   Protocol_* in, Protocol_* out) {
+    std::string fname;
+    protocol::TMessageType mtype;
+    int32_t seqid;
+    in->readMessageBegin(fname, mtype, seqid);
+
+    if (mtype != protocol::T_CALL && mtype != protocol::T_ONEWAY) {
+      GlobalOutput.printf("received invalid message type %d from client",
+                          mtype);
+      _return(false);
+      return;
+    }
+
+    return this->dispatchCallTemplated(_return, in, out, fname, seqid);
+  }
+
+  virtual void dispatchCall(apache::thrift::stdcxx::function<void(bool ok)> _return,
+                            apache::thrift::protocol::TProtocol* in,
+                            apache::thrift::protocol::TProtocol* out,
+                            const std::string& fname, int32_t seqid) = 0;
+
+  virtual void dispatchCallTemplated(apache::thrift::stdcxx::function<void(bool ok)> _return,
+                                     Protocol_* in, Protocol_* out,
+                                     const std::string& fname,
+                                     int32_t seqid) = 0;
+};
+
+/**
+ * Non-templatized version of TAsyncDispatchProcessor,
+ * that doesn't bother trying to perform a dynamic_cast.
+ */
+class TAsyncDispatchProcessor : public TAsyncProcessor {
+ public:
+  virtual void process(apache::thrift::stdcxx::function<void(bool success)> _return,
+                       boost::shared_ptr<protocol::TProtocol> in,
+                       boost::shared_ptr<protocol::TProtocol> out) {
+    protocol::TProtocol* inRaw = in.get();
+    protocol::TProtocol* outRaw = out.get();
+
+    std::string fname;
+    protocol::TMessageType mtype;
+    int32_t seqid;
+    inRaw->readMessageBegin(fname, mtype, seqid);
+
+    // If this doesn't look like a valid call, log an error and return false so
+    // that the server will close the connection.
+    //
+    // (The old generated processor code used to try to skip a T_STRUCT and
+    // continue.  However, that seems unsafe.)
+    if (mtype != protocol::T_CALL && mtype != protocol::T_ONEWAY) {
+      GlobalOutput.printf("received invalid message type %d from client",
+                          mtype);
+      _return(false);
+      return;
+    }
+
+    return dispatchCall(_return, inRaw, outRaw, fname, seqid);
+  }
+
+  virtual void dispatchCall(apache::thrift::stdcxx::function<void(bool ok)> _return,
+                            apache::thrift::protocol::TProtocol* in,
+                            apache::thrift::protocol::TProtocol* out,
+                            const std::string& fname, int32_t seqid) = 0;
+};
+
+// Specialize TAsyncDispatchProcessorT for TProtocol and TDummyProtocol just to
+// use the generic TDispatchProcessor.
+template <>
+class TAsyncDispatchProcessorT<protocol::TDummyProtocol> :
+  public TAsyncDispatchProcessor {};
+template <>
+class TAsyncDispatchProcessorT<protocol::TProtocol> :
+  public TAsyncDispatchProcessor {};
+
+}}} // apache::thrift::async
+
+#endif // _THRIFT_ASYNC_TASYNCDISPATCHPROCESSOR_H_

=== modified file '3rdParty/libthrift/async/TAsyncProcessor.h'
--- 3rdParty/libthrift/async/TAsyncProcessor.h	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/async/TAsyncProcessor.h	2015-02-26 01:00:39 +0000
@@ -20,7 +20,7 @@
 #ifndef _THRIFT_TASYNCPROCESSOR_H_
 #define _THRIFT_TASYNCPROCESSOR_H_ 1
 
-#include <tr1/functional>
+#include <cxxfunctional.h>
 #include <boost/shared_ptr.hpp>
 #include <protocol/TProtocol.h>
 #include <TProcessor.h>
@@ -38,11 +38,11 @@
  public:
   virtual ~TAsyncProcessor() {}
 
-  virtual void process(std::tr1::function<void(bool success)> _return,
+  virtual void process(apache::thrift::stdcxx::function<void(bool success)> _return,
                        boost::shared_ptr<protocol::TProtocol> in,
                        boost::shared_ptr<protocol::TProtocol> out) = 0;
 
-  void process(std::tr1::function<void(bool success)> _return,
+  void process(apache::thrift::stdcxx::function<void(bool success)> _return,
                boost::shared_ptr<apache::thrift::protocol::TProtocol> io) {
     return process(_return, io, io);
   }

=== modified file '3rdParty/libthrift/async/TAsyncProtocolProcessor.cpp'
--- 3rdParty/libthrift/async/TAsyncProtocolProcessor.cpp	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/async/TAsyncProtocolProcessor.cpp	2015-02-26 01:00:39 +0000
@@ -17,7 +17,7 @@
  * under the License.
  */
 
-#include "TAsyncProtocolProcessor.h"
+#include <async/TAsyncProtocolProcessor.h>
 
 using apache::thrift::transport::TBufferBase;
 using apache::thrift::protocol::TProtocol;
@@ -25,22 +25,22 @@
 namespace apache { namespace thrift { namespace async {
 
 void TAsyncProtocolProcessor::process(
-    std::tr1::function<void(bool healthy)> _return,
+    apache::thrift::stdcxx::function<void(bool healthy)> _return,
     boost::shared_ptr<TBufferBase> ibuf,
     boost::shared_ptr<TBufferBase> obuf) {
   boost::shared_ptr<TProtocol> iprot(pfact_->getProtocol(ibuf));
   boost::shared_ptr<TProtocol> oprot(pfact_->getProtocol(obuf));
   return underlying_->process(
-      std::tr1::bind(
+      apache::thrift::stdcxx::bind(
         &TAsyncProtocolProcessor::finish,
         _return,
         oprot,
-        std::tr1::placeholders::_1),
+        apache::thrift::stdcxx::placeholders::_1),
       iprot, oprot);
 }
 
 /* static */ void TAsyncProtocolProcessor::finish(
-    std::tr1::function<void(bool healthy)> _return,
+    apache::thrift::stdcxx::function<void(bool healthy)> _return,
     boost::shared_ptr<TProtocol> oprot,
     bool healthy) {
   (void) oprot;

=== modified file '3rdParty/libthrift/async/TAsyncProtocolProcessor.h'
--- 3rdParty/libthrift/async/TAsyncProtocolProcessor.h	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/async/TAsyncProtocolProcessor.h	2015-02-26 01:00:39 +0000
@@ -20,9 +20,9 @@
 #ifndef _THRIFT_TNAME_ME_H_
 #define _THRIFT_TNAME_ME_H_ 1
 
-#include "TAsyncProcessor.h"
-#include "TAsyncBufferProcessor.h"
-#include "protocol/TProtocol.h"
+#include <async/TAsyncProcessor.h>
+#include <async/TAsyncBufferProcessor.h>
+#include <protocol/TProtocol.h>
 
 namespace apache { namespace thrift { namespace async {
 
@@ -36,7 +36,7 @@
   {}
 
   virtual void process(
-      std::tr1::function<void(bool healthy)> _return,
+      apache::thrift::stdcxx::function<void(bool healthy)> _return,
       boost::shared_ptr<apache::thrift::transport::TBufferBase> ibuf,
       boost::shared_ptr<apache::thrift::transport::TBufferBase> obuf);
 
@@ -44,7 +44,7 @@
 
  private:
   static void finish(
-      std::tr1::function<void(bool healthy)> _return,
+      apache::thrift::stdcxx::function<void(bool healthy)> _return,
       boost::shared_ptr<apache::thrift::protocol::TProtocol> oprot,
       bool healthy);
 

=== modified file '3rdParty/libthrift/async/TEvhttpClientChannel.cpp' (properties changed: +x to -x)
--- 3rdParty/libthrift/async/TEvhttpClientChannel.cpp	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/async/TEvhttpClientChannel.cpp	2015-02-26 01:00:39 +0000
@@ -17,10 +17,10 @@
  * under the License.
  */
 
-#include "TEvhttpClientChannel.h"
+#include <thrift/async/TEvhttpClientChannel.h>
 #include <evhttp.h>
-#include "transport/TBufferTransports.h"
-#include <protocol/TProtocolException.h>
+#include <thrift/transport/TBufferTransports.h>
+#include <thrift/protocol/TProtocolException.h>
 
 #include <iostream>
 #include <sstream>
@@ -142,7 +142,7 @@
   }
   recvBuf_->resetBuffer(
       EVBUFFER_DATA(req->input_buffer),
-      EVBUFFER_LENGTH(req->input_buffer));
+      static_cast<uint32_t>(EVBUFFER_LENGTH(req->input_buffer)));
   cob_();
   return;
 }

=== modified file '3rdParty/libthrift/async/TEvhttpClientChannel.h'
--- 3rdParty/libthrift/async/TEvhttpClientChannel.h	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/async/TEvhttpClientChannel.h	2015-02-26 01:00:39 +0000
@@ -22,7 +22,7 @@
 
 #include <string>
 #include <boost/shared_ptr.hpp>
-#include "TAsyncChannel.h"
+#include <thrift/async/TAsyncChannel.h>
 
 struct event_base;
 struct evhttp_connection;

=== modified file '3rdParty/libthrift/async/TEvhttpServer.cpp' (properties changed: +x to -x)
--- 3rdParty/libthrift/async/TEvhttpServer.cpp	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/async/TEvhttpServer.cpp	2015-02-26 01:00:39 +0000
@@ -17,9 +17,9 @@
  * under the License.
  */
 
-#include "TEvhttpServer.h"
-#include "TAsyncBufferProcessor.h"
-#include "transport/TBufferTransports.h"
+#include <thrift/async/TEvhttpServer.h>
+#include <thrift/async/TAsyncBufferProcessor.h>
+#include <thrift/transport/TBufferTransports.h>
 #include <evhttp.h>
 
 #include <iostream>
@@ -99,7 +99,7 @@
 
 
 TEvhttpServer::RequestContext::RequestContext(struct evhttp_request* req) : req(req)
-  , ibuf(new TMemoryBuffer(EVBUFFER_DATA(req->input_buffer), EVBUFFER_LENGTH(req->input_buffer)))
+  , ibuf(new TMemoryBuffer(EVBUFFER_DATA(req->input_buffer), static_cast<uint32_t>(EVBUFFER_LENGTH(req->input_buffer))))
   , obuf(new TMemoryBuffer())
 {}
 
@@ -116,11 +116,11 @@
 void TEvhttpServer::process(struct evhttp_request* req) {
   RequestContext* ctx = new RequestContext(req);
   return processor_->process(
-      std::tr1::bind(
+      apache::thrift::stdcxx::bind(
         &TEvhttpServer::complete,
         this,
         ctx,
-        std::tr1::placeholders::_1),
+        apache::thrift::stdcxx::placeholders::_1),
       ctx->ibuf,
       ctx->obuf);
 }

=== modified file '3rdParty/libthrift/concurrency/BoostMonitor.cpp'
--- 3rdParty/libthrift/concurrency/BoostMonitor.cpp	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/concurrency/BoostMonitor.cpp	2015-02-26 01:00:39 +0000
@@ -17,15 +17,13 @@
  * under the License.
  */
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-#include "Monitor.h"
-#include "Exception.h"
-#include "Util.h"
+#include <thrift/thrift-config.h>
 
+#include <thrift/concurrency/Monitor.h>
+#include <thrift/concurrency/Exception.h>
+#include <thrift/concurrency/Util.h>
+#include <thrift/transport/PlatformSocket.h>
 #include <assert.h>
-#include <errno.h>
 
 #include <boost/scoped_ptr.hpp>
 #include <boost/thread.hpp>
@@ -38,7 +36,7 @@
  *
  * @version $Id:$
  */
-class Monitor::Impl : public boost::condition_variable {
+class Monitor::Impl : public boost::condition_variable_any {
 
  public:
 
@@ -71,7 +69,7 @@
    */
   void wait(int64_t timeout_ms) {
     int result = waitForTimeRelative(timeout_ms);
-    if (result == ETIMEDOUT) {
+    if (result == THRIFT_ETIMEDOUT) {
       throw TimedOutException();
     } else if (result != 0) {
       throw TException(
@@ -83,7 +81,7 @@
    * Waits until the specified timeout in milliseconds for the condition to
    * occur, or waits forever if timeout_ms == 0.
    *
-   * Returns 0 if condition occurs, ETIMEDOUT on timeout, or an error code.
+   * Returns 0 if condition occurs, THRIFT_ETIMEDOUT on timeout, or an error code.
    */
   int waitForTimeRelative(int64_t timeout_ms) {
     if (timeout_ms == 0LL) {
@@ -91,41 +89,52 @@
     }
 
     assert(mutex_);
-	boost::mutex* mutexImpl =
-      reinterpret_cast<boost::mutex*>(mutex_->getUnderlyingImpl());
+	boost::timed_mutex* mutexImpl =
+      reinterpret_cast<boost::timed_mutex*>(mutex_->getUnderlyingImpl());
     assert(mutexImpl);
 
-	boost::mutex::scoped_lock lock(*mutexImpl, boost::adopt_lock);
-	int res = timed_wait(lock, boost::get_system_time()+boost::posix_time::milliseconds(timeout_ms)) ? 0 : ETIMEDOUT;
+	boost::timed_mutex::scoped_lock lock(*mutexImpl, boost::adopt_lock);
+	int res = timed_wait(lock, boost::get_system_time()+boost::posix_time::milliseconds(timeout_ms)) ? 0 : THRIFT_ETIMEDOUT;
 	lock.release();
 	return res;
   }
 
   /**
-   * Waits until the absolute time specified using struct timespec.
-   * Returns 0 if condition occurs, ETIMEDOUT on timeout, or an error code.
-   */
-  int waitForTime(const timespec* abstime) {
+   * Waits until the absolute time specified using struct THRIFT_TIMESPEC.
+   * Returns 0 if condition occurs, THRIFT_ETIMEDOUT on timeout, or an error code.
+   */
+  int waitForTime(const THRIFT_TIMESPEC* abstime) {
+    struct timeval temp;
+    temp.tv_sec  = static_cast<long>(abstime->tv_sec);
+    temp.tv_usec = static_cast<long>(abstime->tv_nsec) / 1000;
+    return waitForTime(&temp);
+  }
+
+  /**
+   * Waits until the absolute time specified using struct timeval.
+   * Returns 0 if condition occurs, THRIFT_ETIMEDOUT on timeout, or an error code.
+   */
+  int waitForTime(const struct timeval* abstime) {
     assert(mutex_);
-    boost::mutex* mutexImpl =
-      reinterpret_cast<boost::mutex*>(mutex_->getUnderlyingImpl());
+    boost::timed_mutex* mutexImpl =
+      static_cast<boost::timed_mutex*>(mutex_->getUnderlyingImpl());
     assert(mutexImpl);
 
-    struct timespec currenttime;
-    Util::toTimespec(currenttime, Util::currentTime());
+    struct timeval currenttime;
+    Util::toTimeval(currenttime, Util::currentTime());
 
-	long tv_sec = abstime->tv_sec - currenttime.tv_sec;
-	long tv_nsec = abstime->tv_nsec - currenttime.tv_nsec;
+	long tv_sec = static_cast<long>(abstime->tv_sec - currenttime.tv_sec);
+	long tv_usec = static_cast<long>(abstime->tv_usec - currenttime.tv_usec);
 	if(tv_sec < 0)
 		tv_sec = 0;
-	if(tv_nsec < 0)
-		tv_nsec = 0;
+	if(tv_usec < 0)
+		tv_usec = 0;
 
-	boost::mutex::scoped_lock lock(*mutexImpl, boost::adopt_lock);
+	boost::timed_mutex::scoped_lock lock(*mutexImpl, boost::adopt_lock);
 	int res = timed_wait(lock, boost::get_system_time() +
 		boost::posix_time::seconds(tv_sec) +
-		boost::posix_time::microseconds(tv_nsec / 1000)
-		) ? 0 : ETIMEDOUT;
+		boost::posix_time::microseconds(tv_usec)
+		) ? 0 : THRIFT_ETIMEDOUT;
 	lock.release();
 	return res;
   }
@@ -136,12 +145,12 @@
    */
   int waitForever() {
     assert(mutex_);
-    boost::mutex* mutexImpl =
-      reinterpret_cast<boost::mutex*>(mutex_->getUnderlyingImpl());
+    boost::timed_mutex* mutexImpl =
+      reinterpret_cast<boost::timed_mutex*>(mutex_->getUnderlyingImpl());
     assert(mutexImpl);
 
-	boost::mutex::scoped_lock lock(*mutexImpl, boost::adopt_lock);
-	((boost::condition_variable*)this)->wait(lock);
+	boost::timed_mutex::scoped_lock lock(*mutexImpl, boost::adopt_lock);
+	((boost::condition_variable_any*)this)->wait(lock);
 	lock.release();
     return 0;
   }
@@ -179,7 +188,11 @@
 
 void Monitor::wait(int64_t timeout) const { const_cast<Monitor::Impl*>(impl_)->wait(timeout); }
 
-int Monitor::waitForTime(const timespec* abstime) const {
+int Monitor::waitForTime(const THRIFT_TIMESPEC* abstime) const {
+  return const_cast<Monitor::Impl*>(impl_)->waitForTime(abstime);
+}
+
+int Monitor::waitForTime(const timeval* abstime) const {
   return const_cast<Monitor::Impl*>(impl_)->waitForTime(abstime);
 }
 

=== modified file '3rdParty/libthrift/concurrency/BoostMutex.cpp'
--- 3rdParty/libthrift/concurrency/BoostMutex.cpp	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/concurrency/BoostMutex.cpp	2015-02-26 01:00:39 +0000
@@ -17,18 +17,16 @@
  * under the License.
  */
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-#include "Mutex.h"
-#include "Util.h"
+#include <thrift/thrift-config.h>
+
+#include <thrift/concurrency/Mutex.h>
+#include <thrift/concurrency/Util.h>
+#include <thrift/Thrift.h>
 
 #include <cassert>
 #include <boost/thread.hpp>
+#include <boost/thread/mutex.hpp>
 #include <boost/date_time/posix_time/posix_time.hpp>
-#include <boost/interprocess/sync/interprocess_mutex.hpp>
-
-using namespace boost::interprocess;
 
 namespace apache { namespace thrift { namespace concurrency {
 
@@ -37,10 +35,11 @@
  *
  * @version $Id:$
  */
-class Mutex::impl : public interprocess_mutex {
+class Mutex::impl : public boost::timed_mutex {
 };
 
-Mutex::Mutex(Initializer init) : impl_(new Mutex::impl()) {}
+Mutex::Mutex(Initializer init) : impl_(new Mutex::impl())
+{ THRIFT_UNUSED_VARIABLE(init); }
 
 void* Mutex::getUnderlyingImpl() const { return impl_.get(); }
 
@@ -53,7 +52,7 @@
 void Mutex::unlock() const { impl_->unlock(); }
 
 void Mutex::DEFAULT_INITIALIZER(void* arg) {
+  THRIFT_UNUSED_VARIABLE(arg);
 }
 
 }}} // apache::thrift::concurrency
-

=== modified file '3rdParty/libthrift/concurrency/BoostThreadFactory.cpp'
--- 3rdParty/libthrift/concurrency/BoostThreadFactory.cpp	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/concurrency/BoostThreadFactory.cpp	2015-02-26 01:00:39 +0000
@@ -17,11 +17,12 @@
  * under the License.
  */
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-#include "BoostThreadFactory.h"
-#include "Exception.h"
+#include <thrift/thrift-config.h>
+
+#ifdef USE_BOOST_THREAD
+
+#include <thrift/concurrency/BoostThreadFactory.h>
+#include <thrift/concurrency/Exception.h>
 
 #include <cassert>
 
@@ -60,10 +61,10 @@
  public:
 
   BoostThread(bool detached, shared_ptr<Runnable> runnable) :
-	 state_(uninitialized),
-	 detached_(detached) {
-    this->Thread::runnable(runnable);
-  }
+    state_(uninitialized),
+    detached_(detached) {
+      this->Thread::runnable(runnable);
+    }
 
   ~BoostThread() {
     if(!detached_) {
@@ -79,27 +80,27 @@
     if (state_ != uninitialized) {
       return;
     }
-	
-	// Create reference
+
+  // Create reference
     shared_ptr<BoostThread>* selfRef = new shared_ptr<BoostThread>();
     *selfRef = self_.lock();
 
-	thread_ = std::auto_ptr<boost::thread>(new boost::thread(boost::bind(threadMain, (void*)selfRef)));
-
-	if(detached_)
-		thread_->detach();
-
-	state_ = starting;
+    state_ = starting;
+
+    thread_ = std::auto_ptr<boost::thread>(new boost::thread(boost::bind(threadMain, (void*)selfRef)));
+
+    if(detached_)
+      thread_->detach();
   }
 
   void join() {
     if (!detached_ && state_ != uninitialized) {
-	  thread_->join();
+      thread_->join();
     }
   }
 
   Thread::id_t getId() {
-	  return thread_.get() ? thread_->get_id() : boost::thread::id();
+    return thread_.get() ? thread_->get_id() : boost::thread::id();
   }
 
   shared_ptr<Runnable> runnable() const { return Thread::runnable(); }
@@ -116,7 +117,7 @@
   shared_ptr<BoostThread> thread = *(shared_ptr<BoostThread>*)arg;
   delete reinterpret_cast<shared_ptr<BoostThread>*>(arg);
 
-  if (thread == NULL) {
+  if (!thread) {
     return (void*)0;
   }
 
@@ -163,9 +164,8 @@
   void setDetached(bool value) { detached_ = value; }
 
   Thread::id_t getCurrentThreadId() const {
-	  return boost::this_thread::get_id();
+    return boost::this_thread::get_id();
   }
-
 };
 
 BoostThreadFactory::BoostThreadFactory(bool detached) :
@@ -180,3 +180,5 @@
 Thread::id_t BoostThreadFactory::getCurrentThreadId() const { return impl_->getCurrentThreadId(); }
 
 }}} // apache::thrift::concurrency
+
+#endif // USE_BOOST_THREAD

=== modified file '3rdParty/libthrift/concurrency/BoostThreadFactory.h'
--- 3rdParty/libthrift/concurrency/BoostThreadFactory.h	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/concurrency/BoostThreadFactory.h	2015-02-26 01:00:39 +0000
@@ -20,7 +20,7 @@
 #ifndef _THRIFT_CONCURRENCY_BOOSTTHREADFACTORY_H_
 #define _THRIFT_CONCURRENCY_BOOSTTHREADFACTORY_H_ 1
 
-#include "Thread.h"
+#include <thrift/concurrency/Thread.h>
 
 #include <boost/shared_ptr.hpp>
 

=== modified file '3rdParty/libthrift/concurrency/FunctionRunner.h'
--- 3rdParty/libthrift/concurrency/FunctionRunner.h	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/concurrency/FunctionRunner.h	2015-02-26 01:00:39 +0000
@@ -20,8 +20,8 @@
 #ifndef _THRIFT_CONCURRENCY_FUNCTION_RUNNER_H
 #define _THRIFT_CONCURRENCY_FUNCTION_RUNNER_H 1
 
-#include <tr1/functional>
-#include "thrift/lib/cpp/concurrency/Thread.h"
+#include <cxxfunctional.h>
+#include <concurrency/Thread.h>
 
 namespace apache { namespace thrift { namespace concurrency {
 
@@ -34,16 +34,15 @@
  *  void* my_thread_main(void* arg);
  *  shared_ptr<ThreadFactory> factory = ...;
  *  // To create a thread that executes my_thread_main once:
- *  shared_ptr<Thread> thread =
- *    factory->newThread(shared_ptr<FunctionRunner>(
- *      new FunctionRunner(my_thread_main, some_argument)));
+ *  shared_ptr<Thread> thread = factory->newThread(
+ *    FunctionRunner::create(my_thread_main, some_argument));
  *  thread->start();
  *
  *  bool A::foo();
  *  A* a = new A();
  *  // To create a thread that executes a.foo() every 100 milliseconds:
- *  factory->newThread(shared_ptr<FunctionRunner>(
- *    new FunctionRunner(std::tr1::bind(&A::foo, a), 100)))->start();
+ *  factory->newThread(FunctionRunner::create(
+ *    apache::thrift::stdcxx::bind(&A::foo, a), 100))->start();
  *
  */
 
@@ -52,23 +51,43 @@
   // This is the type of callback 'pthread_create()' expects.
   typedef void* (*PthreadFuncPtr)(void *arg);
   // This a fully-generic void(void) callback for custom bindings.
-  typedef std::tr1::function<void()> VoidFunc;
-
-  typedef std::tr1::function<bool()> BoolFunc;
-
+  typedef apache::thrift::stdcxx::function<void()> VoidFunc;
+
+  typedef apache::thrift::stdcxx::function<bool()> BoolFunc;
+
+  /**
+   * Syntactic sugar to make it easier to create new FunctionRunner
+   * objects wrapped in shared_ptr.
+   */
+  static boost::shared_ptr<FunctionRunner> create(const VoidFunc& cob) {
+    return boost::shared_ptr<FunctionRunner>(new FunctionRunner(cob));
+  }
+
+  static boost::shared_ptr<FunctionRunner> create(PthreadFuncPtr func,
+                                                  void* arg) {
+    return boost::shared_ptr<FunctionRunner>(new FunctionRunner(func, arg));
+  }
+
+private:
+  static void pthread_func_wrapper(PthreadFuncPtr func, void *arg)
+  {
+    //discard return value
+    func(arg);
+  }
+public:
   /**
    * Given a 'pthread_create' style callback, this FunctionRunner will
    * execute the given callback.  Note that the 'void*' return value is ignored.
    */
   FunctionRunner(PthreadFuncPtr func, void* arg)
-   : func_(std::tr1::bind(func, arg)), repFunc_(0)
+   : func_(apache::thrift::stdcxx::bind(pthread_func_wrapper, func, arg))
   { }
 
   /**
    * Given a generic callback, this FunctionRunner will execute it.
    */
   FunctionRunner(const VoidFunc& cob)
-   : func_(cob), repFunc_(0)
+   : func_(cob)
   { }
 
   /**
@@ -78,13 +97,13 @@
    * be intervalMs plus execution time of the callback.
    */
   FunctionRunner(const BoolFunc& cob, int intervalMs)
-   : func_(0), repFunc_(cob), intervalMs_(intervalMs)
+   : repFunc_(cob), intervalMs_(intervalMs)
   { }
 
   void run() {
     if (repFunc_) {
       while(repFunc_()) {
-        usleep(intervalMs_*1000);
+        THRIFT_SLEEP_USEC(intervalMs_*1000);
       }
     } else {
       func_();

=== modified file '3rdParty/libthrift/concurrency/Monitor.cpp'
--- 3rdParty/libthrift/concurrency/Monitor.cpp	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/concurrency/Monitor.cpp	2015-02-26 01:00:39 +0000
@@ -17,14 +17,14 @@
  * under the License.
  */
 
-#include "Monitor.h"
-#include "Exception.h"
-#include "Util.h"
+#include <concurrency/Monitor.h>
+#include <concurrency/Exception.h>
+#include <concurrency/Util.h>
+#include <transport/PlatformSocket.h>
 
 #include <boost/scoped_ptr.hpp>
 
 #include <assert.h>
-#include <errno.h>
 
 #include <iostream>
 
@@ -77,7 +77,7 @@
    */
   void wait(int64_t timeout_ms) const {
     int result = waitForTimeRelative(timeout_ms);
-    if (result == ETIMEDOUT) {
+    if (result == THRIFT_ETIMEDOUT) {
       // pthread_cond_timedwait has been observed to return early on
       // various platforms, so comment out this assert.
       //assert(Util::currentTime() >= (now + timeout));
@@ -92,23 +92,23 @@
    * Waits until the specified timeout in milliseconds for the condition to
    * occur, or waits forever if timeout_ms == 0.
    *
-   * Returns 0 if condition occurs, ETIMEDOUT on timeout, or an error code.
+   * Returns 0 if condition occurs, THRIFT_ETIMEDOUT on timeout, or an error code.
    */
   int waitForTimeRelative(int64_t timeout_ms) const {
     if (timeout_ms == 0LL) {
       return waitForever();
     }
 
-    struct timespec abstime;
+    struct THRIFT_TIMESPEC abstime;
     Util::toTimespec(abstime, Util::currentTime() + timeout_ms);
     return waitForTime(&abstime);
   }
 
   /**
-   * Waits until the absolute time specified using struct timespec.
-   * Returns 0 if condition occurs, ETIMEDOUT on timeout, or an error code.
+   * Waits until the absolute time specified using struct THRIFT_TIMESPEC.
+   * Returns 0 if condition occurs, THRIFT_ETIMEDOUT on timeout, or an error code.
    */
-  int waitForTime(const timespec* abstime) const {
+  int waitForTime(const THRIFT_TIMESPEC* abstime) const {
     assert(mutex_);
     pthread_mutex_t* mutexImpl =
       reinterpret_cast<pthread_mutex_t*>(mutex_->getUnderlyingImpl());
@@ -120,6 +120,12 @@
                                   abstime);
   }
 
+  int waitForTime(const struct timeval* abstime) const {
+    struct THRIFT_TIMESPEC temp;
+    temp.tv_sec  = abstime->tv_sec;
+    temp.tv_nsec = abstime->tv_usec * 1000;
+    return waitForTime(&temp);
+  }
   /**
    * Waits forever until the condition occurs.
    * Returns 0 if condition occurs, or an error code otherwise.
@@ -136,12 +142,14 @@
   void notify() {
     // XXX Need to assert that caller owns mutex
     int iret = pthread_cond_signal(&pthread_cond_);
+    THRIFT_UNUSED_VARIABLE(iret);
     assert(iret == 0);
   }
 
   void notifyAll() {
     // XXX Need to assert that caller owns mutex
     int iret = pthread_cond_broadcast(&pthread_cond_);
+    THRIFT_UNUSED_VARIABLE(iret);
     assert(iret == 0);
   }
 
@@ -164,6 +172,7 @@
     if (condInitialized_) {
       condInitialized_ = false;
       int iret = pthread_cond_destroy(&pthread_cond_);
+      THRIFT_UNUSED_VARIABLE(iret);
       assert(iret == 0);
     }
   }
@@ -189,7 +198,11 @@
 
 void Monitor::wait(int64_t timeout) const { impl_->wait(timeout); }
 
-int Monitor::waitForTime(const timespec* abstime) const {
+int Monitor::waitForTime(const THRIFT_TIMESPEC* abstime) const {
+  return impl_->waitForTime(abstime);
+}
+
+int Monitor::waitForTime(const timeval* abstime) const {
   return impl_->waitForTime(abstime);
 }
 

=== modified file '3rdParty/libthrift/concurrency/Monitor.h'
--- 3rdParty/libthrift/concurrency/Monitor.h	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/concurrency/Monitor.h	2015-02-26 01:00:39 +0000
@@ -20,8 +20,8 @@
 #ifndef _THRIFT_CONCURRENCY_MONITOR_H_
 #define _THRIFT_CONCURRENCY_MONITOR_H_ 1
 
-#include "Exception.h"
-#include "Mutex.h"
+#include <concurrency/Exception.h>
+#include <concurrency/Mutex.h>
 
 #include <boost/utility.hpp>
 
@@ -70,15 +70,21 @@
    * Waits a maximum of the specified timeout in milliseconds for the condition
    * to occur, or waits forever if timeout_ms == 0.
    *
-   * Returns 0 if condition occurs, ETIMEDOUT on timeout, or an error code.
+   * Returns 0 if condition occurs, THRIFT_ETIMEDOUT on timeout, or an error code.
    */
   int waitForTimeRelative(int64_t timeout_ms) const;
 
   /**
-   * Waits until the absolute time specified using struct timespec.
-   * Returns 0 if condition occurs, ETIMEDOUT on timeout, or an error code.
-   */
-  int waitForTime(const timespec* abstime) const;
+   * Waits until the absolute time specified using struct THRIFT_TIMESPEC.
+   * Returns 0 if condition occurs, THRIFT_ETIMEDOUT on timeout, or an error code.
+   */
+  int waitForTime(const THRIFT_TIMESPEC* abstime) const;
+
+  /**
+   * Waits until the absolute time specified using struct timeval.
+   * Returns 0 if condition occurs, THRIFT_ETIMEDOUT on timeout, or an error code.
+   */
+  int waitForTime(const struct timeval* abstime) const;
 
   /**
    * Waits forever until the condition occurs.

=== modified file '3rdParty/libthrift/concurrency/Mutex.cpp'
--- 3rdParty/libthrift/concurrency/Mutex.cpp	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/concurrency/Mutex.cpp	2015-02-26 01:00:39 +0000
@@ -17,58 +17,22 @@
  * under the License.
  */
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-#include "Mutex.h"
-#include "Util.h"
+#include <thrift-config.h>
+
+#include <Thrift.h>
+#include <concurrency/Mutex.h>
+#include <concurrency/Util.h>
 
 #include <assert.h>
 #ifdef HAVE_PTHREAD_H
 #include <pthread.h>
-#ifndef PTHREAD_RWLOCK_INITIALIZER
-#define __THRIFT_NO_RWLOCKS
-#endif
 #endif
 #include <signal.h>
 
 using boost::shared_ptr;
 
-#ifdef __THRIFT_NO_RWLOCKS
-typedef pthread_mutex_t pthread_rwlock_t;
-#define pthread_rwlock_init pthread_mutex_init
-#define pthread_rwlock_destroy pthread_mutex_destroy
-#define pthread_rwlock_rdlock pthread_mutex_lock
-#define pthread_rwlock_wrlock pthread_mutex_lock
-#define pthread_rwlock_tryrdlock pthread_mutex_trylock
-#define pthread_rwlock_trywrlock pthread_mutex_trylock
-#define pthread_rwlock_unlock pthread_mutex_unlock
-#endif
-
 namespace apache { namespace thrift { namespace concurrency {
 
-#ifndef HAVE_CLOCK_GETTIME
-
-#define CLOCK_REALTIME 0
-
-/**
- * Fake clock_gettime for systems like darwin
- */
-static int clock_gettime(int clk_id /*ignored*/, struct timespec *tp) {
-  struct timeval now;
-
-  int rv = gettimeofday(&now, NULL);
-  if (rv != 0) {
-    return rv;
-  }
-
-  tp->tv_sec = now.tv_sec;
-  tp->tv_nsec = now.tv_usec * 1000;
-  return 0;
-}
-
-#endif
-
 #ifndef THRIFT_NO_CONTENTION_PROFILING
 
 static sig_atomic_t mutexProfilingSampleRate = 0;
@@ -163,6 +127,7 @@
     if (initialized_) {
       initialized_ = false;
       int ret = pthread_mutex_destroy(&pthread_mutex_);
+      THRIFT_UNUSED_VARIABLE(ret);
       assert(ret == 0);
     }
   }
@@ -179,16 +144,9 @@
 #if defined(_POSIX_TIMEOUTS) && _POSIX_TIMEOUTS >= 200112L
     PROFILE_MUTEX_START_LOCK();
 
-    struct timespec ts, now;
-    clock_gettime(CLOCK_REALTIME, &now);
-    Util::toTimespec(ts, milliseconds);
-    now.tv_sec += ts.tv_sec;
-    now.tv_nsec += ts.tv_nsec;
-    if (now.tv_nsec > 1000000000LL) {
-      now.tv_sec += 1;
-      now.tv_nsec -= 1000000000LL;
-    }
-    int ret = pthread_mutex_timedlock(&pthread_mutex_, &now);
+    struct THRIFT_TIMESPEC ts;
+    Util::toTimespec(ts, milliseconds + Util::currentTime());
+    int ret = pthread_mutex_timedlock(&pthread_mutex_, &ts);
     if (ret == 0) {
       PROFILE_MUTEX_LOCKED();
       return true;
@@ -198,24 +156,22 @@
     return false;
 #else
     /* Otherwise follow solution used by Mono for Android */
-    struct timeval was, now;
-    struct timespec sleepytime, to;
+    struct THRIFT_TIMESPEC sleepytime, now, to;
 
     /* This is just to avoid a completely busy wait */
     sleepytime.tv_sec = 0;
-    sleepytime.tv_nsec = 10000000; /* 10ms */
-
-    Util::toTimespec(to, milliseconds);
-
-    gettimeofday(&was, NULL);
+    sleepytime.tv_nsec = 10000000L; /* 10ms */
+
+    Util::toTimespec(to, milliseconds + Util::currentTime());
+
     while ((trylock()) == false) {
-      gettimeofday(&now, NULL);
-      if (now.tv_sec >= (was.tv_sec + to.tv_sec) && now.tv_usec >= (was.tv_usec + to.tv_nsec / 1000)) {
+      Util::toTimespec(now, Util::currentTime());
+      if (now.tv_sec >= to.tv_sec && now.tv_nsec >= to.tv_nsec) {
         return false;
       }
       nanosleep(&sleepytime, NULL);
     }
- 
+
     return true;
 #endif
   }
@@ -251,6 +207,7 @@
 void Mutex::DEFAULT_INITIALIZER(void* arg) {
   pthread_mutex_t* pthread_mutex = (pthread_mutex_t*)arg;
   int ret = pthread_mutex_init(pthread_mutex, NULL);
+  THRIFT_UNUSED_VARIABLE(ret);
   assert(ret == 0);
 }
 
@@ -269,6 +226,7 @@
 
   ret = pthread_mutexattr_destroy(&mutexattr);
   assert(ret == 0);
+  THRIFT_UNUSED_VARIABLE(ret);
 }
 #endif
 
@@ -305,6 +263,7 @@
     profileTime_ = 0;
 #endif
     int ret = pthread_rwlock_init(&rw_lock_, NULL);
+    THRIFT_UNUSED_VARIABLE(ret);
     assert(ret == 0);
     initialized_ = true;
   }
@@ -313,6 +272,7 @@
     if(initialized_) {
       initialized_ = false;
       int ret = pthread_rwlock_destroy(&rw_lock_);
+      THRIFT_UNUSED_VARIABLE(ret);
       assert(ret == 0);
     }
   }
@@ -329,9 +289,9 @@
     PROFILE_MUTEX_LOCKED();
   }
 
-  bool attemptRead() const { return pthread_rwlock_tryrdlock(&rw_lock_); }
+  bool attemptRead() const { return !pthread_rwlock_tryrdlock(&rw_lock_); }
 
-  bool attemptWrite() const { return pthread_rwlock_trywrlock(&rw_lock_); }
+  bool attemptWrite() const { return !pthread_rwlock_trywrlock(&rw_lock_); }
 
   void release() const {
     PROFILE_MUTEX_START_UNLOCK();
@@ -359,5 +319,35 @@
 
 void ReadWriteMutex::release() const { impl_->release(); }
 
+NoStarveReadWriteMutex::NoStarveReadWriteMutex() : writerWaiting_(false) {}
+
+void NoStarveReadWriteMutex::acquireRead() const
+{
+  if (writerWaiting_) {
+    // writer is waiting, block on the writer's mutex until he's done with it
+    mutex_.lock();
+    mutex_.unlock();
+  }
+
+  ReadWriteMutex::acquireRead();
+}
+
+void NoStarveReadWriteMutex::acquireWrite() const
+{
+  // if we can acquire the rwlock the easy way, we're done
+  if (attemptWrite()) {
+    return;
+  }
+
+  // failed to get the rwlock, do it the hard way:
+  // locking the mutex and setting writerWaiting will cause all new readers to
+  // block on the mutex rather than on the rwlock.
+  mutex_.lock();
+  writerWaiting_ = true;
+  ReadWriteMutex::acquireWrite();
+  writerWaiting_ = false;
+  mutex_.unlock();
+}
+
 }}} // apache::thrift::concurrency
 

=== modified file '3rdParty/libthrift/concurrency/Mutex.h'
--- 3rdParty/libthrift/concurrency/Mutex.h	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/concurrency/Mutex.h	2015-02-26 01:00:39 +0000
@@ -101,6 +101,25 @@
   boost::shared_ptr<impl> impl_;
 };
 
+/**
+ * A ReadWriteMutex that guarantees writers will not be starved by readers:
+ * When a writer attempts to acquire the mutex, all new readers will be
+ * blocked from acquiring the mutex until the writer has acquired and
+ * released it. In some operating systems, this may already be guaranteed
+ * by a regular ReadWriteMutex.
+ */
+class NoStarveReadWriteMutex : public ReadWriteMutex {
+public:
+  NoStarveReadWriteMutex();
+
+  virtual void acquireRead() const;
+  virtual void acquireWrite() const;
+
+private:
+  Mutex mutex_;
+  mutable volatile bool writerWaiting_;
+};
+
 class Guard : boost::noncopyable {
  public:
   Guard(const Mutex& value, int64_t timeout = 0) : mutex_(&value) {
@@ -164,15 +183,6 @@
     const ReadWriteMutex& rw_mutex_;
 };
 
-
-// A little hack to prevent someone from trying to do "Guard(m);"
-// Such a use is invalid because the temporary Guard object is
-// destroyed at the end of the line, releasing the lock.
-// Sorry for polluting the global namespace, but I think it's worth it.
-#define Guard(m) incorrect_use_of_Guard(m)
-#define RWGuard(m) incorrect_use_of_RWGuard(m)
-
-
 }}} // apache::thrift::concurrency
 
 #endif // #ifndef _THRIFT_CONCURRENCY_MUTEX_H_

=== modified file '3rdParty/libthrift/concurrency/PlatformThreadFactory.h'
--- 3rdParty/libthrift/concurrency/PlatformThreadFactory.h	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/concurrency/PlatformThreadFactory.h	2015-02-26 01:00:39 +0000
@@ -20,18 +20,23 @@
 #ifndef _THRIFT_CONCURRENCY_PLATFORMTHREADFACTORY_H_
 #define _THRIFT_CONCURRENCY_PLATFORMTHREADFACTORY_H_ 1
 
-#ifndef USE_BOOST_THREAD
+#include <thrift-config.h>
+#if USE_BOOST_THREAD
+#  include <concurrency/BoostThreadFactory.h>
+#elif USE_STD_THREAD
+#  include <concurrency/StdThreadFactory.h>
+#else
 #  include <concurrency/PosixThreadFactory.h>
-#else
-#  include <concurrency/BoostThreadFactory.h>
 #endif
 
 namespace apache { namespace thrift { namespace concurrency {
 
-#ifndef USE_BOOST_THREAD
+#ifdef USE_BOOST_THREAD
+  typedef BoostThreadFactory PlatformThreadFactory;
+#elif USE_STD_THREAD
+  typedef StdThreadFactory PlatformThreadFactory;
+#else
   typedef PosixThreadFactory PlatformThreadFactory;
-#else
-  typedef BoostThreadFactory PlatformThreadFactory;
 #endif
 
 }}} // apache::thrift::concurrency

=== modified file '3rdParty/libthrift/concurrency/PosixThreadFactory.cpp'
--- 3rdParty/libthrift/concurrency/PosixThreadFactory.cpp	2014-02-18 14:04:33 +0000
+++ 3rdParty/libthrift/concurrency/PosixThreadFactory.cpp	2015-02-26 01:00:39 +0000
@@ -17,11 +17,10 @@
  * under the License.
  */
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-#include "PosixThreadFactory.h"
-#include "Exception.h"
+#include <thrift-config.h>
+
+#include <concurrency/PosixThreadFactory.h>
+#include <concurrency/Exception.h>
 
 #if GOOGLE_PERFTOOLS_REGISTER_THREAD
 #  include <google/profiler.h>
@@ -248,14 +247,8 @@
    * into the correpsonding relative priority level (lowest..highest) and
    * then pro-rate accordingly.
    */
-  static int toPthreadPriority(POLICY
-#if defined HAVE_SCHED_GET_PRIORITY_MAX || defined HAVE_SCHED_GET_PRIORITY_MIN
-      policy
-#endif
-      , PRIORITY priority) {
-#if defined HAVE_SCHED_GET_PRIORITY_MAX || defined HAVE_SCHED_GET_PRIORITY_MIN
+  static int toPthreadPriority(POLICY policy, PRIORITY priority) {
     int pthread_policy = toPthreadPolicy(policy);
-#endif
     int min_priority = 0;
     int max_priority = 0;
 #ifdef HAVE_SCHED_GET_PRIORITY_MIN

=== modified file '3rdParty/libthrift/concurrency/PosixThreadFactory.h'
--- 3rdParty/libthrift/concurrency/PosixThreadFactory.h	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/concurrency/PosixThreadFactory.h	2015-02-26 01:00:39 +0000
@@ -20,7 +20,7 @@
 #ifndef _THRIFT_CONCURRENCY_POSIXTHREADFACTORY_H_
 #define _THRIFT_CONCURRENCY_POSIXTHREADFACTORY_H_ 1
 
-#include "Thread.h"
+#include <concurrency/Thread.h>
 
 #include <boost/shared_ptr.hpp>
 

=== added file '3rdParty/libthrift/concurrency/StdMonitor.cpp'
--- 3rdParty/libthrift/concurrency/StdMonitor.cpp	1970-01-01 00:00:00 +0000
+++ 3rdParty/libthrift/concurrency/StdMonitor.cpp	2015-02-26 01:00:39 +0000
@@ -0,0 +1,217 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include <thrift/thrift-config.h>
+
+#include <thrift/concurrency/Monitor.h>
+#include <thrift/concurrency/Exception.h>
+#include <thrift/concurrency/Util.h>
+#include <thrift/transport/PlatformSocket.h>
+#include <assert.h>
+
+#include <condition_variable>
+#include <chrono>
+#include <thread>
+#include <mutex>
+
+namespace apache { namespace thrift { namespace concurrency {
+
+/**
+ * Monitor implementation using the std thread library
+ *
+ * @version $Id:$
+ */
+class Monitor::Impl {
+
+ public:
+
+  Impl()
+     : ownedMutex_(new Mutex()),
+       conditionVariable_(),
+       mutex_(NULL) {
+    init(ownedMutex_.get());
+  }
+
+  Impl(Mutex* mutex)
+     : ownedMutex_(),
+       conditionVariable_(),
+       mutex_(NULL) {
+    init(mutex);
+  }
+
+  Impl(Monitor* monitor)
+     : ownedMutex_(),
+       conditionVariable_(),
+       mutex_(NULL) {
+    init(&(monitor->mutex()));
+  }
+
+  Mutex& mutex() { return *mutex_; }
+  void lock() { mutex_->lock(); }
+  void unlock() { mutex_->unlock(); }
+
+  /**
+   * Exception-throwing version of waitForTimeRelative(), called simply
+   * wait(int64) for historical reasons.  Timeout is in milliseconds.
+   *
+   * If the condition occurs,  this function returns cleanly; on timeout or
+   * error an exception is thrown.
+   */
+  void wait(int64_t timeout_ms) {
+    int result = waitForTimeRelative(timeout_ms);
+    if (result == THRIFT_ETIMEDOUT) {
+      throw TimedOutException();
+    } else if (result != 0) {
+      throw TException(
+        "Monitor::wait() failed");
+    }
+  }
+
+  /**
+   * Waits until the specified timeout in milliseconds for the condition to
+   * occur, or waits forever if timeout_ms == 0.
+   *
+   * Returns 0 if condition occurs, THRIFT_ETIMEDOUT on timeout, or an error code.
+   */
+  int waitForTimeRelative(int64_t timeout_ms) {
+    if (timeout_ms == 0LL) {
+      return waitForever();
+    }
+
+    assert(mutex_);
+    std::timed_mutex* mutexImpl =
+      static_cast<std::timed_mutex*>(mutex_->getUnderlyingImpl());
+    assert(mutexImpl);
+
+    std::unique_lock<std::timed_mutex> lock(*mutexImpl, std::adopt_lock);
+    bool timedout = (conditionVariable_.wait_for(lock, std::chrono::milliseconds(timeout_ms)) == std::cv_status::timeout);
+    lock.release();
+    return (timedout ? THRIFT_ETIMEDOUT : 0);
+  }
+
+  /**
+   * Waits until the absolute time specified using struct THRIFT_TIMESPEC.
+   * Returns 0 if condition occurs, THRIFT_ETIMEDOUT on timeout, or an error code.
+   */
+  int waitForTime(const THRIFT_TIMESPEC* abstime) {
+    struct timeval temp;
+    temp.tv_sec  = static_cast<long>(abstime->tv_sec);
+    temp.tv_usec = static_cast<long>(abstime->tv_nsec) / 1000;
+    return waitForTime(&temp);
+  }
+
+  /**
+   * Waits until the absolute time specified using struct timeval.
+   * Returns 0 if condition occurs, THRIFT_ETIMEDOUT on timeout, or an error code.
+   */
+  int waitForTime(const struct timeval* abstime) {
+    assert(mutex_);
+    std::timed_mutex* mutexImpl =
+      static_cast<std::timed_mutex*>(mutex_->getUnderlyingImpl());
+    assert(mutexImpl);
+
+    struct timeval currenttime;
+    Util::toTimeval(currenttime, Util::currentTime());
+
+    long tv_sec  = static_cast<long>(abstime->tv_sec  - currenttime.tv_sec);
+    long tv_usec = static_cast<long>(abstime->tv_usec - currenttime.tv_usec);
+    if(tv_sec < 0)
+      tv_sec = 0;
+    if(tv_usec < 0)
+      tv_usec = 0;
+
+    std::unique_lock<std::timed_mutex> lock(*mutexImpl, std::adopt_lock);
+    bool timedout = (conditionVariable_.wait_for(lock,
+      std::chrono::seconds(tv_sec) +
+      std::chrono::microseconds(tv_usec)) == std::cv_status::timeout);
+    lock.release();
+    return (timedout ? THRIFT_ETIMEDOUT : 0);
+  }
+
+  /**
+   * Waits forever until the condition occurs.
+   * Returns 0 if condition occurs, or an error code otherwise.
+   */
+  int waitForever() {
+    assert(mutex_);
+    std::timed_mutex* mutexImpl =
+      static_cast<std::timed_mutex*>(mutex_->getUnderlyingImpl());
+    assert(mutexImpl);
+
+    std::unique_lock<std::timed_mutex> lock(*mutexImpl, std::adopt_lock);
+    conditionVariable_.wait(lock);
+    lock.release();
+    return 0;
+  }
+
+
+  void notify() {
+    conditionVariable_.notify_one();
+  }
+
+  void notifyAll() {
+    conditionVariable_.notify_all();
+  }
+
+ private:
+
+  void init(Mutex* mutex) {
+    mutex_ = mutex;
+  }
+
+  const std::unique_ptr<Mutex> ownedMutex_;
+  std::condition_variable_any conditionVariable_;
+  Mutex* mutex_;
+};
+
+Monitor::Monitor() : impl_(new Monitor::Impl()) {}
+Monitor::Monitor(Mutex* mutex) : impl_(new Monitor::Impl(mutex)) {}
+Monitor::Monitor(Monitor* monitor) : impl_(new Monitor::Impl(monitor)) {}
+
+Monitor::~Monitor() { delete impl_; }
+
+Mutex& Monitor::mutex() const { return const_cast<Monitor::Impl*>(impl_)->mutex(); }
+
+void Monitor::lock() const { const_cast<Monitor::Impl*>(impl_)->lock(); }
+
+void Monitor::unlock() const { const_cast<Monitor::Impl*>(impl_)->unlock(); }
+
+void Monitor::wait(int64_t timeout) const { const_cast<Monitor::Impl*>(impl_)->wait(timeout); }
+
+int Monitor::waitForTime(const THRIFT_TIMESPEC* abstime) const {
+  return const_cast<Monitor::Impl*>(impl_)->waitForTime(abstime);
+}
+
+int Monitor::waitForTime(const timeval* abstime) const {
+  return const_cast<Monitor::Impl*>(impl_)->waitForTime(abstime);
+}
+
+int Monitor::waitForTimeRelative(int64_t timeout_ms) const {
+  return const_cast<Monitor::Impl*>(impl_)->waitForTimeRelative(timeout_ms);
+}
+
+int Monitor::waitForever() const {
+  return const_cast<Monitor::Impl*>(impl_)->waitForever();
+}
+
+void Monitor::notify() const { const_cast<Monitor::Impl*>(impl_)->notify(); }
+
+void Monitor::notifyAll() const { const_cast<Monitor::Impl*>(impl_)->notifyAll(); }
+
+}}} // apache::thrift::concurrency

=== added file '3rdParty/libthrift/concurrency/StdMutex.cpp'
--- 3rdParty/libthrift/concurrency/StdMutex.cpp	1970-01-01 00:00:00 +0000
+++ 3rdParty/libthrift/concurrency/StdMutex.cpp	2015-02-26 01:00:39 +0000
@@ -0,0 +1,55 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include <thrift/thrift-config.h>
+
+#include <thrift/concurrency/Mutex.h>
+#include <thrift/concurrency/Util.h>
+
+#include <cassert>
+#include <chrono>
+#include <mutex>
+
+namespace apache { namespace thrift { namespace concurrency {
+
+/**
+ * Implementation of Mutex class using C++11 std::timed_mutex
+ *
+ * @version $Id:$
+ */
+class Mutex::impl : public std::timed_mutex {
+};
+
+Mutex::Mutex(Initializer init) : impl_(new Mutex::impl()) {}
+
+void* Mutex::getUnderlyingImpl() const { return impl_.get(); }
+
+void Mutex::lock() const { impl_->lock(); }
+
+bool Mutex::trylock() const { return impl_->try_lock(); }
+
+bool Mutex::timedlock(int64_t ms) const { return impl_->try_lock_for(std::chrono::milliseconds(ms)); }
+
+void Mutex::unlock() const { impl_->unlock(); }
+
+void Mutex::DEFAULT_INITIALIZER(void* arg) {
+}
+
+}}} // apache::thrift::concurrency
+

=== added file '3rdParty/libthrift/concurrency/StdThreadFactory.cpp'
--- 3rdParty/libthrift/concurrency/StdThreadFactory.cpp	1970-01-01 00:00:00 +0000
+++ 3rdParty/libthrift/concurrency/StdThreadFactory.cpp	2015-02-26 01:00:39 +0000
@@ -0,0 +1,175 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include <thrift/thrift-config.h>
+
+#ifdef USE_STD_THREAD
+
+#include <thrift/concurrency/StdThreadFactory.h>
+#include <thrift/concurrency/Exception.h>
+
+#include <cassert>
+
+#include <boost/enable_shared_from_this.hpp>
+#include <boost/weak_ptr.hpp>
+#include <thread>
+
+namespace apache { namespace thrift { namespace concurrency {
+
+/**
+ * The C++11 thread class.
+ *
+ * Note that we use boost shared_ptr rather than std shared_ptrs here
+ * because the Thread/Runnable classes use those and we don't want to
+ * mix them.
+ *
+ * @version $Id:$
+ */
+class StdThread: public Thread, public boost::enable_shared_from_this<StdThread> {
+ public:
+
+  enum STATE {
+    uninitialized,
+    starting,
+    started,
+    stopping,
+    stopped
+  };
+
+   static void threadMain(boost::shared_ptr<StdThread> thread);
+
+ private:
+  std::unique_ptr<std::thread> thread_;
+  STATE state_;
+  bool detached_;
+
+ public:
+
+  StdThread(bool detached, boost::shared_ptr<Runnable> runnable) :
+      state_(uninitialized),
+      detached_(detached) {
+    this->Thread::runnable(runnable);
+  }
+
+  ~StdThread() {
+    if(!detached_) {
+      try {
+        join();
+      } catch(...) {
+        // We're really hosed.
+      }
+    }
+  }
+
+  void start() {
+    if (state_ != uninitialized) {
+      return;
+    }
+
+    boost::shared_ptr<StdThread> selfRef = shared_from_this();
+    state_ = starting;
+
+    thread_ = std::unique_ptr<std::thread>(new std::thread(threadMain, selfRef));
+
+    if(detached_)
+      thread_->detach();
+  }
+
+  void join() {
+    if (!detached_ && state_ != uninitialized) {
+      thread_->join();
+    }
+  }
+
+  Thread::id_t getId() {
+    return thread_.get() ? thread_->get_id() : std::thread::id();
+  }
+
+  boost::shared_ptr<Runnable> runnable() const { return Thread::runnable(); }
+
+  void runnable(boost::shared_ptr<Runnable> value) { Thread::runnable(value); }
+};
+
+void StdThread::threadMain(boost::shared_ptr<StdThread> thread) {
+  if (thread == NULL) {
+    return;
+  }
+
+  if (thread->state_ != starting) {
+    return;
+  }
+
+  thread->state_ = started;
+  thread->runnable()->run();
+
+  if (thread->state_ != stopping && thread->state_ != stopped) {
+    thread->state_ = stopping;
+  }
+
+  return;
+}
+
+/**
+ * std::thread factory implementation
+ */
+class StdThreadFactory::Impl {
+
+ private:
+  bool detached_;
+
+ public:
+
+  Impl(bool detached) :
+    detached_(detached) {}
+
+  /**
+   * Creates a new std::thread to run the runnable object
+   *
+   * @param runnable A runnable object
+   */
+  boost::shared_ptr<Thread> newThread(boost::shared_ptr<Runnable> runnable) const {
+    boost::shared_ptr<StdThread> result = boost::shared_ptr<StdThread>(new StdThread(detached_, runnable));
+    runnable->thread(result);
+    return result;
+  }
+
+  bool isDetached() const { return detached_; }
+
+  void setDetached(bool value) { detached_ = value; }
+
+  Thread::id_t getCurrentThreadId() const {
+    return std::this_thread::get_id();
+  }
+
+};
+
+StdThreadFactory::StdThreadFactory(bool detached) :
+  impl_(new StdThreadFactory::Impl(detached)) {}
+
+boost::shared_ptr<Thread> StdThreadFactory::newThread(boost::shared_ptr<Runnable> runnable) const { return impl_->newThread(runnable); }
+
+bool StdThreadFactory::isDetached() const { return impl_->isDetached(); }
+
+void StdThreadFactory::setDetached(bool value) { impl_->setDetached(value); }
+
+Thread::id_t StdThreadFactory::getCurrentThreadId() const { return impl_->getCurrentThreadId(); }
+
+}}} // apache::thrift::concurrency
+
+#endif // USE_STD_THREAD

=== added file '3rdParty/libthrift/concurrency/StdThreadFactory.h'
--- 3rdParty/libthrift/concurrency/StdThreadFactory.h	1970-01-01 00:00:00 +0000
+++ 3rdParty/libthrift/concurrency/StdThreadFactory.h	2015-02-26 01:00:39 +0000
@@ -0,0 +1,72 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#ifndef _THRIFT_CONCURRENCY_STDTHREADFACTORY_H_
+#define _THRIFT_CONCURRENCY_STDTHREADFACTORY_H_ 1
+
+#include <thrift/concurrency/Thread.h>
+
+#include <boost/shared_ptr.hpp>
+
+namespace apache { namespace thrift { namespace concurrency {
+
+/**
+ * A thread factory to create std::threads.
+ *
+ * @version $Id:$
+ */
+class StdThreadFactory : public ThreadFactory {
+
+ public:
+
+  /**
+   * Std thread factory.  All threads created by a factory are reference-counted
+   * via boost::shared_ptr and boost::weak_ptr.  The factory guarantees that threads and
+   * the Runnable tasks they host will be properly cleaned up once the last strong reference
+   * to both is given up.
+   *
+   * By default threads are not joinable.
+   */
+
+  StdThreadFactory(bool detached=true);
+
+  // From ThreadFactory;
+  boost::shared_ptr<Thread> newThread(boost::shared_ptr<Runnable> runnable) const;
+
+  // From ThreadFactory;
+  Thread::id_t getCurrentThreadId() const;
+
+  /**
+   * Sets detached mode of threads
+   */
+  virtual void setDetached(bool detached);
+
+  /**
+   * Gets current detached mode
+   */
+  virtual bool isDetached() const;
+
+private:
+  class Impl;
+  boost::shared_ptr<Impl> impl_;
+};
+
+}}} // apache::thrift::concurrency
+
+#endif // #ifndef _THRIFT_CONCURRENCY_STDTHREADFACTORY_H_

=== modified file '3rdParty/libthrift/concurrency/Thread.h' (properties changed: -x to +x)
--- 3rdParty/libthrift/concurrency/Thread.h	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/concurrency/Thread.h	2015-02-26 01:00:39 +0000
@@ -24,16 +24,16 @@
 #include <boost/shared_ptr.hpp>
 #include <boost/weak_ptr.hpp>
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#ifdef USE_BOOST_THREAD
-#include <boost/thread.hpp>
-#endif
-
-#ifdef HAVE_PTHREAD_H
-#include <pthread.h>
+#include <thrift-config.h>
+
+#if USE_BOOST_THREAD
+#  include <boost/thread.hpp>
+#elif USE_STD_THREAD
+#  include <thread>
+#else
+#  ifdef HAVE_PTHREAD_H
+#    include <pthread.h>
+#  endif
 #endif
 
 namespace apache { namespace thrift { namespace concurrency {
@@ -80,13 +80,19 @@
 
  public:
 
-#ifdef USE_BOOST_THREAD
+#if USE_BOOST_THREAD
   typedef boost::thread::id id_t;
 
   static inline bool is_current(id_t t) { return t == boost::this_thread::get_id(); }
   static inline id_t get_current() { return boost::this_thread::get_id(); }
+#elif USE_STD_THREAD
+  typedef std::thread::id id_t;
+
+  static inline bool is_current(id_t t) { return t == std::this_thread::get_id(); }
+  static inline id_t get_current() { return std::this_thread::get_id(); }
 #else
   typedef pthread_t id_t;
+
   static inline bool is_current(id_t t) { return pthread_equal(pthread_self(), t); }
   static inline id_t get_current() { return pthread_self(); }
 #endif

=== modified file '3rdParty/libthrift/concurrency/ThreadManager.cpp'
--- 3rdParty/libthrift/concurrency/ThreadManager.cpp	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/concurrency/ThreadManager.cpp	2015-02-26 01:00:39 +0000
@@ -17,14 +17,12 @@
  * under the License.
  */
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
+#include <thrift-config.h>
 
-#include "ThreadManager.h"
-#include "Exception.h"
-#include "Monitor.h"
-#include "Util.h"
+#include <concurrency/ThreadManager.h>
+#include <concurrency/Exception.h>
+#include <concurrency/Monitor.h>
+#include <concurrency/Util.h>
 
 #include <boost/shared_ptr.hpp>
 
@@ -310,7 +308,7 @@
         }
       }
 
-      if (task != NULL) {
+      if (task) {
         if (task->state_ == ThreadManager::Task::EXECUTING) {
           try {
             task->run();
@@ -377,7 +375,7 @@
   {
     Synchronized s(monitor_);
     if (state_ == ThreadManager::UNINITIALIZED) {
-      if (threadFactory_ == NULL) {
+      if (!threadFactory_) {
         throw InvalidArgumentException();
       }
       state_ = ThreadManager::STARTED;
@@ -448,8 +446,8 @@
     }
 
     for (std::set<shared_ptr<Thread> >::iterator ix = deadWorkers_.begin(); ix != deadWorkers_.end(); ix++) {
+      idMap_.erase((*ix)->getId());
       workers_.erase(*ix);
-      idMap_.erase((*ix)->getId());
     }
 
     deadWorkers_.clear();
@@ -518,7 +516,7 @@
 
   shared_ptr<ThreadManager::Task> task = tasks_.front();
   tasks_.pop();
-  
+
   return task->getRunnable();
 }
 
@@ -555,8 +553,7 @@
  public:
   SimpleThreadManager(size_t workerCount=4, size_t pendingTaskCountMax=0) :
     workerCount_(workerCount),
-    pendingTaskCountMax_(pendingTaskCountMax),
-    firstTime_(true) {
+    pendingTaskCountMax_(pendingTaskCountMax) {
   }
 
   void start() {
@@ -568,7 +565,6 @@
  private:
   const size_t workerCount_;
   const size_t pendingTaskCountMax_;
-  bool firstTime_;
   Monitor monitor_;
 };
 

=== modified file '3rdParty/libthrift/concurrency/ThreadManager.h'
--- 3rdParty/libthrift/concurrency/ThreadManager.h	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/concurrency/ThreadManager.h	2015-02-26 01:00:39 +0000
@@ -21,9 +21,9 @@
 #define _THRIFT_CONCURRENCY_THREADMANAGER_H_ 1
 
 #include <boost/shared_ptr.hpp>
-#include <tr1/functional>
+#include <cxxfunctional.h>
 #include <sys/types.h>
-#include "Thread.h"
+#include <concurrency/Thread.h>
 
 namespace apache { namespace thrift { namespace concurrency {
 
@@ -57,8 +57,7 @@
   ThreadManager() {}
 
  public:
-  class Task;
-  typedef std::tr1::function<void(boost::shared_ptr<Runnable>)> ExpireCallback;
+  typedef apache::thrift::stdcxx::function<void(boost::shared_ptr<Runnable>)> ExpireCallback;
 
   virtual ~ThreadManager() {}
 

=== modified file '3rdParty/libthrift/concurrency/TimerManager.cpp'
--- 3rdParty/libthrift/concurrency/TimerManager.cpp	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/concurrency/TimerManager.cpp	2015-02-26 01:00:39 +0000
@@ -17,9 +17,9 @@
  * under the License.
  */
 
-#include "TimerManager.h"
-#include "Exception.h"
-#include "Util.h"
+#include <concurrency/TimerManager.h>
+#include <concurrency/Exception.h>
+#include <concurrency/Util.h>
 
 #include <assert.h>
 #include <iostream>
@@ -102,7 +102,7 @@
           assert((timeout != 0 && manager_->taskCount_ > 0) || (timeout == 0 && manager_->taskCount_ == 0));
           try {
             manager_->monitor_.wait(timeout);
-          } catch (TimedOutException &e) {}
+          } catch (TimedOutException &) {}
           now = Util::currentTime();
         }
 
@@ -140,12 +140,20 @@
   friend class TimerManager;
 };
 
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable: 4355) // 'this' used in base member initializer list
+#endif
+
 TimerManager::TimerManager() :
   taskCount_(0),
   state_(TimerManager::UNINITIALIZED),
   dispatcher_(shared_ptr<Dispatcher>(new Dispatcher(this))) {
 }
 
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
 
 TimerManager::~TimerManager() {
 
@@ -166,7 +174,7 @@
   bool doStart = false;
   {
     Synchronized s(monitor_);
-    if (threadFactory_ == NULL) {
+    if (!threadFactory_) {
       throw InvalidArgumentException();
     }
     if (state_ == TimerManager::UNINITIALIZED) {
@@ -255,20 +263,33 @@
   }
 }
 
-void TimerManager::add(shared_ptr<Runnable> task, const struct timespec& value) {
-
-  int64_t expiration;
-  Util::toMilliseconds(expiration, value);
-
-  int64_t now = Util::currentTime();
-
-  if (expiration < now) {
-    throw  InvalidArgumentException();
-  }
-
-  add(task, expiration - now);
-}
-
+void TimerManager::add(shared_ptr<Runnable> task, const struct THRIFT_TIMESPEC& value) {
+
+  int64_t expiration;
+  Util::toMilliseconds(expiration, value);
+
+  int64_t now = Util::currentTime();
+
+  if (expiration < now) {
+    throw  InvalidArgumentException();
+  }
+
+  add(task, expiration - now);
+}
+
+void TimerManager::add(shared_ptr<Runnable> task, const struct timeval& value) {
+
+  int64_t expiration;
+  Util::toMilliseconds(expiration, value);
+
+  int64_t now = Util::currentTime();
+
+  if (expiration < now) {
+    throw  InvalidArgumentException();
+  }
+
+  add(task, expiration - now);
+}
 
 void TimerManager::remove(shared_ptr<Runnable> task) {
   (void) task;

=== modified file '3rdParty/libthrift/concurrency/TimerManager.h'
--- 3rdParty/libthrift/concurrency/TimerManager.h	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/concurrency/TimerManager.h	2015-02-26 01:00:39 +0000
@@ -20,9 +20,9 @@
 #ifndef _THRIFT_CONCURRENCY_TIMERMANAGER_H_
 #define _THRIFT_CONCURRENCY_TIMERMANAGER_H_ 1
 
-#include "Exception.h"
-#include "Monitor.h"
-#include "Thread.h"
+#include <concurrency/Exception.h>
+#include <concurrency/Monitor.h>
+#include <concurrency/Thread.h>
 
 #include <boost/shared_ptr.hpp>
 #include <map>
@@ -77,7 +77,15 @@
    * @param task The task to execute
    * @param timeout Absolute time in the future to execute task.
    */
-  virtual void add(boost::shared_ptr<Runnable> task, const struct timespec& timeout);
+  virtual void add(boost::shared_ptr<Runnable> task, const struct THRIFT_TIMESPEC& timeout);
+
+  /**
+   * Adds a task to be executed at some time in the future by a worker thread.
+   *
+   * @param task The task to execute
+   * @param timeout Absolute time in the future to execute task.
+   */
+  virtual void add(boost::shared_ptr<Runnable> task, const struct timeval& timeout);
 
   /**
    * Removes a pending task

=== modified file '3rdParty/libthrift/concurrency/Util.cpp'
--- 3rdParty/libthrift/concurrency/Util.cpp	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/concurrency/Util.cpp	2015-02-26 01:00:39 +0000
@@ -17,37 +17,24 @@
  * under the License.
  */
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
+#include <thrift-config.h>
+
+#include <Thrift.h>
+#include <concurrency/Util.h>
+
+#if defined(HAVE_SYS_TIME_H)
+#include <sys/time.h>
 #endif
 
-#include "Util.h"
-
-#if defined(HAVE_CLOCK_GETTIME)
-#include <time.h>
-#elif defined(HAVE_SYS_TIME_H)
-#include <sys/time.h>
-#endif // defined(HAVE_CLOCK_GETTIME)
-
 namespace apache { namespace thrift { namespace concurrency {
 
 int64_t Util::currentTimeTicks(int64_t ticksPerSec) {
   int64_t result;
-
-#if defined(HAVE_CLOCK_GETTIME)
-  struct timespec now;
-  int ret = clock_gettime(CLOCK_REALTIME, &now);
-  assert(ret == 0);
-  toTicks(result, now, ticksPerSec);
-#elif defined(HAVE_GETTIMEOFDAY)
   struct timeval now;
-  int ret = gettimeofday(&now, NULL);
+  int ret = THRIFT_GETTIMEOFDAY(&now, NULL);
   assert(ret == 0);
+  THRIFT_UNUSED_VARIABLE(ret); //squelching "unused variable" warning
   toTicks(result, now, ticksPerSec);
-#else
-#error "No high-precision clock is available."
-#endif // defined(HAVE_CLOCK_GETTIME)
-
   return result;
 }
 

=== modified file '3rdParty/libthrift/concurrency/Util.h'
--- 3rdParty/libthrift/concurrency/Util.h	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/concurrency/Util.h	2015-02-26 01:00:39 +0000
@@ -29,6 +29,8 @@
 #include <sys/time.h>
 #endif
 
+#include <transport/PlatformSocket.h>
+
 namespace apache { namespace thrift { namespace concurrency {
 
 /**
@@ -56,23 +58,23 @@
  public:
 
   /**
-   * Converts millisecond timestamp into a timespec struct
+   * Converts millisecond timestamp into a THRIFT_TIMESPEC struct
    *
-   * @param struct timespec& result
+   * @param struct THRIFT_TIMESPEC& result
    * @param time or duration in milliseconds
    */
-  static void toTimespec(struct timespec& result, int64_t value) {
+  static void toTimespec(struct THRIFT_TIMESPEC& result, int64_t value) {
     result.tv_sec = value / MS_PER_S; // ms to s
     result.tv_nsec = (value % MS_PER_S) * NS_PER_MS; // ms to ns
   }
 
   static void toTimeval(struct timeval& result, int64_t value) {
-    result.tv_sec = value / MS_PER_S; // ms to s
-    result.tv_usec = (value % MS_PER_S) * US_PER_MS; // ms to us
+    result.tv_sec  = static_cast<uint32_t>(value / MS_PER_S); // ms to s
+    result.tv_usec = static_cast<uint32_t>((value % MS_PER_S) * US_PER_MS); // ms to us
   }
 
   static void toTicks(int64_t& result, int64_t secs, int64_t oldTicks,
-                            int64_t oldTicksPerSec, int64_t newTicksPerSec) {
+                      int64_t oldTicksPerSec, int64_t newTicksPerSec) {
     result = secs * newTicksPerSec;
     result += oldTicks * newTicksPerSec / oldTicksPerSec;
 
@@ -82,11 +84,11 @@
     }
   }
   /**
-   * Converts struct timespec to arbitrary-sized ticks since epoch
+   * Converts struct THRIFT_TIMESPEC to arbitrary-sized ticks since epoch
    */
   static void toTicks(int64_t& result,
-                            const struct timespec& value,
-                            int64_t ticksPerSec) {
+                      const struct THRIFT_TIMESPEC& value,
+                      int64_t ticksPerSec) {
     return toTicks(result, value.tv_sec, value.tv_nsec, NS_PER_S, ticksPerSec);
   }
 
@@ -94,16 +96,16 @@
    * Converts struct timeval to arbitrary-sized ticks since epoch
    */
   static void toTicks(int64_t& result,
-                            const struct timeval& value,
-                            int64_t ticksPerSec) {
+                      const struct timeval& value,
+                      int64_t ticksPerSec) {
     return toTicks(result, value.tv_sec, value.tv_usec, US_PER_S, ticksPerSec);
   }
 
   /**
-   * Converts struct timespec to milliseconds
+   * Converts struct THRIFT_TIMESPEC to milliseconds
    */
   static void toMilliseconds(int64_t& result,
-                                   const struct timespec& value) {
+                             const struct THRIFT_TIMESPEC& value) {
     return toTicks(result, value, MS_PER_S);
   }
 
@@ -111,14 +113,14 @@
    * Converts struct timeval to milliseconds
    */
   static void toMilliseconds(int64_t& result,
-                                   const struct timeval& value) {
+                             const struct timeval& value) {
     return toTicks(result, value, MS_PER_S);
   }
 
   /**
-   * Converts struct timespec to microseconds
+   * Converts struct THRIFT_TIMESPEC to microseconds
    */
-  static void toUsec(int64_t& result, const struct timespec& value) {
+  static void toUsec(int64_t& result, const struct THRIFT_TIMESPEC& value) {
     return toTicks(result, value, US_PER_S);
   }
 

=== modified file '3rdParty/libthrift/config.h'
--- 3rdParty/libthrift/config.h	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/config.h	2015-02-26 01:00:39 +0000
@@ -2,7 +2,7 @@
  * Android NDK r7 compatible configuration.
  */
 
-#define VERSION     "0.8.0-arm"
+#define VERSION     "0.9.2"
 
 #define HAVE_UNISTD_H
 #define HAVE_INTTYPES_H

=== added file '3rdParty/libthrift/cxxfunctional.h'
--- 3rdParty/libthrift/cxxfunctional.h	1970-01-01 00:00:00 +0000
+++ 3rdParty/libthrift/cxxfunctional.h	2015-02-26 01:00:39 +0000
@@ -0,0 +1,126 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#ifndef _THRIFT_CXXFUNCTIONAL_H_
+#define _THRIFT_CXXFUNCTIONAL_H_ 1
+
+/**
+ * Loads <functional> from the 'right' location, depending
+ * on compiler and whether or not it's using C++03 with TR1
+ * or C++11.
+ */
+
+/*
+ * MSVC 10 and 11 have the <functional> stuff at <functional>.
+ * In MSVC 10 all of the implementations live in std::tr1.
+ * In MSVC 11 all of the implementations live in std, with aliases
+ *  in std::tr1 to point to the ones in std.
+ */
+#ifdef _WIN32
+  #define _THRIFT_USING_MICROSOFT_STDLIB 1
+#endif
+
+#ifdef __clang__
+  /* Clang has two options, depending on standard library:
+   * - no -stdlib or -stdlib=libstdc++ set; uses GNU libstdc++.
+   *    <tr1/functional>
+   * - -stdlib=libc++; uses LLVM libc++.
+   *    <functional>, no 'std::tr1'.
+   *
+   * The compiler itself doesn't define anything differently
+   * depending on the value of -stdlib, but the library headers
+   * will set different preprocessor options. In order to check,
+   * though, we have to pull in some library header.
+   */
+  #include <utility>
+
+  /* With LLVM libc++, utility pulls in __config, which sets
+     _LIBCPP_VERSION. */
+  #if defined(_LIBCPP_VERSION)
+    #define _THRIFT_USING_CLANG_LIBCXX 1
+
+  /* With GNU libstdc++, utility pulls in bits/c++config.h,
+     which sets __GLIBCXX__. */
+  #elif defined(__GLIBCXX__)
+    #define _THRIFT_USING_GNU_LIBSTDCXX 1
+
+  /* No idea. */
+  #else
+    #error Unable to detect which C++ standard library is in use.
+  #endif
+#elif __GNUC__
+  #define _THRIFT_USING_GNU_LIBSTDCXX 1
+#endif
+
+#if _THRIFT_USING_MICROSOFT_STDLIB
+  #include <functional>
+
+  namespace apache { namespace thrift { namespace stdcxx {
+    using ::std::tr1::function;
+    using ::std::tr1::bind;
+
+    namespace placeholders {
+      using ::std::tr1::placeholders::_1;
+      using ::std::tr1::placeholders::_2;
+      using ::std::tr1::placeholders::_3;
+      using ::std::tr1::placeholders::_4;
+      using ::std::tr1::placeholders::_5;
+      using ::std::tr1::placeholders::_6;
+    } // apache::thrift::stdcxx::placeholders
+  }}} // apache::thrift::stdcxx
+
+#elif _THRIFT_USING_CLANG_LIBCXX
+  #include <functional>
+
+  namespace apache { namespace thrift { namespace stdcxx {
+    using ::std::function;
+    using ::std::bind;
+
+    namespace placeholders {
+      using ::std::placeholders::_1;
+      using ::std::placeholders::_2;
+      using ::std::placeholders::_3;
+      using ::std::placeholders::_4;
+      using ::std::placeholders::_5;
+      using ::std::placeholders::_6;
+    } // apache::thrift::stdcxx::placeholders
+  }}} // apache::thrift::stdcxx
+
+#elif _THRIFT_USING_GNU_LIBSTDCXX
+  #include <tr1/functional>
+
+  namespace apache { namespace thrift { namespace stdcxx {
+    using ::std::tr1::function;
+    using ::std::tr1::bind;
+
+    namespace placeholders {
+      using ::std::tr1::placeholders::_1;
+      using ::std::tr1::placeholders::_2;
+      using ::std::tr1::placeholders::_3;
+      using ::std::tr1::placeholders::_4;
+      using ::std::tr1::placeholders::_5;
+      using ::std::tr1::placeholders::_6;
+    } // apache::thrift::stdcxx::placeholders
+  }}} // apache::thrift::stdcxx
+#endif
+
+  // Alias for thrift c++ compatibility namespace
+  namespace tcxx = apache::thrift::stdcxx;
+
+#endif // #ifndef _THRIFT_CXXFUNCTIONAL_H_

=== removed directory '3rdParty/libthrift/jni'
=== removed file '3rdParty/libthrift/jni/Android.mk'
--- 3rdParty/libthrift/jni/Android.mk	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/jni/Android.mk	1970-01-01 00:00:00 +0000
@@ -1,98 +0,0 @@
-#
-# Thrift 0.8.0 static and shared C++ libraries
-#
-
-LOCAL_PATH := $(call my-dir)
-SRC_PATH := ..
-INCLUDE_PATH := $(LOCAL_PATH)/..
-
-THRIFT_FILENAME := libthrift
-THRIFT_CPPFLAGS := -DHAVE_CONFIG_H -D__GLIBC__
-
-ifeq ($(BOOST_ROOT),)
-BOOST_ROOT := $(INCLUDE_PATH)/../boost
-endif
-
-THRIFT_SRC_FILES := \
-    $(SRC_PATH)/Thrift.cpp \
-    $(SRC_PATH)/VirtualProfiling.cpp \
-    $(SRC_PATH)/TApplicationException.cpp \
-    $(SRC_PATH)/async/TAsyncChannel.cpp \
-    $(SRC_PATH)/async/TAsyncProtocolProcessor.cpp \
-    $(SRC_PATH)/processor/PeekProcessor.cpp \
-    $(SRC_PATH)/transport/TSocket.cpp \
-    $(SRC_PATH)/transport/TTransportException.cpp \
-    $(SRC_PATH)/transport/TZlibTransport.cpp \
-    $(SRC_PATH)/transport/TSocketPool.cpp \
-    $(SRC_PATH)/transport/TServerSocket.cpp \
-    $(SRC_PATH)/transport/THttpClient.cpp \
-    $(SRC_PATH)/transport/TTransportUtils.cpp \
-    $(SRC_PATH)/transport/THttpTransport.cpp \
-    $(SRC_PATH)/transport/TBufferTransports.cpp \
-    $(SRC_PATH)/transport/TFileTransport.cpp \
-    $(SRC_PATH)/transport/TSimpleFileTransport.cpp \
-    $(SRC_PATH)/transport/THttpServer.cpp \
-    $(SRC_PATH)/transport/TFDTransport.cpp \
-    $(SRC_PATH)/concurrency/Util.cpp \
-    $(SRC_PATH)/concurrency/PosixThreadFactory.cpp \
-    $(SRC_PATH)/concurrency/TimerManager.cpp \
-    $(SRC_PATH)/concurrency/Mutex.cpp \
-    $(SRC_PATH)/concurrency/ThreadManager.cpp \
-    $(SRC_PATH)/concurrency/Monitor.cpp \
-    $(SRC_PATH)/server/TThreadPoolServer.cpp \
-    $(SRC_PATH)/server/TServer.cpp \
-    $(SRC_PATH)/server/TThreadedServer.cpp \
-    $(SRC_PATH)/server/TSimpleServer.cpp \
-    $(SRC_PATH)/protocol/TDebugProtocol.cpp \
-    $(SRC_PATH)/protocol/TDenseProtocol.cpp \
-    $(SRC_PATH)/protocol/TJSONProtocol.cpp \
-    $(SRC_PATH)/protocol/TBase64Utils.cpp \
-
-    # not supported yet
-    # async/TEvhttpServer.cpp \
-    # async/TEvhttpClientChannel.cpp \
-    # transport/TSSLSocket.cpp \
-    # transport/TSSLServerSocket.cpp \
-    # server/TNonblockingServer.cpp \
-
-#
-# Shared library directives
-#
-
-include $(CLEAR_VARS)
-
-LOCAL_MODULE := thrift_shared
-
-LOCAL_C_INCLUDES := $(INCLUDE_PATH) $(BOOST_ROOT)
-
-LOCAL_MODULE_FILENAME := $(THRIFT_FILENAME)
-LOCAL_CPPFLAGS := $(THRIFT_CPPFLAGS)
-LOCAL_SRC_FILES := $(THRIFT_SRC_FILES)
-
-LOCAL_LDLIBS := -lz
-
-LOCAL_EXPORT_C_INCLUDES := $(INCLUDE_PATH)
-LOCAL_EXPORT_CPPFLAGS := $(THRIFT_CPPFLAGS)
-
-include $(BUILD_SHARED_LIBRARY)
-
-#
-# Static library directives
-#
-
-include $(CLEAR_VARS)
-
-LOCAL_MODULE := thrift_static
-
-LOCAL_C_INCLUDES := $(INCLUDE_PATH) $(BOOST_ROOT)
-
-LOCAL_MODULE_FILENAME := $(THRIFT_FILENAME)
-LOCAL_CPPFLAGS := $(THRIFT_CPPFLAGS)
-LOCAL_SRC_FILES := $(THRIFT_SRC_FILES)
-
-LOCAL_LDLIBS := -lz
-
-LOCAL_EXPORT_C_INCLUDES := $(INCLUDE_PATH)
-LOCAL_EXPORT_CPPFLAGS := $(THRIFT_CPPFLAGS)
-
-include $(BUILD_STATIC_LIBRARY)

=== removed file '3rdParty/libthrift/jni/Application.mk'
--- 3rdParty/libthrift/jni/Application.mk	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/jni/Application.mk	1970-01-01 00:00:00 +0000
@@ -1,7 +0,0 @@
-APP_MODULES      := thrift_shared thrift_static
-APP_PLATFORM     := android-8
-APP_ABI          := all
-APP_STL          := gnustl_static
-APP_OPTIM        := debug
-
-APP_CPPFLAGS     := -fexceptions -frtti
\ No newline at end of file

=== removed file '3rdParty/libthrift/jni/shared.mk'
--- 3rdParty/libthrift/jni/shared.mk	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/jni/shared.mk	1970-01-01 00:00:00 +0000
@@ -1,17 +0,0 @@
-#
-# Thrift 0.8.0 prebuilt shared C++ librariy
-#
-
-__WAS_PATH := $(LOCAL_PATH)
-LOCAL_PATH := $(call my-dir)
-
-include $(CLEAR_VARS)
-
-LOCAL_MODULE := thrift_prebuilt_shared
-LOCAL_SRC_FILES := ../lib/$(TARGET_ARCH_ABI)/libthrift.so
-LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)/..
-LOCAL_EXPORT_CPPFLAGS := -DHAVE_CONFIG_H -D__GLIBC__
-
-include $(PREBUILT_SHARED_LIBRARY)
-
-LOCAL_PATH := $(__WAS_PATH)

=== removed file '3rdParty/libthrift/jni/static.mk'
--- 3rdParty/libthrift/jni/static.mk	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/jni/static.mk	1970-01-01 00:00:00 +0000
@@ -1,17 +0,0 @@
-#
-# Thrift 0.8.0 prebuilt static C++ library
-#
-
-__WAS_PATH := $(LOCAL_PATH)
-LOCAL_PATH := $(call my-dir)
-
-include $(CLEAR_VARS)
-
-LOCAL_MODULE := thrift_prebuilt_static
-LOCAL_SRC_FILES := ../obj/local/$(TARGET_ARCH_ABI)/libthrift.a
-LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)/..
-LOCAL_EXPORT_CPPFLAGS := -DHAVE_CONFIG_H -D__GLIBC__
-
-include $(PREBUILT_STATIC_LIBRARY)
-
-LOCAL_PATH := $(__WAS_PATH)

=== modified file '3rdParty/libthrift/processor/PeekProcessor.cpp'
--- 3rdParty/libthrift/processor/PeekProcessor.cpp	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/processor/PeekProcessor.cpp	2015-02-26 01:00:39 +0000
@@ -17,7 +17,7 @@
  * under the License.
  */
 
-#include "PeekProcessor.h"
+#include <thrift/processor/PeekProcessor.h>
 
 using namespace apache::thrift::transport;
 using namespace apache::thrift::protocol;
@@ -66,7 +66,7 @@
   int32_t seqid;
   in->readMessageBegin(fname, mtype, seqid);
 
-  if (mtype != T_CALL) {
+  if (mtype != T_CALL && mtype != T_ONEWAY) {
     throw TException("Unexpected message type");
   }
 

=== modified file '3rdParty/libthrift/processor/PeekProcessor.h'
--- 3rdParty/libthrift/processor/PeekProcessor.h	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/processor/PeekProcessor.h	2015-02-26 01:00:39 +0000
@@ -21,10 +21,10 @@
 #define PEEKPROCESSOR_H
 
 #include <string>
-#include <TProcessor.h>
-#include <transport/TTransport.h>
-#include <transport/TTransportUtils.h>
-#include <transport/TBufferTransports.h>
+#include <thrift/TProcessor.h>
+#include <thrift/transport/TTransport.h>
+#include <thrift/transport/TTransportUtils.h>
+#include <thrift/transport/TBufferTransports.h>
 #include <boost/shared_ptr.hpp>
 
 namespace apache { namespace thrift { namespace processor {

=== modified file '3rdParty/libthrift/processor/StatsProcessor.h'
--- 3rdParty/libthrift/processor/StatsProcessor.h	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/processor/StatsProcessor.h	2015-02-26 01:00:39 +0000
@@ -21,8 +21,8 @@
 #define STATSPROCESSOR_H
 
 #include <boost/shared_ptr.hpp>
-#include <transport/TTransport.h>
-#include <protocol/TProtocol.h>
+#include <thrift/transport/TTransport.h>
+#include <thrift/protocol/TProtocol.h>
 #include <TProcessor.h>
 
 namespace apache { namespace thrift { namespace processor {
@@ -50,7 +50,7 @@
     int32_t seqid;
 
     piprot_->readMessageBegin(fname, mtype, seqid);
-    if (mtype != apache::thrift::protocol::T_CALL) {
+    if (mtype != apache::thrift::protocol::T_CALL && mtype != apache::thrift::protocol::T_ONEWAY) {
       if (print_) {
         printf("Unknown message type\n");
       }

=== added file '3rdParty/libthrift/processor/TMultiplexedProcessor.h'
--- 3rdParty/libthrift/processor/TMultiplexedProcessor.h	1970-01-01 00:00:00 +0000
+++ 3rdParty/libthrift/processor/TMultiplexedProcessor.h	2015-02-26 01:00:39 +0000
@@ -0,0 +1,218 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#ifndef THRIFT_TMULTIPLEXEDPROCESSOR_H_
+#define THRIFT_TMULTIPLEXEDPROCESSOR_H_ 1
+
+#include <thrift/protocol/TProtocolDecorator.h>
+#include <thrift/TApplicationException.h>
+#include <thrift/TProcessor.h>
+#include <boost/tokenizer.hpp>
+
+namespace apache
+{
+    namespace thrift
+    {
+        using boost::shared_ptr;
+
+        namespace protocol {
+
+            /**
+             *  To be able to work with any protocol, we needed
+             *  to allow them to call readMessageBegin() and get a TMessage in exactly
+             *  the standard format, without the service name prepended to TMessage.name.
+             */
+            class StoredMessageProtocol : public TProtocolDecorator
+            {
+            public:
+                StoredMessageProtocol( shared_ptr<protocol::TProtocol> _protocol,
+                    const std::string& _name, const TMessageType _type,
+                    const int32_t _seqid) :
+                    TProtocolDecorator(_protocol),
+                    name(_name),
+                    type(_type),
+                    seqid(_seqid)
+                {
+                }
+
+                uint32_t readMessageBegin_virt(std::string& _name, TMessageType& _type, int32_t& _seqid)
+                {
+
+                    _name  = name;
+                    _type  = type;
+                    _seqid = seqid;
+
+                    return 0; // (Normal TProtocol read functions return number of bytes read)
+                }
+
+                std::string name;
+                TMessageType type;
+                int32_t seqid;
+            };
+        } //namespace protocol
+
+        /**
+         * <code>TMultiplexedProcessor</code> is a <code>TProcessor</code> allowing
+         * a single <code>TServer</code> to provide multiple services.
+         *
+         * <p>To do so, you instantiate the processor and then register additional
+         * processors with it, as shown in the following example:</p>
+         *
+         * <blockquote><code>
+         *     shared_ptr<TMultiplexedProcessor> processor(new TMultiplexedProcessor());
+         *
+         *     processor->registerProcessor(
+         *         "Calculator",
+         *         shared_ptr<TProcessor>( new CalculatorProcessor(
+         *             shared_ptr<CalculatorHandler>( new CalculatorHandler()))));
+         *
+         *     processor->registerProcessor(
+         *         "WeatherReport",
+         *         shared_ptr<TProcessor>( new WeatherReportProcessor(
+         *             shared_ptr<WeatherReportHandler>( new WeatherReportHandler()))));
+         *
+         *     shared_ptr<TServerTransport> transport(new TServerSocket(9090));
+         *     TSimpleServer server(processor, transport);
+         *
+         *     server.serve();
+         * </code></blockquote>
+         */
+        class TMultiplexedProcessor : public TProcessor
+        {
+        public:
+            typedef std::map< std::string, shared_ptr<TProcessor> > services_t;
+
+           /**
+             * 'Register' a service with this <code>TMultiplexedProcessor</code>.  This
+             * allows us to broker requests to individual services by using the service
+             * name to select them at request time.
+             *
+             * \param [in] serviceName Name of a service, has to be identical to the name
+             *                         declared in the Thrift IDL, e.g. "WeatherReport".
+             * \param [in] processor   Implementation of a service, ususally referred to
+             *                         as "handlers", e.g. WeatherReportHandler,
+             *                         implementing WeatherReportIf interface.
+             */
+            void registerProcessor( const std::string & serviceName,
+                                    shared_ptr<TProcessor> processor )
+            {
+                services[serviceName] = processor;
+            }
+
+            /**
+             * This implementation of <code>process</code> performs the following steps:
+             *
+             * <ol>
+             *     <li>Read the beginning of the message.</li>
+             *     <li>Extract the service name from the message.</li>
+             *     <li>Using the service name to locate the appropriate processor.</li>
+             *     <li>Dispatch to the processor, with a decorated instance of TProtocol
+             *         that allows readMessageBegin() to return the original TMessage.</li>
+             * </ol>
+             *
+             * \throws TException If the message type is not T_CALL or T_ONEWAY, if
+             * the service name was not found in the message, or if the service
+             * name was not found in the service map.
+             */
+            bool process( shared_ptr<protocol::TProtocol> in,
+                          shared_ptr<protocol::TProtocol> out,
+                          void *connectionContext)
+            {
+                std::string name;
+                protocol::TMessageType type;
+                int32_t seqid;
+
+                // Use the actual underlying protocol (e.g. TBinaryProtocol) to read the
+                // message header.  This pulls the message "off the wire", which we'll
+                // deal with at the end of this method.
+                in->readMessageBegin(name, type, seqid);
+
+                if( type != protocol::T_CALL && type != protocol::T_ONEWAY ) {
+                    // Unexpected message type.
+                    in->skip(::apache::thrift::protocol::T_STRUCT);
+                    in->readMessageEnd();
+                    in->getTransport()->readEnd();
+                    const std::string msg("TMultiplexedProcessor: Unexpected message type");
+                    ::apache::thrift::TApplicationException x(
+                        ::apache::thrift::TApplicationException::PROTOCOL_ERROR,
+                        msg);
+                    out->writeMessageBegin(name, ::apache::thrift::protocol::T_EXCEPTION, seqid);
+                    x.write(out.get());
+                    out->writeMessageEnd();
+                    out->getTransport()->writeEnd();
+                    out->getTransport()->flush();
+                    throw TException(msg);
+                }
+
+                // Extract the service name
+
+                boost::tokenizer<boost::char_separator<char> > tok( name, boost::char_separator<char>(":") );
+
+                std::vector<std::string> tokens;
+                std::copy( tok.begin(), tok.end(), std::back_inserter(tokens) );
+
+                // A valid message should consist of two tokens: the service
+                // name and the name of the method to call.
+                if( tokens.size() == 2 )
+                {
+                    // Search for a processor associated with this service name.
+                    services_t::iterator it = services.find(tokens[0]);
+
+                    if( it != services.end() )
+                    {
+                        shared_ptr<TProcessor> processor = it->second;
+                        // Let the processor registered for this service name
+                        // process the message.
+                        return processor->process(
+                            shared_ptr<protocol::TProtocol>(
+                                new protocol::StoredMessageProtocol( in, tokens[1], type, seqid ) ),
+                            out, connectionContext );
+                    }
+                    else
+                    {
+                        // Unknown service.
+                        in->skip(::apache::thrift::protocol::T_STRUCT);
+                        in->readMessageEnd();
+                        in->getTransport()->readEnd();
+
+                        std::string msg("TMultiplexedProcessor: Unknown service: ");
+                        msg += tokens[0];
+                        ::apache::thrift::TApplicationException x(
+                            ::apache::thrift::TApplicationException::PROTOCOL_ERROR,
+                            msg);
+                        out->writeMessageBegin(name, ::apache::thrift::protocol::T_EXCEPTION, seqid);
+                        x.write(out.get());
+                        out->writeMessageEnd();
+                        out->getTransport()->writeEnd();
+                        out->getTransport()->flush();
+                        msg += ". Did you forget to call registerProcessor()?";
+                        throw TException(msg);
+                    }
+                }
+                return false;
+            }
+
+        private:
+            /** Map of service processor objects, indexed by service names. */
+            services_t services;
+        };
+    }
+}
+
+#endif // THRIFT_TMULTIPLEXEDPROCESSOR_H_

=== modified file '3rdParty/libthrift/protocol/TBase64Utils.cpp'
--- 3rdParty/libthrift/protocol/TBase64Utils.cpp	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/protocol/TBase64Utils.cpp	2015-02-26 01:00:39 +0000
@@ -17,7 +17,7 @@
  * under the License.
  */
 
-#include "TBase64Utils.h"
+#include <thrift/protocol/TBase64Utils.h>
 
 #include <boost/static_assert.hpp>
 
@@ -30,36 +30,36 @@
   "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
 void  base64_encode(const uint8_t *in, uint32_t len, uint8_t *buf) {
-  buf[0] = kBase64EncodeTable[(in[0] >> 2) & 0x3F];
+  buf[0] = kBase64EncodeTable[(in[0] >> 2) & 0x3f];
   if (len == 3) {
-    buf[1] = kBase64EncodeTable[((in[0] << 4) + (in[1] >> 4)) & 0x3f];
-    buf[2] = kBase64EncodeTable[((in[1] << 2) + (in[2] >> 6)) & 0x3f];
+    buf[1] = kBase64EncodeTable[((in[0] << 4) & 0x30) | ((in[1] >> 4) & 0x0f)];
+    buf[2] = kBase64EncodeTable[((in[1] << 2) & 0x3c) | ((in[2] >> 6) & 0x03)];
     buf[3] = kBase64EncodeTable[in[2] & 0x3f];
   } else if (len == 2) {
-    buf[1] = kBase64EncodeTable[((in[0] << 4) + (in[1] >> 4)) & 0x3f];
-    buf[2] = kBase64EncodeTable[(in[1] << 2) & 0x3f];
+    buf[1] = kBase64EncodeTable[((in[0] << 4) & 0x30) | ((in[1] >> 4) & 0x0f)];
+    buf[2] = kBase64EncodeTable[(in[1] << 2) & 0x3c];
   } else  { // len == 1
-    buf[1] = kBase64EncodeTable[(in[0] << 4) & 0x3f];
+    buf[1] = kBase64EncodeTable[(in[0] << 4) & 0x30];
   }
 }
 
 static const uint8_t kBase64DecodeTable[256] ={
-  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,62,-1,-1,-1,63,
-  52,53,54,55,56,57,58,59,60,61,-1,-1,-1,-1,-1,-1,
-  -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,
-  15,16,17,18,19,20,21,22,23,24,25,-1,-1,-1,-1,-1,
-  -1,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,
-  41,42,43,44,45,46,47,48,49,50,51,-1,-1,-1,-1,-1,
-  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
+0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
+0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x3e,0xff,0xff,0xff,0x3f,
+0x34,0x35,0x36,0x37,0x38,0x39,0x3a,0x3b,0x3c,0x3d,0xff,0xff,0xff,0xff,0xff,0xff,
+0xff,0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,
+0x0f,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0xff,0xff,0xff,0xff,0xff,
+0xff,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,
+0x29,0x2a,0x2b,0x2c,0x2d,0x2e,0x2f,0x30,0x31,0x32,0x33,0xff,0xff,0xff,0xff,0xff,
+0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
+0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
+0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
+0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
+0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
+0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
+0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
+0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
 };
 
 void base64_decode(uint8_t *buf, uint32_t len) {

=== modified file '3rdParty/libthrift/protocol/TBinaryProtocol.h'
--- 3rdParty/libthrift/protocol/TBinaryProtocol.h	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/protocol/TBinaryProtocol.h	2015-02-26 01:00:39 +0000
@@ -20,8 +20,8 @@
 #ifndef _THRIFT_PROTOCOL_TBINARYPROTOCOL_H_
 #define _THRIFT_PROTOCOL_TBINARYPROTOCOL_H_ 1
 
-#include "TProtocol.h"
-#include "TVirtualProtocol.h"
+#include <protocol/TProtocol.h>
+#include <protocol/TVirtualProtocol.h>
 
 #include <boost/shared_ptr.hpp>
 
@@ -134,7 +134,8 @@
 
   inline uint32_t writeDouble(const double dub);
 
-  inline uint32_t writeString(const std::string& str);
+  template <typename StrType>
+  inline uint32_t writeString(const StrType& str);
 
   inline uint32_t writeBinary(const std::string& str);
 
@@ -187,12 +188,14 @@
 
   inline uint32_t readDouble(double& dub);
 
-  inline uint32_t readString(std::string& str);
+  template<typename StrType>
+  inline uint32_t readString(StrType& str);
 
   inline uint32_t readBinary(std::string& str);
 
  protected:
-  uint32_t readStringBody(std::string& str, int32_t sz);
+  template<typename StrType>
+  uint32_t readStringBody(StrType& str, int32_t sz);
 
   Transport_* trans_;
 
@@ -274,6 +277,6 @@
 
 }}} // apache::thrift::protocol
 
-#include "TBinaryProtocol.tcc"
+#include <protocol/TBinaryProtocol.tcc>
 
 #endif // #ifndef _THRIFT_PROTOCOL_TBINARYPROTOCOL_H_

=== modified file '3rdParty/libthrift/protocol/TBinaryProtocol.tcc'
--- 3rdParty/libthrift/protocol/TBinaryProtocol.tcc	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/protocol/TBinaryProtocol.tcc	2015-02-26 01:00:39 +0000
@@ -20,7 +20,7 @@
 #ifndef _THRIFT_PROTOCOL_TBINARYPROTOCOL_TCC_
 #define _THRIFT_PROTOCOL_TBINARYPROTOCOL_TCC_ 1
 
-#include "TBinaryProtocol.h"
+#include <protocol/TBinaryProtocol.h>
 
 #include <limits>
 
@@ -176,8 +176,11 @@
 
 
 template <class Transport_>
-uint32_t TBinaryProtocolT<Transport_>::writeString(const std::string& str) {
-  uint32_t size = str.size();
+template<typename StrType>
+uint32_t TBinaryProtocolT<Transport_>::writeString(const StrType& str) {
+  if(str.size() > static_cast<size_t>((std::numeric_limits<int32_t>::max)()))
+    throw TProtocolException(TProtocolException::SIZE_LIMIT);
+  uint32_t size = static_cast<uint32_t>(str.size());
   uint32_t result = writeI32((int32_t)size);
   if (size > 0) {
     this->trans_->write((uint8_t*)str.data(), size);
@@ -401,7 +404,8 @@
 }
 
 template <class Transport_>
-uint32_t TBinaryProtocolT<Transport_>::readString(std::string& str) {
+template<typename StrType>
+uint32_t TBinaryProtocolT<Transport_>::readString(StrType& str) {
   uint32_t result;
   int32_t size;
   result = readI32(size);
@@ -414,7 +418,8 @@
 }
 
 template <class Transport_>
-uint32_t TBinaryProtocolT<Transport_>::readStringBody(std::string& str,
+template<typename StrType>
+uint32_t TBinaryProtocolT<Transport_>::readStringBody(StrType& str,
                                                       int32_t size) {
   uint32_t result = 0;
 
@@ -441,17 +446,8 @@
     return size;
   }
 
-  // Use the heap here to prevent stack overflow for v. large strings
-  if (size > this->string_buf_size_ || this->string_buf_ == NULL) {
-    void* new_string_buf = std::realloc(this->string_buf_, (uint32_t)size);
-    if (new_string_buf == NULL) {
-      throw std::bad_alloc();
-    }
-    this->string_buf_ = (uint8_t*)new_string_buf;
-    this->string_buf_size_ = size;
-  }
-  this->trans_->readAll(this->string_buf_, size);
-  str.assign((char*)this->string_buf_, size);
+  str.resize(size);
+  this->trans_->readAll(reinterpret_cast<uint8_t *>(&str[0]), size);
   return (uint32_t)size;
 }
 

=== modified file '3rdParty/libthrift/protocol/TCompactProtocol.h'
--- 3rdParty/libthrift/protocol/TCompactProtocol.h	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/protocol/TCompactProtocol.h	2015-02-26 01:00:39 +0000
@@ -20,7 +20,7 @@
 #ifndef _THRIFT_PROTOCOL_TCOMPACTPROTOCOL_H_
 #define _THRIFT_PROTOCOL_TCOMPACTPROTOCOL_H_ 1
 
-#include "TVirtualProtocol.h"
+#include <thrift/protocol/TVirtualProtocol.h>
 
 #include <stack>
 #include <boost/shared_ptr.hpp>
@@ -35,10 +35,11 @@
   : public TVirtualProtocol< TCompactProtocolT<Transport_> > {
 
  protected:
-  static const int8_t  PROTOCOL_ID = (int8_t)0x82;
+  static const int8_t  PROTOCOL_ID = (int8_t)0x82u;
   static const int8_t  VERSION_N = 1;
   static const int8_t  VERSION_MASK = 0x1f; // 0001 1111
-  static const int8_t  TYPE_MASK = (int8_t)0xE0; // 1110 0000
+  static const int8_t  TYPE_MASK = (int8_t)0xE0u; // 1110 0000
+  static const int8_t  TYPE_BITS = 0x07; // 0000 0111
   static const int32_t TYPE_SHIFT_AMOUNT = 5;
 
   Transport_* trans_;
@@ -161,12 +162,12 @@
                                   const TType fieldType,
                                   const int16_t fieldId,
                                   int8_t typeOverride);
-  uint32_t writeCollectionBegin(int8_t elemType, int32_t size);
+  uint32_t writeCollectionBegin(const TType elemType, int32_t size);
   uint32_t writeVarint32(uint32_t n);
   uint32_t writeVarint64(uint64_t n);
   uint64_t i64ToZigzag(const int64_t l);
   uint32_t i32ToZigzag(const int32_t n);
-  inline int8_t getCompactType(int8_t ttype);
+  inline int8_t getCompactType(const TType ttype);
 
  public:
   uint32_t readMessageBegin(std::string& name,
@@ -284,6 +285,6 @@
 
 }}} // apache::thrift::protocol
 
-#include "TCompactProtocol.tcc"
+#include <thrift/protocol/TCompactProtocol.tcc>
 
 #endif

=== modified file '3rdParty/libthrift/protocol/TCompactProtocol.tcc'
--- 3rdParty/libthrift/protocol/TCompactProtocol.tcc	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/protocol/TCompactProtocol.tcc	2015-02-26 01:00:39 +0000
@@ -198,16 +198,20 @@
 
   if (booleanField_.name != NULL) {
     // we haven't written the field header yet
-    wsize += writeFieldBeginInternal(booleanField_.name,
-                                     booleanField_.fieldType,
-                                     booleanField_.fieldId,
-                                     value ? detail::compact::CT_BOOLEAN_TRUE :
-                                     detail::compact::CT_BOOLEAN_FALSE);
+    wsize
+      += writeFieldBeginInternal(booleanField_.name,
+                                 booleanField_.fieldType,
+                                 booleanField_.fieldId,
+                                 static_cast<int8_t>(value
+                                                     ? detail::compact::CT_BOOLEAN_TRUE
+                                                     : detail::compact::CT_BOOLEAN_FALSE));
     booleanField_.name = NULL;
   } else {
     // we're not part of a field, so just write the value
-    wsize += writeByte(value ? detail::compact::CT_BOOLEAN_TRUE :
-                       detail::compact::CT_BOOLEAN_FALSE);
+    wsize
+      += writeByte(static_cast<int8_t>(value
+                                       ? detail::compact::CT_BOOLEAN_TRUE
+                                       : detail::compact::CT_BOOLEAN_FALSE));
   }
   return wsize;
 }
@@ -266,8 +270,15 @@
 
 template <class Transport_>
 uint32_t TCompactProtocolT<Transport_>::writeBinary(const std::string& str) {
-  uint32_t ssize = str.size();
-  uint32_t wsize = writeVarint32(ssize) + ssize;
+  if(str.size() > (std::numeric_limits<uint32_t>::max)())
+    throw TProtocolException(TProtocolException::SIZE_LIMIT);
+  uint32_t ssize = static_cast<uint32_t>(str.size());
+  uint32_t wsize = writeVarint32(ssize) ;
+  // checking ssize + wsize > uint_max, but we don't want to overflow while checking for overflows.
+  // transforming the check to ssize > uint_max - wsize
+  if(ssize > (std::numeric_limits<uint32_t>::max)() - wsize)
+    throw TProtocolException(TProtocolException::SIZE_LIMIT);
+  wsize += ssize;
   trans_->write((uint8_t*)str.data(), ssize);
   return wsize;
 }
@@ -296,7 +307,8 @@
   // check if we can use delta encoding for the field id
   if (fieldId > lastFieldId_ && fieldId - lastFieldId_ <= 15) {
     // write them together
-    wsize += writeByte((fieldId - lastFieldId_) << 4 | typeToWrite);
+    wsize += writeByte(static_cast<int8_t>((fieldId - lastFieldId_)
+                                           << 4 | typeToWrite));
   } else {
     // write them separate
     wsize += writeByte(typeToWrite);
@@ -312,11 +324,12 @@
  * the wire differ only by the type indicator.
  */
 template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::writeCollectionBegin(int8_t elemType,
+uint32_t TCompactProtocolT<Transport_>::writeCollectionBegin(const TType elemType,
                                                              int32_t size) {
   uint32_t wsize = 0;
   if (size <= 14) {
-    wsize += writeByte(size << 4 | getCompactType(elemType));
+    wsize += writeByte(static_cast<int8_t>(size
+                                           << 4 | getCompactType(elemType)));
   } else {
     wsize += writeByte(0xf0 | getCompactType(elemType));
     wsize += writeVarint32(size);
@@ -388,7 +401,7 @@
  * Given a TType value, find the appropriate detail::compact::Types value
  */
 template <class Transport_>
-int8_t TCompactProtocolT<Transport_>::getCompactType(int8_t ttype) {
+int8_t TCompactProtocolT<Transport_>::getCompactType(const TType ttype) {
   return detail::compact::TTypeToCType[ttype];
 }
 
@@ -420,7 +433,7 @@
     throw TProtocolException(TProtocolException::BAD_VERSION, "Bad protocol version");
   }
 
-  messageType = (TMessageType)((versionAndType >> TYPE_SHIFT_AMOUNT) & 0x03);
+  messageType = (TMessageType)((versionAndType >> TYPE_SHIFT_AMOUNT) & TYPE_BITS);
   rsize += readVarint32(seqid);
   rsize += readString(name);
 
@@ -641,12 +654,13 @@
   BOOST_STATIC_ASSERT(sizeof(double) == sizeof(uint64_t));
   BOOST_STATIC_ASSERT(std::numeric_limits<double>::is_iec559);
 
-  uint64_t bits;
-  uint8_t b[8];
-  trans_->readAll(b, 8);
-  bits = *(uint64_t*)b;
-  bits = letohll(bits);
-  dub = bitwise_cast<double>(bits);
+  union {
+    uint64_t bits;
+    uint8_t b[8];
+  } u;
+  trans_->readAll(u.b, 8);
+  u.bits = letohll(u.bits);
+  dub = bitwise_cast<double>(u.bits);
   return 8;
 }
 
@@ -761,7 +775,7 @@
  */
 template <class Transport_>
 int32_t TCompactProtocolT<Transport_>::zigzagToI32(uint32_t n) {
-  return (n >> 1) ^ -(n & 1);
+  return (n >> 1) ^ static_cast<uint32_t>(-static_cast<int32_t>(n & 1));
 }
 
 /**
@@ -769,7 +783,7 @@
  */
 template <class Transport_>
 int64_t TCompactProtocolT<Transport_>::zigzagToI64(uint64_t n) {
-  return (n >> 1) ^ -(n & 1);
+  return (n >> 1) ^ static_cast<uint64_t>(-static_cast<int64_t>(n & 1));
 }
 
 template <class Transport_>
@@ -801,9 +815,8 @@
     case detail::compact::CT_STRUCT:
       return T_STRUCT;
     default:
-      throw TException("don't know what type: " + type);
+      throw TException(std::string("don't know what type: ") + (char)type);
   }
-  return T_STOP;
 }
 
 }}} // apache::thrift::protocol

=== modified file '3rdParty/libthrift/protocol/TDebugProtocol.cpp'
--- 3rdParty/libthrift/protocol/TDebugProtocol.cpp	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/protocol/TDebugProtocol.cpp	2015-02-26 01:00:39 +0000
@@ -17,7 +17,7 @@
  * under the License.
  */
 
-#include "TDebugProtocol.h"
+#include <thrift/protocol/TDebugProtocol.h>
 
 #include <cassert>
 #include <cctype>
@@ -32,6 +32,7 @@
 static string byte_to_hex(const uint8_t byte) {
   char buf[3];
   int ret = std::sprintf(buf, "%02x", (int)byte);
+  THRIFT_UNUSED_VARIABLE(ret);
   assert(ret == 2);
   assert(buf[2] == '\0');
   return buf;
@@ -74,14 +75,23 @@
 }
 
 uint32_t TDebugProtocol::writePlain(const string& str) {
-  trans_->write((uint8_t*)str.data(), str.length());
-  return str.length();
+  if(str.length() > (std::numeric_limits<uint32_t>::max)())
+    throw TProtocolException(TProtocolException::SIZE_LIMIT);
+  trans_->write((uint8_t*)str.data(), static_cast<uint32_t>(str.length()));
+  return static_cast<uint32_t>(str.length());
 }
 
 uint32_t TDebugProtocol::writeIndented(const string& str) {
-  trans_->write((uint8_t*)indent_str_.data(), indent_str_.length());
-  trans_->write((uint8_t*)str.data(), str.length());
-  return indent_str_.length() + str.length();
+  if(str.length() > (std::numeric_limits<uint32_t>::max)())
+    throw TProtocolException(TProtocolException::SIZE_LIMIT);
+  if(indent_str_.length() > (std::numeric_limits<uint32_t>::max)())
+    throw TProtocolException(TProtocolException::SIZE_LIMIT);
+  uint64_t total_len = indent_str_.length() + str.length();
+  if(total_len > (std::numeric_limits<uint32_t>::max)())
+    throw TProtocolException(TProtocolException::SIZE_LIMIT);
+  trans_->write((uint8_t*)indent_str_.data(), static_cast<uint32_t>(indent_str_.length()));
+  trans_->write((uint8_t*)str.data(), static_cast<uint32_t>(str.length()));
+  return static_cast<uint32_t>(indent_str_.length() + str.length());
 }
 
 uint32_t TDebugProtocol::startItem() {

=== modified file '3rdParty/libthrift/protocol/TDebugProtocol.h'
--- 3rdParty/libthrift/protocol/TDebugProtocol.h	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/protocol/TDebugProtocol.h	2015-02-26 01:00:39 +0000
@@ -20,7 +20,7 @@
 #ifndef _THRIFT_PROTOCOL_TDEBUGPROTOCOL_H_
 #define _THRIFT_PROTOCOL_TDEBUGPROTOCOL_H_ 1
 
-#include "TVirtualProtocol.h"
+#include <thrift/protocol/TVirtualProtocol.h>
 
 #include <boost/shared_ptr.hpp>
 
@@ -171,7 +171,7 @@
 
 
 // TODO(dreiss): Move (part of) ThriftDebugString into a .cpp file and remove this.
-#include <transport/TBufferTransports.h>
+#include <thrift/transport/TBufferTransports.h>
 
 namespace apache { namespace thrift {
 

=== modified file '3rdParty/libthrift/protocol/TDenseProtocol.cpp'
--- 3rdParty/libthrift/protocol/TDenseProtocol.cpp	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/protocol/TDenseProtocol.cpp	2015-02-26 01:00:39 +0000
@@ -89,8 +89,8 @@
 
 #define __STDC_LIMIT_MACROS
 #include <stdint.h>
-#include "TDenseProtocol.h"
-#include "TReflectionLocal.h"
+#include <thrift/protocol/TDenseProtocol.h>
+#include <thrift/TReflectionLocal.h>
 
 // Leaving this on for now.  Disabling it will turn off asserts, which should
 // give a performance boost.  When we have *really* thorough test cases,
@@ -245,7 +245,7 @@
 
   while (vlq > 0) {
     assert(pos >= 0);
-    buf[pos] = (vlq | 0x80);
+    buf[pos] = static_cast<uint8_t>(vlq | 0x80);
     vlq >>= 7;
     pos--;
   }
@@ -253,8 +253,8 @@
   // Back up one step before writing.
   pos++;
 
-  trans_->write(buf+pos, sizeof(buf) - pos);
-  return sizeof(buf) - pos;
+  trans_->write(buf+pos, static_cast<uint32_t>(sizeof(buf) - pos));
+  return static_cast<uint32_t>(sizeof(buf) - pos);
 }
 
 
@@ -463,7 +463,9 @@
 }
 
 uint32_t TDenseProtocol::subWriteString(const std::string& str) {
-  uint32_t size = str.size();
+  if(str.size() > static_cast<size_t>((std::numeric_limits<int32_t>::max)()))
+    throw TProtocolException(TProtocolException::SIZE_LIMIT);
+  uint32_t size = static_cast<uint32_t>(str.size());
   uint32_t xfer = subWriteI32((int32_t)size);
   if (size > 0) {
     trans_->write((uint8_t*)str.data(), size);

=== modified file '3rdParty/libthrift/protocol/TDenseProtocol.h'
--- 3rdParty/libthrift/protocol/TDenseProtocol.h	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/protocol/TDenseProtocol.h	2015-02-26 01:00:39 +0000
@@ -20,7 +20,7 @@
 #ifndef _THRIFT_PROTOCOL_TDENSEPROTOCOL_H_
 #define _THRIFT_PROTOCOL_TDENSEPROTOCOL_H_ 1
 
-#include "TBinaryProtocol.h"
+#include <thrift/protocol/TBinaryProtocol.h>
 
 namespace apache { namespace thrift { namespace protocol {
 

=== modified file '3rdParty/libthrift/protocol/TJSONProtocol.cpp'
--- 3rdParty/libthrift/protocol/TJSONProtocol.cpp	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/protocol/TJSONProtocol.cpp	2015-02-26 01:00:39 +0000
@@ -17,12 +17,12 @@
  * under the License.
  */
 
-#include "TJSONProtocol.h"
+#include <thrift/protocol/TJSONProtocol.h>
 
 #include <math.h>
 #include <boost/lexical_cast.hpp>
-#include "TBase64Utils.h"
-#include <transport/TTransportException.h>
+#include <thrift/protocol/TBase64Utils.h>
+#include <thrift/transport/TTransportException.h>
 
 using namespace apache::thrift::transport;
 
@@ -380,7 +380,7 @@
 // Write the character ch as a JSON escape sequence ("\u00xx")
 uint32_t TJSONProtocol::writeJSONEscapeChar(uint8_t ch) {
   trans_->write((const uint8_t *)kJSONEscapePrefix.c_str(),
-                kJSONEscapePrefix.length());
+                static_cast<uint32_t>(kJSONEscapePrefix.length()));
   uint8_t outCh = hexChar(ch >> 4);
   trans_->write(&outCh, 1);
   outCh = hexChar(ch);
@@ -442,7 +442,9 @@
   trans_->write(&kJSONStringDelimiter, 1);
   uint8_t b[4];
   const uint8_t *bytes = (const uint8_t *)str.c_str();
-  uint32_t len = str.length();
+  if(str.length() > (std::numeric_limits<uint32_t>::max)())
+    throw TProtocolException(TProtocolException::SIZE_LIMIT);
+  uint32_t len = static_cast<uint32_t>(str.length());
   while (len >= 3) {
     // Encode 3 bytes at a time
     base64_encode(bytes, 3, b);
@@ -471,8 +473,10 @@
     trans_->write(&kJSONStringDelimiter, 1);
     result += 1;
   }
-  trans_->write((const uint8_t *)val.c_str(), val.length());
-  result += val.length();
+  if(val.length() > (std::numeric_limits<uint32_t>::max)())
+    throw TProtocolException(TProtocolException::SIZE_LIMIT);
+  trans_->write((const uint8_t *)val.c_str(), static_cast<uint32_t>(val.length()));
+  result += static_cast<uint32_t>(val.length());
   if (escapeNum) {
     trans_->write(&kJSONStringDelimiter, 1);
     result += 1;
@@ -512,8 +516,10 @@
     trans_->write(&kJSONStringDelimiter, 1);
     result += 1;
   }
-  trans_->write((const uint8_t *)val.c_str(), val.length());
-  result += val.length();
+  if(val.length() > (std::numeric_limits<uint32_t>::max)())
+    throw TProtocolException(TProtocolException::SIZE_LIMIT);
+  trans_->write((const uint8_t *)val.c_str(), static_cast<uint32_t>(val.length()));
+  result += static_cast<uint32_t>(val.length());
   if (escapeNum) {
     trans_->write(&kJSONStringDelimiter, 1);
     result += 1;
@@ -721,7 +727,9 @@
   std::string tmp;
   uint32_t result = readJSONString(tmp);
   uint8_t *b = (uint8_t *)tmp.c_str();
-  uint32_t len = tmp.length();
+  if(tmp.length() > (std::numeric_limits<uint32_t>::max)())
+    throw TProtocolException(TProtocolException::SIZE_LIMIT);
+  uint32_t len = static_cast<uint32_t>(tmp.length());
   str.clear();
   while (len >= 4) {
     base64_decode(b, 4);
@@ -869,7 +877,9 @@
   result += readJSONInteger(tmpVal);
   messageType = (TMessageType)tmpVal;
   result += readJSONInteger(tmpVal);
-  seqid = tmpVal;
+  if(tmpVal > static_cast<uint64_t>((std::numeric_limits<int32_t>::max)()))
+    throw TProtocolException(TProtocolException::SIZE_LIMIT);
+  seqid = static_cast<int32_t>(tmpVal);
   return result;
 }
 
@@ -900,7 +910,9 @@
     uint64_t tmpVal = 0;
     std::string tmpStr;
     result += readJSONInteger(tmpVal);
-    fieldId = tmpVal;
+    if(tmpVal > static_cast<uint32_t>((std::numeric_limits<int16_t>::max)()))
+      throw TProtocolException(TProtocolException::SIZE_LIMIT);
+    fieldId = static_cast<int16_t>(tmpVal);
     result += readJSONObjectStart();
     result += readJSONString(tmpStr);
     fieldType = getTypeIDForTypeName(tmpStr);
@@ -923,7 +935,9 @@
   result += readJSONString(tmpStr);
   valType = getTypeIDForTypeName(tmpStr);
   result += readJSONInteger(tmpVal);
-  size = tmpVal;
+  if(tmpVal > (std::numeric_limits<uint32_t>::max)())
+    throw TProtocolException(TProtocolException::SIZE_LIMIT);
+  size = static_cast<uint32_t>(tmpVal);
   result += readJSONObjectStart();
   return result;
 }
@@ -940,7 +954,9 @@
   result += readJSONString(tmpStr);
   elemType = getTypeIDForTypeName(tmpStr);
   result += readJSONInteger(tmpVal);
-  size = tmpVal;
+  if(tmpVal > (std::numeric_limits<uint32_t>::max)())
+    throw TProtocolException(TProtocolException::SIZE_LIMIT);
+  size = static_cast<uint32_t>(tmpVal);
   return result;
 }
 
@@ -956,7 +972,9 @@
   result += readJSONString(tmpStr);
   elemType = getTypeIDForTypeName(tmpStr);
   result += readJSONInteger(tmpVal);
-  size = tmpVal;
+  if(tmpVal > (std::numeric_limits<uint32_t>::max)())
+    throw TProtocolException(TProtocolException::SIZE_LIMIT);
+  size = static_cast<uint32_t>(tmpVal);
   return result;
 }
 

=== modified file '3rdParty/libthrift/protocol/TJSONProtocol.h'
--- 3rdParty/libthrift/protocol/TJSONProtocol.h	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/protocol/TJSONProtocol.h	2015-02-26 01:00:39 +0000
@@ -20,7 +20,7 @@
 #ifndef _THRIFT_PROTOCOL_TJSONPROTOCOL_H_
 #define _THRIFT_PROTOCOL_TJSONPROTOCOL_H_ 1
 
-#include "TVirtualProtocol.h"
+#include <thrift/protocol/TVirtualProtocol.h>
 
 #include <stack>
 
@@ -314,7 +314,7 @@
 
 
 // TODO(dreiss): Move part of ThriftJSONString into a .cpp file and remove this.
-#include <transport/TBufferTransports.h>
+#include <thrift/transport/TBufferTransports.h>
 
 namespace apache { namespace thrift {
 

=== added file '3rdParty/libthrift/protocol/TMultiplexedProtocol.cpp'
--- 3rdParty/libthrift/protocol/TMultiplexedProtocol.cpp	1970-01-01 00:00:00 +0000
+++ 3rdParty/libthrift/protocol/TMultiplexedProtocol.cpp	2015-02-26 01:00:39 +0000
@@ -0,0 +1,47 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include <thrift/protocol/TMultiplexedProtocol.h>
+#include <thrift/processor/TMultiplexedProcessor.h>
+#include <thrift/protocol/TProtocolDecorator.h>
+
+namespace apache
+{
+    namespace thrift
+    {
+        namespace protocol
+        {
+            uint32_t TMultiplexedProtocol::writeMessageBegin_virt(
+                const std::string& _name,
+                const TMessageType _type,
+                const int32_t _seqid)
+            {
+                if( _type == T_CALL || _type == T_ONEWAY )
+                {
+                    return TProtocolDecorator::writeMessageBegin_virt( serviceName + separator + _name, _type, _seqid );
+                }
+                else
+                {
+                    return TProtocolDecorator::writeMessageBegin_virt(_name, _type, _seqid);
+                }
+            }
+        }
+    }
+}
+

=== added file '3rdParty/libthrift/protocol/TMultiplexedProtocol.h'
--- 3rdParty/libthrift/protocol/TMultiplexedProtocol.h	1970-01-01 00:00:00 +0000
+++ 3rdParty/libthrift/protocol/TMultiplexedProtocol.h	2015-02-26 01:00:39 +0000
@@ -0,0 +1,103 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#ifndef THRIFT_TMULTIPLEXEDPROTOCOL_H_
+#define THRIFT_TMULTIPLEXEDPROTOCOL_H_ 1
+
+#include <thrift/protocol/TProtocolDecorator.h>
+
+namespace apache
+{
+    namespace thrift
+    {
+        namespace protocol
+        {
+            using boost::shared_ptr;
+
+            /**
+             * <code>TMultiplexedProtocol</code> is a protocol-independent concrete decorator
+             * that allows a Thrift client to communicate with a multiplexing Thrift server,
+             * by prepending the service name to the function name during function calls.
+             *
+             * \note THIS IS NOT USED BY SERVERS.  On the server, use
+             * {@link apache::thrift::TMultiplexedProcessor TMultiplexedProcessor} to handle requests
+             * from a multiplexing client.
+             *
+             * This example uses a single socket transport to invoke two services:
+             *
+             * <blockquote><code>
+             *     shared_ptr<TSocket> transport(new TSocket("localhost", 9090));
+             *     transport->open();
+             *
+             *     shared_ptr<TBinaryProtocol> protocol(new TBinaryProtocol(transport));
+             *
+             *     shared_ptr<TMultiplexedProtocol> mp1(new TMultiplexedProtocol(protocol, "Calculator"));
+             *     shared_ptr<CalculatorClient> service1(new CalculatorClient(mp1));
+             *
+             *     shared_ptr<TMultiplexedProtocol> mp2(new TMultiplexedProtocol(protocol, "WeatherReport"));
+             *     shared_ptr<WeatherReportClient> service2(new WeatherReportClient(mp2));
+             *
+             *     service1->add(2,2);
+             *     int temp = service2->getTemperature();
+             * </code></blockquote>
+             *
+             * @see apache::thrift::protocol::TProtocolDecorator
+             */
+             class TMultiplexedProtocol : public TProtocolDecorator
+            {
+            public:
+                /**
+                 * Wrap the specified protocol, allowing it to be used to communicate with a
+                 * multiplexing server.  The <code>serviceName</code> is required as it is
+                 * prepended to the message header so that the multiplexing server can broker
+                 * the function call to the proper service.
+                 *
+                 * \param _protocol    Your communication protocol of choice, e.g. <code>TBinaryProtocol</code>.
+                 * \param _serviceName The service name of the service communicating via this protocol.
+                 */
+                 TMultiplexedProtocol( shared_ptr<TProtocol> _protocol, const std::string& _serviceName )
+                    : TProtocolDecorator(_protocol),
+                      serviceName(_serviceName),
+                      separator(":")
+                { }
+                virtual ~TMultiplexedProtocol() {}
+
+                /**
+                 * Prepends the service name to the function name, separated by TMultiplexedProtocol::SEPARATOR.
+                 *
+                 * \param [in] _name   The name of the method to be called in the service.
+                 * \param [in] _type   The type of message
+                 * \param [in] _name   The sequential id of the message
+                 *
+                 * \throws TException  Passed through from wrapped <code>TProtocol</code> instance.
+                 */
+                uint32_t writeMessageBegin_virt(
+                    const std::string& _name,
+                    const TMessageType _type,
+                    const int32_t _seqid);
+            private:
+                const std::string serviceName;
+                const std::string separator;
+            };
+
+        }
+    }
+}
+
+#endif // THRIFT_TMULTIPLEXEDPROTOCOL_H_

=== modified file '3rdParty/libthrift/protocol/TProtocol.h'
--- 3rdParty/libthrift/protocol/TProtocol.h	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/protocol/TProtocol.h	2015-02-26 01:00:39 +0000
@@ -75,10 +75,6 @@
 }
 
 
-namespace apache { namespace thrift { namespace protocol {
-
-using apache::thrift::transport::TTransport;
-
 #ifdef HAVE_SYS_PARAM_H
 #include <sys/param.h>
 #endif
@@ -129,14 +125,21 @@
 #  include <byteswap.h>
 #  define ntohll(n) bswap_64(n)
 #  define htonll(n) bswap_64(n)
-# else /* GNUC & GLIBC */
-#  define ntohll(n) ( (((uint64_t)ntohl(n)) << 32) + ntohl(n >> 32) )
-#  define htonll(n) ( (((uint64_t)htonl(n)) << 32) + htonl(n >> 32) )
-# endif /* GNUC & GLIBC */
+# elif defined(_MSC_VER) /* Microsoft Visual C++ */
+#  define ntohll(n) ( _byteswap_uint64((uint64_t)n) )
+#  define htonll(n) ( _byteswap_uint64((uint64_t)n) )
+# else /* Not GNUC/GLIBC or MSVC */
+#  define ntohll(n) ( (((uint64_t)ntohl((uint32_t)n)) << 32) + ntohl((uint32_t)(n >> 32)) )
+#  define htonll(n) ( (((uint64_t)htonl((uint32_t)n)) << 32) + htonl((uint32_t)(n >> 32)) )
+# endif /* GNUC/GLIBC or MSVC or something else */
 #else /* __THRIFT_BYTE_ORDER */
 # error "Can't define htonll or ntohll!"
 #endif
 
+namespace apache { namespace thrift { namespace protocol {
+
+using apache::thrift::transport::TTransport;
+
 /**
  * Enumerated definition of the types that the Thrift protocol supports.
  * Take special note of the T_END type which is used specifically to mark
@@ -280,6 +283,8 @@
   return 0;
 }
 
+static const uint32_t DEFAULT_RECURSION_LIMIT = 64;
+
 /**
  * Abstract class for a thrift protocol driver. These are all the methods that
  * a protocol must implement. Essentially, there must be some way of reading
@@ -657,15 +662,28 @@
     return ptrans_;
   }
 
+  void incrementRecursionDepth() {
+    if (recursion_limit_ < ++recursion_depth_) {
+      throw TProtocolException(TProtocolException::DEPTH_LIMIT);
+    }
+  }
+
+  void decrementRecursionDepth() {
+    --recursion_depth_;
+  }
+
  protected:
-  TProtocol(boost::shared_ptr<TTransport> ptrans):
-    ptrans_(ptrans) {
-  }
+  TProtocol(boost::shared_ptr<TTransport> ptrans)
+    : ptrans_(ptrans)
+    , recursion_depth_(0)
+    , recursion_limit_(DEFAULT_RECURSION_LIMIT) {}
 
   boost::shared_ptr<TTransport> ptrans_;
 
  private:
   TProtocol() {}
+  uint32_t recursion_depth_;
+  uint32_t recursion_limit_;
 };
 
 /**

=== added file '3rdParty/libthrift/protocol/TProtocolDecorator.h'
--- 3rdParty/libthrift/protocol/TProtocolDecorator.h	1970-01-01 00:00:00 +0000
+++ 3rdParty/libthrift/protocol/TProtocolDecorator.h	2015-02-26 01:00:39 +0000
@@ -0,0 +1,133 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#ifndef THRIFT_TPROTOCOLDECORATOR_H_
+#define THRIFT_TPROTOCOLDECORATOR_H_ 1
+
+#include <thrift/protocol/TProtocol.h>
+#include <boost/shared_ptr.hpp>
+
+namespace apache
+{
+    namespace thrift
+    {
+        namespace protocol
+        {
+            using boost::shared_ptr;
+
+            /**
+             * <code>TProtocolDecorator</code> forwards all requests to an enclosed
+             * <code>TProtocol</code> instance, providing a way to author concise
+             * concrete decorator subclasses.
+             *
+             * <p>See p.175 of Design Patterns (by Gamma et al.)</p>
+             *
+             * @see apache::thrift::protocol::TMultiplexedProtocol
+             */
+            class TProtocolDecorator : public TProtocol
+            {
+            public:
+                virtual ~TProtocolDecorator() {}
+
+                // Desc: Initializes the protocol decorator object.
+                TProtocolDecorator( shared_ptr<TProtocol> proto )
+                    : TProtocol(proto->getTransport()), protocol(proto)
+                {
+                }
+
+                virtual uint32_t writeMessageBegin_virt(
+                    const std::string& name,
+                    const TMessageType messageType,
+                    const int32_t seqid)
+                {
+                    return protocol->writeMessageBegin(name, messageType, seqid);
+                }
+                virtual uint32_t writeMessageEnd_virt() { return protocol->writeMessageEnd(); }
+                virtual uint32_t writeStructBegin_virt(const char* name) { return protocol->writeStructBegin(name); }
+                virtual uint32_t writeStructEnd_virt() { return protocol->writeStructEnd(); }
+
+                virtual uint32_t writeFieldBegin_virt(const char* name,
+                    const TType fieldType,
+                    const int16_t fieldId) { return protocol->writeFieldBegin(name,fieldType,fieldId); }
+
+                virtual uint32_t writeFieldEnd_virt()  { return protocol->writeFieldEnd(); }
+                virtual uint32_t writeFieldStop_virt() { return protocol->writeFieldStop(); }
+
+                virtual uint32_t writeMapBegin_virt(const TType keyType,
+                    const TType valType,
+                    const uint32_t size) { return protocol->writeMapBegin(keyType,valType,size); }
+
+                virtual uint32_t writeMapEnd_virt() { return protocol->writeMapEnd(); }
+
+                virtual uint32_t writeListBegin_virt(const TType elemType, const uint32_t size) { return protocol->writeListBegin(elemType,size); }
+                virtual uint32_t writeListEnd_virt() { return protocol->writeListEnd(); }
+
+                virtual uint32_t writeSetBegin_virt(const TType elemType, const uint32_t size) { return protocol->writeSetBegin(elemType,size); }
+                virtual uint32_t writeSetEnd_virt() { return protocol->writeSetEnd(); }
+
+                virtual uint32_t writeBool_virt(const bool value)  { return protocol->writeBool(value); }
+                virtual uint32_t writeByte_virt(const int8_t byte) { return protocol->writeByte(byte); }
+                virtual uint32_t writeI16_virt(const int16_t i16)  { return protocol->writeI16(i16); }
+                virtual uint32_t writeI32_virt(const int32_t i32)  { return protocol->writeI32(i32); }
+                virtual uint32_t writeI64_virt(const int64_t i64)  { return protocol->writeI64(i64); }
+
+                virtual uint32_t writeDouble_virt(const double dub) { return protocol->writeDouble(dub); }
+                virtual uint32_t writeString_virt(const std::string& str) { return protocol->writeString(str); }
+                virtual uint32_t writeBinary_virt(const std::string& str) { return protocol->writeBinary(str); }
+
+                virtual uint32_t readMessageBegin_virt(std::string& name, TMessageType& messageType, int32_t& seqid) { return protocol->readMessageBegin(name,messageType,seqid); }
+                virtual uint32_t readMessageEnd_virt() { return protocol->readMessageEnd(); }
+
+                virtual uint32_t readStructBegin_virt(std::string& name) { return protocol->readStructBegin(name); }
+                virtual uint32_t readStructEnd_virt() { return protocol->readStructEnd(); }
+
+                virtual uint32_t readFieldBegin_virt(std::string& name, TType& fieldType, int16_t& fieldId) { return protocol->readFieldBegin(name, fieldType, fieldId); }
+                virtual uint32_t readFieldEnd_virt() { return protocol->readFieldEnd(); }
+
+                virtual uint32_t readMapBegin_virt(TType& keyType, TType& valType, uint32_t& size) { return protocol->readMapBegin(keyType,valType,size); }
+                virtual uint32_t readMapEnd_virt() { return protocol->readMapEnd(); }
+
+                virtual uint32_t readListBegin_virt(TType& elemType, uint32_t& size) { return protocol->readListBegin(elemType,size); }
+                virtual uint32_t readListEnd_virt() { return protocol->readListEnd(); }
+
+                virtual uint32_t readSetBegin_virt(TType& elemType, uint32_t& size) { return protocol->readSetBegin(elemType,size); }
+                virtual uint32_t readSetEnd_virt() { return protocol->readSetEnd(); }
+
+                virtual uint32_t readBool_virt(bool& value) { return protocol->readBool(value); }
+                virtual uint32_t readBool_virt(std::vector<bool>::reference value) { return protocol->readBool(value); }
+
+                virtual uint32_t readByte_virt(int8_t& byte) { return protocol->readByte(byte); }
+
+                virtual uint32_t readI16_virt(int16_t& i16) { return protocol->readI16(i16); }
+                virtual uint32_t readI32_virt(int32_t& i32) { return protocol->readI32(i32); }
+                virtual uint32_t readI64_virt(int64_t& i64) { return protocol->readI64(i64); }
+
+                virtual uint32_t readDouble_virt(double& dub) { return protocol->readDouble(dub); }
+
+                virtual uint32_t readString_virt(std::string& str) { return protocol->readString(str); }
+                virtual uint32_t readBinary_virt(std::string& str) { return protocol->readBinary(str); }
+
+            private:
+                shared_ptr<TProtocol> protocol;
+            };
+        }
+    }
+}
+
+#endif // THRIFT_TPROTOCOLDECORATOR_H_

=== modified file '3rdParty/libthrift/protocol/TProtocolException.h'
--- 3rdParty/libthrift/protocol/TProtocolException.h	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/protocol/TProtocolException.h	2015-02-26 01:00:39 +0000
@@ -45,6 +45,7 @@
   , SIZE_LIMIT = 3
   , BAD_VERSION = 4
   , NOT_IMPLEMENTED = 5
+  , DEPTH_LIMIT = 6
   };
 
   TProtocolException() :

=== modified file '3rdParty/libthrift/protocol/TProtocolTap.h'
--- 3rdParty/libthrift/protocol/TProtocolTap.h	2013-11-21 23:30:15 +0000
+++ 3rdParty/libthrift/protocol/TProtocolTap.h	2015-02-26 01:00:39 +0000
@@ -20,7 +20,7 @@
 #ifndef _THRIFT_PROTOCOL_TPROTOCOLTAP_H_
 #define _THRIFT_PROTOCOL_TPROTOCOLTAP_H_ 1
 
-#include <protocol/TVirtualProtocol.h>
+#include <thrift/protocol/TVirtualProtocol.h>
 
 namespace apache { namespace thrift { namespace protocol {
 

=== added directory '3rdParty/libthrift/qt'
=== added file '3rdParty/libthrift/qt/TQIODeviceTransport.cpp'
--- 3rdParty/libthrift/qt/TQIODeviceTransport.cpp	1970-01-01 00:00:00 +0000
+++ 3rdParty/libthrift/qt/TQIODeviceTransport.cpp	2015-02-26 01:00:39 +0000
@@ -0,0 +1,179 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include <thrift/qt/TQIODeviceTransport.h>
+
+#include <QAbstractSocket>
+#include <QIODevice>
+
+#include <thrift/transport/TBufferTransports.h>
+
+using boost::shared_ptr;
+
+namespace apache { namespace thrift { namespace transport {
+
+TQIODeviceTransport::TQIODeviceTransport(shared_ptr<QIODevice> dev)
+  : dev_(dev)
+{
+}
+
+TQIODeviceTransport::~TQIODeviceTransport()
+{
+  dev_->close();
+}
+
+void TQIODeviceTransport::open()
+{
+  if (!isOpen()) {
+    throw TTransportException(TTransportException::NOT_OPEN,
+                              "open(): underlying QIODevice isn't open");
+  }
+}
+
+bool TQIODeviceTransport::isOpen()
+{
+  return dev_->isOpen();
+}
+
+bool TQIODeviceTransport::peek()
+{
+  return dev_->bytesAvailable() > 0;
+}
+
+void TQIODeviceTransport::close()
+{
+  dev_->close();
+}
+
+uint32_t TQIODeviceTransport::readAll(uint8_t* buf, uint32_t len)
+{
+  uint32_t requestLen = len;
+  while (len) {
+    uint32_t readSize;
+    try {
+      readSize = read(buf, len);
+    } catch (...) {
+      if (len != requestLen) {
+        // something read already
+        return requestLen - len;
+      }
+      // error but nothing read yet
+      throw;
+    }
+    if (readSize == 0) {
+      dev_->waitForReadyRead(50);
+    } else {
+      buf += readSize;
+      len -= readSize;
+    }
+  }
+  return requestLen;
+}
+
+uint32_t TQIODeviceTransport::read(uint8_t* buf, uint32_t len)
+{
+  uint32_t actualSize;
+  qint64 readSize;
+
+  if (!dev_->isOpen()) {
+    throw TTransportException(TTransportException::NOT_OPEN,
+                              "read(): underlying QIODevice is not open");
+  }
+
+  actualSize = (uint32_t)std::min((qint64)len, dev_->bytesAvailable());
+  readSize = dev_->read(reinterpret_cast<char *>(buf), actualSize);
+
+  if (readSize < 0) {
+    QAbstractSocket* socket;
+    if ((socket = qobject_cast<QAbstractSocket* >(dev_.get()))) {
+      throw TTransportException(TTransportException::UNKNOWN,
+                                "Failed to read() from QAbstractSocket",
+                                socket->error());
+    }
+    throw TTransportException(TTransportException::UNKNOWN,
+                              "Failed to read from from QIODevice");
+  }
+
+  return (uint32_t)readSize;
+}
+
+void TQIODeviceTransport::write(const uint8_t* buf, uint32_t len)
+{
+  while (len) {
+    uint32_t written = write_partial(buf, len);
+    len -= written;
+    dev_->waitForBytesWritten(50);
+  }
+}
+
+uint32_t TQIODeviceTransport::write_partial(const uint8_t* buf, uint32_t len)
+{
+  qint64 written;
+
+  if (!dev_->isOpen()) {
+    throw TTransportException(TTransportException::NOT_OPEN,
+                              "write_partial(): underlying QIODevice is not open");
+  }
+
+  written = dev_->write(reinterpret_cast<const char*>(buf), len);
+  if (written < 0) {
+    QAbstractSocket* socket;
+    if ((socket = qobject_cast<QAbstractSocket*>(dev_.get()))) {
+      throw TTransportException(TTransportException::UNKNOWN,
+                                "write_partial(): failed to write to QAbstractSocket", socket->error());
+    }
+
+    throw TTransportException(TTransportException::UNKNOWN,
+                              "write_partial(): failed to write to underlying QIODevice");
+  }
+
+  return (uint32_t)written;
+}
+
+void TQIODeviceTransport::flush()
+{
+  if (!dev_->isOpen()) {
+    throw TTransportException(TTransportException::NOT_OPEN,
+                              "flush(): underlying QIODevice is not open");
+  }
+
+  QAbstractSocket* socket;
+
+  if ((socket = qobject_cast<QAbstractSocket*>(dev_.get()))) {
+    socket->flush();
+  } else {
+    dev_->waitForBytesWritten(1);
+  }
+}
+
+uint8_t* TQIODeviceTransport::borrow(uint8_t* buf, uint32_t* len)
+{
+  (void) buf;
+  (void) len;
+  return NULL;
+}
+
+void TQIODeviceTransport::consume(uint32_t len)
+{
+  (void) len;
+  throw TTransportException(TTransportException::UNKNOWN);
+}
+
+}}} // apache::thrift::transport
+

=== added file '3rdParty/libthrift/qt/TQIODeviceTransport.h'
--- 3rdParty/libthrift/qt/TQIODeviceTransport.h	1970-01-01 00:00:00 +0000
+++ 3rdParty/libthrift/qt/TQIODeviceTransport.h	2015-02-26 01:00:39 +0000
@@ -0,0 +1,64 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#ifndef _THRIFT_ASYNC_TQIODEVICE_TRANSPORT_H_
+#define _THRIFT_ASYNC_TQIODEVICE_TRANSPORT_H_ 1
+
+#include <boost/shared_ptr.hpp>
+
+#include <thrift/transport/TVirtualTransport.h>
+
+class QIODevice;
+
+namespace apache { namespace thrift { namespace transport {
+
+/**
+ *  Transport that operates on a QIODevice (socket, file, etc).
+ */
+class TQIODeviceTransport : public apache::thrift::transport::TVirtualTransport<TQIODeviceTransport> {
+ public:
+  explicit TQIODeviceTransport(boost::shared_ptr<QIODevice> dev);
+  virtual ~TQIODeviceTransport();
+
+  void open();
+  bool isOpen();
+  bool peek();
+  void close();
+
+  uint32_t readAll(uint8_t *buf, uint32_t len);
+  uint32_t read(uint8_t* buf, uint32_t len);
+
+  void write(const uint8_t* buf, uint32_t len);
+  uint32_t write_partial(const uint8_t* buf, uint32_t len);
+
+  void flush();
+
+  uint8_t* borrow(uint8_t* buf, uint32_t* len);
+  void consume(uint32_t len);
+
+ private:
+   TQIODeviceTransport(const TQIODeviceTransport&);
+   TQIODeviceTransport& operator=(const TQIODeviceTransport&);
+
+   boost::shared_ptr<QIODevice> dev_;
+};
+}}} // apache::thrift::transport
+
+#endif // #ifndef _THRIFT_ASYNC_TQIODEVICE_TRANSPORT_H_
+

=== added file '3rdParty/libthrift/qt/TQTcpServer.cpp'
--- 3rdParty/libthrift/qt/TQTcpServer.cpp	1970-01-01 00:00:00 +0000
+++ 3rdParty/libthrift/qt/TQTcpServer.cpp	2015-02-26 01:00:39 +0000
@@ -0,0 +1,157 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include <thrift/qt/TQTcpServer.h>
+#include <thrift/qt/TQIODeviceTransport.h>
+
+#include <QTcpSocket>
+
+#include <thrift/cxxfunctional.h>
+
+#include <thrift/protocol/TProtocol.h>
+#include <thrift/async/TAsyncProcessor.h>
+
+using boost::shared_ptr;
+using apache::thrift::protocol::TProtocol;
+using apache::thrift::protocol::TProtocolFactory;
+using apache::thrift::transport::TTransport;
+using apache::thrift::transport::TTransportException;
+using apache::thrift::transport::TQIODeviceTransport;
+using apache::thrift::stdcxx::function;
+using apache::thrift::stdcxx::bind;
+
+QT_USE_NAMESPACE
+
+namespace apache { namespace thrift { namespace async {
+
+struct TQTcpServer::ConnectionContext {
+  shared_ptr<QTcpSocket> connection_;
+  shared_ptr<TTransport> transport_;
+  shared_ptr<TProtocol> iprot_;
+  shared_ptr<TProtocol> oprot_;
+
+  explicit ConnectionContext(shared_ptr<QTcpSocket> connection,
+                             shared_ptr<TTransport> transport,
+                             shared_ptr<TProtocol> iprot,
+                             shared_ptr<TProtocol> oprot)
+    : connection_(connection)
+    , transport_(transport)
+    , iprot_(iprot)
+    , oprot_(oprot)
+  {}
+};
+
+TQTcpServer::TQTcpServer(shared_ptr<QTcpServer> server,
+                         shared_ptr<TAsyncProcessor> processor,
+                         shared_ptr<TProtocolFactory> pfact,
+                         QObject* parent)
+  : QObject(parent)
+  , server_(server)
+  , processor_(processor)
+  , pfact_(pfact)
+{
+  connect(server.get(), SIGNAL(newConnection()), SLOT(processIncoming()));
+}
+
+TQTcpServer::~TQTcpServer()
+{
+}
+
+void TQTcpServer::processIncoming()
+{
+  while (server_->hasPendingConnections()) {
+    // take ownership of the QTcpSocket; technically it could be deleted
+    // when the QTcpServer is destroyed, but any real app should delete this
+    // class before deleting the QTcpServer that we are using
+    shared_ptr<QTcpSocket> connection(server_->nextPendingConnection());
+
+    shared_ptr<TTransport> transport;
+    shared_ptr<TProtocol> iprot;
+    shared_ptr<TProtocol> oprot;
+
+    try {
+      transport = shared_ptr<TTransport>(new TQIODeviceTransport(connection));
+      iprot = shared_ptr<TProtocol>(pfact_->getProtocol(transport));
+      oprot = shared_ptr<TProtocol>(pfact_->getProtocol(transport));
+    } catch(...) {
+      qWarning("[TQTcpServer] Failed to initialize transports/protocols");
+      continue;
+    }
+
+    ctxMap_[connection.get()] =
+      shared_ptr<ConnectionContext>(
+         new ConnectionContext(connection, transport, iprot, oprot));
+
+    connect(connection.get(), SIGNAL(readyRead()), SLOT(beginDecode()));
+
+    // need to use QueuedConnection since we will be deleting the socket in the slot
+    connect(connection.get(), SIGNAL(disconnected()), SLOT(socketClosed()),
+            Qt::QueuedConnection);
+  }
+}
+
+void TQTcpServer::beginDecode()
+{
+  QTcpSocket* connection(qobject_cast<QTcpSocket*>(sender()));
+  Q_ASSERT(connection);
+
+  if (ctxMap_.find(connection) == ctxMap_.end()) {
+    qWarning("[TQTcpServer] Got data on an unknown QTcpSocket");
+    return;
+  }
+
+  shared_ptr<ConnectionContext> ctx = ctxMap_[connection];
+
+  try {
+    processor_->process(
+      bind(&TQTcpServer::finish, this,
+           ctx, apache::thrift::stdcxx::placeholders::_1),
+      ctx->iprot_, ctx->oprot_);
+  } catch(const TTransportException& ex) {
+    qWarning("[TQTcpServer] TTransportException during processing: '%s'",
+             ex.what());
+    ctxMap_.erase(connection);
+  } catch(...) {
+    qWarning("[TQTcpServer] Unknown processor exception");
+    ctxMap_.erase(connection);
+  }
+}
+
+void TQTcpServer::socketClosed()
+{
+  QTcpSocket* connection(qobject_cast<QTcpSocket*>(sender()));
+  Q_ASSERT(connection);
+
+  if (ctxMap_.find(connection) == ctxMap_.end()) {
+    qWarning("[TQTcpServer] Unknown QTcpSocket closed");
+    return;
+  }
+
+  ctxMap_.erase(connection);
+}
+
+void TQTcpServer::finish(shared_ptr<ConnectionContext> ctx, bool healthy)
+{
+  if (!healthy) {
+    qWarning("[TQTcpServer] Processor failed to process data successfully");
+    ctxMap_.erase(ctx->connection_.get());
+  }
+}
+
+}}} // apache::thrift::async

=== added file '3rdParty/libthrift/qt/TQTcpServer.h'
--- 3rdParty/libthrift/qt/TQTcpServer.h	1970-01-01 00:00:00 +0000
+++ 3rdParty/libthrift/qt/TQTcpServer.h	2015-02-26 01:00:39 +0000
@@ -0,0 +1,72 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations