diff --git a/compiler/cpp/src/thrift/generate/t_cpp_generator.cc b/compiler/cpp/src/thrift/generate/t_cpp_generator.cc
index 0839302..cf30363 100644
--- a/compiler/cpp/src/thrift/generate/t_cpp_generator.cc
+++ b/compiler/cpp/src/thrift/generate/t_cpp_generator.cc
@@ -419,7 +419,8 @@
            << "#include <thrift/transport/TTransport.h>" << endl
            << endl;
   // Include C++xx compatibility header
-  f_types_ << "#include <thrift/stdcxx.h>" << endl;
+  f_types_ << "#include <functional>" << endl;
+  f_types_ << "#include <memory>" << endl;
 
   // Include other Thrift includes
   const vector<t_program*>& includes = program_->get_includes();
@@ -1119,7 +1120,7 @@
       continue;
     }
     if (is_reference((*m_iter))) {
-      out << endl << indent() << "void __set_" << (*m_iter)->get_name() << "(::apache::thrift::stdcxx::shared_ptr<"
+      out << endl << indent() << "void __set_" << (*m_iter)->get_name() << "(::std::shared_ptr<"
           << type_name((*m_iter)->get_type(), false, false) << ">";
       out << " val);" << endl;
     } else {
@@ -1239,7 +1240,7 @@
       if (is_reference((*m_iter))) {
         std::string type = type_name((*m_iter)->get_type());
         out << endl << indent() << "void " << tstruct->get_name() << "::__set_"
-            << (*m_iter)->get_name() << "(::apache::thrift::stdcxx::shared_ptr<"
+            << (*m_iter)->get_name() << "(::std::shared_ptr<"
             << type_name((*m_iter)->get_type(), false, false) << ">";
         out << " val) {" << endl;
       } else {
@@ -1717,8 +1718,9 @@
   f_header_ << "#ifndef " << svcname << "_H" << endl << "#define " << svcname << "_H" << endl
             << endl;
   if (gen_cob_style_) {
-    f_header_ << "#include <thrift/transport/TBufferTransports.h>" << endl << // TMemoryBuffer
-        "#include <thrift/stdcxx.h>" << endl
+    f_header_ << "#include <thrift/transport/TBufferTransports.h>" << endl // TMemoryBuffer
+              << "#include <functional>" << endl 
+              << "#include <memory>" << endl
               << "namespace apache { namespace thrift { namespace async {" << endl
               << "class TAsyncChannel;" << endl << "}}}" << endl;
   }
@@ -1968,7 +1970,7 @@
   f_header_ << "class " << singleton_factory_name << " : virtual public " << factory_name << " {"
             << endl << " public:" << endl;
   indent_up();
-  f_header_ << indent() << singleton_factory_name << "(const ::apache::thrift::stdcxx::shared_ptr<" << service_if_name
+  f_header_ << indent() << singleton_factory_name << "(const ::std::shared_ptr<" << service_if_name
             << ">& iface) : iface_(iface) {}" << endl << indent() << "virtual ~"
             << singleton_factory_name << "() {}" << endl << endl << indent() << "virtual "
             << service_if_name << "* getHandler("
@@ -1976,7 +1978,7 @@
             << "  return iface_.get();" << endl << indent() << "}" << endl << indent()
             << "virtual void releaseHandler(" << base_if_name << "* /* handler */) {}" << endl;
 
-  f_header_ << endl << " protected:" << endl << indent() << "::apache::thrift::stdcxx::shared_ptr<" << service_if_name
+  f_header_ << endl << " protected:" << endl << indent() << "::std::shared_ptr<" << service_if_name
             << "> iface_;" << endl;
 
   indent_down();
@@ -2146,7 +2148,7 @@
     extends_multiface = ", public " + extends + "Multiface";
   }
 
-  string list_type = string("std::vector<apache::thrift::stdcxx::shared_ptr<") + service_name_ + "If> >";
+  string list_type = string("std::vector<std::shared_ptr<") + service_name_ + "If> >";
 
   // Generate the header portion
   f_header_ << "class " << service_name_ << "Multiface : "
@@ -2157,7 +2159,7 @@
             << "& ifaces) : ifaces_(ifaces) {" << endl;
   if (!extends.empty()) {
     f_header_ << indent()
-              << "  std::vector<apache::thrift::stdcxx::shared_ptr<" + service_name_ + "If> >::iterator iter;"
+              << "  std::vector<std::shared_ptr<" + service_name_ + "If> >::iterator iter;"
               << endl << indent() << "  for (iter = ifaces.begin(); iter != ifaces.end(); ++iter) {"
               << endl << indent() << "    " << extends << "Multiface::add(*iter);" << endl
               << indent() << "  }" << endl;
@@ -2170,7 +2172,7 @@
   f_header_ << " protected:" << endl;
   indent_up();
   f_header_ << indent() << list_type << " ifaces_;" << endl << indent() << service_name_
-            << "Multiface() {}" << endl << indent() << "void add(::apache::thrift::stdcxx::shared_ptr<"
+            << "Multiface() {}" << endl << indent() << "void add(::std::shared_ptr<"
             << service_name_ << "If> iface) {" << endl;
   if (!extends.empty()) {
     f_header_ << indent() << "  " << extends << "Multiface::add(iface);" << endl;
@@ -2252,7 +2254,7 @@
   } else {
     protocol_type = "::apache::thrift::protocol::TProtocol";
   }
-  string prot_ptr = "apache::thrift::stdcxx::shared_ptr< " + protocol_type + ">";
+  string prot_ptr = "std::shared_ptr< " + protocol_type + ">";
   string client_suffix = "Client" + template_suffix;
   string if_suffix = "If";
   if (style == "Cob") {
@@ -2329,18 +2331,18 @@
     // Note that these are not currently templated for simplicity.
     // TODO(simpkins): should they be templated?
     f_header_ << indent()
-              << "apache::thrift::stdcxx::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {"
+              << "std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {"
               << endl << indent() << "  return " << _this << "piprot_;" << endl << indent() << "}"
               << endl;
 
     f_header_ << indent()
-              << "apache::thrift::stdcxx::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {"
+              << "std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {"
               << endl << indent() << "  return " << _this << "poprot_;" << endl << indent() << "}"
               << endl;
 
   } else /* if (style == "Cob") */ {
     f_header_ << indent() << service_name_ << style << "Client" << short_suffix << "("
-              << "apache::thrift::stdcxx::shared_ptr< ::apache::thrift::async::TAsyncChannel> channel, "
+              << "std::shared_ptr< ::apache::thrift::async::TAsyncChannel> channel, "
               << "::apache::thrift::protocol::TProtocolFactory* protocolFactory) :" << endl;
     if (extends.empty()) {
       f_header_ << indent() << "  channel_(channel)," << endl << indent()
@@ -2350,9 +2352,9 @@
       if (gen_templates_) {
         // TProtocolFactory classes return generic TProtocol pointers.
         // We have to dynamic cast to the Protocol_ type we are expecting.
-        f_header_ << indent() << "  piprot_(::apache::thrift::stdcxx::dynamic_pointer_cast<Protocol_>("
+        f_header_ << indent() << "  piprot_(::std::dynamic_pointer_cast<Protocol_>("
                   << "protocolFactory->getProtocol(itrans_)))," << endl << indent()
-                  << "  poprot_(::apache::thrift::stdcxx::dynamic_pointer_cast<Protocol_>("
+                  << "  poprot_(::std::dynamic_pointer_cast<Protocol_>("
                   << "protocolFactory->getProtocol(otrans_))) {" << endl;
         // Throw a TException if either dynamic cast failed.
         f_header_ << indent() << "  if (!piprot_ || !poprot_) {" << endl << indent()
@@ -2374,7 +2376,7 @@
 
   if (style == "Cob") {
     f_header_ << indent()
-              << "::apache::thrift::stdcxx::shared_ptr< ::apache::thrift::async::TAsyncChannel> getChannel() {" << endl
+              << "::std::shared_ptr< ::apache::thrift::async::TAsyncChannel> getChannel() {" << endl
               << indent() << "  return " << _this << "channel_;" << endl << indent() << "}" << endl;
     if (!gen_no_client_completion_) {
       f_header_ << indent() << "virtual void completed__(bool /* success */) {}" << endl;
@@ -2426,11 +2428,11 @@
 
     if (style == "Cob") {
       f_header_ << indent()
-                << "::apache::thrift::stdcxx::shared_ptr< ::apache::thrift::async::TAsyncChannel> channel_;" << endl
+                << "::std::shared_ptr< ::apache::thrift::async::TAsyncChannel> channel_;" << endl
                 << indent()
-                << "::apache::thrift::stdcxx::shared_ptr< ::apache::thrift::transport::TMemoryBuffer> itrans_;" << endl
+                << "::std::shared_ptr< ::apache::thrift::transport::TMemoryBuffer> itrans_;" << endl
                 << indent()
-                << "::apache::thrift::stdcxx::shared_ptr< ::apache::thrift::transport::TMemoryBuffer> otrans_;"
+                << "::std::shared_ptr< ::apache::thrift::transport::TMemoryBuffer> otrans_;"
                 << endl;
     }
     f_header_ <<
@@ -2512,11 +2514,11 @@
     } else {
       if (!(*f_iter)->is_oneway()) {
         out << indent() << _this << "channel_->sendAndRecvMessage("
-            << "::apache::thrift::stdcxx::bind(cob, this), " << _this << "otrans_.get(), " << _this << "itrans_.get());"
+            << "::std::bind(cob, this), " << _this << "otrans_.get(), " << _this << "itrans_.get());"
             << endl;
       } else {
         out << indent() << _this << "channel_->sendMessage("
-            << "::apache::thrift::stdcxx::bind(cob, this), " << _this << "otrans_.get());" << endl;
+            << "::std::bind(cob, this), " << _this << "otrans_.get());" << endl;
       }
     }
     scope_down(out);
@@ -2867,8 +2869,8 @@
     class_name_ = service_name_ + pstyle_ + "Processor";
     if_name_ = service_name_ + "CobSvIf";
 
-    finish_cob_ = "::apache::thrift::stdcxx::function<void(bool ok)> cob, ";
-    finish_cob_decl_ = "::apache::thrift::stdcxx::function<void(bool ok)>, ";
+    finish_cob_ = "::std::function<void(bool ok)> cob, ";
+    finish_cob_decl_ = "::std::function<void(bool ok)>, ";
     cob_arg_ = "cob, ";
     ret_type_ = "void ";
   } else {
@@ -2929,7 +2931,7 @@
   // Protected data members
   f_header_ << " protected:" << endl;
   indent_up();
-  f_header_ << indent() << "::apache::thrift::stdcxx::shared_ptr<" << if_name_ << "> iface_;" << endl;
+  f_header_ << indent() << "::std::shared_ptr<" << if_name_ << "> iface_;" << endl;
   f_header_ << indent() << "virtual " << ret_type_ << "dispatchCall(" << finish_cob_
             << "::apache::thrift::protocol::TProtocol* iprot, "
             << "::apache::thrift::protocol::TProtocol* oprot, "
@@ -2985,29 +2987,29 @@
                             ? ""
                             : ", const " + type_name((*f_iter)->get_returntype()) + "& _return");
       f_header_ << indent() << "void return_" << (*f_iter)->get_name()
-                << "(::apache::thrift::stdcxx::function<void(bool ok)> cob, int32_t seqid, "
+                << "(::std::function<void(bool ok)> cob, int32_t seqid, "
                 << "::apache::thrift::protocol::TProtocol* oprot, "
                 << "void* ctx" << ret_arg << ");" << endl;
       if (generator_->gen_templates_) {
         f_header_ << indent() << "void return_" << (*f_iter)->get_name()
-                  << "(::apache::thrift::stdcxx::function<void(bool ok)> cob, int32_t seqid, "
+                  << "(::std::function<void(bool ok)> cob, int32_t seqid, "
                   << "Protocol_* oprot, void* ctx" << ret_arg << ");" << endl;
       }
       // XXX Don't declare throw if it doesn't exist
       f_header_ << indent() << "void throw_" << (*f_iter)->get_name()
-                << "(::apache::thrift::stdcxx::function<void(bool ok)> cob, int32_t seqid, "
+                << "(::std::function<void(bool ok)> cob, int32_t seqid, "
                 << "::apache::thrift::protocol::TProtocol* oprot, void* ctx, "
                 << "::apache::thrift::TDelayedException* _throw);" << endl;
       if (generator_->gen_templates_) {
         f_header_ << indent() << "void throw_" << (*f_iter)->get_name()
-                  << "(::apache::thrift::stdcxx::function<void(bool ok)> cob, int32_t seqid, "
+                  << "(::std::function<void(bool ok)> cob, int32_t seqid, "
                   << "Protocol_* oprot, void* ctx, "
                   << "::apache::thrift::TDelayedException* _throw);" << endl;
       }
     }
   }
 
-  f_header_ << " public:" << endl << indent() << class_name_ << "(::apache::thrift::stdcxx::shared_ptr<" << if_name_
+  f_header_ << " public:" << endl << indent() << class_name_ << "(::std::shared_ptr<" << if_name_
             << "> iface) :" << endl;
   if (!extends_.empty()) {
     f_header_ << indent() << "  " << extends_ << "(iface)," << endl;
@@ -3145,14 +3147,14 @@
             << endl << " public:" << endl;
   indent_up();
 
-  f_header_ << indent() << factory_class_name_ << "(const ::apache::thrift::stdcxx::shared_ptr< " << if_factory_name
+  f_header_ << indent() << factory_class_name_ << "(const ::std::shared_ptr< " << if_factory_name
             << " >& handlerFactory) :" << endl << indent()
             << "    handlerFactory_(handlerFactory) {}" << endl << endl << indent()
-            << "::apache::thrift::stdcxx::shared_ptr< ::apache::thrift::"
+            << "::std::shared_ptr< ::apache::thrift::"
             << (style_ == "Cob" ? "async::TAsyncProcessor" : "TProcessor") << " > "
             << "getProcessor(const ::apache::thrift::TConnectionInfo& connInfo);" << endl;
 
-  f_header_ << endl << " protected:" << endl << indent() << "::apache::thrift::stdcxx::shared_ptr< "
+  f_header_ << endl << " protected:" << endl << indent() << "::std::shared_ptr< "
             << if_factory_name << " > handlerFactory_;" << endl;
 
   indent_down();
@@ -3167,17 +3169,17 @@
   }
 
   // Generate the getProcessor() method
-  f_out_ << template_header_ << indent() << "::apache::thrift::stdcxx::shared_ptr< ::apache::thrift::"
+  f_out_ << template_header_ << indent() << "::std::shared_ptr< ::apache::thrift::"
          << (style_ == "Cob" ? "async::TAsyncProcessor" : "TProcessor") << " > "
          << factory_class_name_ << template_suffix_ << "::getProcessor("
          << "const ::apache::thrift::TConnectionInfo& connInfo) {" << endl;
   indent_up();
 
   f_out_ << indent() << "::apache::thrift::ReleaseHandler< " << if_factory_name
-         << " > cleanup(handlerFactory_);" << endl << indent() << "::apache::thrift::stdcxx::shared_ptr< "
+         << " > cleanup(handlerFactory_);" << endl << indent() << "::std::shared_ptr< "
          << if_name_ << " > handler("
          << "handlerFactory_->getHandler(connInfo), cleanup);" << endl << indent()
-         << "::apache::thrift::stdcxx::shared_ptr< ::apache::thrift::"
+         << "::std::shared_ptr< ::apache::thrift::"
          << (style_ == "Cob" ? "async::TAsyncProcessor" : "TProcessor") << " > "
          << "processor(new " << class_name_ << template_suffix_ << "(handler));" << endl << indent()
          << "return processor;" << endl;
@@ -3412,7 +3414,7 @@
       out << indent() << "template <class Protocol_>" << endl;
     }
     out << "void " << tservice->get_name() << "AsyncProcessor" << class_suffix << "::process_"
-        << tfunction->get_name() << "(::apache::thrift::stdcxx::function<void(bool ok)> cob, int32_t seqid, "
+        << tfunction->get_name() << "(::std::function<void(bool ok)> cob, int32_t seqid, "
         << prot_type << "* iprot, " << prot_type << "* oprot)" << endl;
     scope_up(out);
 
@@ -3469,28 +3471,28 @@
       // No return.  Just hand off our cob.
       // TODO(dreiss): Call the cob immediately?
       out << indent() << "iface_->" << tfunction->get_name() << "("
-          << "::apache::thrift::stdcxx::bind(cob, true)" << endl;
+          << "::std::bind(cob, true)" << endl;
       indent_up();
       indent_up();
     } else {
       string ret_arg, ret_placeholder;
       if (!tfunction->get_returntype()->is_void()) {
         ret_arg = ", const " + type_name(tfunction->get_returntype()) + "& _return";
-        ret_placeholder = ", ::apache::thrift::stdcxx::placeholders::_1";
+        ret_placeholder = ", ::std::placeholders::_1";
       }
 
       // When gen_templates_ is true, the return_ and throw_ functions are
       // overloaded.  We have to declare pointers to them so that the compiler
       // can resolve the correct overloaded version.
       out << indent() << "void (" << tservice->get_name() << "AsyncProcessor" << class_suffix
-          << "::*return_fn)(::apache::thrift::stdcxx::function<void(bool ok)> "
+          << "::*return_fn)(::std::function<void(bool ok)> "
           << "cob, int32_t seqid, " << prot_type << "* oprot, void* ctx" << ret_arg
           << ") =" << endl;
       out << indent() << "  &" << tservice->get_name() << "AsyncProcessor" << class_suffix
           << "::return_" << tfunction->get_name() << ";" << endl;
       if (!xceptions.empty()) {
         out << indent() << "void (" << tservice->get_name() << "AsyncProcessor" << class_suffix
-            << "::*throw_fn)(::apache::thrift::stdcxx::function<void(bool ok)> "
+            << "::*throw_fn)(::std::function<void(bool ok)> "
             << "cob, int32_t seqid, " << prot_type << "* oprot, void* ctx, "
             << "::apache::thrift::TDelayedException* _throw) =" << endl;
         out << indent() << "  &" << tservice->get_name() << "AsyncProcessor" << class_suffix
@@ -3500,11 +3502,11 @@
       out << indent() << "iface_->" << tfunction->get_name() << "(" << endl;
       indent_up();
       indent_up();
-      out << indent() << "::apache::thrift::stdcxx::bind(return_fn, this, cob, seqid, oprot, ctx" << ret_placeholder
+      out << indent() << "::std::bind(return_fn, this, cob, seqid, oprot, ctx" << ret_placeholder
           << ")";
       if (!xceptions.empty()) {
-        out << ',' << endl << indent() << "::apache::thrift::stdcxx::bind(throw_fn, this, cob, seqid, oprot, "
-            << "ctx, ::apache::thrift::stdcxx::placeholders::_1)";
+        out << ',' << endl << indent() << "::std::bind(throw_fn, this, cob, seqid, oprot, "
+            << "ctx, ::std::placeholders::_1)";
       }
     }
 
@@ -3529,7 +3531,7 @@
         out << indent() << "template <class Protocol_>" << endl;
       }
       out << "void " << tservice->get_name() << "AsyncProcessor" << class_suffix << "::return_"
-          << tfunction->get_name() << "(::apache::thrift::stdcxx::function<void(bool ok)> cob, int32_t seqid, "
+          << tfunction->get_name() << "(::std::function<void(bool ok)> cob, int32_t seqid, "
           << prot_type << "* oprot, void* ctx" << ret_arg_decl << ')' << endl;
       scope_up(out);
 
@@ -3577,7 +3579,7 @@
         out << indent() << "template <class Protocol_>" << endl;
       }
       out << "void " << tservice->get_name() << "AsyncProcessor" << class_suffix << "::throw_"
-          << tfunction->get_name() << "(::apache::thrift::stdcxx::function<void(bool ok)> cob, int32_t seqid, "
+          << tfunction->get_name() << "(::std::function<void(bool ok)> cob, int32_t seqid, "
           << prot_type << "* oprot, void* ctx, "
           << "::apache::thrift::TDelayedException* _throw)" << endl;
       scope_up(out);
@@ -3707,13 +3709,13 @@
   f_skeleton << indent() << "int main(int argc, char **argv) {" << endl;
   indent_up();
   f_skeleton
-      << indent() << "int port = 9090;" << endl << indent() << "::apache::thrift::stdcxx::shared_ptr<" << svcname
+      << indent() << "int port = 9090;" << endl << indent() << "::std::shared_ptr<" << svcname
       << "Handler> handler(new " << svcname << "Handler());" << endl << indent()
-      << "::apache::thrift::stdcxx::shared_ptr<TProcessor> processor(new " << svcname << "Processor(handler));" << endl
-      << indent() << "::apache::thrift::stdcxx::shared_ptr<TServerTransport> serverTransport(new TServerSocket(port));"
+      << "::std::shared_ptr<TProcessor> processor(new " << svcname << "Processor(handler));" << endl
+      << indent() << "::std::shared_ptr<TServerTransport> serverTransport(new TServerSocket(port));"
       << endl << indent()
-      << "::apache::thrift::stdcxx::shared_ptr<TTransportFactory> transportFactory(new TBufferedTransportFactory());" << endl
-      << indent() << "::apache::thrift::stdcxx::shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());"
+      << "::std::shared_ptr<TTransportFactory> transportFactory(new TBufferedTransportFactory());" << endl
+      << indent() << "::std::shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());"
       << endl << endl << indent()
       << "TSimpleServer server(processor, serverTransport, transportFactory, protocolFactory);"
       << endl << indent() << "server.serve();" << endl << indent() << "return 0;" << endl;
@@ -3802,7 +3804,7 @@
                                                   bool pointer) {
   if (pointer) {
     indent(out) << "if (!" << prefix << ") { " << endl;
-    indent(out) << "  " << prefix << " = ::apache::thrift::stdcxx::shared_ptr<" << type_name(tstruct) << ">(new "
+    indent(out) << "  " << prefix << " = ::std::shared_ptr<" << type_name(tstruct) << ">(new "
                 << type_name(tstruct) << ");" << endl;
     indent(out) << "}" << endl;
     indent(out) << "xfer += " << prefix << "->read(iprot);" << endl;
@@ -4294,7 +4296,7 @@
   }
   result += type_name(tfield->get_type());
   if (is_reference(tfield)) {
-    result = "::apache::thrift::stdcxx::shared_ptr<" + result + ">";
+    result = "::std::shared_ptr<" + result + ">";
   }
   if (pointer) {
     result += "*";
@@ -4373,13 +4375,13 @@
       cob_type = (ttype->is_void() ? "()" : ("(" + type_name(ttype) + " const& _return)"));
       if (has_xceptions) {
         exn_cob
-            = ", ::apache::thrift::stdcxx::function<void(::apache::thrift::TDelayedException* _throw)> /* exn_cob */";
+            = ", ::std::function<void(::apache::thrift::TDelayedException* _throw)> /* exn_cob */";
       }
     } else {
       throw "UNKNOWN STYLE";
     }
 
-    return "void " + prefix + tfunction->get_name() + "(::apache::thrift::stdcxx::function<void" + cob_type + "> cob"
+    return "void " + prefix + tfunction->get_name() + "(::std::function<void" + cob_type + "> cob"
            + exn_cob + argument_list(arglist, name_params, true) + ")";
   } else {
     throw "UNKNOWN STYLE";
diff --git a/compiler/cpp/src/thrift/plugin/plugin.cc b/compiler/cpp/src/thrift/plugin/plugin.cc
index ca5d287..7c4c432 100644
--- a/compiler/cpp/src/thrift/plugin/plugin.cc
+++ b/compiler/cpp/src/thrift/plugin/plugin.cc
@@ -25,7 +25,9 @@
 #endif
 
 #include <cassert>
+#include <functional>
 #include <iostream>
+#include <memory>
 
 #include <boost/range/adaptor/map.hpp>
 #include <boost/range/algorithm/for_each.hpp>
@@ -35,7 +37,6 @@
 #include "thrift/protocol/TBinaryProtocol.h"
 #include "thrift/transport/TBufferTransports.h"
 #include "thrift/transport/TFDTransport.h"
-#include "thrift/stdcxx.h"
 #include "thrift/plugin/plugin_types.h"
 
 namespace apache {
@@ -119,7 +120,7 @@
 
   void compileAll() {
     boost::for_each(*source | boost::adaptors::map_keys,
-                    stdcxx::bind(&TypeCache::compile, this, stdcxx::placeholders::_1));
+                    std::bind(&TypeCache::compile, this, std::placeholders::_1));
   }
 
   std::map<int64_t, S> const* source;
@@ -227,7 +228,7 @@
   assert(to);
   THRIFT_ASSIGN_METADATA();
   boost::for_each(from.constants | boost::adaptors::transformed(convert<t_enum_value>),
-                  stdcxx::bind(&::t_enum::append, to, stdcxx::placeholders::_1));
+                  std::bind(&::t_enum::append, to, std::placeholders::_1));
 }
 THRIFT_CONVERSION(t_list, resolve_type< ::t_type>(from.elem_type)) {
   assert(to);
@@ -264,7 +265,7 @@
   } else if (from.__isset.list_val) {
     to->set_list();
     boost::for_each(from.list_val | boost::adaptors::transformed(&convert<t_const_value>),
-                    stdcxx::bind(&::t_const_value::add_list, to, stdcxx::placeholders::_1));
+                    std::bind(&::t_const_value::add_list, to, std::placeholders::_1));
   } else
     T_CONST_VALUE_CASE(string);
   else T_CONST_VALUE_CASE(integer);
@@ -291,7 +292,7 @@
   to->set_union(from.is_union);
   to->set_xception(from.is_xception);
   boost::for_each(from.members | boost::adaptors::transformed(convert<t_field>),
-                  stdcxx::bind(&::t_struct::append, to, stdcxx::placeholders::_1));
+                  std::bind(&::t_struct::append, to, std::placeholders::_1));
 }
 THRIFT_CONVERSION(t_const,
                   resolve_type< ::t_type>(from.type),
@@ -318,7 +319,7 @@
   THRIFT_ASSIGN_METADATA();
 
   boost::for_each(from.functions | boost::adaptors::transformed(convert<t_function>),
-                  stdcxx::bind(&::t_service::add_function, to, stdcxx::placeholders::_1));
+                  std::bind(&::t_service::add_function, to, std::placeholders::_1));
 
   if (from.__isset.extends_)
     to->set_extends(resolve_service(from.extends_));
@@ -399,9 +400,9 @@
   to->set_out_path(from.out_path, from.out_path_is_absolute);
 
   boost::for_each(from.typedefs | boost::adaptors::transformed(&resolve_type< ::t_typedef>),
-                  stdcxx::bind(&::t_program::add_typedef, to, stdcxx::placeholders::_1));
+                  std::bind(&::t_program::add_typedef, to, std::placeholders::_1));
   boost::for_each(from.enums | boost::adaptors::transformed(&resolve_type< ::t_enum>),
-                  stdcxx::bind(&::t_program::add_enum, to, stdcxx::placeholders::_1));
+                  std::bind(&::t_program::add_enum, to, std::placeholders::_1));
   for (std::vector<int64_t>::const_iterator it = from.objects.begin(); it != from.objects.end();
        it++) {
     ::t_struct* t2 = resolve_type< ::t_struct>(*it);
@@ -412,18 +413,18 @@
     }
   }
   boost::for_each(from.consts | boost::adaptors::transformed(&resolve_const),
-                  stdcxx::bind(&::t_program::add_const, to, stdcxx::placeholders::_1));
+                  std::bind(&::t_program::add_const, to, std::placeholders::_1));
   boost::for_each(from.services | boost::adaptors::transformed(&resolve_service),
-                  stdcxx::bind(&::t_program::add_service, to, stdcxx::placeholders::_1));
+                  std::bind(&::t_program::add_service, to, std::placeholders::_1));
 
   for (std::vector<t_program>::const_iterator it = from.includes.begin(); it != from.includes.end();
        it++) {
     convert(*it, g_program_cache[it->program_id]);
   }
   std::for_each(from.c_includes.begin(), from.c_includes.end(),
-                stdcxx::bind(&::t_program::add_c_include, to, stdcxx::placeholders::_1));
+                std::bind(&::t_program::add_c_include, to, std::placeholders::_1));
   std::for_each(from.cpp_includes.begin(), from.cpp_includes.end(),
-                stdcxx::bind(&::t_program::add_cpp_include, to, stdcxx::placeholders::_1));
+                std::bind(&::t_program::add_cpp_include, to, std::placeholders::_1));
   for (std::map<std::string, std::string>::const_iterator it = from.namespaces.begin();
        it != from.namespaces.end(); it++) {
     to->set_namespace(it->first, it->second);
@@ -437,8 +438,8 @@
 #ifdef _WIN32
   _setmode(fileno(stdin), _O_BINARY);
 #endif
-  stdcxx::shared_ptr<TFramedTransport> transport(
-      new TFramedTransport(stdcxx::make_shared<TFDTransport>(fileno(stdin))));
+  std::shared_ptr<TFramedTransport> transport(
+      new TFramedTransport(std::make_shared<TFDTransport>(fileno(stdin))));
   TBinaryProtocol proto(transport);
   GeneratorInput input;
   try {
diff --git a/compiler/cpp/src/thrift/plugin/plugin_output.cc b/compiler/cpp/src/thrift/plugin/plugin_output.cc
index 81b9a2a..f8223de 100644
--- a/compiler/cpp/src/thrift/plugin/plugin_output.cc
+++ b/compiler/cpp/src/thrift/plugin/plugin_output.cc
@@ -39,12 +39,13 @@
 #include "thrift/plugin/plugin.h"
 #include "thrift/plugin/type_util.h"
 #include "thrift/protocol/TBinaryProtocol.h"
-#include "thrift/stdcxx.h"
 #include "thrift/transport/TBufferTransports.h"
 #include "thrift/transport/TFDTransport.h"
 
 #include "thrift/plugin/plugin_types.h"
 
+#include <memory>
+
 namespace plugin_output {
 
 template <typename From>
@@ -55,8 +56,8 @@
 }
 
 using apache::thrift::protocol::TBinaryProtocol;
-using apache::thrift::stdcxx::make_shared;
-using apache::thrift::stdcxx::shared_ptr;
+using std::make_shared;
+using std::shared_ptr;
 using apache::thrift::transport::TFDTransport;
 using apache::thrift::transport::TFramedTransport;
 
diff --git a/contrib/zeromq/TZmqServer.cpp b/contrib/zeromq/TZmqServer.cpp
index 4df6c92..88660a3 100644
--- a/contrib/zeromq/TZmqServer.cpp
+++ b/contrib/zeromq/TZmqServer.cpp
@@ -21,7 +21,7 @@
 #include <thrift/transport/TBufferTransports.h>
 #include <boost/scoped_ptr.hpp>
 
-using apache::thrift::stdcxx::shared_ptr;
+using apache::thrift::std::shared_ptr;
 using apache::thrift::transport::TMemoryBuffer;
 using apache::thrift::protocol::TProtocol;
 
diff --git a/contrib/zeromq/test-client.cpp b/contrib/zeromq/test-client.cpp
index 70a331e..159c250 100644
--- a/contrib/zeromq/test-client.cpp
+++ b/contrib/zeromq/test-client.cpp
@@ -6,7 +6,7 @@
 #include "TZmqClient.h"
 #include "Storage.h"
 
-using apache::thrift::stdcxx::shared_ptr;
+using apache::thrift::std::shared_ptr;
 using apache::thrift::transport::TZmqClient;
 using apache::thrift::protocol::TBinaryProtocol;
 
diff --git a/contrib/zeromq/test-receiver.cpp b/contrib/zeromq/test-receiver.cpp
index 60791ac..d465bff 100644
--- a/contrib/zeromq/test-receiver.cpp
+++ b/contrib/zeromq/test-receiver.cpp
@@ -2,7 +2,7 @@
 #include "TZmqServer.h"
 #include "Storage.h"
 
-using apache::thrift::stdcxx::shared_ptr;
+using apache::thrift::std::shared_ptr;
 using apache::thrift::TProcessor;
 using apache::thrift::server::TZmqServer;
 using apache::thrift::server::TZmqMultiServer;
diff --git a/contrib/zeromq/test-sender.cpp b/contrib/zeromq/test-sender.cpp
index 8928db3..5c086a1 100644
--- a/contrib/zeromq/test-sender.cpp
+++ b/contrib/zeromq/test-sender.cpp
@@ -6,7 +6,7 @@
 #include "TZmqClient.h"
 #include "Storage.h"
 
-using apache::thrift::stdcxx::shared_ptr;
+using apache::thrift::std::shared_ptr;
 using apache::thrift::transport::TZmqClient;
 using apache::thrift::protocol::TBinaryProtocol;
 
diff --git a/contrib/zeromq/test-server.cpp b/contrib/zeromq/test-server.cpp
index baa1451..e6f1b20 100644
--- a/contrib/zeromq/test-server.cpp
+++ b/contrib/zeromq/test-server.cpp
@@ -2,7 +2,7 @@
 #include "TZmqServer.h"
 #include "Storage.h"
 
-using apache::thrift::stdcxx::shared_ptr;
+using apache::thrift::std::shared_ptr;
 using apache::thrift::TProcessor;
 using apache::thrift::server::TZmqServer;
 using apache::thrift::server::TZmqMultiServer;
diff --git a/lib/c_glib/test/testthrifttestclient.cpp b/lib/c_glib/test/testthrifttestclient.cpp
index 5b06883..1910c8a 100755
--- a/lib/c_glib/test/testthrifttestclient.cpp
+++ b/lib/c_glib/test/testthrifttestclient.cpp
@@ -25,7 +25,7 @@
 #include <thrift/protocol/TBinaryProtocol.h>
 #include <thrift/protocol/TDebugProtocol.h>
 #include <thrift/server/TSimpleServer.h>
-#include <thrift/stdcxx.h>
+#include <memory>
 #include <thrift/transport/TServerSocket.h>
 #include "ThriftTest.h"
 #include "ThriftTest_types.h"
@@ -618,11 +618,11 @@
 
   if (pid == 0) /* child */
   {
-    stdcxx::shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());
-    stdcxx::shared_ptr<TestHandler> testHandler(new TestHandler());
-    stdcxx::shared_ptr<ThriftTestProcessor> testProcessor(new ThriftTestProcessor(testHandler));
-    stdcxx::shared_ptr<TServerSocket> serverSocket(new TServerSocket(TEST_PORT));
-    stdcxx::shared_ptr<TTransportFactory> transportFactory(new TBufferedTransportFactory());
+    std::shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());
+    std::shared_ptr<TestHandler> testHandler(new TestHandler());
+    std::shared_ptr<ThriftTestProcessor> testProcessor(new ThriftTestProcessor(testHandler));
+    std::shared_ptr<TServerSocket> serverSocket(new TServerSocket(TEST_PORT));
+    std::shared_ptr<TTransportFactory> transportFactory(new TBufferedTransportFactory());
     TSimpleServer simpleServer(testProcessor, serverSocket, transportFactory, protocolFactory);
     signal (SIGALRM, bailout);
     alarm (60);
diff --git a/lib/cpp/src/thrift/TDispatchProcessor.h b/lib/cpp/src/thrift/TDispatchProcessor.h
index dadc87b..28d347d 100644
--- a/lib/cpp/src/thrift/TDispatchProcessor.h
+++ b/lib/cpp/src/thrift/TDispatchProcessor.h
@@ -33,8 +33,8 @@
 template <class Protocol_>
 class TDispatchProcessorT : public TProcessor {
 public:
-  virtual bool process(stdcxx::shared_ptr<protocol::TProtocol> in,
-                       stdcxx::shared_ptr<protocol::TProtocol> out,
+  virtual bool process(std::shared_ptr<protocol::TProtocol> in,
+                       std::shared_ptr<protocol::TProtocol> out,
                        void* connectionContext) {
     protocol::TProtocol* inRaw = in.get();
     protocol::TProtocol* outRaw = out.get();
@@ -105,8 +105,8 @@
  */
 class TDispatchProcessor : public TProcessor {
 public:
-  virtual bool process(stdcxx::shared_ptr<protocol::TProtocol> in,
-                       stdcxx::shared_ptr<protocol::TProtocol> out,
+  virtual bool process(std::shared_ptr<protocol::TProtocol> in,
+                       std::shared_ptr<protocol::TProtocol> out,
                        void* connectionContext) {
     std::string fname;
     protocol::TMessageType mtype;
diff --git a/lib/cpp/src/thrift/TProcessor.h b/lib/cpp/src/thrift/TProcessor.h
index 27294d3..6a46466 100644
--- a/lib/cpp/src/thrift/TProcessor.h
+++ b/lib/cpp/src/thrift/TProcessor.h
@@ -22,7 +22,6 @@
 
 #include <string>
 #include <thrift/protocol/TProtocol.h>
-#include <thrift/stdcxx.h>
 
 namespace apache {
 namespace thrift {
@@ -142,28 +141,28 @@
 public:
   virtual ~TProcessor() {}
 
-  virtual bool process(stdcxx::shared_ptr<protocol::TProtocol> in,
-                       stdcxx::shared_ptr<protocol::TProtocol> out,
+  virtual bool process(std::shared_ptr<protocol::TProtocol> in,
+                       std::shared_ptr<protocol::TProtocol> out,
                        void* connectionContext) = 0;
 
-  bool process(stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> io, void* connectionContext) {
+  bool process(std::shared_ptr<apache::thrift::protocol::TProtocol> io, void* connectionContext) {
     return process(io, io, connectionContext);
   }
 
-  stdcxx::shared_ptr<TProcessorEventHandler> getEventHandler() const { return eventHandler_; }
+  std::shared_ptr<TProcessorEventHandler> getEventHandler() const { return eventHandler_; }
 
-  void setEventHandler(stdcxx::shared_ptr<TProcessorEventHandler> eventHandler) {
+  void setEventHandler(std::shared_ptr<TProcessorEventHandler> eventHandler) {
     eventHandler_ = eventHandler;
   }
 
 protected:
   TProcessor() {}
 
-  stdcxx::shared_ptr<TProcessorEventHandler> eventHandler_;
+  std::shared_ptr<TProcessorEventHandler> eventHandler_;
 };
 
 /**
- * This is a helper class to allow stdcxx::shared_ptr to be used with handler
+ * This is a helper class to allow std::shared_ptr to be used with handler
  * pointers returned by the generated handler factories.
  *
  * The handler factory classes generated by the thrift compiler return raw
@@ -177,7 +176,7 @@
 template <typename HandlerFactory_>
 class ReleaseHandler {
 public:
-  ReleaseHandler(const stdcxx::shared_ptr<HandlerFactory_>& handlerFactory)
+  ReleaseHandler(const std::shared_ptr<HandlerFactory_>& handlerFactory)
     : handlerFactory_(handlerFactory) {}
 
   void operator()(typename HandlerFactory_::Handler* handler) {
@@ -187,18 +186,18 @@
   }
 
 private:
-  stdcxx::shared_ptr<HandlerFactory_> handlerFactory_;
+  std::shared_ptr<HandlerFactory_> handlerFactory_;
 };
 
 struct TConnectionInfo {
   // The input and output protocols
-  stdcxx::shared_ptr<protocol::TProtocol> input;
-  stdcxx::shared_ptr<protocol::TProtocol> output;
+  std::shared_ptr<protocol::TProtocol> input;
+  std::shared_ptr<protocol::TProtocol> output;
   // The underlying transport used for the connection
   // This is the transport that was returned by TServerTransport::accept(),
   // and it may be different than the transport pointed to by the input and
   // output protocols.
-  stdcxx::shared_ptr<transport::TTransport> transport;
+  std::shared_ptr<transport::TTransport> transport;
 };
 
 class TProcessorFactory {
@@ -212,17 +211,17 @@
    * accepted on.  This generally means that this call does not need to be
    * thread safe, as it will always be invoked from a single thread.
    */
-  virtual stdcxx::shared_ptr<TProcessor> getProcessor(const TConnectionInfo& connInfo) = 0;
+  virtual std::shared_ptr<TProcessor> getProcessor(const TConnectionInfo& connInfo) = 0;
 };
 
 class TSingletonProcessorFactory : public TProcessorFactory {
 public:
-  TSingletonProcessorFactory(stdcxx::shared_ptr<TProcessor> processor) : processor_(processor) {}
+  TSingletonProcessorFactory(std::shared_ptr<TProcessor> processor) : processor_(processor) {}
 
-  stdcxx::shared_ptr<TProcessor> getProcessor(const TConnectionInfo&) { return processor_; }
+  std::shared_ptr<TProcessor> getProcessor(const TConnectionInfo&) { return processor_; }
 
 private:
-  stdcxx::shared_ptr<TProcessor> processor_;
+  std::shared_ptr<TProcessor> processor_;
 };
 }
 } // apache::thrift
diff --git a/lib/cpp/src/thrift/async/TAsyncBufferProcessor.h b/lib/cpp/src/thrift/async/TAsyncBufferProcessor.h
index 0d56c78..9c96b14 100644
--- a/lib/cpp/src/thrift/async/TAsyncBufferProcessor.h
+++ b/lib/cpp/src/thrift/async/TAsyncBufferProcessor.h
@@ -20,7 +20,7 @@
 #ifndef _THRIFT_TASYNC_BUFFER_PROCESSOR_H_
 #define _THRIFT_TASYNC_BUFFER_PROCESSOR_H_ 1
 
-#include <thrift/stdcxx.h>
+#include <memory>
 #include <thrift/transport/TBufferTransports.h>
 
 namespace apache {
@@ -34,9 +34,9 @@
   // forcefully close the connection (if applicable).
   // "in" and "out" should be TMemoryBuffer or similar,
   // not a wrapper around a socket.
-  virtual void process(stdcxx::function<void(bool healthy)> _return,
-                       stdcxx::shared_ptr<transport::TBufferBase> ibuf,
-                       stdcxx::shared_ptr<transport::TBufferBase> obuf) = 0;
+  virtual void process(std::function<void(bool healthy)> _return,
+                       std::shared_ptr<transport::TBufferBase> ibuf,
+                       std::shared_ptr<transport::TBufferBase> obuf) = 0;
   virtual ~TAsyncBufferProcessor() {}
 };
 }
diff --git a/lib/cpp/src/thrift/async/TAsyncChannel.cpp b/lib/cpp/src/thrift/async/TAsyncChannel.cpp
index c87659f..01b9113 100644
--- a/lib/cpp/src/thrift/async/TAsyncChannel.cpp
+++ b/lib/cpp/src/thrift/async/TAsyncChannel.cpp
@@ -18,7 +18,6 @@
  */
 
 #include <thrift/async/TAsyncChannel.h>
-#include <thrift/stdcxx.h>
 
 namespace apache {
 namespace thrift {
@@ -27,8 +26,8 @@
 void TAsyncChannel::sendAndRecvMessage(const VoidCallback& cob,
                                        TMemoryBuffer* sendBuf,
                                        TMemoryBuffer* recvBuf) {
-  apache::thrift::stdcxx::function<void()> send_done
-      = apache::thrift::stdcxx::bind(&TAsyncChannel::recvMessage, this, cob, recvBuf);
+  std::function<void()> send_done
+      = std::bind(&TAsyncChannel::recvMessage, this, cob, recvBuf);
 
   sendMessage(send_done, sendBuf);
 }
diff --git a/lib/cpp/src/thrift/async/TAsyncChannel.h b/lib/cpp/src/thrift/async/TAsyncChannel.h
index f8d2b03..d7ace96 100644
--- a/lib/cpp/src/thrift/async/TAsyncChannel.h
+++ b/lib/cpp/src/thrift/async/TAsyncChannel.h
@@ -20,7 +20,8 @@
 #ifndef _THRIFT_ASYNC_TASYNCCHANNEL_H_
 #define _THRIFT_ASYNC_TASYNCCHANNEL_H_ 1
 
-#include <thrift/stdcxx.h>
+#include <functional>
+#include <memory>
 #include <thrift/Thrift.h>
 
 namespace apache {
@@ -38,7 +39,7 @@
 
 class TAsyncChannel {
 public:
-  typedef apache::thrift::stdcxx::function<void()> VoidCallback;
+  typedef std::function<void()> VoidCallback;
 
   virtual ~TAsyncChannel() {}
 
diff --git a/lib/cpp/src/thrift/async/TAsyncDispatchProcessor.h b/lib/cpp/src/thrift/async/TAsyncDispatchProcessor.h
index a1450f0..59db597 100644
--- a/lib/cpp/src/thrift/async/TAsyncDispatchProcessor.h
+++ b/lib/cpp/src/thrift/async/TAsyncDispatchProcessor.h
@@ -34,9 +34,9 @@
 template <class Protocol_>
 class TAsyncDispatchProcessorT : public TAsyncProcessor {
 public:
-  virtual void process(apache::thrift::stdcxx::function<void(bool success)> _return,
-                       stdcxx::shared_ptr<protocol::TProtocol> in,
-                       stdcxx::shared_ptr<protocol::TProtocol> out) {
+  virtual void process(std::function<void(bool success)> _return,
+                       std::shared_ptr<protocol::TProtocol> in,
+                       std::shared_ptr<protocol::TProtocol> out) {
     protocol::TProtocol* inRaw = in.get();
     protocol::TProtocol* outRaw = out.get();
 
@@ -70,7 +70,7 @@
     return this->dispatchCall(_return, inRaw, outRaw, fname, seqid);
   }
 
-  void processFast(apache::thrift::stdcxx::function<void(bool success)> _return,
+  void processFast(std::function<void(bool success)> _return,
                    Protocol_* in,
                    Protocol_* out) {
     std::string fname;
@@ -87,13 +87,13 @@
     return this->dispatchCallTemplated(_return, in, out, fname, seqid);
   }
 
-  virtual void dispatchCall(apache::thrift::stdcxx::function<void(bool ok)> _return,
+  virtual void dispatchCall(std::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,
+  virtual void dispatchCallTemplated(std::function<void(bool ok)> _return,
                                      Protocol_* in,
                                      Protocol_* out,
                                      const std::string& fname,
@@ -106,9 +106,9 @@
  */
 class TAsyncDispatchProcessor : public TAsyncProcessor {
 public:
-  virtual void process(apache::thrift::stdcxx::function<void(bool success)> _return,
-                       stdcxx::shared_ptr<protocol::TProtocol> in,
-                       stdcxx::shared_ptr<protocol::TProtocol> out) {
+  virtual void process(std::function<void(bool success)> _return,
+                       std::shared_ptr<protocol::TProtocol> in,
+                       std::shared_ptr<protocol::TProtocol> out) {
     protocol::TProtocol* inRaw = in.get();
     protocol::TProtocol* outRaw = out.get();
 
@@ -131,7 +131,7 @@
     return dispatchCall(_return, inRaw, outRaw, fname, seqid);
   }
 
-  virtual void dispatchCall(apache::thrift::stdcxx::function<void(bool ok)> _return,
+  virtual void dispatchCall(std::function<void(bool ok)> _return,
                             apache::thrift::protocol::TProtocol* in,
                             apache::thrift::protocol::TProtocol* out,
                             const std::string& fname,
diff --git a/lib/cpp/src/thrift/async/TAsyncProcessor.h b/lib/cpp/src/thrift/async/TAsyncProcessor.h
index afc4ffa..fdb976d 100644
--- a/lib/cpp/src/thrift/async/TAsyncProcessor.h
+++ b/lib/cpp/src/thrift/async/TAsyncProcessor.h
@@ -21,7 +21,7 @@
 #define _THRIFT_TASYNCPROCESSOR_H_ 1
 
 #include <thrift/protocol/TProtocol.h>
-#include <thrift/stdcxx.h>
+#include <memory>
 #include <thrift/TProcessor.h>
 
 namespace apache {
@@ -37,25 +37,25 @@
 public:
   virtual ~TAsyncProcessor() {}
 
-  virtual void process(stdcxx::function<void(bool success)> _return,
-                       stdcxx::shared_ptr<protocol::TProtocol> in,
-                       stdcxx::shared_ptr<protocol::TProtocol> out) = 0;
+  virtual void process(std::function<void(bool success)> _return,
+                       std::shared_ptr<protocol::TProtocol> in,
+                       std::shared_ptr<protocol::TProtocol> out) = 0;
 
-  void process(stdcxx::function<void(bool success)> _return,
-               stdcxx::shared_ptr<protocol::TProtocol> io) {
+  void process(std::function<void(bool success)> _return,
+               std::shared_ptr<protocol::TProtocol> io) {
     return process(_return, io, io);
   }
 
-  stdcxx::shared_ptr<TProcessorEventHandler> getEventHandler() const { return eventHandler_; }
+  std::shared_ptr<TProcessorEventHandler> getEventHandler() const { return eventHandler_; }
 
-  void setEventHandler(stdcxx::shared_ptr<TProcessorEventHandler> eventHandler) {
+  void setEventHandler(std::shared_ptr<TProcessorEventHandler> eventHandler) {
     eventHandler_ = eventHandler;
   }
 
 protected:
   TAsyncProcessor() {}
 
-  stdcxx::shared_ptr<TProcessorEventHandler> eventHandler_;
+  std::shared_ptr<TProcessorEventHandler> eventHandler_;
 };
 
 class TAsyncProcessorFactory {
@@ -69,7 +69,7 @@
    * accepted on.  This generally means that this call does not need to be
    * thread safe, as it will always be invoked from a single thread.
    */
-  virtual stdcxx::shared_ptr<TAsyncProcessor> getProcessor(const TConnectionInfo& connInfo) = 0;
+  virtual std::shared_ptr<TAsyncProcessor> getProcessor(const TConnectionInfo& connInfo) = 0;
 };
 }
 }
diff --git a/lib/cpp/src/thrift/async/TAsyncProtocolProcessor.cpp b/lib/cpp/src/thrift/async/TAsyncProtocolProcessor.cpp
index b9ffb04..cb5201b 100644
--- a/lib/cpp/src/thrift/async/TAsyncProtocolProcessor.cpp
+++ b/lib/cpp/src/thrift/async/TAsyncProtocolProcessor.cpp
@@ -26,23 +26,23 @@
 namespace thrift {
 namespace async {
 
-void TAsyncProtocolProcessor::process(apache::thrift::stdcxx::function<void(bool healthy)> _return,
-                                      stdcxx::shared_ptr<TBufferBase> ibuf,
-                                      stdcxx::shared_ptr<TBufferBase> obuf) {
-  stdcxx::shared_ptr<TProtocol> iprot(pfact_->getProtocol(ibuf));
-  stdcxx::shared_ptr<TProtocol> oprot(pfact_->getProtocol(obuf));
+void TAsyncProtocolProcessor::process(std::function<void(bool healthy)> _return,
+                                      std::shared_ptr<TBufferBase> ibuf,
+                                      std::shared_ptr<TBufferBase> obuf) {
+  std::shared_ptr<TProtocol> iprot(pfact_->getProtocol(ibuf));
+  std::shared_ptr<TProtocol> oprot(pfact_->getProtocol(obuf));
   return underlying_
-      ->process(apache::thrift::stdcxx::bind(&TAsyncProtocolProcessor::finish,
+      ->process(std::bind(&TAsyncProtocolProcessor::finish,
                                              _return,
                                              oprot,
-                                             apache::thrift::stdcxx::placeholders::_1),
+                                             std::placeholders::_1),
                 iprot,
                 oprot);
 }
 
 /* static */ void TAsyncProtocolProcessor::finish(
-    apache::thrift::stdcxx::function<void(bool healthy)> _return,
-    stdcxx::shared_ptr<TProtocol> oprot,
+    std::function<void(bool healthy)> _return,
+    std::shared_ptr<TProtocol> oprot,
     bool healthy) {
   (void)oprot;
   // This is a stub function to hold a reference to oprot.
diff --git a/lib/cpp/src/thrift/async/TAsyncProtocolProcessor.h b/lib/cpp/src/thrift/async/TAsyncProtocolProcessor.h
index ce3883c..8052cf3 100644
--- a/lib/cpp/src/thrift/async/TAsyncProtocolProcessor.h
+++ b/lib/cpp/src/thrift/async/TAsyncProtocolProcessor.h
@@ -30,23 +30,23 @@
 
 class TAsyncProtocolProcessor : public TAsyncBufferProcessor {
 public:
-  TAsyncProtocolProcessor(stdcxx::shared_ptr<TAsyncProcessor> underlying,
-                          stdcxx::shared_ptr<apache::thrift::protocol::TProtocolFactory> pfact)
+  TAsyncProtocolProcessor(std::shared_ptr<TAsyncProcessor> underlying,
+                          std::shared_ptr<apache::thrift::protocol::TProtocolFactory> pfact)
     : underlying_(underlying), pfact_(pfact) {}
 
-  virtual void process(apache::thrift::stdcxx::function<void(bool healthy)> _return,
-                       stdcxx::shared_ptr<apache::thrift::transport::TBufferBase> ibuf,
-                       stdcxx::shared_ptr<apache::thrift::transport::TBufferBase> obuf);
+  virtual void process(std::function<void(bool healthy)> _return,
+                       std::shared_ptr<apache::thrift::transport::TBufferBase> ibuf,
+                       std::shared_ptr<apache::thrift::transport::TBufferBase> obuf);
 
   virtual ~TAsyncProtocolProcessor() {}
 
 private:
-  static void finish(apache::thrift::stdcxx::function<void(bool healthy)> _return,
-                     stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> oprot,
+  static void finish(std::function<void(bool healthy)> _return,
+                     std::shared_ptr<apache::thrift::protocol::TProtocol> oprot,
                      bool healthy);
 
-  stdcxx::shared_ptr<TAsyncProcessor> underlying_;
-  stdcxx::shared_ptr<apache::thrift::protocol::TProtocolFactory> pfact_;
+  std::shared_ptr<TAsyncProcessor> underlying_;
+  std::shared_ptr<apache::thrift::protocol::TProtocolFactory> pfact_;
 };
 }
 }
diff --git a/lib/cpp/src/thrift/async/TConcurrentClientSyncInfo.h b/lib/cpp/src/thrift/async/TConcurrentClientSyncInfo.h
index 9ec77b9..0bc5eb5 100644
--- a/lib/cpp/src/thrift/async/TConcurrentClientSyncInfo.h
+++ b/lib/cpp/src/thrift/async/TConcurrentClientSyncInfo.h
@@ -22,7 +22,7 @@
 #include <thrift/protocol/TProtocol.h>
 #include <thrift/concurrency/Mutex.h>
 #include <thrift/concurrency/Monitor.h>
-#include <thrift/stdcxx.h>
+#include <memory>
 #include <vector>
 #include <string>
 #include <map>
@@ -60,7 +60,7 @@
 
 class TConcurrentClientSyncInfo {
 private: // typedefs
-  typedef stdcxx::shared_ptr< ::apache::thrift::concurrency::Monitor> MonitorPtr;
+  typedef std::shared_ptr< ::apache::thrift::concurrency::Monitor> MonitorPtr;
   typedef std::map<int32_t, MonitorPtr> MonitorMap;
 
 public:
diff --git a/lib/cpp/src/thrift/async/TEvhttpClientChannel.h b/lib/cpp/src/thrift/async/TEvhttpClientChannel.h
index 3515ca2..a321f41 100644
--- a/lib/cpp/src/thrift/async/TEvhttpClientChannel.h
+++ b/lib/cpp/src/thrift/async/TEvhttpClientChannel.h
@@ -23,7 +23,7 @@
 #include <queue>
 #include <string>
 #include <utility>
-#include <thrift/stdcxx.h>
+#include <memory>
 #include <thrift/async/TAsyncChannel.h>
 
 struct event_base;
diff --git a/lib/cpp/src/thrift/async/TEvhttpServer.cpp b/lib/cpp/src/thrift/async/TEvhttpServer.cpp
index d87e507..bdc3266 100644
--- a/lib/cpp/src/thrift/async/TEvhttpServer.cpp
+++ b/lib/cpp/src/thrift/async/TEvhttpServer.cpp
@@ -20,7 +20,7 @@
 #include <thrift/async/TEvhttpServer.h>
 #include <thrift/async/TAsyncBufferProcessor.h>
 #include <thrift/transport/TBufferTransports.h>
-#include <thrift/stdcxx.h>
+#include <memory>
 #include <evhttp.h>
 #include <event2/buffer.h>
 #include <event2/buffer_compat.h>
@@ -31,8 +31,7 @@
 #endif
 
 using apache::thrift::transport::TMemoryBuffer;
-using apache::thrift::stdcxx::scoped_ptr;
-using apache::thrift::stdcxx::shared_ptr;
+using std::shared_ptr;
 
 namespace apache {
 namespace thrift {
@@ -40,17 +39,17 @@
 
 struct TEvhttpServer::RequestContext {
   struct evhttp_request* req;
-  stdcxx::shared_ptr<apache::thrift::transport::TMemoryBuffer> ibuf;
-  stdcxx::shared_ptr<apache::thrift::transport::TMemoryBuffer> obuf;
+  std::shared_ptr<apache::thrift::transport::TMemoryBuffer> ibuf;
+  std::shared_ptr<apache::thrift::transport::TMemoryBuffer> obuf;
 
   RequestContext(struct evhttp_request* req);
 };
 
-TEvhttpServer::TEvhttpServer(stdcxx::shared_ptr<TAsyncBufferProcessor> processor)
+TEvhttpServer::TEvhttpServer(std::shared_ptr<TAsyncBufferProcessor> processor)
   : processor_(processor), eb_(NULL), eh_(NULL) {
 }
 
-TEvhttpServer::TEvhttpServer(stdcxx::shared_ptr<TAsyncBufferProcessor> processor, int port)
+TEvhttpServer::TEvhttpServer(std::shared_ptr<TAsyncBufferProcessor> processor, int port)
   : processor_(processor), eb_(NULL), eh_(NULL) {
   // Create event_base and evhttp.
   eb_ = event_base_new();
@@ -110,17 +109,17 @@
 
 void TEvhttpServer::process(struct evhttp_request* req) {
   RequestContext* ctx = new RequestContext(req);
-  return processor_->process(apache::thrift::stdcxx::bind(&TEvhttpServer::complete,
+  return processor_->process(std::bind(&TEvhttpServer::complete,
                                                           this,
                                                           ctx,
-                                                          apache::thrift::stdcxx::placeholders::_1),
+                                                          std::placeholders::_1),
                              ctx->ibuf,
                              ctx->obuf);
 }
 
 void TEvhttpServer::complete(RequestContext* ctx, bool success) {
   (void)success;
-  scoped_ptr<RequestContext> ptr(ctx);
+  std::unique_ptr<RequestContext> ptr(ctx);
 
   int code = success ? 200 : 400;
   const char* reason = success ? "OK" : "Bad Request";
diff --git a/lib/cpp/src/thrift/async/TEvhttpServer.h b/lib/cpp/src/thrift/async/TEvhttpServer.h
index afc679c..c5bf3b6 100644
--- a/lib/cpp/src/thrift/async/TEvhttpServer.h
+++ b/lib/cpp/src/thrift/async/TEvhttpServer.h
@@ -20,7 +20,7 @@
 #ifndef _THRIFT_TEVHTTP_SERVER_H_
 #define _THRIFT_TEVHTTP_SERVER_H_ 1
 
-#include <thrift/stdcxx.h>
+#include <memory>
 
 struct event_base;
 struct evhttp;
@@ -41,14 +41,14 @@
    * address of the server as the extra arg.
    * Do not call "serve" on this server.
    */
-  TEvhttpServer(stdcxx::shared_ptr<TAsyncBufferProcessor> processor);
+  TEvhttpServer(std::shared_ptr<TAsyncBufferProcessor> processor);
 
   /**
    * Create a TEvhttpServer with an embedded event_base and evhttp,
    * listening on port and responding on the endpoint "/".
    * Call "serve" on this server to serve forever.
    */
-  TEvhttpServer(stdcxx::shared_ptr<TAsyncBufferProcessor> processor, int port);
+  TEvhttpServer(std::shared_ptr<TAsyncBufferProcessor> processor, int port);
 
   ~TEvhttpServer();
 
@@ -63,7 +63,7 @@
   void process(struct evhttp_request* req);
   void complete(RequestContext* ctx, bool success);
 
-  stdcxx::shared_ptr<TAsyncBufferProcessor> processor_;
+  std::shared_ptr<TAsyncBufferProcessor> processor_;
   struct event_base* eb_;
   struct evhttp* eh_;
 };
diff --git a/lib/cpp/src/thrift/concurrency/FunctionRunner.h b/lib/cpp/src/thrift/concurrency/FunctionRunner.h
index eabf019..8ad176e 100644
--- a/lib/cpp/src/thrift/concurrency/FunctionRunner.h
+++ b/lib/cpp/src/thrift/concurrency/FunctionRunner.h
@@ -21,7 +21,7 @@
 #define _THRIFT_CONCURRENCY_FUNCTION_RUNNER_H 1
 
 #include <thrift/concurrency/Thread.h>
-#include <thrift/stdcxx.h>
+#include <memory>
 
 namespace apache {
 namespace thrift {
@@ -44,7 +44,7 @@
  *  A* a = new A();
  *  // To create a thread that executes a.foo() every 100 milliseconds:
  *  factory->newThread(FunctionRunner::create(
- *    apache::thrift::stdcxx::bind(&A::foo, a), 100))->start();
+ *    std::bind(&A::foo, a), 100))->start();
  *
  */
 
@@ -53,20 +53,20 @@
   // 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 stdcxx::function<void()> VoidFunc;
+  typedef std::function<void()> VoidFunc;
 
-  typedef stdcxx::function<bool()> BoolFunc;
+  typedef std::function<bool()> BoolFunc;
 
   /**
    * Syntactic sugar to make it easier to create new FunctionRunner
    * objects wrapped in shared_ptr.
    */
-  static stdcxx::shared_ptr<FunctionRunner> create(const VoidFunc& cob) {
-    return stdcxx::shared_ptr<FunctionRunner>(new FunctionRunner(cob));
+  static std::shared_ptr<FunctionRunner> create(const VoidFunc& cob) {
+    return std::shared_ptr<FunctionRunner>(new FunctionRunner(cob));
   }
 
-  static stdcxx::shared_ptr<FunctionRunner> create(PthreadFuncPtr func, void* arg) {
-    return stdcxx::shared_ptr<FunctionRunner>(new FunctionRunner(func, arg));
+  static std::shared_ptr<FunctionRunner> create(PthreadFuncPtr func, void* arg) {
+    return std::shared_ptr<FunctionRunner>(new FunctionRunner(func, arg));
   }
 
 private:
@@ -81,7 +81,7 @@
    * execute the given callback.  Note that the 'void*' return value is ignored.
    */
   FunctionRunner(PthreadFuncPtr func, void* arg)
-    : func_(stdcxx::bind(pthread_func_wrapper, func, arg)), intervalMs_(-1) {}
+    : func_(std::bind(pthread_func_wrapper, func, arg)), intervalMs_(-1) {}
 
   /**
    * Given a generic callback, this FunctionRunner will execute it.
diff --git a/lib/cpp/src/thrift/concurrency/Monitor.cpp b/lib/cpp/src/thrift/concurrency/Monitor.cpp
index af4fcd0..8e4ac79 100644
--- a/lib/cpp/src/thrift/concurrency/Monitor.cpp
+++ b/lib/cpp/src/thrift/concurrency/Monitor.cpp
@@ -23,7 +23,7 @@
 #include <thrift/concurrency/Exception.h>
 #include <thrift/concurrency/Util.h>
 #include <thrift/transport/PlatformSocket.h>
-#include <thrift/stdcxx.h>
+#include <memory>
 
 #include <assert.h>
 
@@ -34,8 +34,8 @@
 namespace apache {
 namespace thrift {
 
-using stdcxx::scoped_ptr;
-using stdcxx::shared_ptr;
+using std::scoped_ptr;
+using std::shared_ptr;
 
 namespace concurrency {
 
diff --git a/lib/cpp/src/thrift/concurrency/Mutex.h b/lib/cpp/src/thrift/concurrency/Mutex.h
index 09b938e..a1f5396 100644
--- a/lib/cpp/src/thrift/concurrency/Mutex.h
+++ b/lib/cpp/src/thrift/concurrency/Mutex.h
@@ -20,7 +20,7 @@
 #ifndef _THRIFT_CONCURRENCY_MUTEX_H_
 #define _THRIFT_CONCURRENCY_MUTEX_H_ 1
 
-#include <thrift/stdcxx.h>
+#include <memory>
 #include <boost/noncopyable.hpp>
 #include <stdint.h>
 
@@ -86,7 +86,7 @@
 
 private:
   class impl;
-  stdcxx::shared_ptr<impl> impl_;
+  std::shared_ptr<impl> impl_;
 };
 
 class ReadWriteMutex {
@@ -107,7 +107,7 @@
 
 private:
   class impl;
-  stdcxx::shared_ptr<impl> impl_;
+  std::shared_ptr<impl> impl_;
 };
 
 /**
diff --git a/lib/cpp/src/thrift/concurrency/PosixThreadFactory.cpp b/lib/cpp/src/thrift/concurrency/PosixThreadFactory.cpp
index 2e35446..5c59269 100644
--- a/lib/cpp/src/thrift/concurrency/PosixThreadFactory.cpp
+++ b/lib/cpp/src/thrift/concurrency/PosixThreadFactory.cpp
@@ -32,7 +32,7 @@
 
 #include <iostream>
 
-#include <thrift/stdcxx.h>
+#include <memory>
 
 namespace apache {
 namespace thrift {
@@ -58,7 +58,7 @@
   int policy_;
   int priority_;
   int stackSize_;
-  stdcxx::weak_ptr<PthreadThread> self_;
+  std::weak_ptr<PthreadThread> self_;
   bool detached_;
 
 public:
@@ -66,7 +66,7 @@
                 int priority,
                 int stackSize,
                 bool detached,
-                stdcxx::shared_ptr<Runnable> runnable)
+                std::shared_ptr<Runnable> runnable)
     :
 
 #ifndef _WIN32
@@ -155,7 +155,7 @@
     }
 
     // Create reference
-    stdcxx::shared_ptr<PthreadThread>* selfRef = new stdcxx::shared_ptr<PthreadThread>();
+    std::shared_ptr<PthreadThread>* selfRef = new std::shared_ptr<PthreadThread>();
     *selfRef = self_.lock();
 
     setState(starting);
@@ -201,19 +201,19 @@
 #endif // _WIN32
   }
 
-  stdcxx::shared_ptr<Runnable> runnable() const { return Thread::runnable(); }
+  std::shared_ptr<Runnable> runnable() const { return Thread::runnable(); }
 
-  void runnable(stdcxx::shared_ptr<Runnable> value) { Thread::runnable(value); }
+  void runnable(std::shared_ptr<Runnable> value) { Thread::runnable(value); }
 
-  void weakRef(stdcxx::shared_ptr<PthreadThread> self) {
+  void weakRef(std::shared_ptr<PthreadThread> self) {
     assert(self.get() == this);
-    self_ = stdcxx::weak_ptr<PthreadThread>(self);
+    self_ = std::weak_ptr<PthreadThread>(self);
   }
 };
 
 void* PthreadThread::threadMain(void* arg) {
-  stdcxx::shared_ptr<PthreadThread> thread = *(stdcxx::shared_ptr<PthreadThread>*)arg;
-  delete reinterpret_cast<stdcxx::shared_ptr<PthreadThread>*>(arg);
+  std::shared_ptr<PthreadThread> thread = *(std::shared_ptr<PthreadThread>*)arg;
+  delete reinterpret_cast<std::shared_ptr<PthreadThread>*>(arg);
 
 #if GOOGLE_PERFTOOLS_REGISTER_THREAD
   ProfilerRegisterThread();
@@ -294,9 +294,9 @@
     stackSize_(1) {
 }
 
-stdcxx::shared_ptr<Thread> PosixThreadFactory::newThread(stdcxx::shared_ptr<Runnable> runnable) const {
-  stdcxx::shared_ptr<PthreadThread> result
-      = stdcxx::shared_ptr<PthreadThread>(new PthreadThread(toPthreadPolicy(policy_),
+std::shared_ptr<Thread> PosixThreadFactory::newThread(std::shared_ptr<Runnable> runnable) const {
+  std::shared_ptr<PthreadThread> result
+      = std::shared_ptr<PthreadThread>(new PthreadThread(toPthreadPolicy(policy_),
                                                     toPthreadPriority(policy_, priority_),
                                                     stackSize_,
                                                     isDetached(),
diff --git a/lib/cpp/src/thrift/concurrency/PosixThreadFactory.h b/lib/cpp/src/thrift/concurrency/PosixThreadFactory.h
index 5e04d01..cb3b17c 100644
--- a/lib/cpp/src/thrift/concurrency/PosixThreadFactory.h
+++ b/lib/cpp/src/thrift/concurrency/PosixThreadFactory.h
@@ -22,7 +22,7 @@
 
 #include <thrift/concurrency/Thread.h>
 
-#include <thrift/stdcxx.h>
+#include <memory>
 
 namespace apache {
 namespace thrift {
@@ -63,7 +63,7 @@
 
   /**
    * Posix thread (pthread) factory.  All threads created by a factory are reference-counted
-   * via stdcxx::shared_ptr.  The factory guarantees that threads and the Runnable tasks 
+   * via std::shared_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.
    *
@@ -88,7 +88,7 @@
   PosixThreadFactory(bool detached);
 
   // From ThreadFactory;
-  stdcxx::shared_ptr<Thread> newThread(stdcxx::shared_ptr<Runnable> runnable) const;
+  std::shared_ptr<Thread> newThread(std::shared_ptr<Runnable> runnable) const;
 
   // From ThreadFactory;
   Thread::id_t getCurrentThreadId() const;
diff --git a/lib/cpp/src/thrift/concurrency/StdThreadFactory.cpp b/lib/cpp/src/thrift/concurrency/StdThreadFactory.cpp
index da0c5e3..c885f3a 100644
--- a/lib/cpp/src/thrift/concurrency/StdThreadFactory.cpp
+++ b/lib/cpp/src/thrift/concurrency/StdThreadFactory.cpp
@@ -24,7 +24,7 @@
 #include <thrift/concurrency/Exception.h>
 #include <thrift/concurrency/Monitor.h>
 #include <thrift/concurrency/StdThreadFactory.h>
-#include <thrift/stdcxx.h>
+#include <memory>
 
 #include <cassert>
 #include <thread>
@@ -42,11 +42,11 @@
  *
  * @version $Id:$
  */
-class StdThread : public Thread, public stdcxx::enable_shared_from_this<StdThread> {
+class StdThread : public Thread, public std::enable_shared_from_this<StdThread> {
 public:
   enum STATE { uninitialized, starting, started, stopping, stopped };
 
-  static void threadMain(stdcxx::shared_ptr<StdThread> thread);
+  static void threadMain(std::shared_ptr<StdThread> thread);
 
 private:
   std::unique_ptr<std::thread> thread_;
@@ -55,7 +55,7 @@
   bool detached_;
 
 public:
-  StdThread(bool detached, stdcxx::shared_ptr<Runnable> runnable)
+  StdThread(bool detached, std::shared_ptr<Runnable> runnable)
     : state_(uninitialized), detached_(detached) {
     this->Thread::runnable(runnable);
   }
@@ -93,7 +93,7 @@
       return;
     }
 
-    stdcxx::shared_ptr<StdThread> selfRef = shared_from_this();
+    std::shared_ptr<StdThread> selfRef = shared_from_this();
     setState(starting);
 
     Synchronized sync(monitor_);
@@ -116,12 +116,12 @@
 
   Thread::id_t getId() { return thread_.get() ? thread_->get_id() : std::thread::id(); }
 
-  stdcxx::shared_ptr<Runnable> runnable() const { return Thread::runnable(); }
+  std::shared_ptr<Runnable> runnable() const { return Thread::runnable(); }
 
-  void runnable(stdcxx::shared_ptr<Runnable> value) { Thread::runnable(value); }
+  void runnable(std::shared_ptr<Runnable> value) { Thread::runnable(value); }
 };
 
-void StdThread::threadMain(stdcxx::shared_ptr<StdThread> thread) {
+void StdThread::threadMain(std::shared_ptr<StdThread> thread) {
 #if GOOGLE_PERFTOOLS_REGISTER_THREAD
   ProfilerRegisterThread();
 #endif
@@ -137,8 +137,8 @@
 StdThreadFactory::StdThreadFactory(bool detached) : ThreadFactory(detached) {
 }
 
-stdcxx::shared_ptr<Thread> StdThreadFactory::newThread(stdcxx::shared_ptr<Runnable> runnable) const {
-  stdcxx::shared_ptr<StdThread> result = stdcxx::shared_ptr<StdThread>(new StdThread(isDetached(), runnable));
+std::shared_ptr<Thread> StdThreadFactory::newThread(std::shared_ptr<Runnable> runnable) const {
+  std::shared_ptr<StdThread> result = std::shared_ptr<StdThread>(new StdThread(isDetached(), runnable));
   runnable->thread(result);
   return result;
 }
diff --git a/lib/cpp/src/thrift/concurrency/StdThreadFactory.h b/lib/cpp/src/thrift/concurrency/StdThreadFactory.h
index 8e116b6..e74046b 100644
--- a/lib/cpp/src/thrift/concurrency/StdThreadFactory.h
+++ b/lib/cpp/src/thrift/concurrency/StdThreadFactory.h
@@ -22,7 +22,7 @@
 
 #include <thrift/concurrency/Thread.h>
 
-#include <thrift/stdcxx.h>
+#include <memory>
 
 namespace apache {
 namespace thrift {
@@ -38,7 +38,7 @@
 public:
   /**
    * Std thread factory.  All threads created by a factory are reference-counted
-   * via stdcxx::shared_ptr.  The factory guarantees that threads and the Runnable tasks
+   * via std::shared_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.
    *
@@ -48,7 +48,7 @@
   StdThreadFactory(bool detached = true);
 
   // From ThreadFactory;
-  stdcxx::shared_ptr<Thread> newThread(stdcxx::shared_ptr<Runnable> runnable) const;
+  std::shared_ptr<Thread> newThread(std::shared_ptr<Runnable> runnable) const;
 
   // From ThreadFactory;
   Thread::id_t getCurrentThreadId() const;
diff --git a/lib/cpp/src/thrift/concurrency/Thread.h b/lib/cpp/src/thrift/concurrency/Thread.h
index 7e2d251..b2ea4e2 100644
--- a/lib/cpp/src/thrift/concurrency/Thread.h
+++ b/lib/cpp/src/thrift/concurrency/Thread.h
@@ -21,7 +21,7 @@
 #define _THRIFT_CONCURRENCY_THREAD_H_ 1
 
 #include <stdint.h>
-#include <thrift/stdcxx.h>
+#include <memory>
 
 #include <thrift/thrift-config.h>
 
@@ -54,16 +54,16 @@
    * Gets the thread object that is hosting this runnable object  - can return
    * an empty boost::shared pointer if no references remain on that thread object
    */
-  virtual stdcxx::shared_ptr<Thread> thread() { return thread_.lock(); }
+  virtual std::shared_ptr<Thread> thread() { return thread_.lock(); }
 
   /**
    * Sets the thread that is executing this object.  This is only meant for
    * use by concrete implementations of Thread.
    */
-  virtual void thread(stdcxx::shared_ptr<Thread> value) { thread_ = value; }
+  virtual void thread(std::shared_ptr<Thread> value) { thread_ = value; }
 
 private:
-  stdcxx::weak_ptr<Thread> thread_;
+  std::weak_ptr<Thread> thread_;
 };
 
 /**
@@ -114,13 +114,13 @@
   /**
    * Gets the runnable object this thread is hosting
    */
-  virtual stdcxx::shared_ptr<Runnable> runnable() const { return _runnable; }
+  virtual std::shared_ptr<Runnable> runnable() const { return _runnable; }
 
 protected:
-  virtual void runnable(stdcxx::shared_ptr<Runnable> value) { _runnable = value; }
+  virtual void runnable(std::shared_ptr<Runnable> value) { _runnable = value; }
 
 private:
-  stdcxx::shared_ptr<Runnable> _runnable;
+  std::shared_ptr<Runnable> _runnable;
 };
 
 /**
@@ -147,7 +147,7 @@
   /**
    * Create a new thread.
    */
-  virtual stdcxx::shared_ptr<Thread> newThread(stdcxx::shared_ptr<Runnable> runnable) const = 0;
+  virtual std::shared_ptr<Thread> newThread(std::shared_ptr<Runnable> runnable) const = 0;
 
   /**
    * Gets the current thread id or unknown_thread_id if the current thread is not a thrift thread
diff --git a/lib/cpp/src/thrift/concurrency/ThreadManager.cpp b/lib/cpp/src/thrift/concurrency/ThreadManager.cpp
index 2e27b7f..58025f9 100644
--- a/lib/cpp/src/thrift/concurrency/ThreadManager.cpp
+++ b/lib/cpp/src/thrift/concurrency/ThreadManager.cpp
@@ -24,7 +24,7 @@
 #include <thrift/concurrency/Monitor.h>
 #include <thrift/concurrency/Util.h>
 
-#include <thrift/stdcxx.h>
+#include <memory>
 
 #include <stdexcept>
 #include <deque>
@@ -34,8 +34,8 @@
 namespace thrift {
 namespace concurrency {
 
-using stdcxx::shared_ptr;
-using stdcxx::dynamic_pointer_cast;
+using std::shared_ptr;
+using std::dynamic_pointer_cast;
 
 /**
  * ThreadManager class
@@ -504,7 +504,7 @@
   }
 }
 
-stdcxx::shared_ptr<Runnable> ThreadManager::Impl::removeNextPending() {
+std::shared_ptr<Runnable> ThreadManager::Impl::removeNextPending() {
   Guard g(mutex_);
   if (state_ != ThreadManager::STARTED) {
     throw IllegalStateException(
@@ -513,7 +513,7 @@
   }
 
   if (tasks_.empty()) {
-    return stdcxx::shared_ptr<Runnable>();
+    return std::shared_ptr<Runnable>();
   }
 
   shared_ptr<ThreadManager::Task> task = tasks_.front();
diff --git a/lib/cpp/src/thrift/concurrency/ThreadManager.h b/lib/cpp/src/thrift/concurrency/ThreadManager.h
index b3b7542..470fc0a 100644
--- a/lib/cpp/src/thrift/concurrency/ThreadManager.h
+++ b/lib/cpp/src/thrift/concurrency/ThreadManager.h
@@ -20,9 +20,10 @@
 #ifndef _THRIFT_CONCURRENCY_THREADMANAGER_H_
 #define _THRIFT_CONCURRENCY_THREADMANAGER_H_ 1
 
+#include <functional>
+#include <memory>
 #include <sys/types.h>
 #include <thrift/concurrency/Thread.h>
-#include <thrift/stdcxx.h>
 
 namespace apache {
 namespace thrift {
@@ -58,7 +59,7 @@
   ThreadManager() {}
 
 public:
-  typedef apache::thrift::stdcxx::function<void(stdcxx::shared_ptr<Runnable>)> ExpireCallback;
+  typedef std::function<void(std::shared_ptr<Runnable>)> ExpireCallback;
 
   virtual ~ThreadManager() {}
 
@@ -87,14 +88,14 @@
   /**
    * \returns the current thread factory
    */
-  virtual stdcxx::shared_ptr<ThreadFactory> threadFactory() const = 0;
+  virtual std::shared_ptr<ThreadFactory> threadFactory() const = 0;
 
   /**
    * Set the thread factory.
    * \throws InvalidArgumentException if the new thread factory has a different
    *                                  detached disposition than the one replacing it
    */
-  virtual void threadFactory(stdcxx::shared_ptr<ThreadFactory> value) = 0;
+  virtual void threadFactory(std::shared_ptr<ThreadFactory> value) = 0;
 
   /**
    * Adds worker thread(s).
@@ -161,21 +162,21 @@
    *
    * @throws TooManyPendingTasksException Pending task count exceeds max pending task count
    */
-  virtual void add(stdcxx::shared_ptr<Runnable> task,
+  virtual void add(std::shared_ptr<Runnable> task,
                    int64_t timeout = 0LL,
                    int64_t expiration = 0LL) = 0;
 
   /**
    * Removes a pending task
    */
-  virtual void remove(stdcxx::shared_ptr<Runnable> task) = 0;
+  virtual void remove(std::shared_ptr<Runnable> task) = 0;
 
   /**
    * Remove the next pending task which would be run.
    *
    * @return the task removed.
    */
-  virtual stdcxx::shared_ptr<Runnable> removeNextPending() = 0;
+  virtual std::shared_ptr<Runnable> removeNextPending() = 0;
 
   /**
    * Remove tasks from front of task queue that have expired.
@@ -190,14 +191,14 @@
    */
   virtual void setExpireCallback(ExpireCallback expireCallback) = 0;
 
-  static stdcxx::shared_ptr<ThreadManager> newThreadManager();
+  static std::shared_ptr<ThreadManager> newThreadManager();
 
   /**
    * Creates a simple thread manager the uses count number of worker threads and has
    * a pendingTaskCountMax maximum pending tasks. The default, 0, specified no limit
    * on pending tasks
    */
-  static stdcxx::shared_ptr<ThreadManager> newSimpleThreadManager(size_t count = 4,
+  static std::shared_ptr<ThreadManager> newSimpleThreadManager(size_t count = 4,
                                                                  size_t pendingTaskCountMax = 0);
 
   class Task;
diff --git a/lib/cpp/src/thrift/concurrency/TimerManager.cpp b/lib/cpp/src/thrift/concurrency/TimerManager.cpp
index 2017146..61a34ff 100644
--- a/lib/cpp/src/thrift/concurrency/TimerManager.cpp
+++ b/lib/cpp/src/thrift/concurrency/TimerManager.cpp
@@ -29,8 +29,8 @@
 namespace thrift {
 namespace concurrency {
 
-using stdcxx::shared_ptr;
-using stdcxx::weak_ptr;
+using std::shared_ptr;
+using std::weak_ptr;
 
 /**
  * TimerManager class
diff --git a/lib/cpp/src/thrift/concurrency/TimerManager.h b/lib/cpp/src/thrift/concurrency/TimerManager.h
index 2bfc6a7..ba79226 100644
--- a/lib/cpp/src/thrift/concurrency/TimerManager.h
+++ b/lib/cpp/src/thrift/concurrency/TimerManager.h
@@ -24,7 +24,7 @@
 #include <thrift/concurrency/Monitor.h>
 #include <thrift/concurrency/Thread.h>
 
-#include <thrift/stdcxx.h>
+#include <memory>
 #include <map>
 #include <time.h>
 
@@ -43,15 +43,15 @@
 
 public:
   class Task;
-  typedef stdcxx::weak_ptr<Task> Timer;
+  typedef std::weak_ptr<Task> Timer;
 
   TimerManager();
 
   virtual ~TimerManager();
 
-  virtual stdcxx::shared_ptr<const ThreadFactory> threadFactory() const;
+  virtual std::shared_ptr<const ThreadFactory> threadFactory() const;
 
-  virtual void threadFactory(stdcxx::shared_ptr<const ThreadFactory> value);
+  virtual void threadFactory(std::shared_ptr<const ThreadFactory> value);
 
   /**
    * Starts the timer manager service
@@ -74,7 +74,7 @@
    * @param timeout Time in milliseconds to delay before executing task
    * @return Handle of the timer, which can be used to remove the timer.
    */
-  virtual Timer add(stdcxx::shared_ptr<Runnable> task, int64_t timeout);
+  virtual Timer add(std::shared_ptr<Runnable> task, int64_t timeout);
 
   /**
    * Adds a task to be executed at some time in the future by a worker thread.
@@ -83,7 +83,7 @@
    * @param timeout Absolute time in the future to execute task.
    * @return Handle of the timer, which can be used to remove the timer.
    */
-  virtual Timer add(stdcxx::shared_ptr<Runnable> task, const struct THRIFT_TIMESPEC& timeout);
+  virtual Timer add(std::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.
@@ -92,7 +92,7 @@
    * @param timeout Absolute time in the future to execute task.
    * @return Handle of the timer, which can be used to remove the timer.
    */
-  virtual Timer add(stdcxx::shared_ptr<Runnable> task, const struct timeval& timeout);
+  virtual Timer add(std::shared_ptr<Runnable> task, const struct timeval& timeout);
 
   /**
    * Removes a pending task
@@ -106,7 +106,7 @@
    * @throws UncancellableTaskException Specified task is already being
    *                                    executed or has completed execution.
    */
-  virtual void remove(stdcxx::shared_ptr<Runnable> task);
+  virtual void remove(std::shared_ptr<Runnable> task);
 
   /**
    * Removes a single pending task
@@ -127,17 +127,17 @@
   virtual STATE state() const;
 
 private:
-  stdcxx::shared_ptr<const ThreadFactory> threadFactory_;
+  std::shared_ptr<const ThreadFactory> threadFactory_;
   friend class Task;
-  std::multimap<int64_t, stdcxx::shared_ptr<Task> > taskMap_;
+  std::multimap<int64_t, std::shared_ptr<Task> > taskMap_;
   size_t taskCount_;
   Monitor monitor_;
   STATE state_;
   class Dispatcher;
   friend class Dispatcher;
-  stdcxx::shared_ptr<Dispatcher> dispatcher_;
-  stdcxx::shared_ptr<Thread> dispatcherThread_;
-  typedef std::multimap<int64_t, stdcxx::shared_ptr<TimerManager::Task> >::iterator task_iterator;
+  std::shared_ptr<Dispatcher> dispatcher_;
+  std::shared_ptr<Thread> dispatcherThread_;
+  typedef std::multimap<int64_t, std::shared_ptr<TimerManager::Task> >::iterator task_iterator;
   typedef std::pair<task_iterator, task_iterator> task_range;
 };
 }
diff --git a/lib/cpp/src/thrift/processor/PeekProcessor.cpp b/lib/cpp/src/thrift/processor/PeekProcessor.cpp
index fa11a72..07f6ba5 100644
--- a/lib/cpp/src/thrift/processor/PeekProcessor.cpp
+++ b/lib/cpp/src/thrift/processor/PeekProcessor.cpp
@@ -34,26 +34,26 @@
 PeekProcessor::~PeekProcessor() {
 }
 
-void PeekProcessor::initialize(stdcxx::shared_ptr<TProcessor> actualProcessor,
-                               stdcxx::shared_ptr<TProtocolFactory> protocolFactory,
-                               stdcxx::shared_ptr<TPipedTransportFactory> transportFactory) {
+void PeekProcessor::initialize(std::shared_ptr<TProcessor> actualProcessor,
+                               std::shared_ptr<TProtocolFactory> protocolFactory,
+                               std::shared_ptr<TPipedTransportFactory> transportFactory) {
   actualProcessor_ = actualProcessor;
   pipedProtocol_ = protocolFactory->getProtocol(targetTransport_);
   transportFactory_ = transportFactory;
   transportFactory_->initializeTargetTransport(targetTransport_);
 }
 
-stdcxx::shared_ptr<TTransport> PeekProcessor::getPipedTransport(stdcxx::shared_ptr<TTransport> in) {
+std::shared_ptr<TTransport> PeekProcessor::getPipedTransport(std::shared_ptr<TTransport> in) {
   return transportFactory_->getTransport(in);
 }
 
-void PeekProcessor::setTargetTransport(stdcxx::shared_ptr<TTransport> targetTransport) {
+void PeekProcessor::setTargetTransport(std::shared_ptr<TTransport> targetTransport) {
   targetTransport_ = targetTransport;
-  if (stdcxx::dynamic_pointer_cast<TMemoryBuffer>(targetTransport_)) {
-    memoryBuffer_ = stdcxx::dynamic_pointer_cast<TMemoryBuffer>(targetTransport);
-  } else if (stdcxx::dynamic_pointer_cast<TPipedTransport>(targetTransport_)) {
-    memoryBuffer_ = stdcxx::dynamic_pointer_cast<TMemoryBuffer>(
-        stdcxx::dynamic_pointer_cast<TPipedTransport>(targetTransport_)->getTargetTransport());
+  if (std::dynamic_pointer_cast<TMemoryBuffer>(targetTransport_)) {
+    memoryBuffer_ = std::dynamic_pointer_cast<TMemoryBuffer>(targetTransport);
+  } else if (std::dynamic_pointer_cast<TPipedTransport>(targetTransport_)) {
+    memoryBuffer_ = std::dynamic_pointer_cast<TMemoryBuffer>(
+        std::dynamic_pointer_cast<TPipedTransport>(targetTransport_)->getTargetTransport());
   }
 
   if (!memoryBuffer_) {
@@ -62,8 +62,8 @@
   }
 }
 
-bool PeekProcessor::process(stdcxx::shared_ptr<TProtocol> in,
-                            stdcxx::shared_ptr<TProtocol> out,
+bool PeekProcessor::process(std::shared_ptr<TProtocol> in,
+                            std::shared_ptr<TProtocol> out,
                             void* connectionContext) {
 
   std::string fname;
@@ -120,7 +120,7 @@
   (void)size;
 }
 
-void PeekProcessor::peek(stdcxx::shared_ptr<TProtocol> in, TType ftype, int16_t fid) {
+void PeekProcessor::peek(std::shared_ptr<TProtocol> in, TType ftype, int16_t fid) {
   (void)fid;
   in->skip(ftype);
 }
diff --git a/lib/cpp/src/thrift/processor/PeekProcessor.h b/lib/cpp/src/thrift/processor/PeekProcessor.h
index f5c10da..efac2b9 100644
--- a/lib/cpp/src/thrift/processor/PeekProcessor.h
+++ b/lib/cpp/src/thrift/processor/PeekProcessor.h
@@ -25,7 +25,7 @@
 #include <thrift/transport/TTransport.h>
 #include <thrift/transport/TTransportUtils.h>
 #include <thrift/transport/TBufferTransports.h>
-#include <thrift/stdcxx.h>
+#include <memory>
 
 namespace apache {
 namespace thrift {
@@ -47,34 +47,34 @@
   //             transportFactory - this TPipedTransportFactory is used to wrap the source transport
   //                                via a call to getPipedTransport
   void initialize(
-      stdcxx::shared_ptr<apache::thrift::TProcessor> actualProcessor,
-      stdcxx::shared_ptr<apache::thrift::protocol::TProtocolFactory> protocolFactory,
-      stdcxx::shared_ptr<apache::thrift::transport::TPipedTransportFactory> transportFactory);
+      std::shared_ptr<apache::thrift::TProcessor> actualProcessor,
+      std::shared_ptr<apache::thrift::protocol::TProtocolFactory> protocolFactory,
+      std::shared_ptr<apache::thrift::transport::TPipedTransportFactory> transportFactory);
 
-  stdcxx::shared_ptr<apache::thrift::transport::TTransport> getPipedTransport(
-      stdcxx::shared_ptr<apache::thrift::transport::TTransport> in);
+  std::shared_ptr<apache::thrift::transport::TTransport> getPipedTransport(
+      std::shared_ptr<apache::thrift::transport::TTransport> in);
 
-  void setTargetTransport(stdcxx::shared_ptr<apache::thrift::transport::TTransport> targetTransport);
+  void setTargetTransport(std::shared_ptr<apache::thrift::transport::TTransport> targetTransport);
 
-  virtual bool process(stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> in,
-                       stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> out,
+  virtual bool process(std::shared_ptr<apache::thrift::protocol::TProtocol> in,
+                       std::shared_ptr<apache::thrift::protocol::TProtocol> out,
                        void* connectionContext);
 
   // The following three functions can be overloaded by child classes to
   // achieve desired peeking behavior
   virtual void peekName(const std::string& fname);
   virtual void peekBuffer(uint8_t* buffer, uint32_t size);
-  virtual void peek(stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> in,
+  virtual void peek(std::shared_ptr<apache::thrift::protocol::TProtocol> in,
                     apache::thrift::protocol::TType ftype,
                     int16_t fid);
   virtual void peekEnd();
 
 private:
-  stdcxx::shared_ptr<apache::thrift::TProcessor> actualProcessor_;
-  stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> pipedProtocol_;
-  stdcxx::shared_ptr<apache::thrift::transport::TPipedTransportFactory> transportFactory_;
-  stdcxx::shared_ptr<apache::thrift::transport::TMemoryBuffer> memoryBuffer_;
-  stdcxx::shared_ptr<apache::thrift::transport::TTransport> targetTransport_;
+  std::shared_ptr<apache::thrift::TProcessor> actualProcessor_;
+  std::shared_ptr<apache::thrift::protocol::TProtocol> pipedProtocol_;
+  std::shared_ptr<apache::thrift::transport::TPipedTransportFactory> transportFactory_;
+  std::shared_ptr<apache::thrift::transport::TMemoryBuffer> memoryBuffer_;
+  std::shared_ptr<apache::thrift::transport::TTransport> targetTransport_;
 };
 }
 }
diff --git a/lib/cpp/src/thrift/processor/StatsProcessor.h b/lib/cpp/src/thrift/processor/StatsProcessor.h
index 8f6725f..e98efb8 100644
--- a/lib/cpp/src/thrift/processor/StatsProcessor.h
+++ b/lib/cpp/src/thrift/processor/StatsProcessor.h
@@ -20,7 +20,7 @@
 #ifndef STATSPROCESSOR_H
 #define STATSPROCESSOR_H
 
-#include <thrift/stdcxx.h>
+#include <memory>
 #include <thrift/transport/TTransport.h>
 #include <thrift/protocol/TProtocol.h>
 #include <TProcessor.h>
@@ -38,8 +38,8 @@
   StatsProcessor(bool print, bool frequency) : print_(print), frequency_(frequency) {}
   virtual ~StatsProcessor(){};
 
-  virtual bool process(stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> piprot,
-                       stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> poprot,
+  virtual bool process(std::shared_ptr<apache::thrift::protocol::TProtocol> piprot,
+                       std::shared_ptr<apache::thrift::protocol::TProtocol> poprot,
                        void* serverContext) {
 
     piprot_ = piprot;
@@ -229,7 +229,7 @@
     }
   }
 
-  stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> piprot_;
+  std::shared_ptr<apache::thrift::protocol::TProtocol> piprot_;
   std::map<std::string, int64_t> frequency_map_;
 
   bool print_;
diff --git a/lib/cpp/src/thrift/processor/TMultiplexedProcessor.h b/lib/cpp/src/thrift/processor/TMultiplexedProcessor.h
index aa3d49f..2aa7f75 100644
--- a/lib/cpp/src/thrift/processor/TMultiplexedProcessor.h
+++ b/lib/cpp/src/thrift/processor/TMultiplexedProcessor.h
@@ -36,7 +36,7 @@
  */
 class StoredMessageProtocol : public TProtocolDecorator {
 public:
-  StoredMessageProtocol(stdcxx::shared_ptr<protocol::TProtocol> _protocol,
+  StoredMessageProtocol(std::shared_ptr<protocol::TProtocol> _protocol,
                         const std::string& _name,
                         const TMessageType _type,
                         const int32_t _seqid)
@@ -65,19 +65,19 @@
  * processors with it, as shown in the following example:</p>
  *
  * <blockquote><code>
- *     stdcxx::shared_ptr<TMultiplexedProcessor> processor(new TMultiplexedProcessor());
+ *     std::shared_ptr<TMultiplexedProcessor> processor(new TMultiplexedProcessor());
  *
  *     processor->registerProcessor(
  *         "Calculator",
- *         stdcxx::shared_ptr<TProcessor>( new CalculatorProcessor(
- *             stdcxx::shared_ptr<CalculatorHandler>( new CalculatorHandler()))));
+ *         std::shared_ptr<TProcessor>( new CalculatorProcessor(
+ *             std::shared_ptr<CalculatorHandler>( new CalculatorHandler()))));
  *
  *     processor->registerProcessor(
  *         "WeatherReport",
- *         stdcxx::shared_ptr<TProcessor>( new WeatherReportProcessor(
- *             stdcxx::shared_ptr<WeatherReportHandler>( new WeatherReportHandler()))));
+ *         std::shared_ptr<TProcessor>( new WeatherReportProcessor(
+ *             std::shared_ptr<WeatherReportHandler>( new WeatherReportHandler()))));
  *
- *     stdcxx::shared_ptr<TServerTransport> transport(new TServerSocket(9090));
+ *     std::shared_ptr<TServerTransport> transport(new TServerSocket(9090));
  *     TSimpleServer server(processor, transport);
  *
  *     server.serve();
@@ -85,7 +85,7 @@
  */
 class TMultiplexedProcessor : public TProcessor {
 public:
-  typedef std::map<std::string, stdcxx::shared_ptr<TProcessor> > services_t;
+  typedef std::map<std::string, std::shared_ptr<TProcessor> > services_t;
 
   /**
     * 'Register' a service with this <code>TMultiplexedProcessor</code>.  This
@@ -98,7 +98,7 @@
     *                         as "handlers", e.g. WeatherReportHandler,
     *                         implementing WeatherReportIf interface.
     */
-  void registerProcessor(const std::string& serviceName, stdcxx::shared_ptr<TProcessor> processor) {
+  void registerProcessor(const std::string& serviceName, std::shared_ptr<TProcessor> processor) {
     services[serviceName] = processor;
   }
 
@@ -106,15 +106,15 @@
    * Register a service to be called to process queries without service name
    * \param [in] processor   Implementation of a service.
    */
-  void registerDefault(const stdcxx::shared_ptr<TProcessor>& processor) {
+  void registerDefault(const std::shared_ptr<TProcessor>& processor) {
     defaultProcessor = processor;
   }
 
   /**
    * Chew up invalid input and return an exception to throw.
    */
-  TException protocol_error(stdcxx::shared_ptr<protocol::TProtocol> in,
-                            stdcxx::shared_ptr<protocol::TProtocol> out,
+  TException protocol_error(std::shared_ptr<protocol::TProtocol> in,
+                            std::shared_ptr<protocol::TProtocol> out,
                             const std::string& name, 
                             int32_t seqid, 
                             const std::string& msg) const {
@@ -147,8 +147,8 @@
    * the service name was not found in the message, or if the service
    * name was not found in the service map.
    */
-  bool process(stdcxx::shared_ptr<protocol::TProtocol> in,
-               stdcxx::shared_ptr<protocol::TProtocol> out,
+  bool process(std::shared_ptr<protocol::TProtocol> in,
+               std::shared_ptr<protocol::TProtocol> out,
                void* connectionContext) {
     std::string name;
     protocol::TMessageType type;
@@ -177,11 +177,11 @@
       services_t::iterator it = services.find(tokens[0]);
 
       if (it != services.end()) {
-        stdcxx::shared_ptr<TProcessor> processor = it->second;
+        std::shared_ptr<TProcessor> processor = it->second;
         // Let the processor registered for this service name
         // process the message.
         return processor
-            ->process(stdcxx::shared_ptr<protocol::TProtocol>(
+            ->process(std::shared_ptr<protocol::TProtocol>(
                           new protocol::StoredMessageProtocol(in, tokens[1], type, seqid)),
                       out,
                       connectionContext);
@@ -195,7 +195,7 @@
 	  if (defaultProcessor) {
         // non-multiplexed client forwards to default processor
         return defaultProcessor            
-            ->process(stdcxx::shared_ptr<protocol::TProtocol>(
+            ->process(std::shared_ptr<protocol::TProtocol>(
                           new protocol::StoredMessageProtocol(in, tokens[0], type, seqid)),
                       out,
                       connectionContext);
@@ -216,7 +216,7 @@
   
   //! If a non-multi client requests something, it goes to the
   //! default processor (if one is defined) for backwards compatibility.
-  stdcxx::shared_ptr<TProcessor> defaultProcessor;
+  std::shared_ptr<TProcessor> defaultProcessor;
 };
 }
 }
diff --git a/lib/cpp/src/thrift/protocol/TBinaryProtocol.h b/lib/cpp/src/thrift/protocol/TBinaryProtocol.h
index f28d278..9067758 100644
--- a/lib/cpp/src/thrift/protocol/TBinaryProtocol.h
+++ b/lib/cpp/src/thrift/protocol/TBinaryProtocol.h
@@ -23,7 +23,7 @@
 #include <thrift/protocol/TProtocol.h>
 #include <thrift/protocol/TVirtualProtocol.h>
 
-#include <thrift/stdcxx.h>
+#include <memory>
 
 namespace apache {
 namespace thrift {
@@ -41,7 +41,7 @@
   static const int32_t VERSION_1 = ((int32_t)0x80010000);
   // VERSION_2 (0x80020000) was taken by TDenseProtocol (which has since been removed)
 
-  TBinaryProtocolT(stdcxx::shared_ptr<Transport_> trans)
+  TBinaryProtocolT(std::shared_ptr<Transport_> trans)
     : TVirtualProtocol<TBinaryProtocolT<Transport_, ByteOrder_> >(trans),
       trans_(trans.get()),
       string_limit_(0),
@@ -49,7 +49,7 @@
       strict_read_(false),
       strict_write_(true) {}
 
-  TBinaryProtocolT(stdcxx::shared_ptr<Transport_> trans,
+  TBinaryProtocolT(std::shared_ptr<Transport_> trans,
                    int32_t string_limit,
                    int32_t container_limit,
                    bool strict_read,
@@ -212,8 +212,8 @@
     strict_write_ = strict_write;
   }
 
-  stdcxx::shared_ptr<TProtocol> getProtocol(stdcxx::shared_ptr<TTransport> trans) {
-    stdcxx::shared_ptr<Transport_> specific_trans = stdcxx::dynamic_pointer_cast<Transport_>(trans);
+  std::shared_ptr<TProtocol> getProtocol(std::shared_ptr<TTransport> trans) {
+    std::shared_ptr<Transport_> specific_trans = std::dynamic_pointer_cast<Transport_>(trans);
     TProtocol* prot;
     if (specific_trans) {
       prot = new TBinaryProtocolT<Transport_, ByteOrder_>(specific_trans,
@@ -229,7 +229,7 @@
                                                           strict_write_);
     }
 
-    return stdcxx::shared_ptr<TProtocol>(prot);
+    return std::shared_ptr<TProtocol>(prot);
   }
 
 private:
diff --git a/lib/cpp/src/thrift/protocol/TCompactProtocol.h b/lib/cpp/src/thrift/protocol/TCompactProtocol.h
index e6024a9..5cfb47d 100644
--- a/lib/cpp/src/thrift/protocol/TCompactProtocol.h
+++ b/lib/cpp/src/thrift/protocol/TCompactProtocol.h
@@ -23,7 +23,7 @@
 #include <thrift/protocol/TVirtualProtocol.h>
 
 #include <stack>
-#include <thrift/stdcxx.h>
+#include <memory>
 
 namespace apache {
 namespace thrift {
@@ -74,7 +74,7 @@
   int16_t lastFieldId_;
 
 public:
-  TCompactProtocolT(stdcxx::shared_ptr<Transport_> trans)
+  TCompactProtocolT(std::shared_ptr<Transport_> trans)
     : TVirtualProtocol<TCompactProtocolT<Transport_> >(trans),
       trans_(trans.get()),
       lastFieldId_(0),
@@ -86,7 +86,7 @@
     boolValue_.hasBoolValue = false;
   }
 
-  TCompactProtocolT(stdcxx::shared_ptr<Transport_> trans,
+  TCompactProtocolT(std::shared_ptr<Transport_> trans,
                     int32_t string_limit,
                     int32_t container_limit)
     : TVirtualProtocol<TCompactProtocolT<Transport_> >(trans),
@@ -239,8 +239,8 @@
 
   void setContainerSizeLimit(int32_t container_limit) { container_limit_ = container_limit; }
 
-  stdcxx::shared_ptr<TProtocol> getProtocol(stdcxx::shared_ptr<TTransport> trans) {
-    stdcxx::shared_ptr<Transport_> specific_trans = stdcxx::dynamic_pointer_cast<Transport_>(trans);
+  std::shared_ptr<TProtocol> getProtocol(std::shared_ptr<TTransport> trans) {
+    std::shared_ptr<Transport_> specific_trans = std::dynamic_pointer_cast<Transport_>(trans);
     TProtocol* prot;
     if (specific_trans) {
       prot = new TCompactProtocolT<Transport_>(specific_trans, string_limit_, container_limit_);
@@ -248,7 +248,7 @@
       prot = new TCompactProtocol(trans, string_limit_, container_limit_);
     }
 
-    return stdcxx::shared_ptr<TProtocol>(prot);
+    return std::shared_ptr<TProtocol>(prot);
   }
 
 private:
diff --git a/lib/cpp/src/thrift/protocol/TDebugProtocol.h b/lib/cpp/src/thrift/protocol/TDebugProtocol.h
index 301d05a..c079624 100644
--- a/lib/cpp/src/thrift/protocol/TDebugProtocol.h
+++ b/lib/cpp/src/thrift/protocol/TDebugProtocol.h
@@ -22,7 +22,7 @@
 
 #include <thrift/protocol/TVirtualProtocol.h>
 
-#include <thrift/stdcxx.h>
+#include <memory>
 
 namespace apache {
 namespace thrift {
@@ -51,7 +51,7 @@
   enum write_state_t { UNINIT, STRUCT, LIST, SET, MAP_KEY, MAP_VALUE };
 
 public:
-  TDebugProtocol(stdcxx::shared_ptr<TTransport> trans)
+  TDebugProtocol(std::shared_ptr<TTransport> trans)
     : TVirtualProtocol<TDebugProtocol>(trans),
       trans_(trans.get()),
       string_limit_(DEFAULT_STRING_LIMIT),
@@ -141,8 +141,8 @@
   TDebugProtocolFactory() {}
   virtual ~TDebugProtocolFactory() {}
 
-  stdcxx::shared_ptr<TProtocol> getProtocol(stdcxx::shared_ptr<TTransport> trans) {
-    return stdcxx::shared_ptr<TProtocol>(new TDebugProtocol(trans));
+  std::shared_ptr<TProtocol> getProtocol(std::shared_ptr<TTransport> trans) {
+    return std::shared_ptr<TProtocol>(new TDebugProtocol(trans));
   }
 };
 }
@@ -160,7 +160,7 @@
   using namespace apache::thrift::transport;
   using namespace apache::thrift::protocol;
   TMemoryBuffer* buffer = new TMemoryBuffer;
-  stdcxx::shared_ptr<TTransport> trans(buffer);
+  std::shared_ptr<TTransport> trans(buffer);
   TDebugProtocol protocol(trans);
 
   ts.write(&protocol);
@@ -178,7 +178,7 @@
   using namespace apache::thrift::transport;
   using namespace apache::thrift::protocol;
   TMemoryBuffer* buffer = new TMemoryBuffer;
-  stdcxx::shared_ptr<TTransport> trans(buffer);
+  std::shared_ptr<TTransport> trans(buffer);
   TDebugProtocol protocol(trans);
 
   // I am gross!
diff --git a/lib/cpp/src/thrift/protocol/THeaderProtocol.cpp b/lib/cpp/src/thrift/protocol/THeaderProtocol.cpp
index 2667617..a19d545 100644
--- a/lib/cpp/src/thrift/protocol/THeaderProtocol.cpp
+++ b/lib/cpp/src/thrift/protocol/THeaderProtocol.cpp
@@ -27,7 +27,7 @@
 #include <limits>
 
 #include <boost/static_assert.hpp>
-#include <thrift/stdcxx.h>
+#include <memory>
 
 namespace apache {
 namespace thrift {
@@ -42,11 +42,11 @@
 
   switch (protoId_) {
   case T_BINARY_PROTOCOL:
-    proto_ = stdcxx::make_shared<TBinaryProtocolT<THeaderTransport> >(trans_);
+    proto_ = std::make_shared<TBinaryProtocolT<THeaderTransport> >(trans_);
     break;
 
   case T_COMPACT_PROTOCOL:
-    proto_ = stdcxx::make_shared<TCompactProtocolT<THeaderTransport> >(trans_);
+    proto_ = std::make_shared<TCompactProtocolT<THeaderTransport> >(trans_);
     break;
 
   default:
diff --git a/lib/cpp/src/thrift/protocol/THeaderProtocol.h b/lib/cpp/src/thrift/protocol/THeaderProtocol.h
index 8cd5017..e5e2b65 100644
--- a/lib/cpp/src/thrift/protocol/THeaderProtocol.h
+++ b/lib/cpp/src/thrift/protocol/THeaderProtocol.h
@@ -25,7 +25,7 @@
 #include <thrift/protocol/TVirtualProtocol.h>
 #include <thrift/transport/THeaderTransport.h>
 
-#include <thrift/stdcxx.h>
+#include <memory>
 
 using apache::thrift::transport::THeaderTransport;
 
@@ -43,21 +43,21 @@
 public:
   void resetProtocol();
 
-  explicit THeaderProtocol(const stdcxx::shared_ptr<TTransport>& trans,
+  explicit THeaderProtocol(const std::shared_ptr<TTransport>& trans,
                            uint16_t protoId = T_COMPACT_PROTOCOL)
-    : TVirtualProtocol<THeaderProtocol>(stdcxx::shared_ptr<TTransport>(new THeaderTransport(trans))),
-      trans_(stdcxx::dynamic_pointer_cast<THeaderTransport>(getTransport())),
+    : TVirtualProtocol<THeaderProtocol>(std::shared_ptr<TTransport>(new THeaderTransport(trans))),
+      trans_(std::dynamic_pointer_cast<THeaderTransport>(getTransport())),
       protoId_(protoId) {
     trans_->setProtocolId(protoId);
     resetProtocol();
   }
 
-  THeaderProtocol(const stdcxx::shared_ptr<TTransport>& inTrans,
-                  const stdcxx::shared_ptr<TTransport>& outTrans,
+  THeaderProtocol(const std::shared_ptr<TTransport>& inTrans,
+                  const std::shared_ptr<TTransport>& outTrans,
                   uint16_t protoId = T_COMPACT_PROTOCOL)
     : TVirtualProtocol<THeaderProtocol>(
-          stdcxx::shared_ptr<TTransport>(new THeaderTransport(inTrans, outTrans))),
-      trans_(stdcxx::dynamic_pointer_cast<THeaderTransport>(getTransport())),
+          std::shared_ptr<TTransport>(new THeaderTransport(inTrans, outTrans))),
+      trans_(std::dynamic_pointer_cast<THeaderTransport>(getTransport())),
       protoId_(protoId) {
     trans_->setProtocolId(protoId);
     resetProtocol();
@@ -182,25 +182,25 @@
   uint32_t readBinary(std::string& binary);
 
 protected:
-  stdcxx::shared_ptr<THeaderTransport> trans_;
+  std::shared_ptr<THeaderTransport> trans_;
 
-  stdcxx::shared_ptr<TProtocol> proto_;
+  std::shared_ptr<TProtocol> proto_;
   uint32_t protoId_;
 };
 
 class THeaderProtocolFactory : public TProtocolFactory {
 public:
-  virtual stdcxx::shared_ptr<TProtocol> getProtocol(stdcxx::shared_ptr<transport::TTransport> trans) {
+  virtual std::shared_ptr<TProtocol> getProtocol(std::shared_ptr<transport::TTransport> trans) {
     THeaderProtocol* headerProtocol
         = new THeaderProtocol(trans, trans, T_BINARY_PROTOCOL);
-    return stdcxx::shared_ptr<TProtocol>(headerProtocol);
+    return std::shared_ptr<TProtocol>(headerProtocol);
   }
 
-  virtual stdcxx::shared_ptr<TProtocol> getProtocol(
-      stdcxx::shared_ptr<transport::TTransport> inTrans,
-      stdcxx::shared_ptr<transport::TTransport> outTrans) {
+  virtual std::shared_ptr<TProtocol> getProtocol(
+      std::shared_ptr<transport::TTransport> inTrans,
+      std::shared_ptr<transport::TTransport> outTrans) {
     THeaderProtocol* headerProtocol = new THeaderProtocol(inTrans, outTrans, T_BINARY_PROTOCOL);
-    return stdcxx::shared_ptr<TProtocol>(headerProtocol);
+    return std::shared_ptr<TProtocol>(headerProtocol);
   }
 };
 }
diff --git a/lib/cpp/src/thrift/protocol/TJSONProtocol.cpp b/lib/cpp/src/thrift/protocol/TJSONProtocol.cpp
index 80def7f..40eb7ad 100644
--- a/lib/cpp/src/thrift/protocol/TJSONProtocol.cpp
+++ b/lib/cpp/src/thrift/protocol/TJSONProtocol.cpp
@@ -398,7 +398,7 @@
   bool first_;
 };
 
-TJSONProtocol::TJSONProtocol(stdcxx::shared_ptr<TTransport> ptrans)
+TJSONProtocol::TJSONProtocol(std::shared_ptr<TTransport> ptrans)
   : TVirtualProtocol<TJSONProtocol>(ptrans),
     trans_(ptrans.get()),
     context_(new TJSONContext()),
@@ -408,7 +408,7 @@
 TJSONProtocol::~TJSONProtocol() {
 }
 
-void TJSONProtocol::pushContext(stdcxx::shared_ptr<TJSONContext> c) {
+void TJSONProtocol::pushContext(std::shared_ptr<TJSONContext> c) {
   contexts_.push(context_);
   context_ = c;
 }
@@ -576,7 +576,7 @@
 uint32_t TJSONProtocol::writeJSONObjectStart() {
   uint32_t result = context_->write(*trans_);
   trans_->write(&kJSONObjectStart, 1);
-  pushContext(stdcxx::shared_ptr<TJSONContext>(new JSONPairContext()));
+  pushContext(std::shared_ptr<TJSONContext>(new JSONPairContext()));
   return result + 1;
 }
 
@@ -589,7 +589,7 @@
 uint32_t TJSONProtocol::writeJSONArrayStart() {
   uint32_t result = context_->write(*trans_);
   trans_->write(&kJSONArrayStart, 1);
-  pushContext(stdcxx::shared_ptr<TJSONContext>(new JSONListContext()));
+  pushContext(std::shared_ptr<TJSONContext>(new JSONListContext()));
   return result + 1;
 }
 
@@ -923,7 +923,7 @@
 uint32_t TJSONProtocol::readJSONObjectStart() {
   uint32_t result = context_->read(reader_);
   result += readJSONSyntaxChar(kJSONObjectStart);
-  pushContext(stdcxx::shared_ptr<TJSONContext>(new JSONPairContext()));
+  pushContext(std::shared_ptr<TJSONContext>(new JSONPairContext()));
   return result;
 }
 
@@ -936,7 +936,7 @@
 uint32_t TJSONProtocol::readJSONArrayStart() {
   uint32_t result = context_->read(reader_);
   result += readJSONSyntaxChar(kJSONArrayStart);
-  pushContext(stdcxx::shared_ptr<TJSONContext>(new JSONListContext()));
+  pushContext(std::shared_ptr<TJSONContext>(new JSONListContext()));
   return result;
 }
 
diff --git a/lib/cpp/src/thrift/protocol/TJSONProtocol.h b/lib/cpp/src/thrift/protocol/TJSONProtocol.h
index 16dff56..9c2f872 100644
--- a/lib/cpp/src/thrift/protocol/TJSONProtocol.h
+++ b/lib/cpp/src/thrift/protocol/TJSONProtocol.h
@@ -96,12 +96,12 @@
  */
 class TJSONProtocol : public TVirtualProtocol<TJSONProtocol> {
 public:
-  TJSONProtocol(stdcxx::shared_ptr<TTransport> ptrans);
+  TJSONProtocol(std::shared_ptr<TTransport> ptrans);
 
   ~TJSONProtocol();
 
 private:
-  void pushContext(stdcxx::shared_ptr<TJSONContext> c);
+  void pushContext(std::shared_ptr<TJSONContext> c);
 
   void popContext();
 
@@ -276,8 +276,8 @@
 private:
   TTransport* trans_;
 
-  std::stack<stdcxx::shared_ptr<TJSONContext> > contexts_;
-  stdcxx::shared_ptr<TJSONContext> context_;
+  std::stack<std::shared_ptr<TJSONContext> > contexts_;
+  std::shared_ptr<TJSONContext> context_;
   LookaheadReader reader_;
 };
 
@@ -290,8 +290,8 @@
 
   virtual ~TJSONProtocolFactory() {}
 
-  stdcxx::shared_ptr<TProtocol> getProtocol(stdcxx::shared_ptr<TTransport> trans) {
-    return stdcxx::shared_ptr<TProtocol>(new TJSONProtocol(trans));
+  std::shared_ptr<TProtocol> getProtocol(std::shared_ptr<TTransport> trans) {
+    return std::shared_ptr<TProtocol>(new TJSONProtocol(trans));
   }
 };
 }
@@ -309,7 +309,7 @@
   using namespace apache::thrift::transport;
   using namespace apache::thrift::protocol;
   TMemoryBuffer* buffer = new TMemoryBuffer;
-  stdcxx::shared_ptr<TTransport> trans(buffer);
+  std::shared_ptr<TTransport> trans(buffer);
   TJSONProtocol protocol(trans);
 
   ts.write(&protocol);
diff --git a/lib/cpp/src/thrift/protocol/TMultiplexedProtocol.h b/lib/cpp/src/thrift/protocol/TMultiplexedProtocol.h
index dd7e88f..94bd82e 100644
--- a/lib/cpp/src/thrift/protocol/TMultiplexedProtocol.h
+++ b/lib/cpp/src/thrift/protocol/TMultiplexedProtocol.h
@@ -25,7 +25,7 @@
 namespace apache {
 namespace thrift {
 namespace protocol {
-using stdcxx::shared_ptr;
+using std::shared_ptr;
 
 /**
  * <code>TMultiplexedProtocol</code> is a protocol-independent concrete decorator
diff --git a/lib/cpp/src/thrift/protocol/TProtocol.h b/lib/cpp/src/thrift/protocol/TProtocol.h
index aa5beea..28e1bb7 100644
--- a/lib/cpp/src/thrift/protocol/TProtocol.h
+++ b/lib/cpp/src/thrift/protocol/TProtocol.h
@@ -28,7 +28,7 @@
 #include <thrift/transport/TTransport.h>
 #include <thrift/protocol/TProtocolException.h>
 
-#include <thrift/stdcxx.h>
+#include <memory>
 #include <boost/static_assert.hpp>
 
 #ifdef HAVE_NETINET_IN_H
@@ -550,12 +550,12 @@
   }
   virtual uint32_t skip_virt(TType type);
 
-  inline stdcxx::shared_ptr<TTransport> getTransport() { return ptrans_; }
+  inline std::shared_ptr<TTransport> getTransport() { return ptrans_; }
 
   // TODO: remove these two calls, they are for backwards
   // compatibility
-  inline stdcxx::shared_ptr<TTransport> getInputTransport() { return ptrans_; }
-  inline stdcxx::shared_ptr<TTransport> getOutputTransport() { return ptrans_; }
+  inline std::shared_ptr<TTransport> getInputTransport() { return ptrans_; }
+  inline std::shared_ptr<TTransport> getOutputTransport() { return ptrans_; }
 
   // input and output recursion depth are kept separate so that one protocol
   // can be used concurrently for both input and output.
@@ -577,11 +577,11 @@
   void setRecurisionLimit(uint32_t depth) {recursion_limit_ = depth;}
 
 protected:
-  TProtocol(stdcxx::shared_ptr<TTransport> ptrans)
+  TProtocol(std::shared_ptr<TTransport> ptrans)
     : ptrans_(ptrans), input_recursion_depth_(0), output_recursion_depth_(0), recursion_limit_(DEFAULT_RECURSION_LIMIT)
   {}
 
-  stdcxx::shared_ptr<TTransport> ptrans_;
+  std::shared_ptr<TTransport> ptrans_;
 
 private:
   TProtocol() {}
@@ -599,9 +599,9 @@
 
   virtual ~TProtocolFactory();
 
-  virtual stdcxx::shared_ptr<TProtocol> getProtocol(stdcxx::shared_ptr<TTransport> trans) = 0;
-  virtual stdcxx::shared_ptr<TProtocol> getProtocol(stdcxx::shared_ptr<TTransport> inTrans,
-               stdcxx::shared_ptr<TTransport> outTrans) {
+  virtual std::shared_ptr<TProtocol> getProtocol(std::shared_ptr<TTransport> trans) = 0;
+  virtual std::shared_ptr<TProtocol> getProtocol(std::shared_ptr<TTransport> inTrans,
+               std::shared_ptr<TTransport> outTrans) {
     (void)outTrans;
     return getProtocol(inTrans);
   }
diff --git a/lib/cpp/src/thrift/protocol/TProtocolDecorator.h b/lib/cpp/src/thrift/protocol/TProtocolDecorator.h
index a353b79..743a0f4 100644
--- a/lib/cpp/src/thrift/protocol/TProtocolDecorator.h
+++ b/lib/cpp/src/thrift/protocol/TProtocolDecorator.h
@@ -21,12 +21,12 @@
 #define THRIFT_TPROTOCOLDECORATOR_H_ 1
 
 #include <thrift/protocol/TProtocol.h>
-#include <thrift/stdcxx.h>
+#include <memory>
 
 namespace apache {
 namespace thrift {
 namespace protocol {
-using stdcxx::shared_ptr;
+using std::shared_ptr;
 
 /**
  * <code>TProtocolDecorator</code> forwards all requests to an enclosed
diff --git a/lib/cpp/src/thrift/protocol/TProtocolTap.h b/lib/cpp/src/thrift/protocol/TProtocolTap.h
index 176d4fd..d000ba6 100644
--- a/lib/cpp/src/thrift/protocol/TProtocolTap.h
+++ b/lib/cpp/src/thrift/protocol/TProtocolTap.h
@@ -36,7 +36,7 @@
  */
 class TProtocolTap : public TVirtualProtocol<TProtocolTap> {
 public:
-  TProtocolTap(stdcxx::shared_ptr<TProtocol> source, stdcxx::shared_ptr<TProtocol> sink)
+  TProtocolTap(std::shared_ptr<TProtocol> source, std::shared_ptr<TProtocol> sink)
     : TVirtualProtocol<TProtocolTap>(source->getTransport()), source_(source), sink_(sink) {}
 
   uint32_t readMessageBegin(std::string& name, TMessageType& messageType, int32_t& seqid) {
@@ -167,8 +167,8 @@
   }
 
 private:
-  stdcxx::shared_ptr<TProtocol> source_;
-  stdcxx::shared_ptr<TProtocol> sink_;
+  std::shared_ptr<TProtocol> source_;
+  std::shared_ptr<TProtocol> sink_;
 };
 }
 }
diff --git a/lib/cpp/src/thrift/protocol/TVirtualProtocol.h b/lib/cpp/src/thrift/protocol/TVirtualProtocol.h
index 628b494..4eea579 100644
--- a/lib/cpp/src/thrift/protocol/TVirtualProtocol.h
+++ b/lib/cpp/src/thrift/protocol/TVirtualProtocol.h
@@ -301,7 +301,7 @@
   uint32_t skip(TType type) { return ::apache::thrift::protocol::skip(*this, type); }
 
 protected:
-  TProtocolDefaults(stdcxx::shared_ptr<TTransport> ptrans) : TProtocol(ptrans) {}
+  TProtocolDefaults(std::shared_ptr<TTransport> ptrans) : TProtocol(ptrans) {}
 };
 
 /**
@@ -504,7 +504,7 @@
   using Super_::readBool; // so we don't hide readBool(bool&)
 
 protected:
-  TVirtualProtocol(stdcxx::shared_ptr<TTransport> ptrans) : Super_(ptrans) {}
+  TVirtualProtocol(std::shared_ptr<TTransport> ptrans) : Super_(ptrans) {}
 };
 }
 }
diff --git a/lib/cpp/src/thrift/qt/TQIODeviceTransport.cpp b/lib/cpp/src/thrift/qt/TQIODeviceTransport.cpp
index 0e46f11..f77c993 100644
--- a/lib/cpp/src/thrift/qt/TQIODeviceTransport.cpp
+++ b/lib/cpp/src/thrift/qt/TQIODeviceTransport.cpp
@@ -23,12 +23,12 @@
 #include <QIODevice>
 
 #include <thrift/transport/TBufferTransports.h>
-#include <thrift/stdcxx.h>
+#include <memory>
 
 namespace apache {
 namespace thrift {
 
-using stdcxx::shared_ptr;
+using std::shared_ptr;
 
 namespace transport {
 
diff --git a/lib/cpp/src/thrift/qt/TQIODeviceTransport.h b/lib/cpp/src/thrift/qt/TQIODeviceTransport.h
index 9087f2c..91ce8d5 100644
--- a/lib/cpp/src/thrift/qt/TQIODeviceTransport.h
+++ b/lib/cpp/src/thrift/qt/TQIODeviceTransport.h
@@ -20,7 +20,7 @@
 #ifndef _THRIFT_ASYNC_TQIODEVICE_TRANSPORT_H_
 #define _THRIFT_ASYNC_TQIODEVICE_TRANSPORT_H_ 1
 
-#include <thrift/stdcxx.h>
+#include <memory>
 
 #include <thrift/transport/TVirtualTransport.h>
 
@@ -36,7 +36,7 @@
 class TQIODeviceTransport
     : public apache::thrift::transport::TVirtualTransport<TQIODeviceTransport> {
 public:
-  explicit TQIODeviceTransport(stdcxx::shared_ptr<QIODevice> dev);
+  explicit TQIODeviceTransport(std::shared_ptr<QIODevice> dev);
   virtual ~TQIODeviceTransport();
 
   void open();
@@ -59,7 +59,7 @@
   TQIODeviceTransport(const TQIODeviceTransport&);
   TQIODeviceTransport& operator=(const TQIODeviceTransport&);
 
-  stdcxx::shared_ptr<QIODevice> dev_;
+  std::shared_ptr<QIODevice> dev_;
 };
 }
 }
diff --git a/lib/cpp/src/thrift/qt/TQTcpServer.cpp b/lib/cpp/src/thrift/qt/TQTcpServer.cpp
index c4669d7..99aad07 100644
--- a/lib/cpp/src/thrift/qt/TQTcpServer.cpp
+++ b/lib/cpp/src/thrift/qt/TQTcpServer.cpp
@@ -17,14 +17,15 @@
  * under the License.
  */
 
+#include <functional>
+#include <memory>
+
 #include <thrift/qt/TQTcpServer.h>
 #include <thrift/qt/TQIODeviceTransport.h>
 
 #include <QMetaType>
 #include <QTcpSocket>
 
-#include <thrift/stdcxx.h>
-
 #include <thrift/protocol/TProtocol.h>
 #include <thrift/async/TAsyncProcessor.h>
 
@@ -33,10 +34,10 @@
 using apache::thrift::transport::TTransport;
 using apache::thrift::transport::TTransportException;
 using apache::thrift::transport::TQIODeviceTransport;
-using apache::thrift::stdcxx::bind;
-using apache::thrift::stdcxx::function;
-using apache::thrift::stdcxx::placeholders::_1;
-using apache::thrift::stdcxx::shared_ptr;
+using std::bind;
+using std::function;
+using std::placeholders::_1;
+using std::shared_ptr;
 
 QT_USE_NAMESPACE
 
diff --git a/lib/cpp/src/thrift/qt/TQTcpServer.h b/lib/cpp/src/thrift/qt/TQTcpServer.h
index 0d32afa..8e3fe3a 100644
--- a/lib/cpp/src/thrift/qt/TQTcpServer.h
+++ b/lib/cpp/src/thrift/qt/TQTcpServer.h
@@ -23,7 +23,7 @@
 #include <QObject>
 #include <QTcpServer>
 
-#include <thrift/stdcxx.h>
+#include <memory>
 
 namespace apache {
 namespace thrift {
@@ -47,9 +47,9 @@
 class TQTcpServer : public QObject {
   Q_OBJECT
 public:
-  TQTcpServer(stdcxx::shared_ptr<QTcpServer> server,
-              stdcxx::shared_ptr<TAsyncProcessor> processor,
-              stdcxx::shared_ptr<apache::thrift::protocol::TProtocolFactory> protocolFactory,
+  TQTcpServer(std::shared_ptr<QTcpServer> server,
+              std::shared_ptr<TAsyncProcessor> processor,
+              std::shared_ptr<apache::thrift::protocol::TProtocolFactory> protocolFactory,
               QObject* parent = NULL);
   virtual ~TQTcpServer();
 
@@ -65,13 +65,13 @@
   struct ConnectionContext;
 
   void scheduleDeleteConnectionContext(QTcpSocket* connection);
-  void finish(stdcxx::shared_ptr<ConnectionContext> ctx, bool healthy);
+  void finish(std::shared_ptr<ConnectionContext> ctx, bool healthy);
 
-  stdcxx::shared_ptr<QTcpServer> server_;
-  stdcxx::shared_ptr<TAsyncProcessor> processor_;
-  stdcxx::shared_ptr<apache::thrift::protocol::TProtocolFactory> pfact_;
+  std::shared_ptr<QTcpServer> server_;
+  std::shared_ptr<TAsyncProcessor> processor_;
+  std::shared_ptr<apache::thrift::protocol::TProtocolFactory> pfact_;
 
-  typedef std::map<QTcpSocket*, stdcxx::shared_ptr<ConnectionContext> > ConnectionContextMap;
+  typedef std::map<QTcpSocket*, std::shared_ptr<ConnectionContext> > ConnectionContextMap;
   ConnectionContextMap ctxMap_;
 };
 }
diff --git a/lib/cpp/src/thrift/server/TConnectedClient.cpp b/lib/cpp/src/thrift/server/TConnectedClient.cpp
index 33ec3a9..acdaa77 100644
--- a/lib/cpp/src/thrift/server/TConnectedClient.cpp
+++ b/lib/cpp/src/thrift/server/TConnectedClient.cpp
@@ -28,7 +28,7 @@
 using apache::thrift::server::TServerEventHandler;
 using apache::thrift::transport::TTransport;
 using apache::thrift::transport::TTransportException;
-using stdcxx::shared_ptr;
+using std::shared_ptr;
 using std::string;
 
 TConnectedClient::TConnectedClient(const shared_ptr<TProcessor>& processor,
diff --git a/lib/cpp/src/thrift/server/TConnectedClient.h b/lib/cpp/src/thrift/server/TConnectedClient.h
index 2f9d4c9..19e70c1 100644
--- a/lib/cpp/src/thrift/server/TConnectedClient.h
+++ b/lib/cpp/src/thrift/server/TConnectedClient.h
@@ -20,7 +20,7 @@
 #ifndef _THRIFT_SERVER_TCONNECTEDCLIENT_H_
 #define _THRIFT_SERVER_TCONNECTEDCLIENT_H_ 1
 
-#include <thrift/stdcxx.h>
+#include <memory>
 #include <thrift/TProcessor.h>
 #include <thrift/protocol/TProtocol.h>
 #include <thrift/server/TServer.h>
@@ -49,11 +49,11 @@
    * @param[in] client         the TTransport representing the client
    */
   TConnectedClient(
-      const stdcxx::shared_ptr<apache::thrift::TProcessor>& processor,
-      const stdcxx::shared_ptr<apache::thrift::protocol::TProtocol>& inputProtocol,
-      const stdcxx::shared_ptr<apache::thrift::protocol::TProtocol>& outputProtocol,
-      const stdcxx::shared_ptr<apache::thrift::server::TServerEventHandler>& eventHandler,
-      const stdcxx::shared_ptr<apache::thrift::transport::TTransport>& client);
+      const std::shared_ptr<apache::thrift::TProcessor>& processor,
+      const std::shared_ptr<apache::thrift::protocol::TProtocol>& inputProtocol,
+      const std::shared_ptr<apache::thrift::protocol::TProtocol>& outputProtocol,
+      const std::shared_ptr<apache::thrift::server::TServerEventHandler>& eventHandler,
+      const std::shared_ptr<apache::thrift::transport::TTransport>& client);
 
   /**
    * Destructor.
@@ -92,11 +92,11 @@
   virtual void cleanup();
 
 private:
-  stdcxx::shared_ptr<apache::thrift::TProcessor> processor_;
-  stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> inputProtocol_;
-  stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> outputProtocol_;
-  stdcxx::shared_ptr<apache::thrift::server::TServerEventHandler> eventHandler_;
-  stdcxx::shared_ptr<apache::thrift::transport::TTransport> client_;
+  std::shared_ptr<apache::thrift::TProcessor> processor_;
+  std::shared_ptr<apache::thrift::protocol::TProtocol> inputProtocol_;
+  std::shared_ptr<apache::thrift::protocol::TProtocol> outputProtocol_;
+  std::shared_ptr<apache::thrift::server::TServerEventHandler> eventHandler_;
+  std::shared_ptr<apache::thrift::transport::TTransport> client_;
 
   /**
    * Context acquired from the eventHandler_ if one exists.
diff --git a/lib/cpp/src/thrift/server/TNonblockingServer.cpp b/lib/cpp/src/thrift/server/TNonblockingServer.cpp
index 1031ec0..f16fce7 100644
--- a/lib/cpp/src/thrift/server/TNonblockingServer.cpp
+++ b/lib/cpp/src/thrift/server/TNonblockingServer.cpp
@@ -84,7 +84,7 @@
 using namespace apache::thrift::concurrency;
 using apache::thrift::transport::TSocket;
 using apache::thrift::transport::TTransportException;
-using stdcxx::shared_ptr;
+using std::shared_ptr;
 
 /// Three states for sockets: recv frame size, recv data, and send mode
 enum TSocketState { SOCKET_RECV_FRAMING, SOCKET_RECV, SOCKET_SEND };
@@ -119,10 +119,10 @@
   TNonblockingServer* server_;
 
   /// TProcessor
-  stdcxx::shared_ptr<TProcessor> processor_;
+  std::shared_ptr<TProcessor> processor_;
 
   /// Object wrapping network socket
-  stdcxx::shared_ptr<TSocket> tSocket_;
+  std::shared_ptr<TSocket> tSocket_;
 
   /// Libevent object
   struct event event_;
@@ -164,23 +164,23 @@
   int32_t callsForResize_;
 
   /// Transport to read from
-  stdcxx::shared_ptr<TMemoryBuffer> inputTransport_;
+  std::shared_ptr<TMemoryBuffer> inputTransport_;
 
   /// Transport that processor writes to
-  stdcxx::shared_ptr<TMemoryBuffer> outputTransport_;
+  std::shared_ptr<TMemoryBuffer> outputTransport_;
 
   /// extra transport generated by transport factory (e.g. BufferedRouterTransport)
-  stdcxx::shared_ptr<TTransport> factoryInputTransport_;
-  stdcxx::shared_ptr<TTransport> factoryOutputTransport_;
+  std::shared_ptr<TTransport> factoryInputTransport_;
+  std::shared_ptr<TTransport> factoryOutputTransport_;
 
   /// Protocol decoder
-  stdcxx::shared_ptr<TProtocol> inputProtocol_;
+  std::shared_ptr<TProtocol> inputProtocol_;
 
   /// Protocol encoder
-  stdcxx::shared_ptr<TProtocol> outputProtocol_;
+  std::shared_ptr<TProtocol> outputProtocol_;
 
   /// Server event handler, if any
-  stdcxx::shared_ptr<TServerEventHandler> serverEventHandler_;
+  std::shared_ptr<TServerEventHandler> serverEventHandler_;
 
   /// Thrift call context, if any
   void* connectionContext_;
@@ -213,7 +213,7 @@
   class Task;
 
   /// Constructor
-  TConnection(stdcxx::shared_ptr<TSocket> socket,
+  TConnection(std::shared_ptr<TSocket> socket,
               TNonblockingIOThread* ioThread) {
     readBuffer_ = NULL;
     readBufferSize_ = 0;
@@ -249,7 +249,7 @@
   void init(TNonblockingIOThread* ioThread);
 
   /// set socket for connection
-  void setSocket(stdcxx::shared_ptr<TSocket> socket);
+  void setSocket(std::shared_ptr<TSocket> socket);
 
   /**
    * This is called when the application transitions from one state into
@@ -305,10 +305,10 @@
   TAppState getState() const { return appState_; }
 
   /// return the TSocket transport wrapping this network connection
-  stdcxx::shared_ptr<TSocket> getTSocket() const { return tSocket_; }
+  std::shared_ptr<TSocket> getTSocket() const { return tSocket_; }
 
   /// return the server event handler if any
-  stdcxx::shared_ptr<TServerEventHandler> getServerEventHandler() { return serverEventHandler_; }
+  std::shared_ptr<TServerEventHandler> getServerEventHandler() { return serverEventHandler_; }
 
   /// return the Thrift connection context if any
   void* getConnectionContext() { return connectionContext_; }
@@ -316,9 +316,9 @@
 
 class TNonblockingServer::TConnection::Task : public Runnable {
 public:
-  Task(stdcxx::shared_ptr<TProcessor> processor,
-       stdcxx::shared_ptr<TProtocol> input,
-       stdcxx::shared_ptr<TProtocol> output,
+  Task(std::shared_ptr<TProcessor> processor,
+       std::shared_ptr<TProtocol> input,
+       std::shared_ptr<TProtocol> output,
        TConnection* connection)
     : processor_(processor),
       input_(input),
@@ -363,11 +363,11 @@
   TConnection* getTConnection() { return connection_; }
 
 private:
-  stdcxx::shared_ptr<TProcessor> processor_;
-  stdcxx::shared_ptr<TProtocol> input_;
-  stdcxx::shared_ptr<TProtocol> output_;
+  std::shared_ptr<TProcessor> processor_;
+  std::shared_ptr<TProtocol> input_;
+  std::shared_ptr<TProtocol> output_;
   TConnection* connection_;
-  stdcxx::shared_ptr<TServerEventHandler> serverEventHandler_;
+  std::shared_ptr<TServerEventHandler> serverEventHandler_;
   void* connectionContext_;
 };
 
@@ -414,7 +414,7 @@
   processor_ = server_->getProcessor(inputProtocol_, outputProtocol_, tSocket_);
 }
 
-void TNonblockingServer::TConnection::setSocket(stdcxx::shared_ptr<TSocket> socket) {
+void TNonblockingServer::TConnection::setSocket(std::shared_ptr<TSocket> socket) {
   tSocket_ = socket;
 }
 
@@ -610,7 +610,7 @@
       // We are setting up a Task to do this work and we will wait on it
 
       // Create task and dispatch to the thread manager
-      stdcxx::shared_ptr<Runnable> task = stdcxx::shared_ptr<Runnable>(
+      std::shared_ptr<Runnable> task = std::shared_ptr<Runnable>(
           new Task(processor_, inputProtocol_, outputProtocol_, this));
       // The application is now waiting on the task to finish
       appState_ = APP_WAIT_TASK;
@@ -888,9 +888,9 @@
   // objects and the Thread objects have shared_ptrs to the TNonblockingIOThread
   // objects (as runnable) so these objects will never deallocate without help.
   while (!ioThreads_.empty()) {
-    stdcxx::shared_ptr<TNonblockingIOThread> iot = ioThreads_.back();
+    std::shared_ptr<TNonblockingIOThread> iot = ioThreads_.back();
     ioThreads_.pop_back();
-    iot->setThread(stdcxx::shared_ptr<Thread>());
+    iot->setThread(std::shared_ptr<Thread>());
   }
 }
 
@@ -898,7 +898,7 @@
  * Creates a new connection either by reusing an object off the stack or
  * by allocating a new one entirely
  */
-TNonblockingServer::TConnection* TNonblockingServer::createConnection(stdcxx::shared_ptr<TSocket> socket) {
+TNonblockingServer::TConnection* TNonblockingServer::createConnection(std::shared_ptr<TSocket> socket) {
   // Check the stack
   Guard g(connMutex_);
 
@@ -954,7 +954,7 @@
   assert(fd == serverSocket_);
 
   // Going to accept a new client socket
-  stdcxx::shared_ptr<TSocket> clientSocket;
+  std::shared_ptr<TSocket> clientSocket;
 
   clientSocket = serverTransport_->accept();
   if (clientSocket) {
@@ -1017,13 +1017,13 @@
 }
 
 
-void TNonblockingServer::setThreadManager(stdcxx::shared_ptr<ThreadManager> threadManager) {
+void TNonblockingServer::setThreadManager(std::shared_ptr<ThreadManager> threadManager) {
   threadManager_ = threadManager;
   if (threadManager) {
     threadManager->setExpireCallback(
-        apache::thrift::stdcxx::bind(&TNonblockingServer::expireClose,
+        std::bind(&TNonblockingServer::expireClose,
                                      this,
-                                     apache::thrift::stdcxx::placeholders::_1));
+                                     std::placeholders::_1));
     threadPoolProcessing_ = true;
   } else {
     threadPoolProcessing_ = false;
@@ -1055,7 +1055,7 @@
 
 bool TNonblockingServer::drainPendingTask() {
   if (threadManager_) {
-    stdcxx::shared_ptr<Runnable> task = threadManager_->removeNextPending();
+    std::shared_ptr<Runnable> task = threadManager_->removeNextPending();
     if (task) {
       TConnection* connection = static_cast<TConnection::Task*>(task.get())->getTConnection();
       assert(connection && connection->getServer() && connection->getState() == APP_WAIT_TASK);
@@ -1066,7 +1066,7 @@
   return false;
 }
 
-void TNonblockingServer::expireClose(stdcxx::shared_ptr<Runnable> task) {
+void TNonblockingServer::expireClose(std::shared_ptr<Runnable> task) {
   TConnection* connection = static_cast<TConnection::Task*>(task.get())->getTConnection();
   assert(connection && connection->getServer() && connection->getState() == APP_WAIT_TASK);
   connection->forceClose();
diff --git a/lib/cpp/src/thrift/server/TNonblockingServer.h b/lib/cpp/src/thrift/server/TNonblockingServer.h
index f95a729..e79c24f 100644
--- a/lib/cpp/src/thrift/server/TNonblockingServer.h
+++ b/lib/cpp/src/thrift/server/TNonblockingServer.h
@@ -21,7 +21,7 @@
 #define _THRIFT_SERVER_TNONBLOCKINGSERVER_H_ 1
 
 #include <thrift/Thrift.h>
-#include <thrift/stdcxx.h>
+#include <memory>
 #include <thrift/server/TServer.h>
 #include <thrift/transport/PlatformSocket.h>
 #include <thrift/transport/TBufferTransports.h>
@@ -160,16 +160,16 @@
   event_base* userEventBase_;
 
   /// For processing via thread pool, may be NULL
-  stdcxx::shared_ptr<ThreadManager> threadManager_;
+  std::shared_ptr<ThreadManager> threadManager_;
 
   /// Is thread pool processing?
   bool threadPoolProcessing_;
 
   // Factory to create the IO threads
-  stdcxx::shared_ptr<PlatformThreadFactory> ioThreadFactory_;
+  std::shared_ptr<PlatformThreadFactory> ioThreadFactory_;
 
   // Vector of IOThread objects that will handle our IO
-  std::vector<stdcxx::shared_ptr<TNonblockingIOThread> > ioThreads_;
+  std::vector<std::shared_ptr<TNonblockingIOThread> > ioThreads_;
 
   // Index of next IO Thread to be used (for round-robin)
   uint32_t nextIOThread_;
@@ -264,7 +264,7 @@
 
   /*
   */
-  stdcxx::shared_ptr<TNonblockingServerTransport> serverTransport_;
+  std::shared_ptr<TNonblockingServerTransport> serverTransport_;
 
   /**
    * Called when server socket had something happen.  We accept all waiting
@@ -301,24 +301,24 @@
   }
 
 public:
-  TNonblockingServer(const stdcxx::shared_ptr<TProcessorFactory>& processorFactory,
-                     const stdcxx::shared_ptr<apache::thrift::transport::TNonblockingServerTransport>& serverTransport)
+  TNonblockingServer(const std::shared_ptr<TProcessorFactory>& processorFactory,
+                     const std::shared_ptr<apache::thrift::transport::TNonblockingServerTransport>& serverTransport)
     : TServer(processorFactory), serverTransport_(serverTransport) {
     init();
   }
 
-  TNonblockingServer(const stdcxx::shared_ptr<TProcessor>& processor,
-                     const stdcxx::shared_ptr<apache::thrift::transport::TNonblockingServerTransport>& serverTransport)
+  TNonblockingServer(const std::shared_ptr<TProcessor>& processor,
+                     const std::shared_ptr<apache::thrift::transport::TNonblockingServerTransport>& serverTransport)
     : TServer(processor), serverTransport_(serverTransport) {
     init();
   }
 
 
-  TNonblockingServer(const stdcxx::shared_ptr<TProcessorFactory>& processorFactory,
-                     const stdcxx::shared_ptr<TProtocolFactory>& protocolFactory,
-                     const stdcxx::shared_ptr<apache::thrift::transport::TNonblockingServerTransport>& serverTransport,
-                     const stdcxx::shared_ptr<ThreadManager>& threadManager
-                     = stdcxx::shared_ptr<ThreadManager>())
+  TNonblockingServer(const std::shared_ptr<TProcessorFactory>& processorFactory,
+                     const std::shared_ptr<TProtocolFactory>& protocolFactory,
+                     const std::shared_ptr<apache::thrift::transport::TNonblockingServerTransport>& serverTransport,
+                     const std::shared_ptr<ThreadManager>& threadManager
+                     = std::shared_ptr<ThreadManager>())
     : TServer(processorFactory), serverTransport_(serverTransport) {
     init();
 
@@ -327,11 +327,11 @@
     setThreadManager(threadManager);
   }
 
-  TNonblockingServer(const stdcxx::shared_ptr<TProcessor>& processor,
-                     const stdcxx::shared_ptr<TProtocolFactory>& protocolFactory,
-                     const stdcxx::shared_ptr<apache::thrift::transport::TNonblockingServerTransport>& serverTransport,
-                     const stdcxx::shared_ptr<ThreadManager>& threadManager
-                     = stdcxx::shared_ptr<ThreadManager>())
+  TNonblockingServer(const std::shared_ptr<TProcessor>& processor,
+                     const std::shared_ptr<TProtocolFactory>& protocolFactory,
+                     const std::shared_ptr<apache::thrift::transport::TNonblockingServerTransport>& serverTransport,
+                     const std::shared_ptr<ThreadManager>& threadManager
+                     = std::shared_ptr<ThreadManager>())
     : TServer(processor), serverTransport_(serverTransport) {
     init();
 
@@ -340,14 +340,14 @@
     setThreadManager(threadManager);
   }
 
-  TNonblockingServer(const stdcxx::shared_ptr<TProcessorFactory>& processorFactory,
-                     const stdcxx::shared_ptr<TTransportFactory>& inputTransportFactory,
-                     const stdcxx::shared_ptr<TTransportFactory>& outputTransportFactory,
-                     const stdcxx::shared_ptr<TProtocolFactory>& inputProtocolFactory,
-                     const stdcxx::shared_ptr<TProtocolFactory>& outputProtocolFactory,
-                     const stdcxx::shared_ptr<apache::thrift::transport::TNonblockingServerTransport>& serverTransport,
-                     const stdcxx::shared_ptr<ThreadManager>& threadManager
-                     = stdcxx::shared_ptr<ThreadManager>())
+  TNonblockingServer(const std::shared_ptr<TProcessorFactory>& processorFactory,
+                     const std::shared_ptr<TTransportFactory>& inputTransportFactory,
+                     const std::shared_ptr<TTransportFactory>& outputTransportFactory,
+                     const std::shared_ptr<TProtocolFactory>& inputProtocolFactory,
+                     const std::shared_ptr<TProtocolFactory>& outputProtocolFactory,
+                     const std::shared_ptr<apache::thrift::transport::TNonblockingServerTransport>& serverTransport,
+                     const std::shared_ptr<ThreadManager>& threadManager
+                     = std::shared_ptr<ThreadManager>())
     : TServer(processorFactory), serverTransport_(serverTransport) {
     init();
 
@@ -358,14 +358,14 @@
     setThreadManager(threadManager);
   }
 
-  TNonblockingServer(const stdcxx::shared_ptr<TProcessor>& processor,
-                     const stdcxx::shared_ptr<TTransportFactory>& inputTransportFactory,
-                     const stdcxx::shared_ptr<TTransportFactory>& outputTransportFactory,
-                     const stdcxx::shared_ptr<TProtocolFactory>& inputProtocolFactory,
-                     const stdcxx::shared_ptr<TProtocolFactory>& outputProtocolFactory,
-                     const stdcxx::shared_ptr<apache::thrift::transport::TNonblockingServerTransport>& serverTransport,
-                     const stdcxx::shared_ptr<ThreadManager>& threadManager
-                     = stdcxx::shared_ptr<ThreadManager>())
+  TNonblockingServer(const std::shared_ptr<TProcessor>& processor,
+                     const std::shared_ptr<TTransportFactory>& inputTransportFactory,
+                     const std::shared_ptr<TTransportFactory>& outputTransportFactory,
+                     const std::shared_ptr<TProtocolFactory>& inputProtocolFactory,
+                     const std::shared_ptr<TProtocolFactory>& outputProtocolFactory,
+                     const std::shared_ptr<apache::thrift::transport::TNonblockingServerTransport>& serverTransport,
+                     const std::shared_ptr<ThreadManager>& threadManager
+                     = std::shared_ptr<ThreadManager>())
     : TServer(processor), serverTransport_(serverTransport) {
     init();
 
@@ -378,11 +378,11 @@
 
   ~TNonblockingServer();
 
-  void setThreadManager(stdcxx::shared_ptr<ThreadManager> threadManager);
+  void setThreadManager(std::shared_ptr<ThreadManager> threadManager);
 
   int getListenPort() { return serverTransport_->getListenPort(); }
 
-  stdcxx::shared_ptr<ThreadManager> getThreadManager() { return threadManager_; }
+  std::shared_ptr<ThreadManager> getThreadManager() { return threadManager_; }
 
   /**
    * Sets the number of IO threads used by this server. Can only be used before
@@ -421,7 +421,7 @@
 
   bool isThreadPoolProcessing() const { return threadPoolProcessing_; }
 
-  void addTask(stdcxx::shared_ptr<Runnable> task) {
+  void addTask(std::shared_ptr<Runnable> task) {
     threadManager_->add(task, 0LL, taskExpireTime_);
   }
 
@@ -709,7 +709,7 @@
    *
    * @param task the runnable associated with the expired task.
    */
-  void expireClose(stdcxx::shared_ptr<Runnable> task);
+  void expireClose(std::shared_ptr<Runnable> task);
 
   /**
    * Return an initialized connection object.  Creates or recovers from
@@ -721,7 +721,7 @@
    * @param addrLen the length of addr
    * @return pointer to initialized TConnection object.
    */
-  TConnection* createConnection(stdcxx::shared_ptr<TSocket> socket);
+  TConnection* createConnection(std::shared_ptr<TSocket> socket);
 
   /**
    * Returns a connection to pool or deletion.  If the connection pool
@@ -765,10 +765,10 @@
   evutil_socket_t getNotificationRecvFD() const { return notificationPipeFDs_[0]; }
 
   // Returns the actual thread object associated with this IO thread.
-  stdcxx::shared_ptr<Thread> getThread() const { return thread_; }
+  std::shared_ptr<Thread> getThread() const { return thread_; }
 
   // Sets the actual thread object associated with this IO thread.
-  void setThread(const stdcxx::shared_ptr<Thread>& t) { thread_ = t; }
+  void setThread(const std::shared_ptr<Thread>& t) { thread_ = t; }
 
   // Used by TConnection objects to indicate processing has finished.
   bool notify(TNonblockingServer::TConnection* conn);
@@ -853,7 +853,7 @@
   evutil_socket_t notificationPipeFDs_[2];
 
   /// Actual IO Thread
-  stdcxx::shared_ptr<Thread> thread_;
+  std::shared_ptr<Thread> thread_;
 };
 }
 }
diff --git a/lib/cpp/src/thrift/server/TServer.h b/lib/cpp/src/thrift/server/TServer.h
index f4cd7bc..3c6d818 100644
--- a/lib/cpp/src/thrift/server/TServer.h
+++ b/lib/cpp/src/thrift/server/TServer.h
@@ -25,7 +25,7 @@
 #include <thrift/protocol/TBinaryProtocol.h>
 #include <thrift/concurrency/Thread.h>
 
-#include <thrift/stdcxx.h>
+#include <memory>
 
 namespace apache {
 namespace thrift {
@@ -58,8 +58,8 @@
   /**
    * Called when a new client has connected and is about to being processing.
    */
-  virtual void* createContext(stdcxx::shared_ptr<TProtocol> input,
-                              stdcxx::shared_ptr<TProtocol> output) {
+  virtual void* createContext(std::shared_ptr<TProtocol> input,
+                              std::shared_ptr<TProtocol> output) {
     (void)input;
     (void)output;
     return NULL;
@@ -70,8 +70,8 @@
    * context.
    */
   virtual void deleteContext(void* serverContext,
-                             stdcxx::shared_ptr<TProtocol> input,
-                             stdcxx::shared_ptr<TProtocol> output) {
+                             std::shared_ptr<TProtocol> input,
+                             std::shared_ptr<TProtocol> output) {
     (void)serverContext;
     (void)input;
     (void)output;
@@ -80,7 +80,7 @@
   /**
    * Called when a client is about to call the processor.
    */
-  virtual void processContext(void* serverContext, stdcxx::shared_ptr<TTransport> transport) {
+  virtual void processContext(void* serverContext, std::shared_ptr<TTransport> transport) {
     (void)serverContext;
     (void)transport;
   }
@@ -107,62 +107,62 @@
   // Allows running the server as a Runnable thread
   virtual void run() { serve(); }
 
-  stdcxx::shared_ptr<TProcessorFactory> getProcessorFactory() { return processorFactory_; }
+  std::shared_ptr<TProcessorFactory> getProcessorFactory() { return processorFactory_; }
 
-  stdcxx::shared_ptr<TServerTransport> getServerTransport() { return serverTransport_; }
+  std::shared_ptr<TServerTransport> getServerTransport() { return serverTransport_; }
 
-  stdcxx::shared_ptr<TTransportFactory> getInputTransportFactory() { return inputTransportFactory_; }
+  std::shared_ptr<TTransportFactory> getInputTransportFactory() { return inputTransportFactory_; }
 
-  stdcxx::shared_ptr<TTransportFactory> getOutputTransportFactory() {
+  std::shared_ptr<TTransportFactory> getOutputTransportFactory() {
     return outputTransportFactory_;
   }
 
-  stdcxx::shared_ptr<TProtocolFactory> getInputProtocolFactory() { return inputProtocolFactory_; }
+  std::shared_ptr<TProtocolFactory> getInputProtocolFactory() { return inputProtocolFactory_; }
 
-  stdcxx::shared_ptr<TProtocolFactory> getOutputProtocolFactory() { return outputProtocolFactory_; }
+  std::shared_ptr<TProtocolFactory> getOutputProtocolFactory() { return outputProtocolFactory_; }
 
-  stdcxx::shared_ptr<TServerEventHandler> getEventHandler() { return eventHandler_; }
+  std::shared_ptr<TServerEventHandler> getEventHandler() { return eventHandler_; }
 
 protected:
-  TServer(const stdcxx::shared_ptr<TProcessorFactory>& processorFactory)
+  TServer(const std::shared_ptr<TProcessorFactory>& processorFactory)
     : processorFactory_(processorFactory) {
-    setInputTransportFactory(stdcxx::shared_ptr<TTransportFactory>(new TTransportFactory()));
-    setOutputTransportFactory(stdcxx::shared_ptr<TTransportFactory>(new TTransportFactory()));
-    setInputProtocolFactory(stdcxx::shared_ptr<TProtocolFactory>(new TBinaryProtocolFactory()));
-    setOutputProtocolFactory(stdcxx::shared_ptr<TProtocolFactory>(new TBinaryProtocolFactory()));
+    setInputTransportFactory(std::shared_ptr<TTransportFactory>(new TTransportFactory()));
+    setOutputTransportFactory(std::shared_ptr<TTransportFactory>(new TTransportFactory()));
+    setInputProtocolFactory(std::shared_ptr<TProtocolFactory>(new TBinaryProtocolFactory()));
+    setOutputProtocolFactory(std::shared_ptr<TProtocolFactory>(new TBinaryProtocolFactory()));
   }
 
-  TServer(const stdcxx::shared_ptr<TProcessor>& processor)
+  TServer(const std::shared_ptr<TProcessor>& processor)
     : processorFactory_(new TSingletonProcessorFactory(processor)) {
-    setInputTransportFactory(stdcxx::shared_ptr<TTransportFactory>(new TTransportFactory()));
-    setOutputTransportFactory(stdcxx::shared_ptr<TTransportFactory>(new TTransportFactory()));
-    setInputProtocolFactory(stdcxx::shared_ptr<TProtocolFactory>(new TBinaryProtocolFactory()));
-    setOutputProtocolFactory(stdcxx::shared_ptr<TProtocolFactory>(new TBinaryProtocolFactory()));
+    setInputTransportFactory(std::shared_ptr<TTransportFactory>(new TTransportFactory()));
+    setOutputTransportFactory(std::shared_ptr<TTransportFactory>(new TTransportFactory()));
+    setInputProtocolFactory(std::shared_ptr<TProtocolFactory>(new TBinaryProtocolFactory()));
+    setOutputProtocolFactory(std::shared_ptr<TProtocolFactory>(new TBinaryProtocolFactory()));
   }
 
-  TServer(const stdcxx::shared_ptr<TProcessorFactory>& processorFactory,
-          const stdcxx::shared_ptr<TServerTransport>& serverTransport)
+  TServer(const std::shared_ptr<TProcessorFactory>& processorFactory,
+          const std::shared_ptr<TServerTransport>& serverTransport)
     : processorFactory_(processorFactory), serverTransport_(serverTransport) {
-    setInputTransportFactory(stdcxx::shared_ptr<TTransportFactory>(new TTransportFactory()));
-    setOutputTransportFactory(stdcxx::shared_ptr<TTransportFactory>(new TTransportFactory()));
-    setInputProtocolFactory(stdcxx::shared_ptr<TProtocolFactory>(new TBinaryProtocolFactory()));
-    setOutputProtocolFactory(stdcxx::shared_ptr<TProtocolFactory>(new TBinaryProtocolFactory()));
+    setInputTransportFactory(std::shared_ptr<TTransportFactory>(new TTransportFactory()));
+    setOutputTransportFactory(std::shared_ptr<TTransportFactory>(new TTransportFactory()));
+    setInputProtocolFactory(std::shared_ptr<TProtocolFactory>(new TBinaryProtocolFactory()));
+    setOutputProtocolFactory(std::shared_ptr<TProtocolFactory>(new TBinaryProtocolFactory()));
   }
 
-  TServer(const stdcxx::shared_ptr<TProcessor>& processor,
-          const stdcxx::shared_ptr<TServerTransport>& serverTransport)
+  TServer(const std::shared_ptr<TProcessor>& processor,
+          const std::shared_ptr<TServerTransport>& serverTransport)
     : processorFactory_(new TSingletonProcessorFactory(processor)),
       serverTransport_(serverTransport) {
-    setInputTransportFactory(stdcxx::shared_ptr<TTransportFactory>(new TTransportFactory()));
-    setOutputTransportFactory(stdcxx::shared_ptr<TTransportFactory>(new TTransportFactory()));
-    setInputProtocolFactory(stdcxx::shared_ptr<TProtocolFactory>(new TBinaryProtocolFactory()));
-    setOutputProtocolFactory(stdcxx::shared_ptr<TProtocolFactory>(new TBinaryProtocolFactory()));
+    setInputTransportFactory(std::shared_ptr<TTransportFactory>(new TTransportFactory()));
+    setOutputTransportFactory(std::shared_ptr<TTransportFactory>(new TTransportFactory()));
+    setInputProtocolFactory(std::shared_ptr<TProtocolFactory>(new TBinaryProtocolFactory()));
+    setOutputProtocolFactory(std::shared_ptr<TProtocolFactory>(new TBinaryProtocolFactory()));
   }
 
-  TServer(const stdcxx::shared_ptr<TProcessorFactory>& processorFactory,
-          const stdcxx::shared_ptr<TServerTransport>& serverTransport,
-          const stdcxx::shared_ptr<TTransportFactory>& transportFactory,
-          const stdcxx::shared_ptr<TProtocolFactory>& protocolFactory)
+  TServer(const std::shared_ptr<TProcessorFactory>& processorFactory,
+          const std::shared_ptr<TServerTransport>& serverTransport,
+          const std::shared_ptr<TTransportFactory>& transportFactory,
+          const std::shared_ptr<TProtocolFactory>& protocolFactory)
     : processorFactory_(processorFactory),
       serverTransport_(serverTransport),
       inputTransportFactory_(transportFactory),
@@ -170,10 +170,10 @@
       inputProtocolFactory_(protocolFactory),
       outputProtocolFactory_(protocolFactory) {}
 
-  TServer(const stdcxx::shared_ptr<TProcessor>& processor,
-          const stdcxx::shared_ptr<TServerTransport>& serverTransport,
-          const stdcxx::shared_ptr<TTransportFactory>& transportFactory,
-          const stdcxx::shared_ptr<TProtocolFactory>& protocolFactory)
+  TServer(const std::shared_ptr<TProcessor>& processor,
+          const std::shared_ptr<TServerTransport>& serverTransport,
+          const std::shared_ptr<TTransportFactory>& transportFactory,
+          const std::shared_ptr<TProtocolFactory>& protocolFactory)
     : processorFactory_(new TSingletonProcessorFactory(processor)),
       serverTransport_(serverTransport),
       inputTransportFactory_(transportFactory),
@@ -181,12 +181,12 @@
       inputProtocolFactory_(protocolFactory),
       outputProtocolFactory_(protocolFactory) {}
 
-  TServer(const stdcxx::shared_ptr<TProcessorFactory>& processorFactory,
-          const stdcxx::shared_ptr<TServerTransport>& serverTransport,
-          const stdcxx::shared_ptr<TTransportFactory>& inputTransportFactory,
-          const stdcxx::shared_ptr<TTransportFactory>& outputTransportFactory,
-          const stdcxx::shared_ptr<TProtocolFactory>& inputProtocolFactory,
-          const stdcxx::shared_ptr<TProtocolFactory>& outputProtocolFactory)
+  TServer(const std::shared_ptr<TProcessorFactory>& processorFactory,
+          const std::shared_ptr<TServerTransport>& serverTransport,
+          const std::shared_ptr<TTransportFactory>& inputTransportFactory,
+          const std::shared_ptr<TTransportFactory>& outputTransportFactory,
+          const std::shared_ptr<TProtocolFactory>& inputProtocolFactory,
+          const std::shared_ptr<TProtocolFactory>& outputProtocolFactory)
     : processorFactory_(processorFactory),
       serverTransport_(serverTransport),
       inputTransportFactory_(inputTransportFactory),
@@ -194,12 +194,12 @@
       inputProtocolFactory_(inputProtocolFactory),
       outputProtocolFactory_(outputProtocolFactory) {}
 
-  TServer(const stdcxx::shared_ptr<TProcessor>& processor,
-          const stdcxx::shared_ptr<TServerTransport>& serverTransport,
-          const stdcxx::shared_ptr<TTransportFactory>& inputTransportFactory,
-          const stdcxx::shared_ptr<TTransportFactory>& outputTransportFactory,
-          const stdcxx::shared_ptr<TProtocolFactory>& inputProtocolFactory,
-          const stdcxx::shared_ptr<TProtocolFactory>& outputProtocolFactory)
+  TServer(const std::shared_ptr<TProcessor>& processor,
+          const std::shared_ptr<TServerTransport>& serverTransport,
+          const std::shared_ptr<TTransportFactory>& inputTransportFactory,
+          const std::shared_ptr<TTransportFactory>& outputTransportFactory,
+          const std::shared_ptr<TProtocolFactory>& inputProtocolFactory,
+          const std::shared_ptr<TProtocolFactory>& outputProtocolFactory)
     : processorFactory_(new TSingletonProcessorFactory(processor)),
       serverTransport_(serverTransport),
       inputTransportFactory_(inputTransportFactory),
@@ -214,9 +214,9 @@
    * call).  This allows the TProcessorFactory to return a different processor
    * for each connection if it desires.
    */
-  stdcxx::shared_ptr<TProcessor> getProcessor(stdcxx::shared_ptr<TProtocol> inputProtocol,
-                                             stdcxx::shared_ptr<TProtocol> outputProtocol,
-                                             stdcxx::shared_ptr<TTransport> transport) {
+  std::shared_ptr<TProcessor> getProcessor(std::shared_ptr<TProtocol> inputProtocol,
+                                             std::shared_ptr<TProtocol> outputProtocol,
+                                             std::shared_ptr<TTransport> transport) {
     TConnectionInfo connInfo;
     connInfo.input = inputProtocol;
     connInfo.output = outputProtocol;
@@ -225,35 +225,35 @@
   }
 
   // Class variables
-  stdcxx::shared_ptr<TProcessorFactory> processorFactory_;
-  stdcxx::shared_ptr<TServerTransport> serverTransport_;
+  std::shared_ptr<TProcessorFactory> processorFactory_;
+  std::shared_ptr<TServerTransport> serverTransport_;
 
-  stdcxx::shared_ptr<TTransportFactory> inputTransportFactory_;
-  stdcxx::shared_ptr<TTransportFactory> outputTransportFactory_;
+  std::shared_ptr<TTransportFactory> inputTransportFactory_;
+  std::shared_ptr<TTransportFactory> outputTransportFactory_;
 
-  stdcxx::shared_ptr<TProtocolFactory> inputProtocolFactory_;
-  stdcxx::shared_ptr<TProtocolFactory> outputProtocolFactory_;
+  std::shared_ptr<TProtocolFactory> inputProtocolFactory_;
+  std::shared_ptr<TProtocolFactory> outputProtocolFactory_;
 
-  stdcxx::shared_ptr<TServerEventHandler> eventHandler_;
+  std::shared_ptr<TServerEventHandler> eventHandler_;
 
 public:
-  void setInputTransportFactory(stdcxx::shared_ptr<TTransportFactory> inputTransportFactory) {
+  void setInputTransportFactory(std::shared_ptr<TTransportFactory> inputTransportFactory) {
     inputTransportFactory_ = inputTransportFactory;
   }
 
-  void setOutputTransportFactory(stdcxx::shared_ptr<TTransportFactory> outputTransportFactory) {
+  void setOutputTransportFactory(std::shared_ptr<TTransportFactory> outputTransportFactory) {
     outputTransportFactory_ = outputTransportFactory;
   }
 
-  void setInputProtocolFactory(stdcxx::shared_ptr<TProtocolFactory> inputProtocolFactory) {
+  void setInputProtocolFactory(std::shared_ptr<TProtocolFactory> inputProtocolFactory) {
     inputProtocolFactory_ = inputProtocolFactory;
   }
 
-  void setOutputProtocolFactory(stdcxx::shared_ptr<TProtocolFactory> outputProtocolFactory) {
+  void setOutputProtocolFactory(std::shared_ptr<TProtocolFactory> outputProtocolFactory) {
     outputProtocolFactory_ = outputProtocolFactory;
   }
 
-  void setServerEventHandler(stdcxx::shared_ptr<TServerEventHandler> eventHandler) {
+  void setServerEventHandler(std::shared_ptr<TServerEventHandler> eventHandler) {
     eventHandler_ = eventHandler;
   }
 };
diff --git a/lib/cpp/src/thrift/server/TServerFramework.cpp b/lib/cpp/src/thrift/server/TServerFramework.cpp
index ae38336..cbeaa24 100644
--- a/lib/cpp/src/thrift/server/TServerFramework.cpp
+++ b/lib/cpp/src/thrift/server/TServerFramework.cpp
@@ -29,8 +29,8 @@
 using apache::thrift::concurrency::Synchronized;
 using apache::thrift::protocol::TProtocol;
 using apache::thrift::protocol::TProtocolFactory;
-using apache::thrift::stdcxx::bind;
-using apache::thrift::stdcxx::shared_ptr;
+using std::bind;
+using std::shared_ptr;
 using apache::thrift::transport::TServerTransport;
 using apache::thrift::transport::TTransport;
 using apache::thrift::transport::TTransportException;
@@ -161,7 +161,7 @@
                                outputProtocol,
                                eventHandler_,
                                client),
-          bind(&TServerFramework::disposeConnectedClient, this, stdcxx::placeholders::_1)));
+          bind(&TServerFramework::disposeConnectedClient, this, std::placeholders::_1)));
 
     } catch (TTransportException& ttx) {
       releaseOneDescriptor("inputTransport", inputTransport);
diff --git a/lib/cpp/src/thrift/server/TServerFramework.h b/lib/cpp/src/thrift/server/TServerFramework.h
index 706fd49..eaacce5 100644
--- a/lib/cpp/src/thrift/server/TServerFramework.h
+++ b/lib/cpp/src/thrift/server/TServerFramework.h
@@ -20,7 +20,7 @@
 #ifndef _THRIFT_SERVER_TSERVERFRAMEWORK_H_
 #define _THRIFT_SERVER_TSERVERFRAMEWORK_H_ 1
 
-#include <thrift/stdcxx.h>
+#include <memory>
 #include <stdint.h>
 #include <thrift/TProcessor.h>
 #include <thrift/concurrency/Monitor.h>
@@ -48,32 +48,32 @@
 class TServerFramework : public TServer {
 public:
   TServerFramework(
-      const stdcxx::shared_ptr<apache::thrift::TProcessorFactory>& processorFactory,
-      const stdcxx::shared_ptr<apache::thrift::transport::TServerTransport>& serverTransport,
-      const stdcxx::shared_ptr<apache::thrift::transport::TTransportFactory>& transportFactory,
-      const stdcxx::shared_ptr<apache::thrift::protocol::TProtocolFactory>& protocolFactory);
+      const std::shared_ptr<apache::thrift::TProcessorFactory>& processorFactory,
+      const std::shared_ptr<apache::thrift::transport::TServerTransport>& serverTransport,
+      const std::shared_ptr<apache::thrift::transport::TTransportFactory>& transportFactory,
+      const std::shared_ptr<apache::thrift::protocol::TProtocolFactory>& protocolFactory);
 
   TServerFramework(
-      const stdcxx::shared_ptr<apache::thrift::TProcessor>& processor,
-      const stdcxx::shared_ptr<apache::thrift::transport::TServerTransport>& serverTransport,
-      const stdcxx::shared_ptr<apache::thrift::transport::TTransportFactory>& transportFactory,
-      const stdcxx::shared_ptr<apache::thrift::protocol::TProtocolFactory>& protocolFactory);
+      const std::shared_ptr<apache::thrift::TProcessor>& processor,
+      const std::shared_ptr<apache::thrift::transport::TServerTransport>& serverTransport,
+      const std::shared_ptr<apache::thrift::transport::TTransportFactory>& transportFactory,
+      const std::shared_ptr<apache::thrift::protocol::TProtocolFactory>& protocolFactory);
 
   TServerFramework(
-      const stdcxx::shared_ptr<apache::thrift::TProcessorFactory>& processorFactory,
-      const stdcxx::shared_ptr<apache::thrift::transport::TServerTransport>& serverTransport,
-      const stdcxx::shared_ptr<apache::thrift::transport::TTransportFactory>& inputTransportFactory,
-      const stdcxx::shared_ptr<apache::thrift::transport::TTransportFactory>& outputTransportFactory,
-      const stdcxx::shared_ptr<apache::thrift::protocol::TProtocolFactory>& inputProtocolFactory,
-      const stdcxx::shared_ptr<apache::thrift::protocol::TProtocolFactory>& outputProtocolFactory);
+      const std::shared_ptr<apache::thrift::TProcessorFactory>& processorFactory,
+      const std::shared_ptr<apache::thrift::transport::TServerTransport>& serverTransport,
+      const std::shared_ptr<apache::thrift::transport::TTransportFactory>& inputTransportFactory,
+      const std::shared_ptr<apache::thrift::transport::TTransportFactory>& outputTransportFactory,
+      const std::shared_ptr<apache::thrift::protocol::TProtocolFactory>& inputProtocolFactory,
+      const std::shared_ptr<apache::thrift::protocol::TProtocolFactory>& outputProtocolFactory);
 
   TServerFramework(
-      const stdcxx::shared_ptr<apache::thrift::TProcessor>& processor,
-      const stdcxx::shared_ptr<apache::thrift::transport::TServerTransport>& serverTransport,
-      const stdcxx::shared_ptr<apache::thrift::transport::TTransportFactory>& inputTransportFactory,
-      const stdcxx::shared_ptr<apache::thrift::transport::TTransportFactory>& outputTransportFactory,
-      const stdcxx::shared_ptr<apache::thrift::protocol::TProtocolFactory>& inputProtocolFactory,
-      const stdcxx::shared_ptr<apache::thrift::protocol::TProtocolFactory>& outputProtocolFactory);
+      const std::shared_ptr<apache::thrift::TProcessor>& processor,
+      const std::shared_ptr<apache::thrift::transport::TServerTransport>& serverTransport,
+      const std::shared_ptr<apache::thrift::transport::TTransportFactory>& inputTransportFactory,
+      const std::shared_ptr<apache::thrift::transport::TTransportFactory>& outputTransportFactory,
+      const std::shared_ptr<apache::thrift::protocol::TProtocolFactory>& inputProtocolFactory,
+      const std::shared_ptr<apache::thrift::protocol::TProtocolFactory>& outputProtocolFactory);
 
   virtual ~TServerFramework();
 
@@ -130,7 +130,7 @@
    *
    * \param[in]  pClient  the newly connected client
    */
-  virtual void onClientConnected(const stdcxx::shared_ptr<TConnectedClient>& pClient) = 0;
+  virtual void onClientConnected(const std::shared_ptr<TConnectedClient>& pClient) = 0;
 
   /**
    * A client has disconnected.
@@ -149,7 +149,7 @@
    * client rate limiting after onClientConnected returns by blocking the
    * serve() thread if the limit has been reached.
    */
-  void newlyConnectedClient(const stdcxx::shared_ptr<TConnectedClient>& pClient);
+  void newlyConnectedClient(const std::shared_ptr<TConnectedClient>& pClient);
 
   /**
    * Smart pointer client deletion.
diff --git a/lib/cpp/src/thrift/server/TSimpleServer.cpp b/lib/cpp/src/thrift/server/TSimpleServer.cpp
index a0afbbe..716234d 100644
--- a/lib/cpp/src/thrift/server/TSimpleServer.cpp
+++ b/lib/cpp/src/thrift/server/TSimpleServer.cpp
@@ -29,7 +29,7 @@
 using apache::thrift::transport::TTransport;
 using apache::thrift::transport::TTransportException;
 using apache::thrift::transport::TTransportFactory;
-using stdcxx::shared_ptr;
+using std::shared_ptr;
 using std::string;
 
 TSimpleServer::TSimpleServer(const shared_ptr<TProcessorFactory>& processorFactory,
diff --git a/lib/cpp/src/thrift/server/TSimpleServer.h b/lib/cpp/src/thrift/server/TSimpleServer.h
index ac4ed34..4549225 100644
--- a/lib/cpp/src/thrift/server/TSimpleServer.h
+++ b/lib/cpp/src/thrift/server/TSimpleServer.h
@@ -34,37 +34,37 @@
 class TSimpleServer : public TServerFramework {
 public:
   TSimpleServer(
-      const stdcxx::shared_ptr<apache::thrift::TProcessorFactory>& processorFactory,
-      const stdcxx::shared_ptr<apache::thrift::transport::TServerTransport>& serverTransport,
-      const stdcxx::shared_ptr<apache::thrift::transport::TTransportFactory>& transportFactory,
-      const stdcxx::shared_ptr<apache::thrift::protocol::TProtocolFactory>& protocolFactory);
+      const std::shared_ptr<apache::thrift::TProcessorFactory>& processorFactory,
+      const std::shared_ptr<apache::thrift::transport::TServerTransport>& serverTransport,
+      const std::shared_ptr<apache::thrift::transport::TTransportFactory>& transportFactory,
+      const std::shared_ptr<apache::thrift::protocol::TProtocolFactory>& protocolFactory);
 
   TSimpleServer(
-      const stdcxx::shared_ptr<apache::thrift::TProcessor>& processor,
-      const stdcxx::shared_ptr<apache::thrift::transport::TServerTransport>& serverTransport,
-      const stdcxx::shared_ptr<apache::thrift::transport::TTransportFactory>& transportFactory,
-      const stdcxx::shared_ptr<apache::thrift::protocol::TProtocolFactory>& protocolFactory);
+      const std::shared_ptr<apache::thrift::TProcessor>& processor,
+      const std::shared_ptr<apache::thrift::transport::TServerTransport>& serverTransport,
+      const std::shared_ptr<apache::thrift::transport::TTransportFactory>& transportFactory,
+      const std::shared_ptr<apache::thrift::protocol::TProtocolFactory>& protocolFactory);
 
   TSimpleServer(
-      const stdcxx::shared_ptr<apache::thrift::TProcessorFactory>& processorFactory,
-      const stdcxx::shared_ptr<apache::thrift::transport::TServerTransport>& serverTransport,
-      const stdcxx::shared_ptr<apache::thrift::transport::TTransportFactory>& inputTransportFactory,
-      const stdcxx::shared_ptr<apache::thrift::transport::TTransportFactory>& outputTransportFactory,
-      const stdcxx::shared_ptr<apache::thrift::protocol::TProtocolFactory>& inputProtocolFactory,
-      const stdcxx::shared_ptr<apache::thrift::protocol::TProtocolFactory>& outputProtocolFactory);
+      const std::shared_ptr<apache::thrift::TProcessorFactory>& processorFactory,
+      const std::shared_ptr<apache::thrift::transport::TServerTransport>& serverTransport,
+      const std::shared_ptr<apache::thrift::transport::TTransportFactory>& inputTransportFactory,
+      const std::shared_ptr<apache::thrift::transport::TTransportFactory>& outputTransportFactory,
+      const std::shared_ptr<apache::thrift::protocol::TProtocolFactory>& inputProtocolFactory,
+      const std::shared_ptr<apache::thrift::protocol::TProtocolFactory>& outputProtocolFactory);
 
   TSimpleServer(
-      const stdcxx::shared_ptr<apache::thrift::TProcessor>& processor,
-      const stdcxx::shared_ptr<apache::thrift::transport::TServerTransport>& serverTransport,
-      const stdcxx::shared_ptr<apache::thrift::transport::TTransportFactory>& inputTransportFactory,
-      const stdcxx::shared_ptr<apache::thrift::transport::TTransportFactory>& outputTransportFactory,
-      const stdcxx::shared_ptr<apache::thrift::protocol::TProtocolFactory>& inputProtocolFactory,
-      const stdcxx::shared_ptr<apache::thrift::protocol::TProtocolFactory>& outputProtocolFactory);
+      const std::shared_ptr<apache::thrift::TProcessor>& processor,
+      const std::shared_ptr<apache::thrift::transport::TServerTransport>& serverTransport,
+      const std::shared_ptr<apache::thrift::transport::TTransportFactory>& inputTransportFactory,
+      const std::shared_ptr<apache::thrift::transport::TTransportFactory>& outputTransportFactory,
+      const std::shared_ptr<apache::thrift::protocol::TProtocolFactory>& inputProtocolFactory,
+      const std::shared_ptr<apache::thrift::protocol::TProtocolFactory>& outputProtocolFactory);
 
   virtual ~TSimpleServer();
 
 protected:
-  virtual void onClientConnected(const stdcxx::shared_ptr<TConnectedClient>& pClient) /* override */;
+  virtual void onClientConnected(const std::shared_ptr<TConnectedClient>& pClient) /* override */;
   virtual void onClientDisconnected(TConnectedClient* pClient) /* override */;
 
 private:
diff --git a/lib/cpp/src/thrift/server/TThreadPoolServer.cpp b/lib/cpp/src/thrift/server/TThreadPoolServer.cpp
index f07ff84..ee345a9 100644
--- a/lib/cpp/src/thrift/server/TThreadPoolServer.cpp
+++ b/lib/cpp/src/thrift/server/TThreadPoolServer.cpp
@@ -30,7 +30,7 @@
 using apache::thrift::transport::TTransport;
 using apache::thrift::transport::TTransportException;
 using apache::thrift::transport::TTransportFactory;
-using stdcxx::shared_ptr;
+using std::shared_ptr;
 using std::string;
 
 TThreadPoolServer::TThreadPoolServer(const shared_ptr<TProcessorFactory>& processorFactory,
@@ -115,7 +115,7 @@
   taskExpiration_ = value;
 }
 
-stdcxx::shared_ptr<apache::thrift::concurrency::ThreadManager>
+std::shared_ptr<apache::thrift::concurrency::ThreadManager>
 TThreadPoolServer::getThreadManager() const {
   return threadManager_;
 }
diff --git a/lib/cpp/src/thrift/server/TThreadPoolServer.h b/lib/cpp/src/thrift/server/TThreadPoolServer.h
index 94088d5..a957b47 100644
--- a/lib/cpp/src/thrift/server/TThreadPoolServer.h
+++ b/lib/cpp/src/thrift/server/TThreadPoolServer.h
@@ -34,39 +34,39 @@
 class TThreadPoolServer : public TServerFramework {
 public:
   TThreadPoolServer(
-      const stdcxx::shared_ptr<apache::thrift::TProcessorFactory>& processorFactory,
-      const stdcxx::shared_ptr<apache::thrift::transport::TServerTransport>& serverTransport,
-      const stdcxx::shared_ptr<apache::thrift::transport::TTransportFactory>& transportFactory,
-      const stdcxx::shared_ptr<apache::thrift::protocol::TProtocolFactory>& protocolFactory,
-      const stdcxx::shared_ptr<apache::thrift::concurrency::ThreadManager>& threadManager
+      const std::shared_ptr<apache::thrift::TProcessorFactory>& processorFactory,
+      const std::shared_ptr<apache::thrift::transport::TServerTransport>& serverTransport,
+      const std::shared_ptr<apache::thrift::transport::TTransportFactory>& transportFactory,
+      const std::shared_ptr<apache::thrift::protocol::TProtocolFactory>& protocolFactory,
+      const std::shared_ptr<apache::thrift::concurrency::ThreadManager>& threadManager
       = apache::thrift::concurrency::ThreadManager::newSimpleThreadManager());
 
   TThreadPoolServer(
-      const stdcxx::shared_ptr<apache::thrift::TProcessor>& processor,
-      const stdcxx::shared_ptr<apache::thrift::transport::TServerTransport>& serverTransport,
-      const stdcxx::shared_ptr<apache::thrift::transport::TTransportFactory>& transportFactory,
-      const stdcxx::shared_ptr<apache::thrift::protocol::TProtocolFactory>& protocolFactory,
-      const stdcxx::shared_ptr<apache::thrift::concurrency::ThreadManager>& threadManager
+      const std::shared_ptr<apache::thrift::TProcessor>& processor,
+      const std::shared_ptr<apache::thrift::transport::TServerTransport>& serverTransport,
+      const std::shared_ptr<apache::thrift::transport::TTransportFactory>& transportFactory,
+      const std::shared_ptr<apache::thrift::protocol::TProtocolFactory>& protocolFactory,
+      const std::shared_ptr<apache::thrift::concurrency::ThreadManager>& threadManager
       = apache::thrift::concurrency::ThreadManager::newSimpleThreadManager());
 
   TThreadPoolServer(
-      const stdcxx::shared_ptr<apache::thrift::TProcessorFactory>& processorFactory,
-      const stdcxx::shared_ptr<apache::thrift::transport::TServerTransport>& serverTransport,
-      const stdcxx::shared_ptr<apache::thrift::transport::TTransportFactory>& inputTransportFactory,
-      const stdcxx::shared_ptr<apache::thrift::transport::TTransportFactory>& outputTransportFactory,
-      const stdcxx::shared_ptr<apache::thrift::protocol::TProtocolFactory>& inputProtocolFactory,
-      const stdcxx::shared_ptr<apache::thrift::protocol::TProtocolFactory>& outputProtocolFactory,
-      const stdcxx::shared_ptr<apache::thrift::concurrency::ThreadManager>& threadManager
+      const std::shared_ptr<apache::thrift::TProcessorFactory>& processorFactory,
+      const std::shared_ptr<apache::thrift::transport::TServerTransport>& serverTransport,
+      const std::shared_ptr<apache::thrift::transport::TTransportFactory>& inputTransportFactory,
+      const std::shared_ptr<apache::thrift::transport::TTransportFactory>& outputTransportFactory,
+      const std::shared_ptr<apache::thrift::protocol::TProtocolFactory>& inputProtocolFactory,
+      const std::shared_ptr<apache::thrift::protocol::TProtocolFactory>& outputProtocolFactory,
+      const std::shared_ptr<apache::thrift::concurrency::ThreadManager>& threadManager
       = apache::thrift::concurrency::ThreadManager::newSimpleThreadManager());
 
   TThreadPoolServer(
-      const stdcxx::shared_ptr<apache::thrift::TProcessor>& processor,
-      const stdcxx::shared_ptr<apache::thrift::transport::TServerTransport>& serverTransport,
-      const stdcxx::shared_ptr<apache::thrift::transport::TTransportFactory>& inputTransportFactory,
-      const stdcxx::shared_ptr<apache::thrift::transport::TTransportFactory>& outputTransportFactory,
-      const stdcxx::shared_ptr<apache::thrift::protocol::TProtocolFactory>& inputProtocolFactory,
-      const stdcxx::shared_ptr<apache::thrift::protocol::TProtocolFactory>& outputProtocolFactory,
-      const stdcxx::shared_ptr<apache::thrift::concurrency::ThreadManager>& threadManager
+      const std::shared_ptr<apache::thrift::TProcessor>& processor,
+      const std::shared_ptr<apache::thrift::transport::TServerTransport>& serverTransport,
+      const std::shared_ptr<apache::thrift::transport::TTransportFactory>& inputTransportFactory,
+      const std::shared_ptr<apache::thrift::transport::TTransportFactory>& outputTransportFactory,
+      const std::shared_ptr<apache::thrift::protocol::TProtocolFactory>& inputProtocolFactory,
+      const std::shared_ptr<apache::thrift::protocol::TProtocolFactory>& outputProtocolFactory,
+      const std::shared_ptr<apache::thrift::concurrency::ThreadManager>& threadManager
       = apache::thrift::concurrency::ThreadManager::newSimpleThreadManager());
 
   virtual ~TThreadPoolServer();
@@ -83,13 +83,13 @@
   virtual int64_t getTaskExpiration() const;
   virtual void setTaskExpiration(int64_t value);
 
-  virtual stdcxx::shared_ptr<apache::thrift::concurrency::ThreadManager> getThreadManager() const;
+  virtual std::shared_ptr<apache::thrift::concurrency::ThreadManager> getThreadManager() const;
 
 protected:
-  virtual void onClientConnected(const stdcxx::shared_ptr<TConnectedClient>& pClient) /* override */;
+  virtual void onClientConnected(const std::shared_ptr<TConnectedClient>& pClient) /* override */;
   virtual void onClientDisconnected(TConnectedClient* pClient) /* override */;
 
-  stdcxx::shared_ptr<apache::thrift::concurrency::ThreadManager> threadManager_;
+  std::shared_ptr<apache::thrift::concurrency::ThreadManager> threadManager_;
   boost::atomic<int64_t> timeout_;
   boost::atomic<int64_t> taskExpiration_;
 };
diff --git a/lib/cpp/src/thrift/server/TThreadedServer.cpp b/lib/cpp/src/thrift/server/TThreadedServer.cpp
index 3fe5aa6..2264df7 100644
--- a/lib/cpp/src/thrift/server/TThreadedServer.cpp
+++ b/lib/cpp/src/thrift/server/TThreadedServer.cpp
@@ -18,7 +18,7 @@
  */
 
 #include <string>
-#include <thrift/stdcxx.h>
+#include <memory>
 #include <thrift/concurrency/PlatformThreadFactory.h>
 #include <thrift/server/TThreadedServer.h>
 
@@ -32,8 +32,8 @@
 using apache::thrift::concurrency::ThreadFactory;
 using apache::thrift::protocol::TProtocol;
 using apache::thrift::protocol::TProtocolFactory;
-using apache::thrift::stdcxx::make_shared;
-using apache::thrift::stdcxx::shared_ptr;
+using std::make_shared;
+using std::shared_ptr;
 using apache::thrift::transport::TServerTransport;
 using apache::thrift::transport::TTransport;
 using apache::thrift::transport::TTransportException;
diff --git a/lib/cpp/src/thrift/server/TThreadedServer.h b/lib/cpp/src/thrift/server/TThreadedServer.h
index 1e0a824..c5ccd03 100644
--- a/lib/cpp/src/thrift/server/TThreadedServer.h
+++ b/lib/cpp/src/thrift/server/TThreadedServer.h
@@ -38,43 +38,43 @@
 class TThreadedServer : public TServerFramework {
 public:
   TThreadedServer(
-      const stdcxx::shared_ptr<apache::thrift::TProcessorFactory>& processorFactory,
-      const stdcxx::shared_ptr<apache::thrift::transport::TServerTransport>& serverTransport,
-      const stdcxx::shared_ptr<apache::thrift::transport::TTransportFactory>& transportFactory,
-      const stdcxx::shared_ptr<apache::thrift::protocol::TProtocolFactory>& protocolFactory,
-      const stdcxx::shared_ptr<apache::thrift::concurrency::ThreadFactory>& threadFactory
-      = stdcxx::shared_ptr<apache::thrift::concurrency::ThreadFactory>(
+      const std::shared_ptr<apache::thrift::TProcessorFactory>& processorFactory,
+      const std::shared_ptr<apache::thrift::transport::TServerTransport>& serverTransport,
+      const std::shared_ptr<apache::thrift::transport::TTransportFactory>& transportFactory,
+      const std::shared_ptr<apache::thrift::protocol::TProtocolFactory>& protocolFactory,
+      const std::shared_ptr<apache::thrift::concurrency::ThreadFactory>& threadFactory
+      = std::shared_ptr<apache::thrift::concurrency::ThreadFactory>(
           new apache::thrift::concurrency::PlatformThreadFactory(false)));
 
   TThreadedServer(
-      const stdcxx::shared_ptr<apache::thrift::TProcessor>& processor,
-      const stdcxx::shared_ptr<apache::thrift::transport::TServerTransport>& serverTransport,
-      const stdcxx::shared_ptr<apache::thrift::transport::TTransportFactory>& transportFactory,
-      const stdcxx::shared_ptr<apache::thrift::protocol::TProtocolFactory>& protocolFactory,
-      const stdcxx::shared_ptr<apache::thrift::concurrency::ThreadFactory>& threadFactory
-      = stdcxx::shared_ptr<apache::thrift::concurrency::ThreadFactory>(
+      const std::shared_ptr<apache::thrift::TProcessor>& processor,
+      const std::shared_ptr<apache::thrift::transport::TServerTransport>& serverTransport,
+      const std::shared_ptr<apache::thrift::transport::TTransportFactory>& transportFactory,
+      const std::shared_ptr<apache::thrift::protocol::TProtocolFactory>& protocolFactory,
+      const std::shared_ptr<apache::thrift::concurrency::ThreadFactory>& threadFactory
+      = std::shared_ptr<apache::thrift::concurrency::ThreadFactory>(
           new apache::thrift::concurrency::PlatformThreadFactory(false)));
 
   TThreadedServer(
-      const stdcxx::shared_ptr<apache::thrift::TProcessorFactory>& processorFactory,
-      const stdcxx::shared_ptr<apache::thrift::transport::TServerTransport>& serverTransport,
-      const stdcxx::shared_ptr<apache::thrift::transport::TTransportFactory>& inputTransportFactory,
-      const stdcxx::shared_ptr<apache::thrift::transport::TTransportFactory>& outputTransportFactory,
-      const stdcxx::shared_ptr<apache::thrift::protocol::TProtocolFactory>& inputProtocolFactory,
-      const stdcxx::shared_ptr<apache::thrift::protocol::TProtocolFactory>& outputProtocolFactory,
-      const stdcxx::shared_ptr<apache::thrift::concurrency::ThreadFactory>& threadFactory
-      = stdcxx::shared_ptr<apache::thrift::concurrency::ThreadFactory>(
+      const std::shared_ptr<apache::thrift::TProcessorFactory>& processorFactory,
+      const std::shared_ptr<apache::thrift::transport::TServerTransport>& serverTransport,
+      const std::shared_ptr<apache::thrift::transport::TTransportFactory>& inputTransportFactory,
+      const std::shared_ptr<apache::thrift::transport::TTransportFactory>& outputTransportFactory,
+      const std::shared_ptr<apache::thrift::protocol::TProtocolFactory>& inputProtocolFactory,
+      const std::shared_ptr<apache::thrift::protocol::TProtocolFactory>& outputProtocolFactory,
+      const std::shared_ptr<apache::thrift::concurrency::ThreadFactory>& threadFactory
+      = std::shared_ptr<apache::thrift::concurrency::ThreadFactory>(
           new apache::thrift::concurrency::PlatformThreadFactory(false)));
 
   TThreadedServer(
-      const stdcxx::shared_ptr<apache::thrift::TProcessor>& processor,
-      const stdcxx::shared_ptr<apache::thrift::transport::TServerTransport>& serverTransport,
-      const stdcxx::shared_ptr<apache::thrift::transport::TTransportFactory>& inputTransportFactory,
-      const stdcxx::shared_ptr<apache::thrift::transport::TTransportFactory>& outputTransportFactory,
-      const stdcxx::shared_ptr<apache::thrift::protocol::TProtocolFactory>& inputProtocolFactory,
-      const stdcxx::shared_ptr<apache::thrift::protocol::TProtocolFactory>& outputProtocolFactory,
-      const stdcxx::shared_ptr<apache::thrift::concurrency::ThreadFactory>& threadFactory
-      = stdcxx::shared_ptr<apache::thrift::concurrency::ThreadFactory>(
+      const std::shared_ptr<apache::thrift::TProcessor>& processor,
+      const std::shared_ptr<apache::thrift::transport::TServerTransport>& serverTransport,
+      const std::shared_ptr<apache::thrift::transport::TTransportFactory>& inputTransportFactory,
+      const std::shared_ptr<apache::thrift::transport::TTransportFactory>& outputTransportFactory,
+      const std::shared_ptr<apache::thrift::protocol::TProtocolFactory>& inputProtocolFactory,
+      const std::shared_ptr<apache::thrift::protocol::TProtocolFactory>& outputProtocolFactory,
+      const std::shared_ptr<apache::thrift::concurrency::ThreadFactory>& threadFactory
+      = std::shared_ptr<apache::thrift::concurrency::ThreadFactory>(
           new apache::thrift::concurrency::PlatformThreadFactory(false)));
 
   virtual ~TThreadedServer();
@@ -95,14 +95,14 @@
   /**
    * Implementation of TServerFramework::onClientConnected
    */
-  virtual void onClientConnected(const stdcxx::shared_ptr<TConnectedClient>& pClient) /* override */;
+  virtual void onClientConnected(const std::shared_ptr<TConnectedClient>& pClient) /* override */;
 
   /**
    * Implementation of TServerFramework::onClientDisconnected
    */
   virtual void onClientDisconnected(TConnectedClient *pClient) /* override */;
 
-  stdcxx::shared_ptr<apache::thrift::concurrency::ThreadFactory> threadFactory_;
+  std::shared_ptr<apache::thrift::concurrency::ThreadFactory> threadFactory_;
 
   /**
    * A helper wrapper used to wrap the client in something we can use to maintain
@@ -114,16 +114,16 @@
   class TConnectedClientRunner : public apache::thrift::concurrency::Runnable
   {
   public:
-    TConnectedClientRunner(const stdcxx::shared_ptr<TConnectedClient>& pClient);
+    TConnectedClientRunner(const std::shared_ptr<TConnectedClient>& pClient);
     virtual ~TConnectedClientRunner();
     void run() /* override */;
   private:
-    stdcxx::shared_ptr<TConnectedClient> pClient_;
+    std::shared_ptr<TConnectedClient> pClient_;
   };
 
   apache::thrift::concurrency::Monitor clientMonitor_;
 
-  typedef std::map<TConnectedClient *, stdcxx::shared_ptr<apache::thrift::concurrency::Thread> > ClientMap;
+  typedef std::map<TConnectedClient *, std::shared_ptr<apache::thrift::concurrency::Thread> > ClientMap;
 
   /**
    * A map of active clients
diff --git a/lib/cpp/src/thrift/stdcxx.h b/lib/cpp/src/thrift/stdcxx.h
deleted file mode 100644
index 20910de..0000000
--- a/lib/cpp/src/thrift/stdcxx.h
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- * 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_STDCXX_H_
-#define _THRIFT_STDCXX_H_ 1
-
-#include <boost/config.hpp>
-#include <boost/version.hpp>
-
-///////////////////////////////////////////////////////////////////
-//
-// functional (function, bind)
-//
-///////////////////////////////////////////////////////////////////
-
-#include <functional>
-
-namespace apache { namespace thrift { namespace stdcxx {
-  using ::std::bind;
-  using ::std::function;
-
-  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;
-    using ::std::placeholders::_7;
-    using ::std::placeholders::_8;
-    using ::std::placeholders::_9;
-  } // apache::thrift::stdcxx::placeholders
-}}} // apache::thrift::stdcxx
-
-
-///////////////////////////////////////////////////////////////////
-//
-// Smart Pointers
-//
-///////////////////////////////////////////////////////////////////
-
-#include <memory>
-
-namespace apache { namespace thrift { namespace stdcxx {
-
-using ::std::const_pointer_cast;
-using ::std::dynamic_pointer_cast;
-using ::std::enable_shared_from_this;
-using ::std::make_shared;
-template <typename T> using scoped_ptr = std::unique_ptr<T>;		// compiler must support template aliasing
-using ::std::shared_ptr;
-using ::std::static_pointer_cast;
-using ::std::weak_ptr;
-
-
-}}} // apache::thrift::stdcxx
-
-#endif // #ifndef _THRIFT_STDCXX_H_
diff --git a/lib/cpp/src/thrift/transport/TBufferTransports.h b/lib/cpp/src/thrift/transport/TBufferTransports.h
index 79aace6..c423f9c 100644
--- a/lib/cpp/src/thrift/transport/TBufferTransports.h
+++ b/lib/cpp/src/thrift/transport/TBufferTransports.h
@@ -186,7 +186,7 @@
   static const int DEFAULT_BUFFER_SIZE = 512;
 
   /// Use default buffer sizes.
-  TBufferedTransport(stdcxx::shared_ptr<TTransport> transport)
+  TBufferedTransport(std::shared_ptr<TTransport> transport)
     : transport_(transport),
       rBufSize_(DEFAULT_BUFFER_SIZE),
       wBufSize_(DEFAULT_BUFFER_SIZE),
@@ -196,7 +196,7 @@
   }
 
   /// Use specified buffer sizes.
-  TBufferedTransport(stdcxx::shared_ptr<TTransport> transport, uint32_t sz)
+  TBufferedTransport(std::shared_ptr<TTransport> transport, uint32_t sz)
     : transport_(transport),
       rBufSize_(sz),
       wBufSize_(sz),
@@ -206,7 +206,7 @@
   }
 
   /// Use specified read and write buffer sizes.
-  TBufferedTransport(stdcxx::shared_ptr<TTransport> transport, uint32_t rsz, uint32_t wsz)
+  TBufferedTransport(std::shared_ptr<TTransport> transport, uint32_t rsz, uint32_t wsz)
     : transport_(transport),
       rBufSize_(rsz),
       wBufSize_(wsz),
@@ -255,7 +255,7 @@
    */
   virtual const uint8_t* borrowSlow(uint8_t* buf, uint32_t* len);
 
-  stdcxx::shared_ptr<TTransport> getUnderlyingTransport() { return transport_; }
+  std::shared_ptr<TTransport> getUnderlyingTransport() { return transport_; }
 
   /*
    * TVirtualTransport provides a default implementation of readAll().
@@ -270,7 +270,7 @@
     // Write size never changes.
   }
 
-  stdcxx::shared_ptr<TTransport> transport_;
+  std::shared_ptr<TTransport> transport_;
 
   uint32_t rBufSize_;
   uint32_t wBufSize_;
@@ -291,8 +291,8 @@
   /**
    * Wraps the transport into a buffered one.
    */
-  virtual stdcxx::shared_ptr<TTransport> getTransport(stdcxx::shared_ptr<TTransport> trans) {
-    return stdcxx::shared_ptr<TTransport>(new TBufferedTransport(trans));
+  virtual std::shared_ptr<TTransport> getTransport(std::shared_ptr<TTransport> trans) {
+    return std::shared_ptr<TTransport>(new TBufferedTransport(trans));
   }
 };
 
@@ -319,7 +319,7 @@
     initPointers();
   }
 
-  TFramedTransport(stdcxx::shared_ptr<TTransport> transport)
+  TFramedTransport(std::shared_ptr<TTransport> transport)
     : transport_(transport),
       rBufSize_(0),
       wBufSize_(DEFAULT_BUFFER_SIZE),
@@ -330,7 +330,7 @@
     initPointers();
   }
 
-  TFramedTransport(stdcxx::shared_ptr<TTransport> transport,
+  TFramedTransport(std::shared_ptr<TTransport> transport,
                    uint32_t sz,
                    uint32_t bufReclaimThresh = (std::numeric_limits<uint32_t>::max)())
     : transport_(transport),
@@ -366,7 +366,7 @@
 
   const uint8_t* borrowSlow(uint8_t* buf, uint32_t* len);
 
-  stdcxx::shared_ptr<TTransport> getUnderlyingTransport() { return transport_; }
+  std::shared_ptr<TTransport> getUnderlyingTransport() { return transport_; }
 
   /*
    * TVirtualTransport provides a default implementation of readAll().
@@ -407,7 +407,7 @@
     this->write((uint8_t*)&pad, sizeof(pad));
   }
 
-  stdcxx::shared_ptr<TTransport> transport_;
+  std::shared_ptr<TTransport> transport_;
 
   uint32_t rBufSize_;
   uint32_t wBufSize_;
@@ -430,8 +430,8 @@
   /**
    * Wraps the transport into a framed one.
    */
-  virtual stdcxx::shared_ptr<TTransport> getTransport(stdcxx::shared_ptr<TTransport> trans) {
-    return stdcxx::shared_ptr<TTransport>(new TFramedTransport(trans));
+  virtual std::shared_ptr<TTransport> getTransport(std::shared_ptr<TTransport> trans) {
+    return std::shared_ptr<TTransport>(new TFramedTransport(trans));
   }
 };
 
diff --git a/lib/cpp/src/thrift/transport/TFileTransport.cpp b/lib/cpp/src/thrift/transport/TFileTransport.cpp
index b08a5f1..c9f65b8 100644
--- a/lib/cpp/src/thrift/transport/TFileTransport.cpp
+++ b/lib/cpp/src/thrift/transport/TFileTransport.cpp
@@ -61,7 +61,7 @@
 namespace thrift {
 namespace transport {
 
-using stdcxx::shared_ptr;
+using std::shared_ptr;
 using std::cerr;
 using std::cout;
 using std::endl;
diff --git a/lib/cpp/src/thrift/transport/TFileTransport.h b/lib/cpp/src/thrift/transport/TFileTransport.h
index d6da436..4fbdd9e 100644
--- a/lib/cpp/src/thrift/transport/TFileTransport.h
+++ b/lib/cpp/src/thrift/transport/TFileTransport.h
@@ -28,7 +28,6 @@
 #include <stdio.h>
 
 #include <boost/atomic.hpp>
-#include <thrift/stdcxx.h>
 
 #include <thrift/concurrency/Mutex.h>
 #include <thrift/concurrency/Monitor.h>
@@ -339,7 +338,7 @@
 
   // writer thread
   apache::thrift::concurrency::PlatformThreadFactory threadFactory_;
-  stdcxx::shared_ptr<apache::thrift::concurrency::Thread> writerThread_;
+  std::shared_ptr<apache::thrift::concurrency::Thread> writerThread_;
 
   // buffers to hold data before it is flushed. Each element of the buffer stores a msg that
   // needs to be written to the file.  The buffers are swapped by the writer thread.
@@ -390,14 +389,14 @@
    * @param protocolFactory protocol factory
    * @param inputTransport file transport
    */
-  TFileProcessor(stdcxx::shared_ptr<TProcessor> processor,
-                 stdcxx::shared_ptr<TProtocolFactory> protocolFactory,
-                 stdcxx::shared_ptr<TFileReaderTransport> inputTransport);
+  TFileProcessor(std::shared_ptr<TProcessor> processor,
+                 std::shared_ptr<TProtocolFactory> protocolFactory,
+                 std::shared_ptr<TFileReaderTransport> inputTransport);
 
-  TFileProcessor(stdcxx::shared_ptr<TProcessor> processor,
-                 stdcxx::shared_ptr<TProtocolFactory> inputProtocolFactory,
-                 stdcxx::shared_ptr<TProtocolFactory> outputProtocolFactory,
-                 stdcxx::shared_ptr<TFileReaderTransport> inputTransport);
+  TFileProcessor(std::shared_ptr<TProcessor> processor,
+                 std::shared_ptr<TProtocolFactory> inputProtocolFactory,
+                 std::shared_ptr<TProtocolFactory> outputProtocolFactory,
+                 std::shared_ptr<TFileReaderTransport> inputTransport);
 
   /**
    * Constructor
@@ -407,10 +406,10 @@
    * @param inputTransport input file transport
    * @param output output transport
    */
-  TFileProcessor(stdcxx::shared_ptr<TProcessor> processor,
-                 stdcxx::shared_ptr<TProtocolFactory> protocolFactory,
-                 stdcxx::shared_ptr<TFileReaderTransport> inputTransport,
-                 stdcxx::shared_ptr<TTransport> outputTransport);
+  TFileProcessor(std::shared_ptr<TProcessor> processor,
+                 std::shared_ptr<TProtocolFactory> protocolFactory,
+                 std::shared_ptr<TFileReaderTransport> inputTransport,
+                 std::shared_ptr<TTransport> outputTransport);
 
   /**
    * processes events from the file
@@ -427,11 +426,11 @@
   void processChunk();
 
 private:
-  stdcxx::shared_ptr<TProcessor> processor_;
-  stdcxx::shared_ptr<TProtocolFactory> inputProtocolFactory_;
-  stdcxx::shared_ptr<TProtocolFactory> outputProtocolFactory_;
-  stdcxx::shared_ptr<TFileReaderTransport> inputTransport_;
-  stdcxx::shared_ptr<TTransport> outputTransport_;
+  std::shared_ptr<TProcessor> processor_;
+  std::shared_ptr<TProtocolFactory> inputProtocolFactory_;
+  std::shared_ptr<TProtocolFactory> outputProtocolFactory_;
+  std::shared_ptr<TFileReaderTransport> inputTransport_;
+  std::shared_ptr<TTransport> outputTransport_;
 };
 }
 }
diff --git a/lib/cpp/src/thrift/transport/THeaderTransport.cpp b/lib/cpp/src/thrift/transport/THeaderTransport.cpp
index ea16591..25084ec 100644
--- a/lib/cpp/src/thrift/transport/THeaderTransport.cpp
+++ b/lib/cpp/src/thrift/transport/THeaderTransport.cpp
@@ -22,7 +22,6 @@
 #include <thrift/protocol/TProtocolTypes.h>
 #include <thrift/protocol/TBinaryProtocol.h>
 #include <thrift/protocol/TCompactProtocol.h>
-#include <thrift/stdcxx.h>
 
 #include <limits>
 #include <utility>
@@ -37,7 +36,7 @@
 namespace apache {
 namespace thrift {
 
-using stdcxx::shared_ptr;
+using std::shared_ptr;
 
 namespace transport {
 
diff --git a/lib/cpp/src/thrift/transport/THeaderTransport.h b/lib/cpp/src/thrift/transport/THeaderTransport.h
index 1a2c8e0..e6c57e6 100644
--- a/lib/cpp/src/thrift/transport/THeaderTransport.h
+++ b/lib/cpp/src/thrift/transport/THeaderTransport.h
@@ -34,7 +34,6 @@
 #endif
 
 #include <boost/scoped_array.hpp>
-#include <thrift/stdcxx.h>
 
 #include <thrift/protocol/TProtocolTypes.h>
 #include <thrift/transport/TBufferTransports.h>
@@ -75,7 +74,7 @@
   static const int THRIFT_MAX_VARINT32_BYTES = 5;
 
   /// Use default buffer sizes.
-  explicit THeaderTransport(const stdcxx::shared_ptr<TTransport>& transport)
+  explicit THeaderTransport(const std::shared_ptr<TTransport>& transport)
     : TVirtualTransport(transport),
       outTransport_(transport),
       protoId(T_COMPACT_PROTOCOL),
@@ -88,8 +87,8 @@
     initBuffers();
   }
 
-  THeaderTransport(const stdcxx::shared_ptr<TTransport> inTransport,
-                   const stdcxx::shared_ptr<TTransport> outTransport)
+  THeaderTransport(const std::shared_ptr<TTransport> inTransport,
+                   const std::shared_ptr<TTransport> outTransport)
     : TVirtualTransport(inTransport),
       outTransport_(outTransport),
       protoId(T_COMPACT_PROTOCOL),
@@ -186,7 +185,7 @@
     setWriteBuffer(wBuf_.get(), wBufSize_);
   }
 
-  stdcxx::shared_ptr<TTransport> outTransport_;
+  std::shared_ptr<TTransport> outTransport_;
 
   // 0 and 16th bits must be 0 to differentiate from framed & unframed
   static const uint32_t HEADER_MAGIC = 0x0FFF0000;
@@ -265,8 +264,8 @@
   /**
    * Wraps the transport into a header one.
    */
-  virtual stdcxx::shared_ptr<TTransport> getTransport(stdcxx::shared_ptr<TTransport> trans) {
-    return stdcxx::shared_ptr<TTransport>(new THeaderTransport(trans));
+  virtual std::shared_ptr<TTransport> getTransport(std::shared_ptr<TTransport> trans) {
+    return std::shared_ptr<TTransport>(new THeaderTransport(trans));
   }
 };
 }
diff --git a/lib/cpp/src/thrift/transport/THttpClient.cpp b/lib/cpp/src/thrift/transport/THttpClient.cpp
index afd02a8..d152197 100644
--- a/lib/cpp/src/thrift/transport/THttpClient.cpp
+++ b/lib/cpp/src/thrift/transport/THttpClient.cpp
@@ -32,14 +32,14 @@
 namespace thrift {
 namespace transport {
 
-THttpClient::THttpClient(stdcxx::shared_ptr<TTransport> transport,
+THttpClient::THttpClient(std::shared_ptr<TTransport> transport,
                          std::string host,
                          std::string path)
   : THttpTransport(transport), host_(host), path_(path) {
 }
 
 THttpClient::THttpClient(string host, int port, string path)
-  : THttpTransport(stdcxx::shared_ptr<TTransport>(new TSocket(host, port))),
+  : THttpTransport(std::shared_ptr<TTransport>(new TSocket(host, port))),
     host_(host),
     path_(path) {
 }
diff --git a/lib/cpp/src/thrift/transport/THttpClient.h b/lib/cpp/src/thrift/transport/THttpClient.h
index 96fd5b8..f4fb12a 100644
--- a/lib/cpp/src/thrift/transport/THttpClient.h
+++ b/lib/cpp/src/thrift/transport/THttpClient.h
@@ -28,7 +28,7 @@
 
 class THttpClient : public THttpTransport {
 public:
-  THttpClient(stdcxx::shared_ptr<TTransport> transport, std::string host, std::string path = "");
+  THttpClient(std::shared_ptr<TTransport> transport, std::string host, std::string path = "");
 
   THttpClient(std::string host, int port, std::string path = "");
 
diff --git a/lib/cpp/src/thrift/transport/THttpServer.cpp b/lib/cpp/src/thrift/transport/THttpServer.cpp
index 2f48cf6..96b2480 100644
--- a/lib/cpp/src/thrift/transport/THttpServer.cpp
+++ b/lib/cpp/src/thrift/transport/THttpServer.cpp
@@ -34,7 +34,7 @@
 namespace thrift {
 namespace transport {
 
-THttpServer::THttpServer(stdcxx::shared_ptr<TTransport> transport) : THttpTransport(transport) {
+THttpServer::THttpServer(std::shared_ptr<TTransport> transport) : THttpTransport(transport) {
 }
 
 THttpServer::~THttpServer() {
diff --git a/lib/cpp/src/thrift/transport/THttpServer.h b/lib/cpp/src/thrift/transport/THttpServer.h
index 086dd6f..c38606f 100644
--- a/lib/cpp/src/thrift/transport/THttpServer.h
+++ b/lib/cpp/src/thrift/transport/THttpServer.h
@@ -28,7 +28,7 @@
 
 class THttpServer : public THttpTransport {
 public:
-  THttpServer(stdcxx::shared_ptr<TTransport> transport);
+  THttpServer(std::shared_ptr<TTransport> transport);
 
   virtual ~THttpServer();
 
@@ -53,8 +53,8 @@
   /**
    * Wraps the transport into a buffered one.
    */
-  virtual stdcxx::shared_ptr<TTransport> getTransport(stdcxx::shared_ptr<TTransport> trans) {
-    return stdcxx::shared_ptr<TTransport>(new THttpServer(trans));
+  virtual std::shared_ptr<TTransport> getTransport(std::shared_ptr<TTransport> trans) {
+    return std::shared_ptr<TTransport>(new THttpServer(trans));
   }
 };
 }
diff --git a/lib/cpp/src/thrift/transport/THttpTransport.cpp b/lib/cpp/src/thrift/transport/THttpTransport.cpp
index 4ccb4d3..6ccc034 100644
--- a/lib/cpp/src/thrift/transport/THttpTransport.cpp
+++ b/lib/cpp/src/thrift/transport/THttpTransport.cpp
@@ -31,7 +31,7 @@
 const char* THttpTransport::CRLF = "\r\n";
 const int THttpTransport::CRLF_LEN = 2;
 
-THttpTransport::THttpTransport(stdcxx::shared_ptr<TTransport> transport)
+THttpTransport::THttpTransport(std::shared_ptr<TTransport> transport)
   : transport_(transport),
     origin_(""),
     readHeaders_(true),
diff --git a/lib/cpp/src/thrift/transport/THttpTransport.h b/lib/cpp/src/thrift/transport/THttpTransport.h
index 3fa80f8..e46ab7f 100644
--- a/lib/cpp/src/thrift/transport/THttpTransport.h
+++ b/lib/cpp/src/thrift/transport/THttpTransport.h
@@ -36,7 +36,7 @@
  */
 class THttpTransport : public TVirtualTransport<THttpTransport> {
 public:
-  THttpTransport(stdcxx::shared_ptr<TTransport> transport);
+  THttpTransport(std::shared_ptr<TTransport> transport);
 
   virtual ~THttpTransport();
 
@@ -59,7 +59,7 @@
   virtual const std::string getOrigin();
 
 protected:
-  stdcxx::shared_ptr<TTransport> transport_;
+  std::shared_ptr<TTransport> transport_;
   std::string origin_;
 
   TMemoryBuffer writeBuffer_;
diff --git a/lib/cpp/src/thrift/transport/TNonblockingSSLServerSocket.cpp b/lib/cpp/src/thrift/transport/TNonblockingSSLServerSocket.cpp
index da83bea..adec5d0 100644
--- a/lib/cpp/src/thrift/transport/TNonblockingSSLServerSocket.cpp
+++ b/lib/cpp/src/thrift/transport/TNonblockingSSLServerSocket.cpp
@@ -27,14 +27,14 @@
 /**
  * Nonblocking SSL server socket implementation.
  */
-TNonblockingSSLServerSocket::TNonblockingSSLServerSocket(int port, stdcxx::shared_ptr<TSSLSocketFactory> factory)
+TNonblockingSSLServerSocket::TNonblockingSSLServerSocket(int port, std::shared_ptr<TSSLSocketFactory> factory)
   : TNonblockingServerSocket(port), factory_(factory) {
   factory_->server(true);
 }
 
 TNonblockingSSLServerSocket::TNonblockingSSLServerSocket(const std::string& address,
                                    int port,
-                                   stdcxx::shared_ptr<TSSLSocketFactory> factory)
+                                   std::shared_ptr<TSSLSocketFactory> factory)
   : TNonblockingServerSocket(address, port), factory_(factory) {
   factory_->server(true);
 }
@@ -42,13 +42,13 @@
 TNonblockingSSLServerSocket::TNonblockingSSLServerSocket(int port,
                                    int sendTimeout,
                                    int recvTimeout,
-                                   stdcxx::shared_ptr<TSSLSocketFactory> factory)
+                                   std::shared_ptr<TSSLSocketFactory> factory)
   : TNonblockingServerSocket(port, sendTimeout, recvTimeout), factory_(factory) {
   factory_->server(true);
 }
 
-stdcxx::shared_ptr<TSocket> TNonblockingSSLServerSocket::createSocket(THRIFT_SOCKET client) {
-  stdcxx::shared_ptr<TSSLSocket> tSSLSocket;
+std::shared_ptr<TSocket> TNonblockingSSLServerSocket::createSocket(THRIFT_SOCKET client) {
+  std::shared_ptr<TSSLSocket> tSSLSocket;
   tSSLSocket = factory_->createSocket(client);
   tSSLSocket->setLibeventSafe();
   return tSSLSocket;
diff --git a/lib/cpp/src/thrift/transport/TNonblockingSSLServerSocket.h b/lib/cpp/src/thrift/transport/TNonblockingSSLServerSocket.h
index 7aaff53..215c405 100644
--- a/lib/cpp/src/thrift/transport/TNonblockingSSLServerSocket.h
+++ b/lib/cpp/src/thrift/transport/TNonblockingSSLServerSocket.h
@@ -21,7 +21,6 @@
 #define _THRIFT_TRANSPORT_TNONBLOCKINGSSLSERVERSOCKET_H_ 1
 
 #include <thrift/transport/TNonblockingServerSocket.h>
-#include <thrift/stdcxx.h>
 
 namespace apache {
 namespace thrift {
@@ -40,7 +39,7 @@
    * @param port    Listening port
    * @param factory SSL socket factory implementation
    */
-  TNonblockingSSLServerSocket(int port, stdcxx::shared_ptr<TSSLSocketFactory> factory);
+  TNonblockingSSLServerSocket(int port, std::shared_ptr<TSSLSocketFactory> factory);
 
   /**
    * Constructor.  Binds to the specified address.
@@ -51,7 +50,7 @@
    */
   TNonblockingSSLServerSocket(const std::string& address,
                    int port,
-                   stdcxx::shared_ptr<TSSLSocketFactory> factory);
+                   std::shared_ptr<TSSLSocketFactory> factory);
 
   /**
    * Constructor.  Binds to all interfaces.
@@ -64,11 +63,11 @@
   TNonblockingSSLServerSocket(int port,
                    int sendTimeout,
                    int recvTimeout,
-                   stdcxx::shared_ptr<TSSLSocketFactory> factory);
+                   std::shared_ptr<TSSLSocketFactory> factory);
 
 protected:
-  stdcxx::shared_ptr<TSocket> createSocket(THRIFT_SOCKET socket);
-  stdcxx::shared_ptr<TSSLSocketFactory> factory_;
+  std::shared_ptr<TSocket> createSocket(THRIFT_SOCKET socket);
+  std::shared_ptr<TSSLSocketFactory> factory_;
 };
 }
 }
diff --git a/lib/cpp/src/thrift/transport/TNonblockingServerSocket.cpp b/lib/cpp/src/thrift/transport/TNonblockingServerSocket.cpp
index cca52a4..3d34cca 100644
--- a/lib/cpp/src/thrift/transport/TNonblockingServerSocket.cpp
+++ b/lib/cpp/src/thrift/transport/TNonblockingServerSocket.cpp
@@ -74,7 +74,7 @@
 namespace transport {
 
 using std::string;
-using stdcxx::shared_ptr;
+using std::shared_ptr;
 
 TNonblockingServerSocket::TNonblockingServerSocket(int port)
   : port_(port),
diff --git a/lib/cpp/src/thrift/transport/TNonblockingServerSocket.h b/lib/cpp/src/thrift/transport/TNonblockingServerSocket.h
index 1d33239..1586ff0 100644
--- a/lib/cpp/src/thrift/transport/TNonblockingServerSocket.h
+++ b/lib/cpp/src/thrift/transport/TNonblockingServerSocket.h
@@ -22,7 +22,6 @@
 
 #include <thrift/transport/TNonblockingServerTransport.h>
 #include <thrift/transport/PlatformSocket.h>
-#include <thrift/stdcxx.h>
 
 namespace apache {
 namespace thrift {
@@ -37,7 +36,7 @@
  */
 class TNonblockingServerSocket : public TNonblockingServerTransport {
 public:
-  typedef apache::thrift::stdcxx::function<void(THRIFT_SOCKET fd)> socket_func_t;
+  typedef std::function<void(THRIFT_SOCKET fd)> socket_func_t;
 
   const static int DEFAULT_BACKLOG = 1024;
 
@@ -108,8 +107,8 @@
   void close();
 
 protected:
-  apache::thrift::stdcxx::shared_ptr<TSocket> acceptImpl();
-  virtual apache::thrift::stdcxx::shared_ptr<TSocket> createSocket(THRIFT_SOCKET client);
+  std::shared_ptr<TSocket> acceptImpl();
+  virtual std::shared_ptr<TSocket> createSocket(THRIFT_SOCKET client);
 
 private:
   int port_;
diff --git a/lib/cpp/src/thrift/transport/TNonblockingServerTransport.h b/lib/cpp/src/thrift/transport/TNonblockingServerTransport.h
index c32a051..3142e19 100644
--- a/lib/cpp/src/thrift/transport/TNonblockingServerTransport.h
+++ b/lib/cpp/src/thrift/transport/TNonblockingServerTransport.h
@@ -22,7 +22,6 @@
 
 #include <thrift/transport/TSocket.h>
 #include <thrift/transport/TTransportException.h>
-#include <thrift/stdcxx.h>
 
 namespace apache {
 namespace thrift {
@@ -56,8 +55,8 @@
    * @return A new TTransport object
    * @throws TTransportException if there is an error
    */
-  stdcxx::shared_ptr<TSocket> accept() {
-    stdcxx::shared_ptr<TSocket> result = acceptImpl();
+  std::shared_ptr<TSocket> accept() {
+    std::shared_ptr<TSocket> result = acceptImpl();
     if (!result) {
       throw TTransportException("accept() may not return NULL");
     }
@@ -91,7 +90,7 @@
    * @return A newly allocated TTransport object
    * @throw TTransportException If an error occurs
    */
-  virtual stdcxx::shared_ptr<TSocket> acceptImpl() = 0;
+  virtual std::shared_ptr<TSocket> acceptImpl() = 0;
 
 };
 }
diff --git a/lib/cpp/src/thrift/transport/TPipe.h b/lib/cpp/src/thrift/transport/TPipe.h
index dfc5f2c..aa14f95 100644
--- a/lib/cpp/src/thrift/transport/TPipe.h
+++ b/lib/cpp/src/thrift/transport/TPipe.h
@@ -95,7 +95,7 @@
   HANDLE getNativeWaitHandle();
 
 private:
-  stdcxx::shared_ptr<TPipeImpl> impl_;
+  std::shared_ptr<TPipeImpl> impl_;
 
   std::string pipename_;
 
diff --git a/lib/cpp/src/thrift/transport/TPipeServer.cpp b/lib/cpp/src/thrift/transport/TPipeServer.cpp
index 5923a62..55c3580 100644
--- a/lib/cpp/src/thrift/transport/TPipeServer.cpp
+++ b/lib/cpp/src/thrift/transport/TPipeServer.cpp
@@ -22,7 +22,6 @@
 
 #include <thrift/transport/TPipe.h>
 #include <thrift/transport/TPipeServer.h>
-#include <thrift/stdcxx.h>
 #include <boost/noncopyable.hpp>
 
 #ifdef _WIN32
@@ -37,14 +36,14 @@
 
 #ifdef _WIN32
 
-using stdcxx::shared_ptr;
+using std::shared_ptr;
 
 class TPipeServerImpl : boost::noncopyable {
 public:
   TPipeServerImpl() {}
   virtual ~TPipeServerImpl() {}
   virtual void interrupt() = 0;
-  virtual stdcxx::shared_ptr<TTransport> acceptImpl() = 0;
+  virtual std::shared_ptr<TTransport> acceptImpl() = 0;
 
   virtual HANDLE getPipeHandle() = 0;
   virtual HANDLE getWrtPipeHandle() = 0;
@@ -75,7 +74,7 @@
 
   virtual void interrupt() {} // not currently implemented
 
-  virtual stdcxx::shared_ptr<TTransport> acceptImpl();
+  virtual std::shared_ptr<TTransport> acceptImpl();
 
   virtual HANDLE getPipeHandle() { return PipeR_.h; }
   virtual HANDLE getWrtPipeHandle() { return PipeW_.h; }
@@ -117,7 +116,7 @@
     }
   }
 
-  virtual stdcxx::shared_ptr<TTransport> acceptImpl();
+  virtual std::shared_ptr<TTransport> acceptImpl();
 
   virtual HANDLE getPipeHandle() { return Pipe_.h; }
   virtual HANDLE getWrtPipeHandle() { return INVALID_HANDLE_VALUE; }
@@ -141,7 +140,7 @@
 
   TCriticalSection pipe_protect_;
   // only read or write these variables underneath a locked pipe_protect_
-  stdcxx::shared_ptr<TPipe> cached_client_;
+  std::shared_ptr<TPipe> cached_client_;
   TAutoHandle Pipe_;
 };
 
diff --git a/lib/cpp/src/thrift/transport/TPipeServer.h b/lib/cpp/src/thrift/transport/TPipeServer.h
index 117773c..c9b13e5 100644
--- a/lib/cpp/src/thrift/transport/TPipeServer.h
+++ b/lib/cpp/src/thrift/transport/TPipeServer.h
@@ -20,8 +20,8 @@
 #ifndef _THRIFT_TRANSPORT_TSERVERWINPIPES_H_
 #define _THRIFT_TRANSPORT_TSERVERWINPIPES_H_ 1
 
+#include <memory>
 #include <thrift/transport/TServerTransport.h>
-#include <thrift/stdcxx.h>
 #ifndef _WIN32
 #include <thrift/transport/TServerSocket.h>
 #endif
@@ -82,10 +82,10 @@
   HANDLE getNativeWaitHandle();
 
 protected:
-  virtual stdcxx::shared_ptr<TTransport> acceptImpl();
+  virtual std::shared_ptr<TTransport> acceptImpl();
 
 private:
-  stdcxx::shared_ptr<TPipeServerImpl> impl_;
+  std::shared_ptr<TPipeServerImpl> impl_;
 
   std::string pipename_;
   uint32_t bufsize_;
diff --git a/lib/cpp/src/thrift/transport/TSSLServerSocket.cpp b/lib/cpp/src/thrift/transport/TSSLServerSocket.cpp
index 8e81ad7..34605c0 100644
--- a/lib/cpp/src/thrift/transport/TSSLServerSocket.cpp
+++ b/lib/cpp/src/thrift/transport/TSSLServerSocket.cpp
@@ -27,14 +27,14 @@
 /**
  * SSL server socket implementation.
  */
-TSSLServerSocket::TSSLServerSocket(int port, stdcxx::shared_ptr<TSSLSocketFactory> factory)
+TSSLServerSocket::TSSLServerSocket(int port, std::shared_ptr<TSSLSocketFactory> factory)
   : TServerSocket(port), factory_(factory) {
   factory_->server(true);
 }
 
 TSSLServerSocket::TSSLServerSocket(const std::string& address,
                                    int port,
-                                   stdcxx::shared_ptr<TSSLSocketFactory> factory)
+                                   std::shared_ptr<TSSLSocketFactory> factory)
   : TServerSocket(address, port), factory_(factory) {
   factory_->server(true);
 }
@@ -42,12 +42,12 @@
 TSSLServerSocket::TSSLServerSocket(int port,
                                    int sendTimeout,
                                    int recvTimeout,
-                                   stdcxx::shared_ptr<TSSLSocketFactory> factory)
+                                   std::shared_ptr<TSSLSocketFactory> factory)
   : TServerSocket(port, sendTimeout, recvTimeout), factory_(factory) {
   factory_->server(true);
 }
 
-stdcxx::shared_ptr<TSocket> TSSLServerSocket::createSocket(THRIFT_SOCKET client) {
+std::shared_ptr<TSocket> TSSLServerSocket::createSocket(THRIFT_SOCKET client) {
   if (interruptableChildren_) {
       return factory_->createSocket(client, pChildInterruptSockReader_);
 
diff --git a/lib/cpp/src/thrift/transport/TSSLServerSocket.h b/lib/cpp/src/thrift/transport/TSSLServerSocket.h
index dda9af4..8b75de8 100644
--- a/lib/cpp/src/thrift/transport/TSSLServerSocket.h
+++ b/lib/cpp/src/thrift/transport/TSSLServerSocket.h
@@ -20,7 +20,6 @@
 #ifndef _THRIFT_TRANSPORT_TSSLSERVERSOCKET_H_
 #define _THRIFT_TRANSPORT_TSSLSERVERSOCKET_H_ 1
 
-#include <thrift/stdcxx.h>
 #include <thrift/transport/TServerSocket.h>
 
 namespace apache {
@@ -40,7 +39,7 @@
    * @param port    Listening port
    * @param factory SSL socket factory implementation
    */
-  TSSLServerSocket(int port, stdcxx::shared_ptr<TSSLSocketFactory> factory);
+  TSSLServerSocket(int port, std::shared_ptr<TSSLSocketFactory> factory);
 
   /**
    * Constructor.  Binds to the specified address.
@@ -51,7 +50,7 @@
    */
   TSSLServerSocket(const std::string& address,
                    int port,
-                   stdcxx::shared_ptr<TSSLSocketFactory> factory);
+                   std::shared_ptr<TSSLSocketFactory> factory);
 
   /**
    * Constructor.  Binds to all interfaces.
@@ -64,11 +63,11 @@
   TSSLServerSocket(int port,
                    int sendTimeout,
                    int recvTimeout,
-                   stdcxx::shared_ptr<TSSLSocketFactory> factory);
+                   std::shared_ptr<TSSLSocketFactory> factory);
 
 protected:
-  stdcxx::shared_ptr<TSocket> createSocket(THRIFT_SOCKET socket);
-  stdcxx::shared_ptr<TSSLSocketFactory> factory_;
+  std::shared_ptr<TSocket> createSocket(THRIFT_SOCKET socket);
+  std::shared_ptr<TSSLSocketFactory> factory_;
 };
 }
 }
diff --git a/lib/cpp/src/thrift/transport/TSSLSocket.cpp b/lib/cpp/src/thrift/transport/TSSLSocket.cpp
index 5f8a2c0..718e9b1 100644
--- a/lib/cpp/src/thrift/transport/TSSLSocket.cpp
+++ b/lib/cpp/src/thrift/transport/TSSLSocket.cpp
@@ -213,33 +213,33 @@
 }
 
 // TSSLSocket implementation
-TSSLSocket::TSSLSocket(stdcxx::shared_ptr<SSLContext> ctx)
+TSSLSocket::TSSLSocket(std::shared_ptr<SSLContext> ctx)
   : TSocket(), server_(false), ssl_(NULL), ctx_(ctx) {
   init();
 }
 
-TSSLSocket::TSSLSocket(stdcxx::shared_ptr<SSLContext> ctx, stdcxx::shared_ptr<THRIFT_SOCKET> interruptListener)
+TSSLSocket::TSSLSocket(std::shared_ptr<SSLContext> ctx, std::shared_ptr<THRIFT_SOCKET> interruptListener)
         : TSocket(), server_(false), ssl_(NULL), ctx_(ctx) {
   init();
   interruptListener_ = interruptListener;
 }
 
-TSSLSocket::TSSLSocket(stdcxx::shared_ptr<SSLContext> ctx, THRIFT_SOCKET socket)
+TSSLSocket::TSSLSocket(std::shared_ptr<SSLContext> ctx, THRIFT_SOCKET socket)
   : TSocket(socket), server_(false), ssl_(NULL), ctx_(ctx) {
   init();
 }
 
-TSSLSocket::TSSLSocket(stdcxx::shared_ptr<SSLContext> ctx, THRIFT_SOCKET socket, stdcxx::shared_ptr<THRIFT_SOCKET> interruptListener)
+TSSLSocket::TSSLSocket(std::shared_ptr<SSLContext> ctx, THRIFT_SOCKET socket, std::shared_ptr<THRIFT_SOCKET> interruptListener)
         : TSocket(socket, interruptListener), server_(false), ssl_(NULL), ctx_(ctx) {
   init();
 }
 
-TSSLSocket::TSSLSocket(stdcxx::shared_ptr<SSLContext> ctx, string host, int port)
+TSSLSocket::TSSLSocket(std::shared_ptr<SSLContext> ctx, string host, int port)
   : TSocket(host, port), server_(false), ssl_(NULL), ctx_(ctx) {
   init();
 }
 
-TSSLSocket::TSSLSocket(stdcxx::shared_ptr<SSLContext> ctx, string host, int port, stdcxx::shared_ptr<THRIFT_SOCKET> interruptListener)
+TSSLSocket::TSSLSocket(std::shared_ptr<SSLContext> ctx, string host, int port, std::shared_ptr<THRIFT_SOCKET> interruptListener)
         : TSocket(host, port), server_(false), ssl_(NULL), ctx_(ctx) {
   init();
   interruptListener_ = interruptListener;
@@ -857,7 +857,7 @@
     randomize();
   }
   count_++;
-  ctx_ = stdcxx::shared_ptr<SSLContext>(new SSLContext(protocol));
+  ctx_ = std::shared_ptr<SSLContext>(new SSLContext(protocol));
 }
 
 TSSLSocketFactory::~TSSLSocketFactory() {
@@ -869,47 +869,47 @@
   }
 }
 
-stdcxx::shared_ptr<TSSLSocket> TSSLSocketFactory::createSocket() {
-  stdcxx::shared_ptr<TSSLSocket> ssl(new TSSLSocket(ctx_));
+std::shared_ptr<TSSLSocket> TSSLSocketFactory::createSocket() {
+  std::shared_ptr<TSSLSocket> ssl(new TSSLSocket(ctx_));
   setup(ssl);
   return ssl;
 }
 
-stdcxx::shared_ptr<TSSLSocket> TSSLSocketFactory::createSocket(stdcxx::shared_ptr<THRIFT_SOCKET> interruptListener) {
-  stdcxx::shared_ptr<TSSLSocket> ssl(new TSSLSocket(ctx_, interruptListener));
+std::shared_ptr<TSSLSocket> TSSLSocketFactory::createSocket(std::shared_ptr<THRIFT_SOCKET> interruptListener) {
+  std::shared_ptr<TSSLSocket> ssl(new TSSLSocket(ctx_, interruptListener));
   setup(ssl);
   return ssl;
 }
 
-stdcxx::shared_ptr<TSSLSocket> TSSLSocketFactory::createSocket(THRIFT_SOCKET socket) {
-  stdcxx::shared_ptr<TSSLSocket> ssl(new TSSLSocket(ctx_, socket));
+std::shared_ptr<TSSLSocket> TSSLSocketFactory::createSocket(THRIFT_SOCKET socket) {
+  std::shared_ptr<TSSLSocket> ssl(new TSSLSocket(ctx_, socket));
   setup(ssl);
   return ssl;
 }
 
-stdcxx::shared_ptr<TSSLSocket> TSSLSocketFactory::createSocket(THRIFT_SOCKET socket, stdcxx::shared_ptr<THRIFT_SOCKET> interruptListener) {
-  stdcxx::shared_ptr<TSSLSocket> ssl(new TSSLSocket(ctx_, socket, interruptListener));
+std::shared_ptr<TSSLSocket> TSSLSocketFactory::createSocket(THRIFT_SOCKET socket, std::shared_ptr<THRIFT_SOCKET> interruptListener) {
+  std::shared_ptr<TSSLSocket> ssl(new TSSLSocket(ctx_, socket, interruptListener));
   setup(ssl);
   return ssl;
 }
 
-stdcxx::shared_ptr<TSSLSocket> TSSLSocketFactory::createSocket(const string& host, int port) {
-  stdcxx::shared_ptr<TSSLSocket> ssl(new TSSLSocket(ctx_, host, port));
+std::shared_ptr<TSSLSocket> TSSLSocketFactory::createSocket(const string& host, int port) {
+  std::shared_ptr<TSSLSocket> ssl(new TSSLSocket(ctx_, host, port));
   setup(ssl);
   return ssl;
 }
 
-stdcxx::shared_ptr<TSSLSocket> TSSLSocketFactory::createSocket(const string& host, int port, stdcxx::shared_ptr<THRIFT_SOCKET> interruptListener) {
-  stdcxx::shared_ptr<TSSLSocket> ssl(new TSSLSocket(ctx_, host, port, interruptListener));
+std::shared_ptr<TSSLSocket> TSSLSocketFactory::createSocket(const string& host, int port, std::shared_ptr<THRIFT_SOCKET> interruptListener) {
+  std::shared_ptr<TSSLSocket> ssl(new TSSLSocket(ctx_, host, port, interruptListener));
   setup(ssl);
   return ssl;
 }
 
 
-void TSSLSocketFactory::setup(stdcxx::shared_ptr<TSSLSocket> ssl) {
+void TSSLSocketFactory::setup(std::shared_ptr<TSSLSocket> ssl) {
   ssl->server(server());
   if (access_ == NULL && !server()) {
-    access_ = stdcxx::shared_ptr<AccessManager>(new DefaultClientAccessManager);
+    access_ = std::shared_ptr<AccessManager>(new DefaultClientAccessManager);
   }
   if (access_ != NULL) {
     ssl->access(access_);
diff --git a/lib/cpp/src/thrift/transport/TSSLSocket.h b/lib/cpp/src/thrift/transport/TSSLSocket.h
index d8fd77e..5a87d1e 100644
--- a/lib/cpp/src/thrift/transport/TSSLSocket.h
+++ b/lib/cpp/src/thrift/transport/TSSLSocket.h
@@ -26,7 +26,6 @@
 #include <openssl/ssl.h>
 #include <string>
 #include <thrift/concurrency/Mutex.h>
-#include <thrift/stdcxx.h>
 
 namespace apache {
 namespace thrift {
@@ -98,7 +97,7 @@
    *
    * @param manager  Instance of AccessManager
    */
-  virtual void access(stdcxx::shared_ptr<AccessManager> manager) { access_ = manager; }
+  virtual void access(std::shared_ptr<AccessManager> manager) { access_ = manager; }
   /**
    * Set eventSafe flag if libevent is used.
    */
@@ -112,37 +111,37 @@
   /**
    * Constructor.
    */
-  TSSLSocket(stdcxx::shared_ptr<SSLContext> ctx);
+  TSSLSocket(std::shared_ptr<SSLContext> ctx);
   /**
    * Constructor with an interrupt signal.
    */
-  TSSLSocket(stdcxx::shared_ptr<SSLContext> ctx, stdcxx::shared_ptr<THRIFT_SOCKET> interruptListener);
+  TSSLSocket(std::shared_ptr<SSLContext> ctx, std::shared_ptr<THRIFT_SOCKET> interruptListener);
   /**
    * Constructor, create an instance of TSSLSocket given an existing socket.
    *
    * @param socket An existing socket
    */
-  TSSLSocket(stdcxx::shared_ptr<SSLContext> ctx, THRIFT_SOCKET socket);
+  TSSLSocket(std::shared_ptr<SSLContext> ctx, THRIFT_SOCKET socket);
   /**
    * Constructor, create an instance of TSSLSocket given an existing socket that can be interrupted.
    *
    * @param socket An existing socket
    */
-  TSSLSocket(stdcxx::shared_ptr<SSLContext> ctx, THRIFT_SOCKET socket, stdcxx::shared_ptr<THRIFT_SOCKET> interruptListener);
+  TSSLSocket(std::shared_ptr<SSLContext> ctx, THRIFT_SOCKET socket, std::shared_ptr<THRIFT_SOCKET> interruptListener);
    /**
    * Constructor.
    *
    * @param host  Remote host name
    * @param port  Remote port number
    */
-  TSSLSocket(stdcxx::shared_ptr<SSLContext> ctx, std::string host, int port);
+  TSSLSocket(std::shared_ptr<SSLContext> ctx, std::string host, int port);
     /**
   * Constructor with an interrupt signal.
   *
   * @param host  Remote host name
   * @param port  Remote port number
   */
-    TSSLSocket(stdcxx::shared_ptr<SSLContext> ctx, std::string host, int port, stdcxx::shared_ptr<THRIFT_SOCKET> interruptListener);
+    TSSLSocket(std::shared_ptr<SSLContext> ctx, std::string host, int port, std::shared_ptr<THRIFT_SOCKET> interruptListener);
   /**
    * Authorize peer access after SSL handshake completes.
    */
@@ -171,8 +170,8 @@
 
   bool server_;
   SSL* ssl_;
-  stdcxx::shared_ptr<SSLContext> ctx_;
-  stdcxx::shared_ptr<AccessManager> access_;
+  std::shared_ptr<SSLContext> ctx_;
+  std::shared_ptr<AccessManager> access_;
   friend class TSSLSocketFactory;
 
 private:
@@ -212,37 +211,37 @@
   /**
    * Create an instance of TSSLSocket with a fresh new socket.
    */
-  virtual stdcxx::shared_ptr<TSSLSocket> createSocket();
+  virtual std::shared_ptr<TSSLSocket> createSocket();
   /**
    * Create an instance of TSSLSocket with a fresh new socket, which is interruptable.
    */
-  virtual stdcxx::shared_ptr<TSSLSocket> createSocket(stdcxx::shared_ptr<THRIFT_SOCKET> interruptListener);
+  virtual std::shared_ptr<TSSLSocket> createSocket(std::shared_ptr<THRIFT_SOCKET> interruptListener);
   /**
    * Create an instance of TSSLSocket with the given socket.
    *
    * @param socket An existing socket.
    */
-  virtual stdcxx::shared_ptr<TSSLSocket> createSocket(THRIFT_SOCKET socket);
+  virtual std::shared_ptr<TSSLSocket> createSocket(THRIFT_SOCKET socket);
   /**
    * Create an instance of TSSLSocket with the given socket which is interruptable.
    *
    * @param socket An existing socket.
    */
-  virtual stdcxx::shared_ptr<TSSLSocket> createSocket(THRIFT_SOCKET socket, stdcxx::shared_ptr<THRIFT_SOCKET> interruptListener);
+  virtual std::shared_ptr<TSSLSocket> createSocket(THRIFT_SOCKET socket, std::shared_ptr<THRIFT_SOCKET> interruptListener);
   /**
   * Create an instance of TSSLSocket.
   *
   * @param host  Remote host to be connected to
   * @param port  Remote port to be connected to
   */
-  virtual stdcxx::shared_ptr<TSSLSocket> createSocket(const std::string& host, int port);
+  virtual std::shared_ptr<TSSLSocket> createSocket(const std::string& host, int port);
   /**
   * Create an instance of TSSLSocket.
   *
   * @param host  Remote host to be connected to
   * @param port  Remote port to be connected to
   */
-  virtual stdcxx::shared_ptr<TSSLSocket> createSocket(const std::string& host, int port, stdcxx::shared_ptr<THRIFT_SOCKET> interruptListener);
+  virtual std::shared_ptr<TSSLSocket> createSocket(const std::string& host, int port, std::shared_ptr<THRIFT_SOCKET> interruptListener);
   /**
    * Set ciphers to be used in SSL handshake process.
    *
@@ -300,13 +299,13 @@
    *
    * @param manager  The AccessManager instance
    */
-  virtual void access(stdcxx::shared_ptr<AccessManager> manager) { access_ = manager; }
+  virtual void access(std::shared_ptr<AccessManager> manager) { access_ = manager; }
   static void setManualOpenSSLInitialization(bool manualOpenSSLInitialization) {
     manualOpenSSLInitialization_ = manualOpenSSLInitialization;
   }
 
 protected:
-  stdcxx::shared_ptr<SSLContext> ctx_;
+  std::shared_ptr<SSLContext> ctx_;
 
   /**
    * Override this method for custom password callback. It may be called
@@ -319,11 +318,11 @@
 
 private:
   bool server_;
-  stdcxx::shared_ptr<AccessManager> access_;
+  std::shared_ptr<AccessManager> access_;
   static concurrency::Mutex mutex_;
   static uint64_t count_;
   static bool manualOpenSSLInitialization_;
-  void setup(stdcxx::shared_ptr<TSSLSocket> ssl);
+  void setup(std::shared_ptr<TSSLSocket> ssl);
   static int passwordCallback(char* password, int size, int, void* data);
 };
 
diff --git a/lib/cpp/src/thrift/transport/TServerSocket.cpp b/lib/cpp/src/thrift/transport/TServerSocket.cpp
index 3f11a59..118b993 100644
--- a/lib/cpp/src/thrift/transport/TServerSocket.cpp
+++ b/lib/cpp/src/thrift/transport/TServerSocket.cpp
@@ -46,7 +46,6 @@
 #include <thrift/transport/TSocket.h>
 #include <thrift/transport/TServerSocket.h>
 #include <thrift/transport/PlatformSocket.h>
-#include <thrift/stdcxx.h>
 
 #ifndef AF_LOCAL
 #define AF_LOCAL AF_UNIX
@@ -81,7 +80,7 @@
 namespace thrift {
 namespace transport {
 
-using stdcxx::shared_ptr;
+using std::shared_ptr;
 
 TGetAddrInfoWrapper::TGetAddrInfoWrapper(const char* node,
                                          const char* service,
@@ -249,7 +248,7 @@
   } else {
     childInterruptSockWriter_ = sv[1];
     pChildInterruptSockReader_
-        = stdcxx::shared_ptr<THRIFT_SOCKET>(new THRIFT_SOCKET(sv[0]), destroyer_of_fine_sockets);
+        = std::shared_ptr<THRIFT_SOCKET>(new THRIFT_SOCKET(sv[0]), destroyer_of_fine_sockets);
   }
 
   // Validate port number
diff --git a/lib/cpp/src/thrift/transport/TServerSocket.h b/lib/cpp/src/thrift/transport/TServerSocket.h
index 1daaa82..b23d2c1 100644
--- a/lib/cpp/src/thrift/transport/TServerSocket.h
+++ b/lib/cpp/src/thrift/transport/TServerSocket.h
@@ -21,7 +21,6 @@
 #define _THRIFT_TRANSPORT_TSERVERSOCKET_H_ 1
 
 #include <thrift/concurrency/Mutex.h>
-#include <thrift/stdcxx.h>
 #include <thrift/transport/PlatformSocket.h>
 #include <thrift/transport/TServerTransport.h>
 
@@ -62,7 +61,7 @@
  */
 class TServerSocket : public TServerTransport {
 public:
-  typedef apache::thrift::stdcxx::function<void(THRIFT_SOCKET fd)> socket_func_t;
+  typedef std::function<void(THRIFT_SOCKET fd)> socket_func_t;
 
   const static int DEFAULT_BACKLOG = 1024;
 
@@ -147,10 +146,10 @@
   void close();
 
 protected:
-  stdcxx::shared_ptr<TTransport> acceptImpl();
-  virtual stdcxx::shared_ptr<TSocket> createSocket(THRIFT_SOCKET client);
+  std::shared_ptr<TTransport> acceptImpl();
+  virtual std::shared_ptr<TSocket> createSocket(THRIFT_SOCKET client);
   bool interruptableChildren_;
-  stdcxx::shared_ptr<THRIFT_SOCKET> pChildInterruptSockReader_; // if interruptableChildren_ this is shared with child TSockets
+  std::shared_ptr<THRIFT_SOCKET> pChildInterruptSockReader_; // if interruptableChildren_ this is shared with child TSockets
 
 private:
   void notify(THRIFT_SOCKET notifySock);
diff --git a/lib/cpp/src/thrift/transport/TServerTransport.h b/lib/cpp/src/thrift/transport/TServerTransport.h
index 9d5a3d5..db7632a 100644
--- a/lib/cpp/src/thrift/transport/TServerTransport.h
+++ b/lib/cpp/src/thrift/transport/TServerTransport.h
@@ -22,7 +22,6 @@
 
 #include <thrift/transport/TTransport.h>
 #include <thrift/transport/TTransportException.h>
-#include <thrift/stdcxx.h>
 
 namespace apache {
 namespace thrift {
@@ -56,8 +55,8 @@
    * @return A new TTransport object
    * @throws TTransportException if there is an error
    */
-  stdcxx::shared_ptr<TTransport> accept() {
-    stdcxx::shared_ptr<TTransport> result = acceptImpl();
+  std::shared_ptr<TTransport> accept() {
+    std::shared_ptr<TTransport> result = acceptImpl();
     if (!result) {
       throw TTransportException("accept() may not return NULL");
     }
@@ -105,7 +104,7 @@
    * @return A newly allocated TTransport object
    * @throw TTransportException If an error occurs
    */
-  virtual stdcxx::shared_ptr<TTransport> acceptImpl() = 0;
+  virtual std::shared_ptr<TTransport> acceptImpl() = 0;
 };
 }
 }
diff --git a/lib/cpp/src/thrift/transport/TShortReadTransport.h b/lib/cpp/src/thrift/transport/TShortReadTransport.h
index 550b6ba..118252d 100644
--- a/lib/cpp/src/thrift/transport/TShortReadTransport.h
+++ b/lib/cpp/src/thrift/transport/TShortReadTransport.h
@@ -38,7 +38,7 @@
  */
 class TShortReadTransport : public TVirtualTransport<TShortReadTransport> {
 public:
-  TShortReadTransport(stdcxx::shared_ptr<TTransport> transport, double full_prob)
+  TShortReadTransport(std::shared_ptr<TTransport> transport, double full_prob)
     : transport_(transport), fullProb_(full_prob) {}
 
   bool isOpen() { return transport_->isOpen(); }
@@ -68,10 +68,10 @@
 
   void consume(uint32_t len) { return transport_->consume(len); }
 
-  stdcxx::shared_ptr<TTransport> getUnderlyingTransport() { return transport_; }
+  std::shared_ptr<TTransport> getUnderlyingTransport() { return transport_; }
 
 protected:
-  stdcxx::shared_ptr<TTransport> transport_;
+  std::shared_ptr<TTransport> transport_;
   double fullProb_;
 };
 }
diff --git a/lib/cpp/src/thrift/transport/TSocket.cpp b/lib/cpp/src/thrift/transport/TSocket.cpp
index 18cadbc..c6c2bfa 100644
--- a/lib/cpp/src/thrift/transport/TSocket.cpp
+++ b/lib/cpp/src/thrift/transport/TSocket.cpp
@@ -144,7 +144,7 @@
 #endif
 }
 
-TSocket::TSocket(THRIFT_SOCKET socket, stdcxx::shared_ptr<THRIFT_SOCKET> interruptListener)
+TSocket::TSocket(THRIFT_SOCKET socket, std::shared_ptr<THRIFT_SOCKET> interruptListener)
   : port_(0),
     socket_(socket),
     peerPort_(0),
diff --git a/lib/cpp/src/thrift/transport/TSocket.h b/lib/cpp/src/thrift/transport/TSocket.h
index 66d9e6c..4030d46 100644
--- a/lib/cpp/src/thrift/transport/TSocket.h
+++ b/lib/cpp/src/thrift/transport/TSocket.h
@@ -270,7 +270,7 @@
    * Constructor to create socket from file descriptor that
    * can be interrupted safely.
    */
-  TSocket(THRIFT_SOCKET socket, stdcxx::shared_ptr<THRIFT_SOCKET> interruptListener);
+  TSocket(THRIFT_SOCKET socket, std::shared_ptr<THRIFT_SOCKET> interruptListener);
 
   /**
    * Set a cache of the peer address (used when trivially available: e.g.
@@ -307,7 +307,7 @@
    * A shared socket pointer that will interrupt a blocking read if data
    * becomes available on it
    */
-  stdcxx::shared_ptr<THRIFT_SOCKET> interruptListener_;
+  std::shared_ptr<THRIFT_SOCKET> interruptListener_;
 
   /** Connect timeout in ms */
   int connTimeout_;
diff --git a/lib/cpp/src/thrift/transport/TSocketPool.cpp b/lib/cpp/src/thrift/transport/TSocketPool.cpp
index a34d135..5477bbb 100644
--- a/lib/cpp/src/thrift/transport/TSocketPool.cpp
+++ b/lib/cpp/src/thrift/transport/TSocketPool.cpp
@@ -35,7 +35,7 @@
 namespace thrift {
 namespace transport {
 
-using stdcxx::shared_ptr;
+using std::shared_ptr;
 
 /**
  * TSocketPoolServer implementation
diff --git a/lib/cpp/src/thrift/transport/TSocketPool.h b/lib/cpp/src/thrift/transport/TSocketPool.h
index bd49e55..18f101c 100644
--- a/lib/cpp/src/thrift/transport/TSocketPool.h
+++ b/lib/cpp/src/thrift/transport/TSocketPool.h
@@ -92,7 +92,7 @@
    *
    * @param servers list of TSocketPoolServers
    */
-  TSocketPool(const std::vector<stdcxx::shared_ptr<TSocketPoolServer> >& servers);
+  TSocketPool(const std::vector<std::shared_ptr<TSocketPoolServer> >& servers);
 
   /**
    * Socket pool constructor
@@ -115,17 +115,17 @@
   /**
    * Add a server to the pool
    */
-  void addServer(stdcxx::shared_ptr<TSocketPoolServer>& server);
+  void addServer(std::shared_ptr<TSocketPoolServer>& server);
 
   /**
    * Set list of servers in this pool
    */
-  void setServers(const std::vector<stdcxx::shared_ptr<TSocketPoolServer> >& servers);
+  void setServers(const std::vector<std::shared_ptr<TSocketPoolServer> >& servers);
 
   /**
    * Get list of servers in this pool
    */
-  void getServers(std::vector<stdcxx::shared_ptr<TSocketPoolServer> >& servers);
+  void getServers(std::vector<std::shared_ptr<TSocketPoolServer> >& servers);
 
   /**
    * Sets how many times to keep retrying a host in the connect function.
@@ -163,13 +163,13 @@
   void close();
 
 protected:
-  void setCurrentServer(const stdcxx::shared_ptr<TSocketPoolServer>& server);
+  void setCurrentServer(const std::shared_ptr<TSocketPoolServer>& server);
 
   /** List of servers to connect to */
-  std::vector<stdcxx::shared_ptr<TSocketPoolServer> > servers_;
+  std::vector<std::shared_ptr<TSocketPoolServer> > servers_;
 
   /** Current server */
-  stdcxx::shared_ptr<TSocketPoolServer> currentServer_;
+  std::shared_ptr<TSocketPoolServer> currentServer_;
 
   /** How many times to retry each host in connect */
   int numRetries_;
diff --git a/lib/cpp/src/thrift/transport/TTransport.h b/lib/cpp/src/thrift/transport/TTransport.h
index de03290..d844239 100644
--- a/lib/cpp/src/thrift/transport/TTransport.h
+++ b/lib/cpp/src/thrift/transport/TTransport.h
@@ -21,8 +21,8 @@
 #define _THRIFT_TRANSPORT_TTRANSPORT_H_ 1
 
 #include <thrift/Thrift.h>
-#include <thrift/stdcxx.h>
 #include <thrift/transport/TTransportException.h>
+#include <memory>
 #include <string>
 
 namespace apache {
@@ -260,7 +260,7 @@
   /**
    * Default implementation does nothing, just returns the transport given.
    */
-  virtual stdcxx::shared_ptr<TTransport> getTransport(stdcxx::shared_ptr<TTransport> trans) {
+  virtual std::shared_ptr<TTransport> getTransport(std::shared_ptr<TTransport> trans) {
     return trans;
   }
 };
diff --git a/lib/cpp/src/thrift/transport/TTransportUtils.cpp b/lib/cpp/src/thrift/transport/TTransportUtils.cpp
index 5a236dc..6f47c79 100644
--- a/lib/cpp/src/thrift/transport/TTransportUtils.cpp
+++ b/lib/cpp/src/thrift/transport/TTransportUtils.cpp
@@ -103,8 +103,8 @@
 }
 
 TPipedFileReaderTransport::TPipedFileReaderTransport(
-    stdcxx::shared_ptr<TFileReaderTransport> srcTrans,
-    stdcxx::shared_ptr<TTransport> dstTrans)
+    std::shared_ptr<TFileReaderTransport> srcTrans,
+    std::shared_ptr<TTransport> dstTrans)
   : TPipedTransport(srcTrans, dstTrans), srcTrans_(srcTrans) {
 }
 
diff --git a/lib/cpp/src/thrift/transport/TTransportUtils.h b/lib/cpp/src/thrift/transport/TTransportUtils.h
index f3b4c5a..4c82dd3 100644
--- a/lib/cpp/src/thrift/transport/TTransportUtils.h
+++ b/lib/cpp/src/thrift/transport/TTransportUtils.h
@@ -63,7 +63,7 @@
  */
 class TPipedTransport : virtual public TTransport {
 public:
-  TPipedTransport(stdcxx::shared_ptr<TTransport> srcTrans, stdcxx::shared_ptr<TTransport> dstTrans)
+  TPipedTransport(std::shared_ptr<TTransport> srcTrans, std::shared_ptr<TTransport> dstTrans)
     : srcTrans_(srcTrans),
       dstTrans_(dstTrans),
       rBufSize_(512),
@@ -86,8 +86,8 @@
     }
   }
 
-  TPipedTransport(stdcxx::shared_ptr<TTransport> srcTrans,
-                  stdcxx::shared_ptr<TTransport> dstTrans,
+  TPipedTransport(std::shared_ptr<TTransport> srcTrans,
+                  std::shared_ptr<TTransport> dstTrans,
                   uint32_t sz)
     : srcTrans_(srcTrans),
       dstTrans_(dstTrans),
@@ -174,7 +174,7 @@
 
   void flush();
 
-  stdcxx::shared_ptr<TTransport> getTargetTransport() { return dstTrans_; }
+  std::shared_ptr<TTransport> getTargetTransport() { return dstTrans_; }
 
   /*
    * Override TTransport *_virt() functions to invoke our implementations.
@@ -185,8 +185,8 @@
   virtual void write_virt(const uint8_t* buf, uint32_t len) { this->write(buf, len); }
 
 protected:
-  stdcxx::shared_ptr<TTransport> srcTrans_;
-  stdcxx::shared_ptr<TTransport> dstTrans_;
+  std::shared_ptr<TTransport> srcTrans_;
+  std::shared_ptr<TTransport> dstTrans_;
 
   uint8_t* rBuf_;
   uint32_t rBufSize_;
@@ -208,7 +208,7 @@
 class TPipedTransportFactory : public TTransportFactory {
 public:
   TPipedTransportFactory() {}
-  TPipedTransportFactory(stdcxx::shared_ptr<TTransport> dstTrans) {
+  TPipedTransportFactory(std::shared_ptr<TTransport> dstTrans) {
     initializeTargetTransport(dstTrans);
   }
   virtual ~TPipedTransportFactory() {}
@@ -216,11 +216,11 @@
   /**
    * Wraps the base transport into a piped transport.
    */
-  virtual stdcxx::shared_ptr<TTransport> getTransport(stdcxx::shared_ptr<TTransport> srcTrans) {
-    return stdcxx::shared_ptr<TTransport>(new TPipedTransport(srcTrans, dstTrans_));
+  virtual std::shared_ptr<TTransport> getTransport(std::shared_ptr<TTransport> srcTrans) {
+    return std::shared_ptr<TTransport>(new TPipedTransport(srcTrans, dstTrans_));
   }
 
-  virtual void initializeTargetTransport(stdcxx::shared_ptr<TTransport> dstTrans) {
+  virtual void initializeTargetTransport(std::shared_ptr<TTransport> dstTrans) {
     if (dstTrans_.get() == NULL) {
       dstTrans_ = dstTrans;
     } else {
@@ -229,7 +229,7 @@
   }
 
 protected:
-  stdcxx::shared_ptr<TTransport> dstTrans_;
+  std::shared_ptr<TTransport> dstTrans_;
 };
 
 /**
@@ -240,8 +240,8 @@
  */
 class TPipedFileReaderTransport : public TPipedTransport, public TFileReaderTransport {
 public:
-  TPipedFileReaderTransport(stdcxx::shared_ptr<TFileReaderTransport> srcTrans,
-                            stdcxx::shared_ptr<TTransport> dstTrans);
+  TPipedFileReaderTransport(std::shared_ptr<TFileReaderTransport> srcTrans,
+                            std::shared_ptr<TTransport> dstTrans);
 
   ~TPipedFileReaderTransport();
 
@@ -277,7 +277,7 @@
 protected:
   // shouldn't be used
   TPipedFileReaderTransport();
-  stdcxx::shared_ptr<TFileReaderTransport> srcTrans_;
+  std::shared_ptr<TFileReaderTransport> srcTrans_;
 };
 
 /**
@@ -287,23 +287,23 @@
 class TPipedFileReaderTransportFactory : public TPipedTransportFactory {
 public:
   TPipedFileReaderTransportFactory() {}
-  TPipedFileReaderTransportFactory(stdcxx::shared_ptr<TTransport> dstTrans)
+  TPipedFileReaderTransportFactory(std::shared_ptr<TTransport> dstTrans)
     : TPipedTransportFactory(dstTrans) {}
   virtual ~TPipedFileReaderTransportFactory() {}
 
-  stdcxx::shared_ptr<TTransport> getTransport(stdcxx::shared_ptr<TTransport> srcTrans) {
-    stdcxx::shared_ptr<TFileReaderTransport> pFileReaderTransport
-        = stdcxx::dynamic_pointer_cast<TFileReaderTransport>(srcTrans);
+  std::shared_ptr<TTransport> getTransport(std::shared_ptr<TTransport> srcTrans) {
+    std::shared_ptr<TFileReaderTransport> pFileReaderTransport
+        = std::dynamic_pointer_cast<TFileReaderTransport>(srcTrans);
     if (pFileReaderTransport.get() != NULL) {
       return getFileReaderTransport(pFileReaderTransport);
     } else {
-      return stdcxx::shared_ptr<TTransport>();
+      return std::shared_ptr<TTransport>();
     }
   }
 
-  stdcxx::shared_ptr<TFileReaderTransport> getFileReaderTransport(
-      stdcxx::shared_ptr<TFileReaderTransport> srcTrans) {
-    return stdcxx::shared_ptr<TFileReaderTransport>(
+  std::shared_ptr<TFileReaderTransport> getFileReaderTransport(
+      std::shared_ptr<TFileReaderTransport> srcTrans) {
+    return std::shared_ptr<TFileReaderTransport>(
         new TPipedFileReaderTransport(srcTrans, dstTrans_));
   }
 };
diff --git a/lib/cpp/src/thrift/transport/TZlibTransport.h b/lib/cpp/src/thrift/transport/TZlibTransport.h
index 59acd69..b45ec43 100644
--- a/lib/cpp/src/thrift/transport/TZlibTransport.h
+++ b/lib/cpp/src/thrift/transport/TZlibTransport.h
@@ -78,7 +78,7 @@
    * @param cwbuf_size   Compressed buffer size for writing.
    * @param comp_level   Compression level (0=none[fast], 6=default, 9=max[slow]).
    */
-  TZlibTransport(stdcxx::shared_ptr<TTransport> transport,
+  TZlibTransport(std::shared_ptr<TTransport> transport,
                  int urbuf_size = DEFAULT_URBUF_SIZE,
                  int crbuf_size = DEFAULT_CRBUF_SIZE,
                  int uwbuf_size = DEFAULT_UWBUF_SIZE,
@@ -180,7 +180,7 @@
   static const int DEFAULT_UWBUF_SIZE = 128;
   static const int DEFAULT_CWBUF_SIZE = 1024;
 
-  stdcxx::shared_ptr<TTransport> getUnderlyingTransport() const { return transport_; }
+  std::shared_ptr<TTransport> getUnderlyingTransport() const { return transport_; }
 
 protected:
   inline void checkZlibRv(int status, const char* msg);
@@ -195,7 +195,7 @@
   // Larger (or equal) writes are dumped straight to zlib.
   static const uint32_t MIN_DIRECT_DEFLATE_SIZE = 32;
 
-  stdcxx::shared_ptr<TTransport> transport_;
+  std::shared_ptr<TTransport> transport_;
 
   int urpos_;
   int uwpos_;
@@ -231,8 +231,8 @@
 
   virtual ~TZlibTransportFactory() {}
 
-  virtual stdcxx::shared_ptr<TTransport> getTransport(stdcxx::shared_ptr<TTransport> trans) {
-    return stdcxx::shared_ptr<TTransport>(new TZlibTransport(trans));
+  virtual std::shared_ptr<TTransport> getTransport(std::shared_ptr<TTransport> trans) {
+    return std::shared_ptr<TTransport>(new TZlibTransport(trans));
   }
 };
 }
diff --git a/lib/cpp/src/thrift/windows/TWinsockSingleton.h b/lib/cpp/src/thrift/windows/TWinsockSingleton.h
index 50458a9..a30806b 100644
--- a/lib/cpp/src/thrift/windows/TWinsockSingleton.h
+++ b/lib/cpp/src/thrift/windows/TWinsockSingleton.h
@@ -33,9 +33,9 @@
 // boost
 #include <boost/noncopyable.hpp>
 
+#include <memory>
 #include <mutex>
 
-#include <thrift/stdcxx.h>
 
 namespace apache {
 namespace thrift {
@@ -48,7 +48,7 @@
 class TWinsockSingleton : private boost::noncopyable {
 
 public:
-  typedef stdcxx::shared_ptr<TWinsockSingleton> instance_ptr;
+  typedef std::shared_ptr<TWinsockSingleton> instance_ptr;
 
 private:
   TWinsockSingleton(void);
diff --git a/lib/cpp/test/AllProtocolTests.tcc b/lib/cpp/test/AllProtocolTests.tcc
index b6df656..a7eab07 100644
--- a/lib/cpp/test/AllProtocolTests.tcc
+++ b/lib/cpp/test/AllProtocolTests.tcc
@@ -28,7 +28,7 @@
 
 #include "GenericHelpers.h"
 
-using apache::thrift::stdcxx::shared_ptr;
+using std::shared_ptr;
 using namespace apache::thrift;
 using namespace apache::thrift::protocol;
 using namespace apache::thrift::transport;
diff --git a/lib/cpp/test/Benchmark.cpp b/lib/cpp/test/Benchmark.cpp
index afde7d4..5ff77aa 100644
--- a/lib/cpp/test/Benchmark.cpp
+++ b/lib/cpp/test/Benchmark.cpp
@@ -23,8 +23,8 @@
 #include <iostream>
 #define _USE_MATH_DEFINES
 #include <math.h>
+#include <memory>
 #include "thrift/protocol/TBinaryProtocol.h"
-#include "thrift/stdcxx.h"
 #include "thrift/transport/TBufferTransports.h"
 #include "gen-cpp/DebugProtoTest_types.h"
 
@@ -68,7 +68,7 @@
   ooe.base64 = "\1\2\3\255";
 
   int num = 100000;
-  apache::thrift::stdcxx::shared_ptr<TMemoryBuffer> buf(new TMemoryBuffer(num*1000));
+  std::shared_ptr<TMemoryBuffer> buf(new TMemoryBuffer(num*1000));
 
   uint8_t* data = NULL;
   uint32_t datasize = 0;
@@ -89,7 +89,7 @@
   buf->getBuffer(&data, &datasize);
 
   {
-    apache::thrift::stdcxx::shared_ptr<TMemoryBuffer> buf2(new TMemoryBuffer(data, datasize));
+    std::shared_ptr<TMemoryBuffer> buf2(new TMemoryBuffer(data, datasize));
     TBinaryProtocolT<TMemoryBuffer> prot(buf2);
     OneOfEach ooe2;
     double elapsed = 0.0;
@@ -117,7 +117,7 @@
 
   {
     OneOfEach ooe2;
-    apache::thrift::stdcxx::shared_ptr<TMemoryBuffer> buf2(new TMemoryBuffer(data, datasize));
+    std::shared_ptr<TMemoryBuffer> buf2(new TMemoryBuffer(data, datasize));
     TBinaryProtocolT<TMemoryBuffer, TNetworkLittleEndian> prot(buf2);
     double elapsed = 0.0;
     Timer timer;
@@ -143,7 +143,7 @@
   }
 
   {
-    apache::thrift::stdcxx::shared_ptr<TMemoryBuffer> buf2(new TMemoryBuffer(data, datasize));
+    std::shared_ptr<TMemoryBuffer> buf2(new TMemoryBuffer(data, datasize));
     TBinaryProtocolT<TMemoryBuffer> prot(buf2);
     OneOfEach ooe2;
     double elapsed = 0.0;
@@ -182,7 +182,7 @@
   buf->getBuffer(&data, &datasize);
 
   {
-    apache::thrift::stdcxx::shared_ptr<TMemoryBuffer> buf2(new TMemoryBuffer(data, datasize));
+    std::shared_ptr<TMemoryBuffer> buf2(new TMemoryBuffer(data, datasize));
     TBinaryProtocolT<TMemoryBuffer> prot(buf2);
     ListDoublePerf listDoublePerf2;
     double elapsed = 0.0;
@@ -206,7 +206,7 @@
 
   {
     ListDoublePerf listDoublePerf2;
-    apache::thrift::stdcxx::shared_ptr<TMemoryBuffer> buf2(new TMemoryBuffer(data, datasize));
+    std::shared_ptr<TMemoryBuffer> buf2(new TMemoryBuffer(data, datasize));
     TBinaryProtocolT<TMemoryBuffer, TNetworkLittleEndian> prot(buf2);
     double elapsed = 0.0;
     Timer timer;
@@ -228,7 +228,7 @@
   }
 
   {
-    apache::thrift::stdcxx::shared_ptr<TMemoryBuffer> buf2(new TMemoryBuffer(data, datasize));
+    std::shared_ptr<TMemoryBuffer> buf2(new TMemoryBuffer(data, datasize));
     TBinaryProtocolT<TMemoryBuffer> prot(buf2);
     ListDoublePerf listDoublePerf2;
     double elapsed = 0.0;
diff --git a/lib/cpp/test/DebugProtoTest.cpp b/lib/cpp/test/DebugProtoTest.cpp
index e04600a..060f354 100644
--- a/lib/cpp/test/DebugProtoTest.cpp
+++ b/lib/cpp/test/DebugProtoTest.cpp
@@ -21,14 +21,14 @@
 #include <cmath>
 #include "gen-cpp/DebugProtoTest_types.h"
 #include <thrift/protocol/TDebugProtocol.h>
-#include <thrift/stdcxx.h>
+#include <memory>
 
 #define BOOST_TEST_MODULE DebugProtoTest
 #include <boost/test/unit_test.hpp>
 
 using namespace thrift::test::debug;
 
-static ::apache::thrift::stdcxx::shared_ptr<OneOfEach> ooe;
+static ::std::shared_ptr<OneOfEach> ooe;
 
 void testCaseSetup_1() {
   ooe.reset(new OneOfEach);
@@ -81,7 +81,7 @@
     "Expected:\n" << expected_result << "\nGotten:\n" << result);
 }
 
-static ::apache::thrift::stdcxx::shared_ptr<Nesting> n;
+static ::std::shared_ptr<Nesting> n;
 
 void testCaseSetup_2() {
   testCaseSetup_1();
@@ -149,7 +149,7 @@
     "Expected:\n" << expected_result << "\nGotten:\n" << result);
 }
 
-static ::apache::thrift::stdcxx::shared_ptr<HolyMoley> hm;
+static ::std::shared_ptr<HolyMoley> hm;
 
 void testCaseSetup_3() {
   testCaseSetup_2();
diff --git a/lib/cpp/test/GenericHelpers.h b/lib/cpp/test/GenericHelpers.h
index e131c42..bcef9f2 100644
--- a/lib/cpp/test/GenericHelpers.h
+++ b/lib/cpp/test/GenericHelpers.h
@@ -21,7 +21,7 @@
 #define _THRIFT_TEST_GENERICHELPERS_H_ 1
 
 #include <thrift/protocol/TProtocol.h>
-#include <thrift/stdcxx.h>
+#include <memory>
 #include <thrift/Thrift.h>
 
 /* ClassName Helper for cleaner exceptions */
@@ -63,43 +63,43 @@
 public:
   /* Write functions */
 
-  static uint32_t write(apache::thrift::stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> proto, const int8_t& val) {
+  static uint32_t write(std::shared_ptr<apache::thrift::protocol::TProtocol> proto, const int8_t& val) {
     return proto->writeByte(val);
   }
 
-  static uint32_t write(apache::thrift::stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> proto, const int16_t& val) {
+  static uint32_t write(std::shared_ptr<apache::thrift::protocol::TProtocol> proto, const int16_t& val) {
     return proto->writeI16(val);
   }
 
-  static uint32_t write(apache::thrift::stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> proto, const int32_t& val) {
+  static uint32_t write(std::shared_ptr<apache::thrift::protocol::TProtocol> proto, const int32_t& val) {
     return proto->writeI32(val);
   }
 
-  static uint32_t write(apache::thrift::stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> proto, const double& val) {
+  static uint32_t write(std::shared_ptr<apache::thrift::protocol::TProtocol> proto, const double& val) {
     return proto->writeDouble(val);
   }
 
-  static uint32_t write(apache::thrift::stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> proto, const int64_t& val) {
+  static uint32_t write(std::shared_ptr<apache::thrift::protocol::TProtocol> proto, const int64_t& val) {
     return proto->writeI64(val);
   }
 
-  static uint32_t write(apache::thrift::stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> proto, const std::string& val) {
+  static uint32_t write(std::shared_ptr<apache::thrift::protocol::TProtocol> proto, const std::string& val) {
     return proto->writeString(val);
   }
 
   /* Read functions */
 
-  static uint32_t read(apache::thrift::stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> proto, int8_t& val) { return proto->readByte(val); }
+  static uint32_t read(std::shared_ptr<apache::thrift::protocol::TProtocol> proto, int8_t& val) { return proto->readByte(val); }
 
-  static uint32_t read(apache::thrift::stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> proto, int16_t& val) { return proto->readI16(val); }
+  static uint32_t read(std::shared_ptr<apache::thrift::protocol::TProtocol> proto, int16_t& val) { return proto->readI16(val); }
 
-  static uint32_t read(apache::thrift::stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> proto, int32_t& val) { return proto->readI32(val); }
+  static uint32_t read(std::shared_ptr<apache::thrift::protocol::TProtocol> proto, int32_t& val) { return proto->readI32(val); }
 
-  static uint32_t read(apache::thrift::stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> proto, int64_t& val) { return proto->readI64(val); }
+  static uint32_t read(std::shared_ptr<apache::thrift::protocol::TProtocol> proto, int64_t& val) { return proto->readI64(val); }
 
-  static uint32_t read(apache::thrift::stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> proto, double& val) { return proto->readDouble(val); }
+  static uint32_t read(std::shared_ptr<apache::thrift::protocol::TProtocol> proto, double& val) { return proto->readDouble(val); }
 
-  static uint32_t read(apache::thrift::stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> proto, std::string& val) {
+  static uint32_t read(std::shared_ptr<apache::thrift::protocol::TProtocol> proto, std::string& val) {
     return proto->readString(val);
   }
 };
diff --git a/lib/cpp/test/JSONProtoTest.cpp b/lib/cpp/test/JSONProtoTest.cpp
index 77bc250..c2ad73e 100644
--- a/lib/cpp/test/JSONProtoTest.cpp
+++ b/lib/cpp/test/JSONProtoTest.cpp
@@ -22,7 +22,7 @@
 #include <iomanip>
 #include <sstream>
 #include <thrift/protocol/TJSONProtocol.h>
-#include <thrift/stdcxx.h>
+#include <memory>
 #include <thrift/transport/TBufferTransports.h>
 #include "gen-cpp/DebugProtoTest_types.h"
 
@@ -34,7 +34,7 @@
 using apache::thrift::transport::TMemoryBuffer;
 using apache::thrift::protocol::TJSONProtocol;
 
-static stdcxx::shared_ptr<OneOfEach> ooe;
+static std::shared_ptr<OneOfEach> ooe;
 
 void testCaseSetup_1() {
   ooe.reset(new OneOfEach);
@@ -67,7 +67,7 @@
     "Expected:\n" << expected_result << "\nGotten:\n" << result);
 }
 
-static stdcxx::shared_ptr<Nesting> n;
+static std::shared_ptr<Nesting> n;
 
 void testCaseSetup_2() {
   testCaseSetup_1();
@@ -107,7 +107,7 @@
     "Expected:\n" << expected_result << "\nGotten:\n" << result);
 }
 
-static stdcxx::shared_ptr<HolyMoley> hm;
+static std::shared_ptr<HolyMoley> hm;
 
 void testCaseSetup_3() {
   testCaseSetup_2();
@@ -185,8 +185,8 @@
 BOOST_AUTO_TEST_CASE(test_json_proto_4) {
   testCaseSetup_1();
 
-  stdcxx::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer());
-  stdcxx::shared_ptr<TJSONProtocol> proto(new TJSONProtocol(buffer));
+  std::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer());
+  std::shared_ptr<TJSONProtocol> proto(new TJSONProtocol(buffer));
 
   ooe->write(proto.get());
   OneOfEach ooe2;
@@ -198,8 +198,8 @@
 BOOST_AUTO_TEST_CASE(test_json_proto_5) {
   testCaseSetup_3();
 
-  stdcxx::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer());
-  stdcxx::shared_ptr<TJSONProtocol> proto(new TJSONProtocol(buffer));
+  std::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer());
+  std::shared_ptr<TJSONProtocol> proto(new TJSONProtocol(buffer));
 
   hm->write(proto.get());
   HolyMoley hm2;
@@ -236,8 +236,8 @@
 }
 
 BOOST_AUTO_TEST_CASE(test_json_proto_7) {
-  stdcxx::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer());
-  stdcxx::shared_ptr<TJSONProtocol> proto(new TJSONProtocol(buffer));
+  std::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer());
+  std::shared_ptr<TJSONProtocol> proto(new TJSONProtocol(buffer));
 
   Base64 base;
   base.a = 123;
@@ -265,9 +265,9 @@
   "\",3,1,2,3]}}";
 
   const std::size_t bufSiz = strlen(json_string) * sizeof(char);
-  stdcxx::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer(
+  std::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer(
     (uint8_t*)(json_string), static_cast<uint32_t>(bufSiz)));
-  stdcxx::shared_ptr<TJSONProtocol> proto(new TJSONProtocol(buffer));
+  std::shared_ptr<TJSONProtocol> proto(new TJSONProtocol(buffer));
 
   OneOfEach ooe2;
 
@@ -294,9 +294,9 @@
   "\",3,1,2,3]}}";
   const char* expected_zomg_unicode = "\xe0\xb8\x81 \xf0\x9d\x94\xbe";
 
-  stdcxx::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer(
+  std::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer(
     (uint8_t*)(json_string), sizeof(json_string)));
-  stdcxx::shared_ptr<TJSONProtocol> proto(new TJSONProtocol(buffer));
+  std::shared_ptr<TJSONProtocol> proto(new TJSONProtocol(buffer));
 
   OneOfEach ooe2;
   ooe2.read(proto.get());
@@ -315,9 +315,9 @@
   ":[\"i8\",3,1,2,3]},\"13\":{\"lst\":[\"i16\",3,1,2,3]},\"14\":{\"lst\":[\"i64"
   "\",3,1,2,3]}}";
 
-  stdcxx::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer(
+  std::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer(
     (uint8_t*)(json_string), sizeof(json_string)));
-  stdcxx::shared_ptr<TJSONProtocol> proto(new TJSONProtocol(buffer));
+  std::shared_ptr<TJSONProtocol> proto(new TJSONProtocol(buffer));
 
   OneOfEach ooe2;
   BOOST_CHECK_THROW(ooe2.read(proto.get()),
@@ -333,9 +333,9 @@
   ":[\"i8\",3,1,2,3]},\"13\":{\"lst\":[\"i16\",3,1,2,3]},\"14\":{\"lst\":[\"i64"
   "\",3,1,2,3]}}";
 
-  stdcxx::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer(
+  std::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer(
     (uint8_t*)(json_string), sizeof(json_string)));
-  stdcxx::shared_ptr<TJSONProtocol> proto(new TJSONProtocol(buffer));
+  std::shared_ptr<TJSONProtocol> proto(new TJSONProtocol(buffer));
 
   OneOfEach ooe2;
   BOOST_CHECK_THROW(ooe2.read(proto.get()),
diff --git a/lib/cpp/test/OneWayHTTPTest.cpp b/lib/cpp/test/OneWayHTTPTest.cpp
index 3fe63b6..89fa164 100644
--- a/lib/cpp/test/OneWayHTTPTest.cpp
+++ b/lib/cpp/test/OneWayHTTPTest.cpp
@@ -30,7 +30,7 @@
 #include <thrift/transport/THttpClient.h>
 #include <thrift/transport/TServerSocket.h>
 #include <thrift/transport/TSocket.h>
-#include <thrift/stdcxx.h>
+#include <memory>
 #include <thrift/transport/TBufferTransports.h>
 #include "gen-cpp/OneWayService.h"
 
@@ -54,7 +54,7 @@
 using apache::thrift::transport::TServerSocket;
 using apache::thrift::transport::TSocket;
 using apache::thrift::transport::TTransportException;
-using apache::thrift::stdcxx::shared_ptr;
+using std::shared_ptr;
 using std::cout;
 using std::cerr;
 using std::endl;
@@ -138,7 +138,7 @@
 
 class TBlockableBufferedTransport : public TBufferedTransport {
  public:
-  TBlockableBufferedTransport(stdcxx::shared_ptr<TTransport> transport)
+  TBlockableBufferedTransport(std::shared_ptr<TTransport> transport)
     : TBufferedTransport(transport, 10240),
     blocked_(false) {
   }
@@ -176,14 +176,14 @@
 
 BOOST_AUTO_TEST_CASE( JSON_BufferedHTTP )
 {
-  stdcxx::shared_ptr<TServerSocket> ss = stdcxx::make_shared<TServerSocket>(0) ;
+  std::shared_ptr<TServerSocket> ss = std::make_shared<TServerSocket>(0) ;
   TThreadedServer server(
-    stdcxx::make_shared<onewaytest::OneWayServiceProcessorFactory>(stdcxx::make_shared<OneWayServiceCloneFactory>()),
+    std::make_shared<onewaytest::OneWayServiceProcessorFactory>(std::make_shared<OneWayServiceCloneFactory>()),
     ss, //port
-    stdcxx::make_shared<THttpServerTransportFactory>(),
-    stdcxx::make_shared<TJSONProtocolFactory>());
+    std::make_shared<THttpServerTransportFactory>(),
+    std::make_shared<TJSONProtocolFactory>());
 
-  stdcxx::shared_ptr<TServerReadyEventHandler> pEventHandler(new TServerReadyEventHandler) ;
+  std::shared_ptr<TServerReadyEventHandler> pEventHandler(new TServerReadyEventHandler) ;
   server.setServerEventHandler(pEventHandler);
 
 #ifdef ENABLE_STDERR_LOGGING
@@ -205,11 +205,11 @@
 #endif
 
   {
-    stdcxx::shared_ptr<TSocket> socket(new TSocket("localhost", port));
+    std::shared_ptr<TSocket> socket(new TSocket("localhost", port));
     socket->setRecvTimeout(10000) ; // 1000msec should be enough
-    stdcxx::shared_ptr<TBlockableBufferedTransport> blockable_transport(new TBlockableBufferedTransport(socket));
-    stdcxx::shared_ptr<TTransport> transport(new THttpClient(blockable_transport, "localhost", "/service"));
-    stdcxx::shared_ptr<TProtocol> protocol(new TJSONProtocol(transport));
+    std::shared_ptr<TBlockableBufferedTransport> blockable_transport(new TBlockableBufferedTransport(socket));
+    std::shared_ptr<TTransport> transport(new THttpClient(blockable_transport, "localhost", "/service"));
+    std::shared_ptr<TProtocol> protocol(new TJSONProtocol(transport));
     onewaytest::OneWayServiceClient client(protocol);
 
 
diff --git a/lib/cpp/test/OptionalRequiredTest.cpp b/lib/cpp/test/OptionalRequiredTest.cpp
index 55fe249..4c43546 100644
--- a/lib/cpp/test/OptionalRequiredTest.cpp
+++ b/lib/cpp/test/OptionalRequiredTest.cpp
@@ -40,7 +40,7 @@
 void trywrite(const Struct& s, bool should_work) {
   bool worked;
   try {
-    TBinaryProtocol protocol(stdcxx::shared_ptr<TTransport>(new TMemoryBuffer));
+    TBinaryProtocol protocol(std::shared_ptr<TTransport>(new TMemoryBuffer));
     s.write(&protocol);
     worked = true;
   } catch (TProtocolException & ex) {
@@ -52,7 +52,7 @@
 
 template <typename Struct1, typename Struct2>
 void write_to_read(const Struct1& w, Struct2& r) {
-  TBinaryProtocol protocol(stdcxx::shared_ptr<TTransport>(new TMemoryBuffer));
+  TBinaryProtocol protocol(std::shared_ptr<TTransport>(new TMemoryBuffer));
   w.write(&protocol);
   r.read(&protocol);
 }
@@ -303,7 +303,7 @@
   o1.im_big.push_back(mymap);
   BOOST_CHECK(o1 == o2);
 
-  TBinaryProtocol protocol(stdcxx::shared_ptr<TTransport>(new TMemoryBuffer));
+  TBinaryProtocol protocol(std::shared_ptr<TTransport>(new TMemoryBuffer));
   o1.write(&protocol);
 
   o1.im_big.push_back(mymap);
diff --git a/lib/cpp/test/RecursiveTest.cpp b/lib/cpp/test/RecursiveTest.cpp
index ce5569b..15f234c 100644
--- a/lib/cpp/test/RecursiveTest.cpp
+++ b/lib/cpp/test/RecursiveTest.cpp
@@ -23,7 +23,7 @@
 
 #include "gen-cpp/Recursive_types.h"
 #include <thrift/protocol/TBinaryProtocol.h>
-#include <thrift/stdcxx.h>
+#include <memory>
 #include <thrift/transport/TBufferTransports.h>
 
 #define BOOST_TEST_MODULE RecursiveTest
@@ -31,7 +31,7 @@
 
 using apache::thrift::transport::TMemoryBuffer;
 using apache::thrift::protocol::TBinaryProtocol;
-using apache::thrift::stdcxx::shared_ptr;
+using std::shared_ptr;
 
 BOOST_AUTO_TEST_CASE(test_recursive_1) {
   shared_ptr<TMemoryBuffer> buf(new TMemoryBuffer());
diff --git a/lib/cpp/test/SecurityTest.cpp b/lib/cpp/test/SecurityTest.cpp
index 51ee427..982a4f3 100644
--- a/lib/cpp/test/SecurityTest.cpp
+++ b/lib/cpp/test/SecurityTest.cpp
@@ -23,7 +23,7 @@
 #include <boost/foreach.hpp>
 #include <boost/format.hpp>
 #include <boost/thread.hpp>
-#include <thrift/stdcxx.h>
+#include <memory>
 #include <thrift/transport/TSSLServerSocket.h>
 #include <thrift/transport/TSSLSocket.h>
 #include <thrift/transport/TTransport.h>
@@ -40,8 +40,8 @@
 using apache::thrift::transport::TTransportException;
 using apache::thrift::transport::TTransportFactory;
 
-using apache::thrift::stdcxx::bind;
-using apache::thrift::stdcxx::shared_ptr;
+using std::bind;
+using std::shared_ptr;
 
 boost::filesystem::path keyDir;
 boost::filesystem::path certFile(const std::string& filename)
diff --git a/lib/cpp/test/SpecializationTest.cpp b/lib/cpp/test/SpecializationTest.cpp
index a060b4f..008837d 100644
--- a/lib/cpp/test/SpecializationTest.cpp
+++ b/lib/cpp/test/SpecializationTest.cpp
@@ -82,8 +82,8 @@
   stage2.back().message = "nevermore";
   hm.bonks["poe"] = stage2;
 
-  apache::thrift::stdcxx::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer());
-  apache::thrift::stdcxx::shared_ptr<TProtocol> proto(new MyProtocol(buffer));
+  std::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer());
+  std::shared_ptr<TProtocol> proto(new MyProtocol(buffer));
 
   ooe.write(proto.get());
   OneOfEach ooe2;
diff --git a/lib/cpp/test/TBufferBaseTest.cpp b/lib/cpp/test/TBufferBaseTest.cpp
index 4201ddb..430302c 100644
--- a/lib/cpp/test/TBufferBaseTest.cpp
+++ b/lib/cpp/test/TBufferBaseTest.cpp
@@ -21,9 +21,9 @@
 #include <boost/test/auto_unit_test.hpp>
 #include <thrift/transport/TBufferTransports.h>
 #include <thrift/transport/TShortReadTransport.h>
-#include <thrift/stdcxx.h>
+#include <memory>
 
-using apache::thrift::stdcxx::shared_ptr;
+using std::shared_ptr;
 using apache::thrift::transport::TMemoryBuffer;
 using apache::thrift::transport::TBufferedTransport;
 using apache::thrift::transport::TFramedTransport;
diff --git a/lib/cpp/test/TMemoryBufferTest.cpp b/lib/cpp/test/TMemoryBufferTest.cpp
index d81b1d8..9206872 100644
--- a/lib/cpp/test/TMemoryBufferTest.cpp
+++ b/lib/cpp/test/TMemoryBufferTest.cpp
@@ -22,7 +22,7 @@
 #include <climits>
 #include <vector>
 #include <thrift/protocol/TBinaryProtocol.h>
-#include <thrift/stdcxx.h>
+#include <memory>
 #include <thrift/transport/TBufferTransports.h>
 #include "gen-cpp/ThriftTest_types.h"
 
@@ -31,7 +31,7 @@
 using apache::thrift::protocol::TBinaryProtocol;
 using apache::thrift::transport::TMemoryBuffer;
 using apache::thrift::transport::TTransportException;
-using apache::thrift::stdcxx::shared_ptr;
+using std::shared_ptr;
 using std::cout;
 using std::endl;
 using std::string;
diff --git a/lib/cpp/test/TNonblockingSSLServerTest.cpp b/lib/cpp/test/TNonblockingSSLServerTest.cpp
index 2efb140..330380b 100644
--- a/lib/cpp/test/TNonblockingSSLServerTest.cpp
+++ b/lib/cpp/test/TNonblockingSSLServerTest.cpp
@@ -19,8 +19,6 @@
 
 #define BOOST_TEST_MODULE TNonblockingSSLServerTest
 #include <boost/test/unit_test.hpp>
-#include <boost/smart_ptr.hpp>
-#include <boost/shared_ptr.hpp>
 #include <boost/filesystem.hpp>
 #include <boost/format.hpp>
 
@@ -105,8 +103,8 @@
 BOOST_GLOBAL_FIXTURE(GlobalFixtureSSL)
 #endif
 
-stdcxx::shared_ptr<TSSLSocketFactory> createServerSocketFactory() {
-  stdcxx::shared_ptr<TSSLSocketFactory> pServerSocketFactory;
+std::shared_ptr<TSSLSocketFactory> createServerSocketFactory() {
+  std::shared_ptr<TSSLSocketFactory> pServerSocketFactory;
 
   pServerSocketFactory.reset(new TSSLSocketFactory());
   pServerSocketFactory->ciphers("ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
@@ -116,8 +114,8 @@
   return pServerSocketFactory;
 }
 
-stdcxx::shared_ptr<TSSLSocketFactory> createClientSocketFactory() {
-  stdcxx::shared_ptr<TSSLSocketFactory> pClientSocketFactory;
+std::shared_ptr<TSSLSocketFactory> createClientSocketFactory() {
+  std::shared_ptr<TSSLSocketFactory> pClientSocketFactory;
 
   pClientSocketFactory.reset(new TSSLSocketFactory());
   pClientSocketFactory->authenticate(true);
@@ -145,12 +143,12 @@
 
   struct Runner : public apache::thrift::concurrency::Runnable {
     int port;
-    stdcxx::shared_ptr<event_base> userEventBase;
-    stdcxx::shared_ptr<TProcessor> processor;
-    stdcxx::shared_ptr<server::TNonblockingServer> server;
-    stdcxx::shared_ptr<ListenEventHandler> listenHandler;
-    stdcxx::shared_ptr<TSSLSocketFactory> pServerSocketFactory;
-    stdcxx::shared_ptr<transport::TNonblockingSSLServerSocket> socket;
+    std::shared_ptr<event_base> userEventBase;
+    std::shared_ptr<TProcessor> processor;
+    std::shared_ptr<server::TNonblockingServer> server;
+    std::shared_ptr<ListenEventHandler> listenHandler;
+    std::shared_ptr<TSSLSocketFactory> pServerSocketFactory;
+    std::shared_ptr<transport::TNonblockingSSLServerSocket> socket;
     Mutex mutex_;
 
     Runner() {
@@ -198,7 +196,7 @@
   };
 
 protected:
-  Fixture() : processor(new test::ParentServiceProcessor(stdcxx::make_shared<Handler>())) {}
+  Fixture() : processor(new test::ParentServiceProcessor(std::make_shared<Handler>())) {}
 
   ~Fixture() {
     if (server) {
@@ -214,12 +212,12 @@
   }
 
   int startServer(int port) {
-    stdcxx::shared_ptr<Runner> runner(new Runner);
+    std::shared_ptr<Runner> runner(new Runner);
     runner->port = port;
     runner->processor = processor;
     runner->userEventBase = userEventBase_;
 
-    apache::thrift::stdcxx::scoped_ptr<apache::thrift::concurrency::ThreadFactory> threadFactory(
+    std::unique_ptr<apache::thrift::concurrency::ThreadFactory> threadFactory(
         new apache::thrift::concurrency::PlatformThreadFactory(
 #if !USE_STD_THREAD
             concurrency::PlatformThreadFactory::OTHER, concurrency::PlatformThreadFactory::NORMAL,
@@ -235,11 +233,11 @@
   }
 
   bool canCommunicate(int serverPort) {
-    stdcxx::shared_ptr<TSSLSocketFactory> pClientSocketFactory = createClientSocketFactory();
-    stdcxx::shared_ptr<TSSLSocket> socket = pClientSocketFactory->createSocket("localhost", serverPort);
+    std::shared_ptr<TSSLSocketFactory> pClientSocketFactory = createClientSocketFactory();
+    std::shared_ptr<TSSLSocket> socket = pClientSocketFactory->createSocket("localhost", serverPort);
     socket->open();
-    test::ParentServiceClient client(stdcxx::make_shared<protocol::TBinaryProtocol>(
-        stdcxx::make_shared<transport::TFramedTransport>(socket)));
+    test::ParentServiceClient client(std::make_shared<protocol::TBinaryProtocol>(
+        std::make_shared<transport::TFramedTransport>(socket)));
     client.addString("foo");
     std::vector<std::string> strings;
     client.getStrings(strings);
@@ -247,12 +245,12 @@
   }
 
 private:
-  stdcxx::shared_ptr<event_base> userEventBase_;
-  stdcxx::shared_ptr<test::ParentServiceProcessor> processor;
+  std::shared_ptr<event_base> userEventBase_;
+  std::shared_ptr<test::ParentServiceProcessor> processor;
 protected:
-  stdcxx::shared_ptr<server::TNonblockingServer> server;
+  std::shared_ptr<server::TNonblockingServer> server;
 private:
-  stdcxx::shared_ptr<apache::thrift::concurrency::Thread> thread;
+  std::shared_ptr<apache::thrift::concurrency::Thread> thread;
 
 };
 
diff --git a/lib/cpp/test/TNonblockingServerTest.cpp b/lib/cpp/test/TNonblockingServerTest.cpp
index 5e10907..f0bb283 100644
--- a/lib/cpp/test/TNonblockingServerTest.cpp
+++ b/lib/cpp/test/TNonblockingServerTest.cpp
@@ -19,12 +19,12 @@
 
 #define BOOST_TEST_MODULE TNonblockingServerTest
 #include <boost/test/unit_test.hpp>
+#include <memory>
 
 #include "thrift/concurrency/Monitor.h"
 #include "thrift/concurrency/Thread.h"
 #include "thrift/server/TNonblockingServer.h"
 #include "thrift/transport/TNonblockingServerSocket.h"
-#include "thrift/stdcxx.h"
 
 #include "gen-cpp/ParentService.h"
 
@@ -38,8 +38,8 @@
 using apache::thrift::concurrency::Thread;
 using apache::thrift::concurrency::ThreadFactory;
 using apache::thrift::server::TServerEventHandler;
-using apache::thrift::stdcxx::make_shared;
-using apache::thrift::stdcxx::shared_ptr;
+using std::make_shared;
+using std::shared_ptr;
 
 using namespace apache::thrift;
 
diff --git a/lib/cpp/test/TPipeInterruptTest.cpp b/lib/cpp/test/TPipeInterruptTest.cpp
index 232e4bb..2423f56 100644
--- a/lib/cpp/test/TPipeInterruptTest.cpp
+++ b/lib/cpp/test/TPipeInterruptTest.cpp
@@ -27,7 +27,7 @@
 #include <boost/thread/thread.hpp>
 #include <thrift/transport/TPipe.h>
 #include <thrift/transport/TPipeServer.h>
-#include <thrift/stdcxx.h>
+#include <memory>
 
 using apache::thrift::transport::TPipeServer;
 using apache::thrift::transport::TPipe;
@@ -52,7 +52,7 @@
   {
     for (;;)
     {
-      stdcxx::shared_ptr<TTransport> temp = pipe->accept();
+      std::shared_ptr<TTransport> temp = pipe->accept();
     }
   }
   catch (...) {/*just want to make sure nothing crashes*/ }
@@ -70,8 +70,8 @@
   {
     TPipeServer pipeServer("TPipeInterruptTest");
     pipeServer.listen();
-    boost::thread acceptThread(stdcxx::bind(acceptWorker, &pipeServer));
-    boost::thread interruptThread(stdcxx::bind(interruptWorker, &pipeServer));
+    boost::thread acceptThread(std::bind(acceptWorker, &pipeServer));
+    boost::thread interruptThread(std::bind(interruptWorker, &pipeServer));
     try
     {
       for (;;)
diff --git a/lib/cpp/test/TPipedTransportTest.cpp b/lib/cpp/test/TPipedTransportTest.cpp
index a3ce662..f3091a4 100644
--- a/lib/cpp/test/TPipedTransportTest.cpp
+++ b/lib/cpp/test/TPipedTransportTest.cpp
@@ -18,7 +18,7 @@
  */
 
 #include <thrift/Thrift.h>
-#include <thrift/stdcxx.h>
+#include <memory>
 #include <thrift/transport/TTransportUtils.h>
 #include <thrift/transport/TBufferTransports.h>
 
@@ -31,9 +31,9 @@
 using namespace apache::thrift;
 
 BOOST_AUTO_TEST_CASE(test_read_write) {
-  stdcxx::shared_ptr<TMemoryBuffer> underlying(new TMemoryBuffer);
-  stdcxx::shared_ptr<TMemoryBuffer> pipe(new TMemoryBuffer);
-  stdcxx::shared_ptr<TPipedTransport> trans(new TPipedTransport(underlying, pipe));
+  std::shared_ptr<TMemoryBuffer> underlying(new TMemoryBuffer);
+  std::shared_ptr<TMemoryBuffer> pipe(new TMemoryBuffer);
+  std::shared_ptr<TPipedTransport> trans(new TPipedTransport(underlying, pipe));
 
   uint8_t buffer[4];
 
diff --git a/lib/cpp/test/TSSLSocketInterruptTest.cpp b/lib/cpp/test/TSSLSocketInterruptTest.cpp
index 85f6c39..33f686c 100644
--- a/lib/cpp/test/TSSLSocketInterruptTest.cpp
+++ b/lib/cpp/test/TSSLSocketInterruptTest.cpp
@@ -24,7 +24,7 @@
 #include <boost/thread/thread.hpp>
 #include <boost/filesystem.hpp>
 #include <boost/format.hpp>
-#include <thrift/stdcxx.h>
+#include <memory>
 #include <thrift/transport/TSSLSocket.h>
 #include <thrift/transport/TSSLServerSocket.h>
 #ifdef __linux__
@@ -37,8 +37,8 @@
 using apache::thrift::transport::TTransportException;
 using apache::thrift::transport::TSSLSocketFactory;
 
-using apache::thrift::stdcxx::static_pointer_cast;
-using apache::thrift::stdcxx::shared_ptr;
+using std::static_pointer_cast;
+using std::shared_ptr;
 
 BOOST_AUTO_TEST_SUITE(TSSLSocketInterruptTest)
 
@@ -146,7 +146,7 @@
   shared_ptr<TSSLSocket> clientSock = pClientSocketFactory->createSocket("localhost", port);
   clientSock->open();
   shared_ptr<TTransport> accepted = sock1.accept();
-  boost::thread readThread(apache::thrift::stdcxx::bind(readerWorkerMustThrow, accepted));
+  boost::thread readThread(std::bind(readerWorkerMustThrow, accepted));
   boost::this_thread::sleep(boost::posix_time::milliseconds(50));
   // readThread is practically guaranteed to be blocking now
   sock1.interruptChildren();
@@ -166,7 +166,7 @@
   shared_ptr<TSSLSocket> clientSock = pClientSocketFactory->createSocket("localhost", port);
   clientSock->open();
   shared_ptr<TTransport> accepted = sock1.accept();
-  boost::thread readThread(apache::thrift::stdcxx::bind(readerWorkerMustThrow, accepted));
+  boost::thread readThread(std::bind(readerWorkerMustThrow, accepted));
   clientSock->write((const uint8_t*)"0", 1);
   boost::this_thread::sleep(boost::posix_time::milliseconds(50));
   // readThread is practically guaranteed to be blocking now
@@ -189,7 +189,7 @@
   clientSock->open();
   shared_ptr<TTransport> accepted = sock1.accept();
   static_pointer_cast<TSSLSocket>(accepted)->setRecvTimeout(1000);
-  boost::thread readThread(apache::thrift::stdcxx::bind(readerWorker, accepted, 0));
+  boost::thread readThread(std::bind(readerWorker, accepted, 0));
   clientSock->write((const uint8_t*)"0", 1);
   boost::this_thread::sleep(boost::posix_time::milliseconds(50));
   // readThread is practically guaranteed to be blocking here
@@ -241,7 +241,7 @@
   shared_ptr<TSSLSocket> clientSock = pClientSocketFactory->createSocket("localhost", port);
   clientSock->open();
   shared_ptr<TTransport> accepted = sock1.accept();
-  boost::thread peekThread(apache::thrift::stdcxx::bind(peekerWorkerInterrupt, accepted));
+  boost::thread peekThread(std::bind(peekerWorkerInterrupt, accepted));
   clientSock->write((const uint8_t*)"0", 1);
   boost::this_thread::sleep(boost::posix_time::milliseconds(50));
   // peekThread is practically guaranteed to be blocking now
@@ -264,7 +264,7 @@
   clientSock->open();
   shared_ptr<TTransport> accepted = sock1.accept();
   static_pointer_cast<TSSLSocket>(accepted)->setRecvTimeout(1000);
-  boost::thread peekThread(apache::thrift::stdcxx::bind(peekerWorker, accepted, false));
+  boost::thread peekThread(std::bind(peekerWorker, accepted, false));
   clientSock->write((const uint8_t*)"0", 1);
   boost::this_thread::sleep(boost::posix_time::milliseconds(50));
   // peekThread is practically guaranteed to be blocking now
diff --git a/lib/cpp/test/TServerIntegrationTest.cpp b/lib/cpp/test/TServerIntegrationTest.cpp
index 5f7b2e8..3723679 100644
--- a/lib/cpp/test/TServerIntegrationTest.cpp
+++ b/lib/cpp/test/TServerIntegrationTest.cpp
@@ -27,7 +27,7 @@
 #include <thrift/server/TSimpleServer.h>
 #include <thrift/server/TThreadPoolServer.h>
 #include <thrift/server/TThreadedServer.h>
-#include <thrift/stdcxx.h>
+#include <memory>
 #include <thrift/protocol/TBinaryProtocol.h>
 #include <thrift/transport/TServerSocket.h>
 #include <thrift/transport/TSocket.h>
@@ -55,9 +55,9 @@
 using apache::thrift::server::TSimpleServer;
 using apache::thrift::server::TThreadPoolServer;
 using apache::thrift::server::TThreadedServer;
-using apache::thrift::stdcxx::dynamic_pointer_cast;
-using apache::thrift::stdcxx::make_shared;
-using apache::thrift::stdcxx::shared_ptr;
+using std::dynamic_pointer_cast;
+using std::make_shared;
+using std::shared_ptr;
 using apache::thrift::test::ParentServiceClient;
 using apache::thrift::test::ParentServiceIf;
 using apache::thrift::test::ParentServiceIfFactory;
@@ -177,7 +177,7 @@
   }
 
   void startServer() {
-    pServerThread.reset(new boost::thread(apache::thrift::stdcxx::bind(&TServerType::serve, pServer.get())));
+    pServerThread.reset(new boost::thread(std::bind(&TServerType::serve, pServer.get())));
 
     // block until listen() completes so clients will be able to connect
     Synchronized sync(*(pEventHandler.get()));
@@ -235,7 +235,7 @@
       pClientSock->open();
       client.incrementGeneration();
       holdThreads.push_back(shared_ptr<boost::thread>(
-          new boost::thread(apache::thrift::stdcxx::bind(&TServerIntegrationTestFixture::delayClose,
+          new boost::thread(std::bind(&TServerIntegrationTestFixture::delayClose,
                                         this,
                                         pClientSock,
                                         milliseconds(10 * numToMake)))));
@@ -284,7 +284,7 @@
     std::vector<shared_ptr<boost::thread> > holdThreads;
     for (int64_t i = 0; i < numToMake; ++i) {
       holdThreads.push_back(shared_ptr<boost::thread>(
-        new boost::thread(apache::thrift::stdcxx::bind(&TServerIntegrationTestFixture::stressor, this))));
+        new boost::thread(std::bind(&TServerIntegrationTestFixture::stressor, this))));
     }
 
     boost::this_thread::sleep(duration);
@@ -479,11 +479,11 @@
   // Ensure they have been accepted
   blockUntilAccepted(2);
 
-  boost::thread t1(apache::thrift::stdcxx::bind(&TServerIntegrationTestFixture::delayClose,
+  boost::thread t1(std::bind(&TServerIntegrationTestFixture::delayClose,
                                this,
                                pClientSock1,
                                milliseconds(250)));
-  boost::thread t2(apache::thrift::stdcxx::bind(&TServerIntegrationTestFixture::delayClose,
+  boost::thread t2(std::bind(&TServerIntegrationTestFixture::delayClose,
                                this,
                                pClientSock2,
                                milliseconds(250)));
@@ -517,7 +517,7 @@
   BOOST_CHECK_EQUAL(2, pServer->getConcurrentClientCount());
 
   // a third client cannot connect until one of the other two closes
-  boost::thread t2(apache::thrift::stdcxx::bind(&TServerIntegrationTestFixture::delayClose,
+  boost::thread t2(std::bind(&TServerIntegrationTestFixture::delayClose,
                                this,
                                pClientSock2,
                                milliseconds(250)));
diff --git a/lib/cpp/test/TServerSocketTest.cpp b/lib/cpp/test/TServerSocketTest.cpp
index a191147..bec6d47 100644
--- a/lib/cpp/test/TServerSocketTest.cpp
+++ b/lib/cpp/test/TServerSocketTest.cpp
@@ -20,7 +20,7 @@
 #include <boost/test/auto_unit_test.hpp>
 #include <thrift/transport/TSocket.h>
 #include <thrift/transport/TServerSocket.h>
-#include <thrift/stdcxx.h>
+#include <memory>
 #include "TTransportCheckThrow.h"
 #include <iostream>
 
@@ -28,7 +28,7 @@
 using apache::thrift::transport::TSocket;
 using apache::thrift::transport::TTransport;
 using apache::thrift::transport::TTransportException;
-using apache::thrift::stdcxx::shared_ptr;
+using std::shared_ptr;
 
 BOOST_AUTO_TEST_SUITE(TServerSocketTest)
 
diff --git a/lib/cpp/test/TServerTransportTest.cpp b/lib/cpp/test/TServerTransportTest.cpp
index dc6aede..539bd28 100644
--- a/lib/cpp/test/TServerTransportTest.cpp
+++ b/lib/cpp/test/TServerTransportTest.cpp
@@ -20,12 +20,12 @@
 #include <boost/test/auto_unit_test.hpp>
 #include <thrift/transport/TSocket.h>
 #include <thrift/transport/TServerTransport.h>
-#include <thrift/stdcxx.h>
+#include <memory>
 
 using apache::thrift::transport::TServerTransport;
 using apache::thrift::transport::TTransport;
 using apache::thrift::transport::TTransportException;
-using apache::thrift::stdcxx::shared_ptr;
+using std::shared_ptr;
 
 BOOST_AUTO_TEST_SUITE(TServerTransportTest)
 
diff --git a/lib/cpp/test/TSocketInterruptTest.cpp b/lib/cpp/test/TSocketInterruptTest.cpp
index 3a189cc..366242f 100644
--- a/lib/cpp/test/TSocketInterruptTest.cpp
+++ b/lib/cpp/test/TSocketInterruptTest.cpp
@@ -25,7 +25,7 @@
 #include <boost/thread/thread.hpp>
 #include <thrift/transport/TSocket.h>
 #include <thrift/transport/TServerSocket.h>
-#include <thrift/stdcxx.h>
+#include <memory>
 
 using apache::thrift::transport::TServerSocket;
 using apache::thrift::transport::TSocket;
@@ -35,12 +35,12 @@
 
 BOOST_AUTO_TEST_SUITE(TSocketInterruptTest)
 
-void readerWorker(stdcxx::shared_ptr<TTransport> tt, uint32_t expectedResult) {
+void readerWorker(std::shared_ptr<TTransport> tt, uint32_t expectedResult) {
   uint8_t buf[4];
   BOOST_CHECK_EQUAL(expectedResult, tt->read(buf, 4));
 }
 
-void readerWorkerMustThrow(stdcxx::shared_ptr<TTransport> tt) {
+void readerWorkerMustThrow(std::shared_ptr<TTransport> tt) {
   try {
     uint8_t buf[4];
     tt->read(buf, 4);
@@ -56,8 +56,8 @@
   int port = sock1.getPort();
   TSocket clientSock("localhost", port);
   clientSock.open();
-  stdcxx::shared_ptr<TTransport> accepted = sock1.accept();
-  boost::thread readThread(stdcxx::bind(readerWorkerMustThrow, accepted));
+  std::shared_ptr<TTransport> accepted = sock1.accept();
+  boost::thread readThread(std::bind(readerWorkerMustThrow, accepted));
   boost::this_thread::sleep(boost::posix_time::milliseconds(50));
   // readThread is practically guaranteed to be blocking now
   sock1.interruptChildren();
@@ -75,8 +75,8 @@
   int port = sock1.getPort();
   TSocket clientSock("localhost", port);
   clientSock.open();
-  stdcxx::shared_ptr<TTransport> accepted = sock1.accept();
-  boost::thread readThread(stdcxx::bind(readerWorker, accepted, 0));
+  std::shared_ptr<TTransport> accepted = sock1.accept();
+  boost::thread readThread(std::bind(readerWorker, accepted, 0));
   boost::this_thread::sleep(boost::posix_time::milliseconds(50));
   // readThread is practically guaranteed to be blocking here
   sock1.interruptChildren();
@@ -97,7 +97,7 @@
   sock1.close();
 }
 
-void peekerWorker(stdcxx::shared_ptr<TTransport> tt, bool expectedResult) {
+void peekerWorker(std::shared_ptr<TTransport> tt, bool expectedResult) {
   BOOST_CHECK_EQUAL(expectedResult, tt->peek());
 }
 
@@ -107,9 +107,9 @@
   int port = sock1.getPort();
   TSocket clientSock("localhost", port);
   clientSock.open();
-  stdcxx::shared_ptr<TTransport> accepted = sock1.accept();
+  std::shared_ptr<TTransport> accepted = sock1.accept();
   // peek() will return false if child is interrupted
-  boost::thread peekThread(stdcxx::bind(peekerWorker, accepted, false));
+  boost::thread peekThread(std::bind(peekerWorker, accepted, false));
   boost::this_thread::sleep(boost::posix_time::milliseconds(50));
   // peekThread is practically guaranteed to be blocking now
   sock1.interruptChildren();
@@ -127,9 +127,9 @@
   int port = sock1.getPort();
   TSocket clientSock("localhost", port);
   clientSock.open();
-  stdcxx::shared_ptr<TTransport> accepted = sock1.accept();
+  std::shared_ptr<TTransport> accepted = sock1.accept();
   // peek() will return false when remote side is closed
-  boost::thread peekThread(stdcxx::bind(peekerWorker, accepted, false));
+  boost::thread peekThread(std::bind(peekerWorker, accepted, false));
   boost::this_thread::sleep(boost::posix_time::milliseconds(50));
   // peekThread is practically guaranteed to be blocking now
   sock1.interruptChildren();
diff --git a/lib/cpp/test/TransportTest.cpp b/lib/cpp/test/TransportTest.cpp
index d6ab457..ce19544 100644
--- a/lib/cpp/test/TransportTest.cpp
+++ b/lib/cpp/test/TransportTest.cpp
@@ -26,7 +26,6 @@
 #endif
 #include <sstream>
 #include <fstream>
-#include <thrift/stdcxx.h>
 
 #include <boost/mpl/list.hpp>
 #include <boost/shared_array.hpp>
@@ -114,7 +113,7 @@
   std::string describe() const { return generator_->describe(); }
 
 private:
-  stdcxx::shared_ptr<SizeGenerator> generator_;
+  std::shared_ptr<SizeGenerator> generator_;
 };
 
 /**************************************************************************
@@ -137,8 +136,8 @@
 
   CoupledTransports() : in(), out() {}
 
-  stdcxx::shared_ptr<Transport_> in;
-  stdcxx::shared_ptr<Transport_> out;
+  std::shared_ptr<Transport_> in;
+  std::shared_ptr<Transport_> out;
 
 private:
   CoupledTransports(const CoupledTransports&);
@@ -155,7 +154,7 @@
     out = buf;
   }
 
-  stdcxx::shared_ptr<TMemoryBuffer> buf;
+  std::shared_ptr<TMemoryBuffer> buf;
 };
 
 /**
@@ -341,11 +340,11 @@
  **************************************************************************/
 
 struct TriggerInfo {
-  TriggerInfo(int seconds, const stdcxx::shared_ptr<TTransport>& transport, uint32_t writeLength)
+  TriggerInfo(int seconds, const std::shared_ptr<TTransport>& transport, uint32_t writeLength)
     : timeoutSeconds(seconds), transport(transport), writeLength(writeLength), next(NULL) {}
 
   int timeoutSeconds;
-  stdcxx::shared_ptr<TTransport> transport;
+  std::shared_ptr<TTransport> transport;
   uint32_t writeLength;
   TriggerInfo* next;
 };
@@ -420,7 +419,7 @@
  * to the end.)
  */
 void add_trigger(unsigned int seconds,
-                 const stdcxx::shared_ptr<TTransport>& transport,
+                 const std::shared_ptr<TTransport>& transport,
                  uint32_t write_len) {
   TriggerInfo* info = new TriggerInfo(seconds, transport, write_len);
   {
@@ -460,7 +459,7 @@
 }
 
 void set_trigger(unsigned int seconds,
-                 const stdcxx::shared_ptr<TTransport>& transport,
+                 const std::shared_ptr<TTransport>& transport,
                  uint32_t write_len) {
   clear_triggers();
   add_trigger(seconds, transport, write_len);
@@ -976,11 +975,11 @@
          << rChunkSizeGen.describe() << ", " << maxOutstanding << ")";
 
 #if (BOOST_VERSION >= 105900)
-    stdcxx::function<void ()> test_func
+    std::function<void ()> test_func
 #else
     boost::unit_test::callback0<> test_func
 #endif
-        = stdcxx::bind(test_rw<CoupledTransports>,
+        = std::bind(test_rw<CoupledTransports>,
                                        totalSize,
                                        wSizeGen,
                                        rSizeGen,
@@ -1026,7 +1025,7 @@
  **************************************************************************/
 
 struct global_fixture {
-  stdcxx::shared_ptr<apache::thrift::concurrency::Thread> alarmThread_;
+  std::shared_ptr<apache::thrift::concurrency::Thread> alarmThread_;
   global_fixture() {
 #if _WIN32
     apache::thrift::transport::TWinsockSingleton::create();
diff --git a/lib/cpp/test/ZlibTest.cpp b/lib/cpp/test/ZlibTest.cpp
index ea54487..c826814 100644
--- a/lib/cpp/test/ZlibTest.cpp
+++ b/lib/cpp/test/ZlibTest.cpp
@@ -36,7 +36,7 @@
 #include <cstddef>
 #include <fstream>
 #include <iostream>
-#include <thrift/stdcxx.h>
+#include <memory>
 
 #include <boost/random.hpp>
 #include <boost/shared_array.hpp>
@@ -47,7 +47,7 @@
 #include <thrift/transport/TZlibTransport.h>
 
 using namespace apache::thrift::transport;
-using apache::thrift::stdcxx::shared_ptr;
+using std::shared_ptr;
 using std::string;
 
 boost::mt19937 rng;
@@ -347,8 +347,8 @@
   do {                                                                                             \
     ::std::ostringstream name_ss;                                                                  \
     name_ss << name << "-" << BOOST_STRINGIZE(_FUNC);                                              \
-    ::apache::thrift::stdcxx::function<void ()> test_func =                                        \
-        ::apache::thrift::stdcxx::bind(_FUNC, ##__VA_ARGS__);                                      \
+    ::std::function<void ()> test_func =                                        \
+        ::std::bind(_FUNC, ##__VA_ARGS__);                                      \
     ::boost::unit_test::test_case* tc                                                              \
         = ::boost::unit_test::make_test_case(test_func, name_ss.str(), __FILE__, __LINE__);        \
     (suite)->add(tc);                                                                              \
@@ -359,7 +359,7 @@
     ::std::ostringstream name_ss;                                                                  \
     name_ss << name << "-" << BOOST_STRINGIZE(_FUNC);                                              \
     ::boost::unit_test::test_case* tc                                                              \
-        = ::boost::unit_test::make_test_case(::apache::thrift::stdcxx::bind(_FUNC,                 \
+        = ::boost::unit_test::make_test_case(::std::bind(_FUNC,                 \
                                                                             ##__VA_ARGS__),        \
                                              name_ss.str());                                       \
     (suite)->add(tc);                                                                              \
diff --git a/lib/cpp/test/concurrency/RWMutexStarveTest.cpp b/lib/cpp/test/concurrency/RWMutexStarveTest.cpp
index 849e078..985a230 100644
--- a/lib/cpp/test/concurrency/RWMutexStarveTest.cpp
+++ b/lib/cpp/test/concurrency/RWMutexStarveTest.cpp
@@ -23,9 +23,9 @@
 
 #include "thrift/concurrency/Mutex.h"
 #include "thrift/concurrency/PosixThreadFactory.h"
-#include <thrift/stdcxx.h>
+#include <memory>
 
-using apache::thrift::stdcxx::shared_ptr;
+using std::shared_ptr;
 using boost::unit_test::test_suite;
 using boost::unit_test::framework::master_test_suite;
 
diff --git a/lib/cpp/test/concurrency/ThreadFactoryTests.h b/lib/cpp/test/concurrency/ThreadFactoryTests.h
index 48330f3..ba98502 100644
--- a/lib/cpp/test/concurrency/ThreadFactoryTests.h
+++ b/lib/cpp/test/concurrency/ThreadFactoryTests.h
@@ -33,7 +33,7 @@
 namespace concurrency {
 namespace test {
 
-using stdcxx::shared_ptr;
+using std::shared_ptr;
 using namespace apache::thrift::concurrency;
 
 /**
diff --git a/lib/cpp/test/concurrency/ThreadManagerTests.h b/lib/cpp/test/concurrency/ThreadManagerTests.h
index 15a43ff..d6c092d 100644
--- a/lib/cpp/test/concurrency/ThreadManagerTests.h
+++ b/lib/cpp/test/concurrency/ThreadManagerTests.h
@@ -36,8 +36,8 @@
 
 using namespace apache::thrift::concurrency;
 
-static std::deque<stdcxx::shared_ptr<Runnable> > m_expired;
-static void expiredNotifier(stdcxx::shared_ptr<Runnable> runnable)
+static std::deque<std::shared_ptr<Runnable> > m_expired;
+static void expiredNotifier(std::shared_ptr<Runnable> runnable)
 {
   m_expired.push_back(runnable);
 }
@@ -452,7 +452,7 @@
     std::cout << "\t\t\t\tstarting.. " << std::endl;
 
     threadManager->start();
-    threadManager->setExpireCallback(expiredNotifier); // apache::thrift::stdcxx::bind(&ThreadManagerTests::expiredNotifier, this));
+    threadManager->setExpireCallback(expiredNotifier); // std::bind(&ThreadManagerTests::expiredNotifier, this));
 
 #define EXPECT(FUNC, COUNT) { size_t c = FUNC; if (c != COUNT) { std::cerr << "expected " #FUNC" to be " #COUNT ", but was " << c << std::endl; return false; } }
 
diff --git a/lib/cpp/test/processor/Handlers.h b/lib/cpp/test/processor/Handlers.h
index ad47229..29784d8 100644
--- a/lib/cpp/test/processor/Handlers.h
+++ b/lib/cpp/test/processor/Handlers.h
@@ -29,7 +29,7 @@
 
 class ParentHandler : virtual public ParentServiceIf {
 public:
-  ParentHandler(const stdcxx::shared_ptr<EventLog>& log)
+  ParentHandler(const std::shared_ptr<EventLog>& log)
     : triggerMonitor(&mutex_), generation_(0), wait_(false), log_(log) {}
 
   int32_t incrementGeneration() {
@@ -136,7 +136,7 @@
   int32_t generation_;
   bool wait_;
   std::vector<std::string> strings_;
-  stdcxx::shared_ptr<EventLog> log_;
+  std::shared_ptr<EventLog> log_;
 };
 
 #ifdef _WIN32
@@ -146,7 +146,7 @@
 
 class ChildHandler : public ParentHandler, virtual public ChildServiceIf {
 public:
-  ChildHandler(const stdcxx::shared_ptr<EventLog>& log) : ParentHandler(log), value_(0) {}
+  ChildHandler(const std::shared_ptr<EventLog>& log) : ParentHandler(log), value_(0) {}
 
   int32_t setValue(const int32_t value) {
     concurrency::Guard g(mutex_);
@@ -174,13 +174,13 @@
 
 struct ConnContext {
 public:
-  ConnContext(stdcxx::shared_ptr<protocol::TProtocol> in,
-              stdcxx::shared_ptr<protocol::TProtocol> out,
+  ConnContext(std::shared_ptr<protocol::TProtocol> in,
+              std::shared_ptr<protocol::TProtocol> out,
               uint32_t id)
     : input(in), output(out), id(id) {}
 
-  stdcxx::shared_ptr<protocol::TProtocol> input;
-  stdcxx::shared_ptr<protocol::TProtocol> output;
+  std::shared_ptr<protocol::TProtocol> input;
+  std::shared_ptr<protocol::TProtocol> output;
   uint32_t id;
 };
 
@@ -196,12 +196,12 @@
 
 class ServerEventHandler : public server::TServerEventHandler {
 public:
-  ServerEventHandler(const stdcxx::shared_ptr<EventLog>& log) : nextId_(1), log_(log) {}
+  ServerEventHandler(const std::shared_ptr<EventLog>& log) : nextId_(1), log_(log) {}
 
   virtual void preServe() {}
 
-  virtual void* createContext(stdcxx::shared_ptr<protocol::TProtocol> input,
-                              stdcxx::shared_ptr<protocol::TProtocol> output) {
+  virtual void* createContext(std::shared_ptr<protocol::TProtocol> input,
+                              std::shared_ptr<protocol::TProtocol> output) {
     ConnContext* context = new ConnContext(input, output, nextId_);
     ++nextId_;
     log_->append(EventLog::ET_CONN_CREATED, context->id, 0);
@@ -209,8 +209,8 @@
   }
 
   virtual void deleteContext(void* serverContext,
-                             stdcxx::shared_ptr<protocol::TProtocol> input,
-                             stdcxx::shared_ptr<protocol::TProtocol> output) {
+                             std::shared_ptr<protocol::TProtocol> input,
+                             std::shared_ptr<protocol::TProtocol> output) {
     ConnContext* context = reinterpret_cast<ConnContext*>(serverContext);
 
     if (input != context->input) {
@@ -226,7 +226,7 @@
   }
 
   virtual void processContext(void* serverContext,
-                              stdcxx::shared_ptr<transport::TTransport> transport) {
+                              std::shared_ptr<transport::TTransport> transport) {
 // TODO: We currently don't test the behavior of the processContext()
 // calls.  The various server implementations call processContext() at
 // slightly different times, and it is too annoying to try and account for
@@ -251,12 +251,12 @@
 
 protected:
   uint32_t nextId_;
-  stdcxx::shared_ptr<EventLog> log_;
+  std::shared_ptr<EventLog> log_;
 };
 
 class ProcessorEventHandler : public TProcessorEventHandler {
 public:
-  ProcessorEventHandler(const stdcxx::shared_ptr<EventLog>& log) : nextId_(1), log_(log) {}
+  ProcessorEventHandler(const std::shared_ptr<EventLog>& log) : nextId_(1), log_(log) {}
 
   void* getContext(const char* fnName, void* serverContext) {
     ConnContext* connContext = reinterpret_cast<ConnContext*>(serverContext);
@@ -329,7 +329,7 @@
   }
 
   uint32_t nextId_;
-  stdcxx::shared_ptr<EventLog> log_;
+  std::shared_ptr<EventLog> log_;
 };
 }
 }
diff --git a/lib/cpp/test/processor/ProcessorTest.cpp b/lib/cpp/test/processor/ProcessorTest.cpp
index c9e186f..36ce013 100644
--- a/lib/cpp/test/processor/ProcessorTest.cpp
+++ b/lib/cpp/test/processor/ProcessorTest.cpp
@@ -57,13 +57,13 @@
 public:
   typedef TSimpleServer ServerType;
 
-  stdcxx::shared_ptr<TSimpleServer> createServer(
-      const stdcxx::shared_ptr<TProcessor>& processor,
+  std::shared_ptr<TSimpleServer> createServer(
+      const std::shared_ptr<TProcessor>& processor,
       uint16_t port,
-      const stdcxx::shared_ptr<TTransportFactory>& transportFactory,
-      const stdcxx::shared_ptr<TProtocolFactory>& protocolFactory) {
-    stdcxx::shared_ptr<TServerSocket> socket(new TServerSocket(port));
-    return stdcxx::shared_ptr<TSimpleServer>(
+      const std::shared_ptr<TTransportFactory>& transportFactory,
+      const std::shared_ptr<TProtocolFactory>& protocolFactory) {
+    std::shared_ptr<TServerSocket> socket(new TServerSocket(port));
+    return std::shared_ptr<TSimpleServer>(
         new TSimpleServer(processor, socket, transportFactory, protocolFactory));
   }
 };
@@ -72,13 +72,13 @@
 public:
   typedef TThreadedServer ServerType;
 
-  stdcxx::shared_ptr<TThreadedServer> createServer(
-      const stdcxx::shared_ptr<TProcessor>& processor,
+  std::shared_ptr<TThreadedServer> createServer(
+      const std::shared_ptr<TProcessor>& processor,
       uint16_t port,
-      const stdcxx::shared_ptr<TTransportFactory>& transportFactory,
-      const stdcxx::shared_ptr<TProtocolFactory>& protocolFactory) {
-    stdcxx::shared_ptr<TServerSocket> socket(new TServerSocket(port));
-    return stdcxx::shared_ptr<TThreadedServer>(
+      const std::shared_ptr<TTransportFactory>& transportFactory,
+      const std::shared_ptr<TProtocolFactory>& protocolFactory) {
+    std::shared_ptr<TServerSocket> socket(new TServerSocket(port));
+    return std::shared_ptr<TThreadedServer>(
         new TThreadedServer(processor, socket, transportFactory, protocolFactory));
   }
 };
@@ -87,19 +87,19 @@
 public:
   typedef TThreadPoolServer ServerType;
 
-  stdcxx::shared_ptr<TThreadPoolServer> createServer(
-      const stdcxx::shared_ptr<TProcessor>& processor,
+  std::shared_ptr<TThreadPoolServer> createServer(
+      const std::shared_ptr<TProcessor>& processor,
       uint16_t port,
-      const stdcxx::shared_ptr<TTransportFactory>& transportFactory,
-      const stdcxx::shared_ptr<TProtocolFactory>& protocolFactory) {
-    stdcxx::shared_ptr<TServerSocket> socket(new TServerSocket(port));
+      const std::shared_ptr<TTransportFactory>& transportFactory,
+      const std::shared_ptr<TProtocolFactory>& protocolFactory) {
+    std::shared_ptr<TServerSocket> socket(new TServerSocket(port));
 
-    stdcxx::shared_ptr<PlatformThreadFactory> threadFactory(new PlatformThreadFactory);
-    stdcxx::shared_ptr<ThreadManager> threadManager = ThreadManager::newSimpleThreadManager(8);
+    std::shared_ptr<PlatformThreadFactory> threadFactory(new PlatformThreadFactory);
+    std::shared_ptr<ThreadManager> threadManager = ThreadManager::newSimpleThreadManager(8);
     threadManager->threadFactory(threadFactory);
     threadManager->start();
 
-    return stdcxx::shared_ptr<TThreadPoolServer>(
+    return std::shared_ptr<TThreadPoolServer>(
         new TThreadPoolServer(processor, socket, transportFactory, protocolFactory, threadManager));
   }
 };
@@ -108,11 +108,11 @@
 public:
   typedef TNonblockingServer ServerType;
 
-  stdcxx::shared_ptr<TNonblockingServer> createServer(
-      const stdcxx::shared_ptr<TProcessor>& processor,
+  std::shared_ptr<TNonblockingServer> createServer(
+      const std::shared_ptr<TProcessor>& processor,
       uint16_t port,
-      const stdcxx::shared_ptr<TTransportFactory>& transportFactory,
-      const stdcxx::shared_ptr<TProtocolFactory>& protocolFactory) {
+      const std::shared_ptr<TTransportFactory>& transportFactory,
+      const std::shared_ptr<TProtocolFactory>& protocolFactory) {
     // TNonblockingServer automatically uses TFramedTransport.
     // Raise an exception if the supplied transport factory is not a
     // TFramedTransportFactory
@@ -122,13 +122,13 @@
       throw TException("TNonblockingServer must use TFramedTransport");
     }
 
-    stdcxx::shared_ptr<TNonblockingServerSocket> socket(new TNonblockingServerSocket(port));
-    stdcxx::shared_ptr<PlatformThreadFactory> threadFactory(new PlatformThreadFactory);
-    stdcxx::shared_ptr<ThreadManager> threadManager = ThreadManager::newSimpleThreadManager(8);
+    std::shared_ptr<TNonblockingServerSocket> socket(new TNonblockingServerSocket(port));
+    std::shared_ptr<PlatformThreadFactory> threadFactory(new PlatformThreadFactory);
+    std::shared_ptr<ThreadManager> threadManager = ThreadManager::newSimpleThreadManager(8);
     threadManager->threadFactory(threadFactory);
     threadManager->start();
 
-    return stdcxx::shared_ptr<TNonblockingServer>(
+    return std::shared_ptr<TNonblockingServer>(
         new TNonblockingServer(processor, protocolFactory, socket, threadManager));
   }
 };
@@ -137,11 +137,11 @@
 public:
   typedef TNonblockingServer ServerType;
 
-  stdcxx::shared_ptr<TNonblockingServer> createServer(
-      const stdcxx::shared_ptr<TProcessor>& processor,
+  std::shared_ptr<TNonblockingServer> createServer(
+      const std::shared_ptr<TProcessor>& processor,
       uint16_t port,
-      const stdcxx::shared_ptr<TTransportFactory>& transportFactory,
-      const stdcxx::shared_ptr<TProtocolFactory>& protocolFactory) {
+      const std::shared_ptr<TTransportFactory>& transportFactory,
+      const std::shared_ptr<TProtocolFactory>& protocolFactory) {
     // TNonblockingServer automatically uses TFramedTransport.
     // Raise an exception if the supplied transport factory is not a
     // TFramedTransportFactory
@@ -151,10 +151,10 @@
       throw TException("TNonblockingServer must use TFramedTransport");
     }
 
-    stdcxx::shared_ptr<TNonblockingServerSocket> socket(new TNonblockingServerSocket(port));
+    std::shared_ptr<TNonblockingServerSocket> socket(new TNonblockingServerSocket(port));
     // Use a NULL ThreadManager
-    stdcxx::shared_ptr<ThreadManager> threadManager;
-    return stdcxx::shared_ptr<TNonblockingServer>(
+    std::shared_ptr<ThreadManager> threadManager;
+    return std::shared_ptr<TNonblockingServer>(
         new TNonblockingServer(processor, protocolFactory, socket, threadManager));
   }
 };
@@ -244,48 +244,48 @@
     processor_->setEventHandler(processorEventHandler_);
   }
 
-  stdcxx::shared_ptr<TServer> createServer(uint16_t port) {
+  std::shared_ptr<TServer> createServer(uint16_t port) {
     ServerTraits_ serverTraits;
     return serverTraits.createServer(processor_, port, transportFactory_, protocolFactory_);
   }
 
-  stdcxx::shared_ptr<TServerEventHandler> getServerEventHandler() { return serverEventHandler_; }
+  std::shared_ptr<TServerEventHandler> getServerEventHandler() { return serverEventHandler_; }
 
   void bindSuccessful(uint16_t port) { port_ = port; }
 
   uint16_t getPort() const { return port_; }
 
-  const stdcxx::shared_ptr<EventLog>& getLog() const { return log_; }
+  const std::shared_ptr<EventLog>& getLog() const { return log_; }
 
-  const stdcxx::shared_ptr<Handler>& getHandler() const { return handler_; }
+  const std::shared_ptr<Handler>& getHandler() const { return handler_; }
 
-  stdcxx::shared_ptr<Client> createClient() {
+  std::shared_ptr<Client> createClient() {
     typedef typename ServiceTraits_::Protocol Protocol;
 
-    stdcxx::shared_ptr<TSocket> socket(new TSocket("127.0.0.1", port_));
-    stdcxx::shared_ptr<Transport_> transport(new Transport_(socket));
-    stdcxx::shared_ptr<Protocol> protocol(new Protocol(transport));
+    std::shared_ptr<TSocket> socket(new TSocket("127.0.0.1", port_));
+    std::shared_ptr<Transport_> transport(new Transport_(socket));
+    std::shared_ptr<Protocol> protocol(new Protocol(transport));
     transport->open();
 
-    stdcxx::shared_ptr<Client> client(new Client(protocol));
+    std::shared_ptr<Client> client(new Client(protocol));
     return client;
   }
 
 private:
   uint16_t port_;
-  stdcxx::shared_ptr<EventLog> log_;
-  stdcxx::shared_ptr<Handler> handler_;
-  stdcxx::shared_ptr<Processor> processor_;
-  stdcxx::shared_ptr<TTransportFactory> transportFactory_;
-  stdcxx::shared_ptr<TProtocolFactory> protocolFactory_;
-  stdcxx::shared_ptr<TServerEventHandler> serverEventHandler_;
-  stdcxx::shared_ptr<TProcessorEventHandler> processorEventHandler_;
+  std::shared_ptr<EventLog> log_;
+  std::shared_ptr<Handler> handler_;
+  std::shared_ptr<Processor> processor_;
+  std::shared_ptr<TTransportFactory> transportFactory_;
+  std::shared_ptr<TProtocolFactory> protocolFactory_;
+  std::shared_ptr<TServerEventHandler> serverEventHandler_;
+  std::shared_ptr<TProcessorEventHandler> processorEventHandler_;
 };
 
 /**
  * Check that there are no more events in the log
  */
-void checkNoEvents(const stdcxx::shared_ptr<EventLog>& log) {
+void checkNoEvents(const std::shared_ptr<EventLog>& log) {
   // Wait for an event with a very short timeout period.  We don't expect
   // anything to be present, so we will normally wait for the full timeout.
   // On the other hand, a non-zero timeout is nice since it does give a short
@@ -299,7 +299,7 @@
  *
  * Returns the connection ID allocated by the server.
  */
-uint32_t checkNewConnEvents(const stdcxx::shared_ptr<EventLog>& log) {
+uint32_t checkNewConnEvents(const std::shared_ptr<EventLog>& log) {
   // Check for an ET_CONN_CREATED event
   Event event = log->waitForEvent(2500);
   BOOST_CHECK_EQUAL(EventLog::ET_CONN_CREATED, event.type);
@@ -314,7 +314,7 @@
 /**
  * Check for the events that should be logged when a connection is closed.
  */
-void checkCloseEvents(const stdcxx::shared_ptr<EventLog>& log, uint32_t connId) {
+void checkCloseEvents(const std::shared_ptr<EventLog>& log, uint32_t connId) {
   // Check for an ET_CONN_DESTROYED event
   Event event = log->waitForEvent();
   BOOST_CHECK_EQUAL(EventLog::ET_CONN_DESTROYED, event.type);
@@ -332,7 +332,7 @@
  *
  * Returns the call ID allocated by the server.
  */
-uint32_t checkCallHandlerEvents(const stdcxx::shared_ptr<EventLog>& log,
+uint32_t checkCallHandlerEvents(const std::shared_ptr<EventLog>& log,
                                 uint32_t connId,
                                 EventType callType,
                                 const string& callName) {
@@ -369,7 +369,7 @@
 /**
  * Check for the events that should be after a handler returns.
  */
-void checkCallPostHandlerEvents(const stdcxx::shared_ptr<EventLog>& log,
+void checkCallPostHandlerEvents(const std::shared_ptr<EventLog>& log,
                                 uint32_t connId,
                                 uint32_t callId,
                                 const string& callName) {
@@ -409,7 +409,7 @@
  *
  * Returns the call ID allocated by the server.
  */
-uint32_t checkCallEvents(const stdcxx::shared_ptr<EventLog>& log,
+uint32_t checkCallEvents(const std::shared_ptr<EventLog>& log,
                          uint32_t connId,
                          EventType callType,
                          const string& callName) {
@@ -424,8 +424,8 @@
  */
 
 template <typename State_>
-void testParentService(const stdcxx::shared_ptr<State_>& state) {
-  stdcxx::shared_ptr<typename State_::Client> client = state->createClient();
+void testParentService(const std::shared_ptr<State_>& state) {
+  std::shared_ptr<typename State_::Client> client = state->createClient();
 
   int32_t gen = client->getGeneration();
   int32_t newGen = client->incrementGeneration();
@@ -446,8 +446,8 @@
 }
 
 template <typename State_>
-void testChildService(const stdcxx::shared_ptr<State_>& state) {
-  stdcxx::shared_ptr<typename State_::Client> client = state->createClient();
+void testChildService(const std::shared_ptr<State_>& state) {
+  std::shared_ptr<typename State_::Client> client = state->createClient();
 
   // Test calling some of the parent methids via the a child client
   int32_t gen = client->getGeneration();
@@ -468,7 +468,7 @@
   typedef ServiceState<ServerTraits, ParentServiceTraits<TemplateTraits> > State;
 
   // Start the server
-  stdcxx::shared_ptr<State> state(new State);
+  std::shared_ptr<State> state(new State);
   ServerThread serverThread(state, true);
 
   testParentService(state);
@@ -479,7 +479,7 @@
   typedef ServiceState<ServerTraits, ChildServiceTraits<TemplateTraits> > State;
 
   // Start the server
-  stdcxx::shared_ptr<State> state(new State);
+  std::shared_ptr<State> state(new State);
   ServerThread serverThread(state, true);
 
   testParentService(state);
@@ -502,10 +502,10 @@
                        TBufferedTransport> State;
 
   // Start the server
-  stdcxx::shared_ptr<State> state(new State);
+  std::shared_ptr<State> state(new State);
   ServerThread serverThread(state, true);
 
-  const stdcxx::shared_ptr<EventLog>& log = state->getLog();
+  const std::shared_ptr<EventLog>& log = state->getLog();
 
   // Make sure we're at the end of the log
   checkNoEvents(log);
@@ -514,7 +514,7 @@
 
   // Make sure createContext() is called after a connection has been
   // established.  We open a plain socket instead of creating a client.
-  stdcxx::shared_ptr<TSocket> socket(new TSocket("127.0.0.1", state->getPort()));
+  std::shared_ptr<TSocket> socket(new TSocket("127.0.0.1", state->getPort()));
   socket->open();
 
   // Make sure the proper events occurred after a new connection
@@ -635,19 +635,19 @@
   typedef ServiceState<ServerTraits, ChildServiceTraits<TemplateTraits> > State;
 
   // Start the server
-  stdcxx::shared_ptr<State> state(new State);
+  std::shared_ptr<State> state(new State);
   ServerThread serverThread(state, true);
 
-  const stdcxx::shared_ptr<EventLog>& log = state->getLog();
+  const std::shared_ptr<EventLog>& log = state->getLog();
 
   // Create a client
-  stdcxx::shared_ptr<typename State::Client> client1 = state->createClient();
+  std::shared_ptr<typename State::Client> client1 = state->createClient();
 
   // Make sure the expected events were logged
   uint32_t client1Id = checkNewConnEvents(log);
 
   // Create a second client
-  stdcxx::shared_ptr<typename State::Client> client2 = state->createClient();
+  std::shared_ptr<typename State::Client> client2 = state->createClient();
 
   // Make sure the expected events were logged
   uint32_t client2Id = checkNewConnEvents(log);
@@ -683,13 +683,13 @@
   typedef ServiceState<ServerTraits, ChildServiceTraits<TemplateTraits> > State;
 
   // Start the server
-  stdcxx::shared_ptr<State> state(new State);
+  std::shared_ptr<State> state(new State);
   ServerThread serverThread(state, true);
 
-  const stdcxx::shared_ptr<EventLog>& log = state->getLog();
+  const std::shared_ptr<EventLog>& log = state->getLog();
 
   // Create a client
-  stdcxx::shared_ptr<typename State::Client> client = state->createClient();
+  std::shared_ptr<typename State::Client> client = state->createClient();
   uint32_t connId = checkNewConnEvents(log);
 
   // Make a oneway call
@@ -735,13 +735,13 @@
   typedef ServiceState<ServerTraits, ChildServiceTraits<TemplateTraits> > State;
 
   // Start the server
-  stdcxx::shared_ptr<State> state(new State);
+  std::shared_ptr<State> state(new State);
   ServerThread serverThread(state, true);
 
-  const stdcxx::shared_ptr<EventLog>& log = state->getLog();
+  const std::shared_ptr<EventLog>& log = state->getLog();
 
   // Create a client
-  stdcxx::shared_ptr<typename State::Client> client = state->createClient();
+  std::shared_ptr<typename State::Client> client = state->createClient();
   uint32_t connId = checkNewConnEvents(log);
 
   // Send the exceptionWait() call
@@ -790,13 +790,13 @@
   typedef ServiceState<ServerTraits, ChildServiceTraits<TemplateTraits> > State;
 
   // Start the server
-  stdcxx::shared_ptr<State> state(new State);
+  std::shared_ptr<State> state(new State);
   ServerThread serverThread(state, true);
 
-  const stdcxx::shared_ptr<EventLog>& log = state->getLog();
+  const std::shared_ptr<EventLog>& log = state->getLog();
 
   // Create a client
-  stdcxx::shared_ptr<typename State::Client> client = state->createClient();
+  std::shared_ptr<typename State::Client> client = state->createClient();
   uint32_t connId = checkNewConnEvents(log);
 
   // Send the unexpectedExceptionWait() call
diff --git a/lib/cpp/test/processor/ServerThread.cpp b/lib/cpp/test/processor/ServerThread.cpp
index e752d5e..4d1ec4c 100644
--- a/lib/cpp/test/processor/ServerThread.cpp
+++ b/lib/cpp/test/processor/ServerThread.cpp
@@ -130,7 +130,7 @@
   serverState_->bindSuccessful(port_);
 
   // Set the real server event handler (replacing ourself)
-  stdcxx::shared_ptr<server::TServerEventHandler> serverEventHandler
+  std::shared_ptr<server::TServerEventHandler> serverEventHandler
       = serverState_->getServerEventHandler();
   server_->setServerEventHandler(serverEventHandler);
 
diff --git a/lib/cpp/test/processor/ServerThread.h b/lib/cpp/test/processor/ServerThread.h
index 21c3b60..61e31a3 100644
--- a/lib/cpp/test/processor/ServerThread.h
+++ b/lib/cpp/test/processor/ServerThread.h
@@ -43,7 +43,7 @@
    * If the server returned fails to bind to the specified port when serve() is
    * called on it, createServer() may be called again on a different port.
    */
-  virtual stdcxx::shared_ptr<server::TServer> createServer(uint16_t port) = 0;
+  virtual std::shared_ptr<server::TServer> createServer(uint16_t port) = 0;
 
   /**
    * Get the TServerEventHandler to set on the server.
@@ -52,8 +52,8 @@
    * start serving traffic.  It is invoked from the server thread, rather than
    * the main thread.
    */
-  virtual stdcxx::shared_ptr<server::TServerEventHandler> getServerEventHandler() {
-    return stdcxx::shared_ptr<server::TServerEventHandler>();
+  virtual std::shared_ptr<server::TServerEventHandler> getServerEventHandler() {
+    return std::shared_ptr<server::TServerEventHandler>();
   }
 
   /**
@@ -70,7 +70,7 @@
  */
 class ServerThread {
 public:
-  ServerThread(const stdcxx::shared_ptr<ServerState>& state, bool autoStart)
+  ServerThread(const std::shared_ptr<ServerState>& state, bool autoStart)
     : port_(0),
       running_(false),
       serving_(false),
@@ -116,7 +116,7 @@
   void run();
   void preServe();
 
-  stdcxx::shared_ptr<Helper> helper_;
+  std::shared_ptr<Helper> helper_;
 
   uint16_t port_;
   bool running_;
@@ -124,9 +124,9 @@
   bool error_;
   concurrency::Monitor serverMonitor_;
 
-  stdcxx::shared_ptr<ServerState> serverState_;
-  stdcxx::shared_ptr<server::TServer> server_;
-  stdcxx::shared_ptr<concurrency::Thread> thread_;
+  std::shared_ptr<ServerState> serverState_;
+  std::shared_ptr<server::TServer> server_;
+  std::shared_ptr<concurrency::Thread> thread_;
 };
 }
 }
diff --git a/lib/cpp/test/qt/TQTcpServerTest.cpp b/lib/cpp/test/qt/TQTcpServerTest.cpp
index 8a327aa..58d0c6d 100644
--- a/lib/cpp/test/qt/TQTcpServerTest.cpp
+++ b/lib/cpp/test/qt/TQTcpServerTest.cpp
@@ -8,7 +8,6 @@
 #include <QThread>
 
 #ifndef Q_MOC_RUN
-  #include "thrift/stdcxx.h"
   #include "thrift/protocol/TBinaryProtocol.h"
   #include "thrift/async/TAsyncProcessor.h"
   #include "thrift/qt/TQTcpServer.h"
@@ -21,25 +20,25 @@
 
 struct AsyncHandler : public test::ParentServiceCobSvIf {
   std::vector<std::string> strings;
-  virtual void addString(stdcxx::function<void()> cob, const std::string& s) {
+  virtual void addString(std::function<void()> cob, const std::string& s) {
     strings.push_back(s);
     cob();
   }
-  virtual void getStrings(stdcxx::function<void(std::vector<std::string> const& _return)> cob) {
+  virtual void getStrings(std::function<void(std::vector<std::string> const& _return)> cob) {
     cob(strings);
   }
 
   // Overrides not used in this test
-  virtual void incrementGeneration(stdcxx::function<void(int32_t const& _return)> cob) {}
-  virtual void getGeneration(stdcxx::function<void(int32_t const& _return)> cob) {}
-  virtual void getDataWait(stdcxx::function<void(std::string const& _return)> cob,
+  virtual void incrementGeneration(std::function<void(int32_t const& _return)> cob) {}
+  virtual void getGeneration(std::function<void(int32_t const& _return)> cob) {}
+  virtual void getDataWait(std::function<void(std::string const& _return)> cob,
                            const int32_t length) {}
-  virtual void onewayWait(stdcxx::function<void()> cob) {}
+  virtual void onewayWait(std::function<void()> cob) {}
   virtual void exceptionWait(
-      stdcxx::function<void()> cob,
-      stdcxx::function<void(::apache::thrift::TDelayedException* _throw)> /* exn_cob */,
+      std::function<void()> cob,
+      std::function<void(::apache::thrift::TDelayedException* _throw)> /* exn_cob */,
       const std::string& message) {}
-  virtual void unexpectedExceptionWait(stdcxx::function<void()> cob, const std::string& message) {}
+  virtual void unexpectedExceptionWait(std::function<void()> cob, const std::string& message) {}
 };
 
 class TQTcpServerTest : public QObject {
@@ -51,18 +50,18 @@
   void test_communicate();
 
 private:
-  stdcxx::shared_ptr<QThread> serverThread;
-  stdcxx::shared_ptr<async::TQTcpServer> server;
-  stdcxx::shared_ptr<test::ParentServiceClient> client;
+  std::shared_ptr<QThread> serverThread;
+  std::shared_ptr<async::TQTcpServer> server;
+  std::shared_ptr<test::ParentServiceClient> client;
 };
 
 void TQTcpServerTest::initTestCase() {
   // setup server
-  stdcxx::shared_ptr<QTcpServer> serverSocket = stdcxx::make_shared<QTcpServer>();
+  std::shared_ptr<QTcpServer> serverSocket = std::make_shared<QTcpServer>();
   server.reset(new async::TQTcpServer(serverSocket,
-                                      stdcxx::make_shared<test::ParentServiceAsyncProcessor>(
-                                      stdcxx::make_shared<AsyncHandler>()),
-                                      stdcxx::make_shared<protocol::TBinaryProtocolFactory>()));
+                                      std::make_shared<test::ParentServiceAsyncProcessor>(
+                                      std::make_shared<AsyncHandler>()),
+                                      std::make_shared<protocol::TBinaryProtocolFactory>()));
   QVERIFY(serverSocket->listen(QHostAddress::LocalHost));
   int port = serverSocket->serverPort();
   QVERIFY(port > 0);
@@ -74,9 +73,9 @@
   serverThread->start();
 
   // setup client
-  stdcxx::shared_ptr<QTcpSocket> socket = stdcxx::make_shared<QTcpSocket>();
-  client.reset(new test::ParentServiceClient(stdcxx::make_shared<protocol::TBinaryProtocol>(
-      stdcxx::make_shared<transport::TQIODeviceTransport>(socket))));
+  std::shared_ptr<QTcpSocket> socket = std::make_shared<QTcpSocket>();
+  client.reset(new test::ParentServiceClient(std::make_shared<protocol::TBinaryProtocol>(
+      std::make_shared<transport::TQIODeviceTransport>(socket))));
   socket->connectToHost(QHostAddress::LocalHost, port);
   QVERIFY(socket->waitForConnected());
 }
diff --git a/lib/php/src/ext/thrift_protocol/php_thrift_protocol.cpp b/lib/php/src/ext/thrift_protocol/php_thrift_protocol.cpp
index 63c8905..019e2a7 100644
--- a/lib/php/src/ext/thrift_protocol/php_thrift_protocol.cpp
+++ b/lib/php/src/ext/thrift_protocol/php_thrift_protocol.cpp
@@ -111,23 +111,23 @@
 
 class PHPExceptionWrapper : public std::exception {
 public:
-  PHPExceptionWrapper(zval* _ex) throw() {
+  PHPExceptionWrapper(zval* _ex) noexcept {
     ZVAL_COPY(&ex, _ex);
     snprintf(_what, 40, "PHP exception zval=%p", _ex);
   }
 
-  PHPExceptionWrapper(zend_object* _exobj) throw() {
+  PHPExceptionWrapper(zend_object* _exobj) noexcept {
     ZVAL_OBJ(&ex, _exobj);
     snprintf(_what, 40, "PHP exception zval=%p", _exobj);
   }
-  ~PHPExceptionWrapper() throw() {
+  ~PHPExceptionWrapper() noexcept {
     zval_dtor(&ex);
   }
 
-  const char* what() const throw() {
+  const char* what() const noexcept {
     return _what;
   }
-  operator zval*() const throw() {
+  operator zval*() const noexcept {
     return const_cast<zval*>(&ex);
   } // Zend API doesn't do 'const'...
 protected:
diff --git a/lib/py/src/ext/types.h b/lib/py/src/ext/types.h
index 5cd8dda..84933f4 100644
--- a/lib/py/src/ext/types.h
+++ b/lib/py/src/ext/types.h
@@ -89,19 +89,19 @@
     if (obj_)
       Py_DECREF(obj_);
   }
-  PyObject* get() throw() { return obj_; }
+  PyObject* get() noexcept { return obj_; }
   operator bool() { return obj_; }
-  void reset(PyObject* py_object) throw() {
+  void reset(PyObject* py_object) noexcept {
     if (obj_)
       Py_DECREF(obj_);
     obj_ = py_object;
   }
-  PyObject* release() throw() {
+  PyObject* release() noexcept {
     PyObject* tmp = obj_;
     obj_ = NULL;
     return tmp;
   }
-  void swap(ScopedPyObject& other) throw() {
+  void swap(ScopedPyObject& other) noexcept {
     ScopedPyObject tmp(other.release());
     other.reset(release());
     reset(tmp.release());
diff --git a/test/cpp/src/StressTest.cpp b/test/cpp/src/StressTest.cpp
index 5ff5e44..585f89a 100644
--- a/test/cpp/src/StressTest.cpp
+++ b/test/cpp/src/StressTest.cpp
@@ -31,7 +31,6 @@
 #include <thrift/transport/TTransportUtils.h>
 #include <thrift/transport/TFileTransport.h>
 #include <thrift/TLogging.h>
-#include <thrift/stdcxx.h>
 
 #include "Service.h"
 #include <iostream>
@@ -108,8 +107,8 @@
 };
 class ClientThread : public Runnable {
 public:
-  ClientThread(stdcxx::shared_ptr<TTransport> transport,
-               stdcxx::shared_ptr<ServiceIf> client,
+  ClientThread(std::shared_ptr<TTransport> transport,
+               std::shared_ptr<ServiceIf> client,
                Monitor& monitor,
                size_t& workerCount,
                size_t loopCount,
@@ -225,8 +224,8 @@
     }
   }
 
-  stdcxx::shared_ptr<TTransport> _transport;
-  stdcxx::shared_ptr<ServiceIf> _client;
+  std::shared_ptr<TTransport> _transport;
+  std::shared_ptr<ServiceIf> _client;
   Monitor& _monitor;
   size_t& _workerCount;
   size_t _loopCount;
@@ -391,24 +390,24 @@
     cerr << usage.str();
   }
 
-  stdcxx::shared_ptr<PlatformThreadFactory> threadFactory
-      = stdcxx::shared_ptr<PlatformThreadFactory>(new PlatformThreadFactory());
+  std::shared_ptr<PlatformThreadFactory> threadFactory
+      = std::shared_ptr<PlatformThreadFactory>(new PlatformThreadFactory());
 
   // Dispatcher
-  stdcxx::shared_ptr<Server> serviceHandler(new Server());
+  std::shared_ptr<Server> serviceHandler(new Server());
 
   if (replayRequests) {
-    stdcxx::shared_ptr<Server> serviceHandler(new Server());
-    stdcxx::shared_ptr<ServiceProcessor> serviceProcessor(new ServiceProcessor(serviceHandler));
+    std::shared_ptr<Server> serviceHandler(new Server());
+    std::shared_ptr<ServiceProcessor> serviceProcessor(new ServiceProcessor(serviceHandler));
 
     // Transports
-    stdcxx::shared_ptr<TFileTransport> fileTransport(new TFileTransport(requestLogPath));
+    std::shared_ptr<TFileTransport> fileTransport(new TFileTransport(requestLogPath));
     fileTransport->setChunkSize(2 * 1024 * 1024);
     fileTransport->setMaxEventSize(1024 * 16);
     fileTransport->seekToEnd();
 
     // Protocol Factory
-    stdcxx::shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());
+    std::shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());
 
     TFileProcessor fileProcessor(serviceProcessor, protocolFactory, fileTransport);
 
@@ -418,28 +417,28 @@
 
   if (runServer) {
 
-    stdcxx::shared_ptr<ServiceProcessor> serviceProcessor(new ServiceProcessor(serviceHandler));
+    std::shared_ptr<ServiceProcessor> serviceProcessor(new ServiceProcessor(serviceHandler));
 
     // Transport
-    stdcxx::shared_ptr<TServerSocket> serverSocket(new TServerSocket(port));
+    std::shared_ptr<TServerSocket> serverSocket(new TServerSocket(port));
 
     // Transport Factory
-    stdcxx::shared_ptr<TTransportFactory> transportFactory(new TBufferedTransportFactory());
+    std::shared_ptr<TTransportFactory> transportFactory(new TBufferedTransportFactory());
 
     // Protocol Factory
-    stdcxx::shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());
+    std::shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());
 
     if (logRequests) {
       // initialize the log file
-      stdcxx::shared_ptr<TFileTransport> fileTransport(new TFileTransport(requestLogPath));
+      std::shared_ptr<TFileTransport> fileTransport(new TFileTransport(requestLogPath));
       fileTransport->setChunkSize(2 * 1024 * 1024);
       fileTransport->setMaxEventSize(1024 * 16);
 
       transportFactory
-          = stdcxx::shared_ptr<TTransportFactory>(new TPipedTransportFactory(fileTransport));
+          = std::shared_ptr<TTransportFactory>(new TPipedTransportFactory(fileTransport));
     }
 
-    stdcxx::shared_ptr<TServer> server;
+    std::shared_ptr<TServer> server;
 
     if (serverType == "simple") {
 
@@ -453,7 +452,7 @@
 
     } else if (serverType == "thread-pool") {
 
-      stdcxx::shared_ptr<ThreadManager> threadManager
+      std::shared_ptr<ThreadManager> threadManager
           = ThreadManager::newSimpleThreadManager(workerCount);
 
       threadManager->threadFactory(threadFactory);
@@ -465,9 +464,9 @@
                                          threadManager));
     }
 
-    stdcxx::shared_ptr<TStartObserver> observer(new TStartObserver);
+    std::shared_ptr<TStartObserver> observer(new TStartObserver);
     server->setServerEventHandler(observer);
-    stdcxx::shared_ptr<Thread> serverThread = threadFactory->newThread(server);
+    std::shared_ptr<Thread> serverThread = threadFactory->newThread(server);
 
     cerr << "Starting the server on port " << port << endl;
 
@@ -486,7 +485,7 @@
 
     size_t threadCount = 0;
 
-    set<stdcxx::shared_ptr<Thread> > clientThreads;
+    set<std::shared_ptr<Thread> > clientThreads;
 
     if (callName == "echoVoid") {
       loopType = T_VOID;
@@ -505,28 +504,28 @@
     if(clientType == "regular") {
       for (size_t ix = 0; ix < clientCount; ix++) {
 
-        stdcxx::shared_ptr<TSocket> socket(new TSocket("127.0.0.1", port));
-        stdcxx::shared_ptr<TBufferedTransport> bufferedSocket(new TBufferedTransport(socket, 2048));
-        stdcxx::shared_ptr<TProtocol> protocol(new TBinaryProtocol(bufferedSocket));
-        stdcxx::shared_ptr<ServiceClient> serviceClient(new ServiceClient(protocol));
+        std::shared_ptr<TSocket> socket(new TSocket("127.0.0.1", port));
+        std::shared_ptr<TBufferedTransport> bufferedSocket(new TBufferedTransport(socket, 2048));
+        std::shared_ptr<TProtocol> protocol(new TBinaryProtocol(bufferedSocket));
+        std::shared_ptr<ServiceClient> serviceClient(new ServiceClient(protocol));
 
-        clientThreads.insert(threadFactory->newThread(stdcxx::shared_ptr<ClientThread>(
+        clientThreads.insert(threadFactory->newThread(std::shared_ptr<ClientThread>(
             new ClientThread(socket, serviceClient, monitor, threadCount, loopCount, loopType, OpenAndCloseTransportInThread))));
       }
     } else if(clientType == "concurrent") {
-      stdcxx::shared_ptr<TSocket> socket(new TSocket("127.0.0.1", port));
-      stdcxx::shared_ptr<TBufferedTransport> bufferedSocket(new TBufferedTransport(socket, 2048));
-      stdcxx::shared_ptr<TProtocol> protocol(new TBinaryProtocol(bufferedSocket));
-      //stdcxx::shared_ptr<ServiceClient> serviceClient(new ServiceClient(protocol));
-      stdcxx::shared_ptr<ServiceConcurrentClient> serviceClient(new ServiceConcurrentClient(protocol));
+      std::shared_ptr<TSocket> socket(new TSocket("127.0.0.1", port));
+      std::shared_ptr<TBufferedTransport> bufferedSocket(new TBufferedTransport(socket, 2048));
+      std::shared_ptr<TProtocol> protocol(new TBinaryProtocol(bufferedSocket));
+      //std::shared_ptr<ServiceClient> serviceClient(new ServiceClient(protocol));
+      std::shared_ptr<ServiceConcurrentClient> serviceClient(new ServiceConcurrentClient(protocol));
       socket->open();
       for (size_t ix = 0; ix < clientCount; ix++) {
-        clientThreads.insert(threadFactory->newThread(stdcxx::shared_ptr<ClientThread>(
+        clientThreads.insert(threadFactory->newThread(std::shared_ptr<ClientThread>(
             new ClientThread(socket, serviceClient, monitor, threadCount, loopCount, loopType, DontOpenAndCloseTransportInThread))));
       }
     }
 
-    for (std::set<stdcxx::shared_ptr<Thread> >::const_iterator thread = clientThreads.begin();
+    for (std::set<std::shared_ptr<Thread> >::const_iterator thread = clientThreads.begin();
          thread != clientThreads.end();
          thread++) {
       (*thread)->start();
@@ -559,12 +558,12 @@
     int64_t minTime = 9223372036854775807LL;
     int64_t maxTime = 0;
 
-    for (set<stdcxx::shared_ptr<Thread> >::iterator ix = clientThreads.begin();
+    for (set<std::shared_ptr<Thread> >::iterator ix = clientThreads.begin();
          ix != clientThreads.end();
          ix++) {
 
-      stdcxx::shared_ptr<ClientThread> client
-          = stdcxx::dynamic_pointer_cast<ClientThread>((*ix)->runnable());
+      std::shared_ptr<ClientThread> client
+          = std::dynamic_pointer_cast<ClientThread>((*ix)->runnable());
 
       int64_t delta = client->_endTime - client->_startTime;
 
diff --git a/test/cpp/src/StressTestNonBlocking.cpp b/test/cpp/src/StressTestNonBlocking.cpp
index e68988f..1d3ed73 100644
--- a/test/cpp/src/StressTestNonBlocking.cpp
+++ b/test/cpp/src/StressTestNonBlocking.cpp
@@ -33,7 +33,6 @@
 #include <thrift/transport/TTransportUtils.h>
 #include <thrift/transport/TFileTransport.h>
 #include <thrift/TLogging.h>
-#include <thrift/stdcxx.h>
 
 #include "Service.h"
 
@@ -109,8 +108,8 @@
 
 class ClientThread : public Runnable {
 public:
-  ClientThread(stdcxx::shared_ptr<TTransport> transport,
-               stdcxx::shared_ptr<ServiceClient> client,
+  ClientThread(std::shared_ptr<TTransport> transport,
+               std::shared_ptr<ServiceClient> client,
                Monitor& monitor,
                size_t& workerCount,
                size_t loopCount,
@@ -221,8 +220,8 @@
     }
   }
 
-  stdcxx::shared_ptr<TTransport> _transport;
-  stdcxx::shared_ptr<ServiceClient> _client;
+  std::shared_ptr<TTransport> _transport;
+  std::shared_ptr<ServiceClient> _client;
   Monitor& _monitor;
   size_t& _workerCount;
   size_t _loopCount;
@@ -344,24 +343,24 @@
     cerr << usage.str();
   }
 
-  stdcxx::shared_ptr<PlatformThreadFactory> threadFactory
-      = stdcxx::shared_ptr<PlatformThreadFactory>(new PlatformThreadFactory());
+  std::shared_ptr<PlatformThreadFactory> threadFactory
+      = std::shared_ptr<PlatformThreadFactory>(new PlatformThreadFactory());
 
   // Dispatcher
-  stdcxx::shared_ptr<Server> serviceHandler(new Server());
+  std::shared_ptr<Server> serviceHandler(new Server());
 
   if (replayRequests) {
-    stdcxx::shared_ptr<Server> serviceHandler(new Server());
-    stdcxx::shared_ptr<ServiceProcessor> serviceProcessor(new ServiceProcessor(serviceHandler));
+    std::shared_ptr<Server> serviceHandler(new Server());
+    std::shared_ptr<ServiceProcessor> serviceProcessor(new ServiceProcessor(serviceHandler));
 
     // Transports
-    stdcxx::shared_ptr<TFileTransport> fileTransport(new TFileTransport(requestLogPath));
+    std::shared_ptr<TFileTransport> fileTransport(new TFileTransport(requestLogPath));
     fileTransport->setChunkSize(2 * 1024 * 1024);
     fileTransport->setMaxEventSize(1024 * 16);
     fileTransport->seekToEnd();
 
     // Protocol Factory
-    stdcxx::shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());
+    std::shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());
 
     TFileProcessor fileProcessor(serviceProcessor, protocolFactory, fileTransport);
 
@@ -371,50 +370,50 @@
 
   if (runServer) {
 
-    stdcxx::shared_ptr<ServiceProcessor> serviceProcessor(new ServiceProcessor(serviceHandler));
+    std::shared_ptr<ServiceProcessor> serviceProcessor(new ServiceProcessor(serviceHandler));
 
     // Protocol Factory
-    stdcxx::shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());
+    std::shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());
 
     // Transport Factory
-    stdcxx::shared_ptr<TTransportFactory> transportFactory;
+    std::shared_ptr<TTransportFactory> transportFactory;
 
     if (logRequests) {
       // initialize the log file
-      stdcxx::shared_ptr<TFileTransport> fileTransport(new TFileTransport(requestLogPath));
+      std::shared_ptr<TFileTransport> fileTransport(new TFileTransport(requestLogPath));
       fileTransport->setChunkSize(2 * 1024 * 1024);
       fileTransport->setMaxEventSize(1024 * 16);
 
       transportFactory
-          = stdcxx::shared_ptr<TTransportFactory>(new TPipedTransportFactory(fileTransport));
+          = std::shared_ptr<TTransportFactory>(new TPipedTransportFactory(fileTransport));
     }
 
-    stdcxx::shared_ptr<Thread> serverThread;
-    stdcxx::shared_ptr<Thread> serverThread2;
-    stdcxx::shared_ptr<transport::TNonblockingServerSocket> nbSocket1;
-    stdcxx::shared_ptr<transport::TNonblockingServerSocket> nbSocket2;
+    std::shared_ptr<Thread> serverThread;
+    std::shared_ptr<Thread> serverThread2;
+    std::shared_ptr<transport::TNonblockingServerSocket> nbSocket1;
+    std::shared_ptr<transport::TNonblockingServerSocket> nbSocket2;
 
     if (serverType == "simple") {
 
       nbSocket1.reset(new transport::TNonblockingServerSocket(port));
-      serverThread = threadFactory->newThread(stdcxx::shared_ptr<TServer>(
+      serverThread = threadFactory->newThread(std::shared_ptr<TServer>(
           new TNonblockingServer(serviceProcessor, protocolFactory, nbSocket1)));
       nbSocket2.reset(new transport::TNonblockingServerSocket(port + 1));
-      serverThread2 = threadFactory->newThread(stdcxx::shared_ptr<TServer>(
+      serverThread2 = threadFactory->newThread(std::shared_ptr<TServer>(
           new TNonblockingServer(serviceProcessor, protocolFactory, nbSocket2)));
 
     } else if (serverType == "thread-pool") {
 
-      stdcxx::shared_ptr<ThreadManager> threadManager
+      std::shared_ptr<ThreadManager> threadManager
           = ThreadManager::newSimpleThreadManager(workerCount);
 
       threadManager->threadFactory(threadFactory);
       threadManager->start();
       nbSocket1.reset(new transport::TNonblockingServerSocket(port));
-      serverThread = threadFactory->newThread(stdcxx::shared_ptr<TServer>(
+      serverThread = threadFactory->newThread(std::shared_ptr<TServer>(
           new TNonblockingServer(serviceProcessor, protocolFactory, nbSocket1, threadManager)));
       nbSocket2.reset(new transport::TNonblockingServerSocket(port + 1));
-      serverThread2 = threadFactory->newThread(stdcxx::shared_ptr<TServer>(
+      serverThread2 = threadFactory->newThread(std::shared_ptr<TServer>(
           new TNonblockingServer(serviceProcessor, protocolFactory, nbSocket2, threadManager)));
     }
 
@@ -437,7 +436,7 @@
 
     size_t threadCount = 0;
 
-    set<stdcxx::shared_ptr<Thread> > clientThreads;
+    set<std::shared_ptr<Thread> > clientThreads;
 
     if (callName == "echoVoid") {
       loopType = T_VOID;
@@ -455,16 +454,16 @@
 
     for (uint32_t ix = 0; ix < clientCount; ix++) {
 
-      stdcxx::shared_ptr<TSocket> socket(new TSocket("127.0.0.1", port + (ix % 2)));
-      stdcxx::shared_ptr<TFramedTransport> framedSocket(new TFramedTransport(socket));
-      stdcxx::shared_ptr<TProtocol> protocol(new TBinaryProtocol(framedSocket));
-      stdcxx::shared_ptr<ServiceClient> serviceClient(new ServiceClient(protocol));
+      std::shared_ptr<TSocket> socket(new TSocket("127.0.0.1", port + (ix % 2)));
+      std::shared_ptr<TFramedTransport> framedSocket(new TFramedTransport(socket));
+      std::shared_ptr<TProtocol> protocol(new TBinaryProtocol(framedSocket));
+      std::shared_ptr<ServiceClient> serviceClient(new ServiceClient(protocol));
 
-      clientThreads.insert(threadFactory->newThread(stdcxx::shared_ptr<ClientThread>(
+      clientThreads.insert(threadFactory->newThread(std::shared_ptr<ClientThread>(
           new ClientThread(socket, serviceClient, monitor, threadCount, loopCount, loopType))));
     }
 
-    for (std::set<stdcxx::shared_ptr<Thread> >::const_iterator thread = clientThreads.begin();
+    for (std::set<std::shared_ptr<Thread> >::const_iterator thread = clientThreads.begin();
          thread != clientThreads.end();
          thread++) {
       (*thread)->start();
@@ -497,12 +496,12 @@
     int64_t minTime = 9223372036854775807LL;
     int64_t maxTime = 0;
 
-    for (set<stdcxx::shared_ptr<Thread> >::iterator ix = clientThreads.begin();
+    for (set<std::shared_ptr<Thread> >::iterator ix = clientThreads.begin();
          ix != clientThreads.end();
          ix++) {
 
-      stdcxx::shared_ptr<ClientThread> client
-          = stdcxx::dynamic_pointer_cast<ClientThread>((*ix)->runnable());
+      std::shared_ptr<ClientThread> client
+          = std::dynamic_pointer_cast<ClientThread>((*ix)->runnable());
 
       int64_t delta = client->_endTime - client->_startTime;
 
diff --git a/test/cpp/src/TestClient.cpp b/test/cpp/src/TestClient.cpp
index ca21326..89f3fd1 100644
--- a/test/cpp/src/TestClient.cpp
+++ b/test/cpp/src/TestClient.cpp
@@ -46,7 +46,6 @@
 #include <boost/filesystem.hpp>
 #include <boost/program_options.hpp>
 #include <boost/random/random_device.hpp>
-#include <thrift/stdcxx.h>
 #if _WIN32
 #include <thrift/windows/TWinsockSingleton.h>
 #endif
@@ -98,10 +97,10 @@
     for (int testNr = 0; testNr < 10; ++testNr) {
       std::ostringstream os;
       os << "test" << testNr;
-      client->testString(stdcxx::bind(testString_clientReturn,
+      client->testString(std::bind(testString_clientReturn,
                                     base,
                                     testNr,
-                                    stdcxx::placeholders::_1),
+                                    std::placeholders::_1),
                        os.str());
     }
   } catch (TException& exn) {
@@ -254,18 +253,18 @@
   }
 
   // THRIFT-4164: The factory MUST outlive any sockets it creates for correct behavior!
-  stdcxx::shared_ptr<TSSLSocketFactory> factory;
-  stdcxx::shared_ptr<TSocket> socket;
-  stdcxx::shared_ptr<TTransport> transport;
-  stdcxx::shared_ptr<TProtocol> protocol;
-  stdcxx::shared_ptr<TProtocol> protocol2;  // SecondService for multiplexed
+  std::shared_ptr<TSSLSocketFactory> factory;
+  std::shared_ptr<TSocket> socket;
+  std::shared_ptr<TTransport> transport;
+  std::shared_ptr<TProtocol> protocol;
+  std::shared_ptr<TProtocol> protocol2;  // SecondService for multiplexed
 
   if (ssl) {
     cout << "Client Certificate File: " << certPath << endl;
     cout << "Client Key         File: " << keyPath << endl;
     cout << "CA                 File: " << caPath << endl;
 
-    factory = stdcxx::shared_ptr<TSSLSocketFactory>(new TSSLSocketFactory());
+    factory = std::shared_ptr<TSSLSocketFactory>(new TSSLSocketFactory());
     factory->ciphers("ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
     factory->loadTrustedCertificates(caPath.c_str());
     factory->loadCertificate(certPath.c_str());
@@ -277,42 +276,42 @@
       if (abstract_namespace) {
         std::string abstract_socket("\0", 1);
         abstract_socket += domain_socket;
-        socket = stdcxx::shared_ptr<TSocket>(new TSocket(abstract_socket));
+        socket = std::shared_ptr<TSocket>(new TSocket(abstract_socket));
       } else {
-        socket = stdcxx::shared_ptr<TSocket>(new TSocket(domain_socket));
+        socket = std::shared_ptr<TSocket>(new TSocket(domain_socket));
       }
       port = 0;
     } else {
-      socket = stdcxx::shared_ptr<TSocket>(new TSocket(host, port));
+      socket = std::shared_ptr<TSocket>(new TSocket(host, port));
     }
   }
 
   if (transport_type.compare("http") == 0) {
-    transport = stdcxx::make_shared<THttpClient>(socket, host, "/service");
+    transport = std::make_shared<THttpClient>(socket, host, "/service");
   } else if (transport_type.compare("framed") == 0) {
-    transport = stdcxx::make_shared<TFramedTransport>(socket);
+    transport = std::make_shared<TFramedTransport>(socket);
   } else {
-    transport = stdcxx::make_shared<TBufferedTransport>(socket);
+    transport = std::make_shared<TBufferedTransport>(socket);
   }
 
   if (zlib) {
-    transport = stdcxx::make_shared<TZlibTransport>(transport);
+    transport = std::make_shared<TZlibTransport>(transport);
   }
 
   if (protocol_type == "json" || protocol_type == "multij") {
-    protocol = stdcxx::make_shared<TJSONProtocol>(transport);
+    protocol = std::make_shared<TJSONProtocol>(transport);
   } else if (protocol_type == "compact" || protocol_type == "multic") {
-    protocol = stdcxx::make_shared<TCompactProtocol>(transport);
+    protocol = std::make_shared<TCompactProtocol>(transport);
   } else if (protocol_type == "header" || protocol_type == "multih") {
-    protocol = stdcxx::make_shared<THeaderProtocol>(transport);
+    protocol = std::make_shared<THeaderProtocol>(transport);
   } else {
-    protocol = stdcxx::make_shared<TBinaryProtocol>(transport);
+    protocol = std::make_shared<TBinaryProtocol>(transport);
   }
 
   if (boost::starts_with(protocol_type, "multi")) {
-  protocol2 = stdcxx::make_shared<TMultiplexedProtocol>(protocol, "SecondService");
+  protocol2 = std::make_shared<TMultiplexedProtocol>(protocol, "SecondService");
   // we don't need access to the original protocol any more, so...
-  protocol = stdcxx::make_shared<TMultiplexedProtocol>(protocol, "ThriftTest");
+  protocol = std::make_shared<TMultiplexedProtocol>(protocol, "ThriftTest");
   }
 
   // Connection info
@@ -334,14 +333,14 @@
     cout << "Libevent Features: 0x" << hex << event_base_get_features(base) << endl;
 #endif
 
-    stdcxx::shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());
+    std::shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());
 
-    stdcxx::shared_ptr<TAsyncChannel> channel(
+    std::shared_ptr<TAsyncChannel> channel(
         new TEvhttpClientChannel(host.c_str(), "/", host.c_str(), port, base));
     ThriftTestCobClient* client = new ThriftTestCobClient(channel, protocolFactory.get());
-    client->testVoid(stdcxx::bind(testVoid_clientReturn,
+    client->testVoid(std::bind(testVoid_clientReturn,
                                 base,
-                                stdcxx::placeholders::_1));
+                                std::placeholders::_1));
 
     event_base_loop(base, 0);
     return 0;
diff --git a/test/cpp/src/TestServer.cpp b/test/cpp/src/TestServer.cpp
index 323f873..6222017 100644
--- a/test/cpp/src/TestServer.cpp
+++ b/test/cpp/src/TestServer.cpp
@@ -61,7 +61,6 @@
 #include <boost/algorithm/string.hpp>
 #include <boost/program_options.hpp>
 #include <boost/filesystem.hpp>
-#include <thrift/stdcxx.h>
 
 #if _WIN32
 #include <thrift/windows/TWinsockSingleton.h>
@@ -395,66 +394,66 @@
 
 class TestHandlerAsync : public ThriftTestCobSvIf {
 public:
-  TestHandlerAsync(stdcxx::shared_ptr<TestHandler>& handler) : _delegate(handler) {}
+  TestHandlerAsync(std::shared_ptr<TestHandler>& handler) : _delegate(handler) {}
   virtual ~TestHandlerAsync() {}
 
-  virtual void testVoid(stdcxx::function<void()> cob) {
+  virtual void testVoid(std::function<void()> cob) {
     _delegate->testVoid();
     cob();
   }
 
-  virtual void testString(stdcxx::function<void(std::string const& _return)> cob,
+  virtual void testString(std::function<void(std::string const& _return)> cob,
                           const std::string& thing) {
     std::string res;
     _delegate->testString(res, thing);
     cob(res);
   }
 
-  virtual void testBool(stdcxx::function<void(bool const& _return)> cob, const bool thing) {
+  virtual void testBool(std::function<void(bool const& _return)> cob, const bool thing) {
     bool res = _delegate->testBool(thing);
     cob(res);
   }
 
-  virtual void testByte(stdcxx::function<void(int8_t const& _return)> cob, const int8_t thing) {
+  virtual void testByte(std::function<void(int8_t const& _return)> cob, const int8_t thing) {
     int8_t res = _delegate->testByte(thing);
     cob(res);
   }
 
-  virtual void testI32(stdcxx::function<void(int32_t const& _return)> cob, const int32_t thing) {
+  virtual void testI32(std::function<void(int32_t const& _return)> cob, const int32_t thing) {
     int32_t res = _delegate->testI32(thing);
     cob(res);
   }
 
-  virtual void testI64(stdcxx::function<void(int64_t const& _return)> cob, const int64_t thing) {
+  virtual void testI64(std::function<void(int64_t const& _return)> cob, const int64_t thing) {
     int64_t res = _delegate->testI64(thing);
     cob(res);
   }
 
-  virtual void testDouble(stdcxx::function<void(double const& _return)> cob, const double thing) {
+  virtual void testDouble(std::function<void(double const& _return)> cob, const double thing) {
     double res = _delegate->testDouble(thing);
     cob(res);
   }
 
-  virtual void testBinary(stdcxx::function<void(std::string const& _return)> cob,
+  virtual void testBinary(std::function<void(std::string const& _return)> cob,
                           const std::string& thing) {
     std::string res;
     _delegate->testBinary(res, thing);
     cob(res);
   }
 
-  virtual void testStruct(stdcxx::function<void(Xtruct const& _return)> cob, const Xtruct& thing) {
+  virtual void testStruct(std::function<void(Xtruct const& _return)> cob, const Xtruct& thing) {
     Xtruct res;
     _delegate->testStruct(res, thing);
     cob(res);
   }
 
-  virtual void testNest(stdcxx::function<void(Xtruct2 const& _return)> cob, const Xtruct2& thing) {
+  virtual void testNest(std::function<void(Xtruct2 const& _return)> cob, const Xtruct2& thing) {
     Xtruct2 res;
     _delegate->testNest(res, thing);
     cob(res);
   }
 
-  virtual void testMap(stdcxx::function<void(std::map<int32_t, int32_t> const& _return)> cob,
+  virtual void testMap(std::function<void(std::map<int32_t, int32_t> const& _return)> cob,
                        const std::map<int32_t, int32_t>& thing) {
     std::map<int32_t, int32_t> res;
     _delegate->testMap(res, thing);
@@ -462,40 +461,40 @@
   }
 
   virtual void testStringMap(
-      stdcxx::function<void(std::map<std::string, std::string> const& _return)> cob,
+      std::function<void(std::map<std::string, std::string> const& _return)> cob,
       const std::map<std::string, std::string>& thing) {
     std::map<std::string, std::string> res;
     _delegate->testStringMap(res, thing);
     cob(res);
   }
 
-  virtual void testSet(stdcxx::function<void(std::set<int32_t> const& _return)> cob,
+  virtual void testSet(std::function<void(std::set<int32_t> const& _return)> cob,
                        const std::set<int32_t>& thing) {
     std::set<int32_t> res;
     _delegate->testSet(res, thing);
     cob(res);
   }
 
-  virtual void testList(stdcxx::function<void(std::vector<int32_t> const& _return)> cob,
+  virtual void testList(std::function<void(std::vector<int32_t> const& _return)> cob,
                         const std::vector<int32_t>& thing) {
     std::vector<int32_t> res;
     _delegate->testList(res, thing);
     cob(res);
   }
 
-  virtual void testEnum(stdcxx::function<void(Numberz::type const& _return)> cob,
+  virtual void testEnum(std::function<void(Numberz::type const& _return)> cob,
                         const Numberz::type thing) {
     Numberz::type res = _delegate->testEnum(thing);
     cob(res);
   }
 
-  virtual void testTypedef(stdcxx::function<void(UserId const& _return)> cob, const UserId thing) {
+  virtual void testTypedef(std::function<void(UserId const& _return)> cob, const UserId thing) {
     UserId res = _delegate->testTypedef(thing);
     cob(res);
   }
 
   virtual void testMapMap(
-      stdcxx::function<void(std::map<int32_t, std::map<int32_t, int32_t> > const& _return)> cob,
+      std::function<void(std::map<int32_t, std::map<int32_t, int32_t> > const& _return)> cob,
       const int32_t hello) {
     std::map<int32_t, std::map<int32_t, int32_t> > res;
     _delegate->testMapMap(res, hello);
@@ -503,14 +502,14 @@
   }
 
   virtual void testInsanity(
-      stdcxx::function<void(std::map<UserId, std::map<Numberz::type, Insanity> > const& _return)> cob,
+      std::function<void(std::map<UserId, std::map<Numberz::type, Insanity> > const& _return)> cob,
       const Insanity& argument) {
     std::map<UserId, std::map<Numberz::type, Insanity> > res;
     _delegate->testInsanity(res, argument);
     cob(res);
   }
 
-  virtual void testMulti(stdcxx::function<void(Xtruct const& _return)> cob,
+  virtual void testMulti(std::function<void(Xtruct const& _return)> cob,
                          const int8_t arg0,
                          const int32_t arg1,
                          const int64_t arg2,
@@ -523,8 +522,8 @@
   }
 
   virtual void testException(
-      stdcxx::function<void()> cob,
-      stdcxx::function<void(::apache::thrift::TDelayedException* _throw)> exn_cob,
+      std::function<void()> cob,
+      std::function<void(::apache::thrift::TDelayedException* _throw)> exn_cob,
       const std::string& arg) {
     try {
       _delegate->testException(arg);
@@ -536,8 +535,8 @@
   }
 
   virtual void testMultiException(
-      stdcxx::function<void(Xtruct const& _return)> cob,
-      stdcxx::function<void(::apache::thrift::TDelayedException* _throw)> exn_cob,
+      std::function<void(Xtruct const& _return)> cob,
+      std::function<void(::apache::thrift::TDelayedException* _throw)> exn_cob,
       const std::string& arg0,
       const std::string& arg1) {
     Xtruct res;
@@ -550,13 +549,13 @@
     cob(res);
   }
 
-  virtual void testOneway(stdcxx::function<void()> cob, const int32_t secondsToSleep) {
+  virtual void testOneway(std::function<void()> cob, const int32_t secondsToSleep) {
     _delegate->testOneway(secondsToSleep);
     cob();
   }
 
 protected:
-  stdcxx::shared_ptr<TestHandler> _delegate;
+  std::shared_ptr<TestHandler> _delegate;
 };
 
 namespace po = boost::program_options;
@@ -668,9 +667,9 @@
   }
 
   // Dispatcher
-  stdcxx::shared_ptr<TProtocolFactory> protocolFactory;
+  std::shared_ptr<TProtocolFactory> protocolFactory;
   if (protocol_type == "json" || protocol_type == "multij") {
-    stdcxx::shared_ptr<TProtocolFactory> jsonProtocolFactory(new TJSONProtocolFactory());
+    std::shared_ptr<TProtocolFactory> jsonProtocolFactory(new TJSONProtocolFactory());
     protocolFactory = jsonProtocolFactory;
   } else if (protocol_type == "compact" || protocol_type == "multic") {
     TCompactProtocolFactoryT<TBufferBase> *compactProtocolFactory = new TCompactProtocolFactoryT<TBufferBase>();
@@ -678,7 +677,7 @@
     compactProtocolFactory->setStringSizeLimit(string_limit);
     protocolFactory.reset(compactProtocolFactory);
   } else if (protocol_type == "header" || protocol_type == "multih") {
-    stdcxx::shared_ptr<TProtocolFactory> headerProtocolFactory(new THeaderProtocolFactory());
+    std::shared_ptr<TProtocolFactory> headerProtocolFactory(new THeaderProtocolFactory());
     protocolFactory = headerProtocolFactory;
   } else {
     TBinaryProtocolFactoryT<TBufferBase>* binaryProtocolFactory = new TBinaryProtocolFactoryT<TBufferBase>();
@@ -688,56 +687,56 @@
   }
 
   // Processors
-  stdcxx::shared_ptr<TestHandler> testHandler(new TestHandler());
-  stdcxx::shared_ptr<TProcessor> testProcessor(new ThriftTestProcessor(testHandler));
+  std::shared_ptr<TestHandler> testHandler(new TestHandler());
+  std::shared_ptr<TProcessor> testProcessor(new ThriftTestProcessor(testHandler));
 
   if (vm.count("processor-events")) {
     testProcessor->setEventHandler(
-        stdcxx::shared_ptr<TProcessorEventHandler>(new TestProcessorEventHandler()));
+        std::shared_ptr<TProcessorEventHandler>(new TestProcessorEventHandler()));
   }
 
   // Transport
-  stdcxx::shared_ptr<TSSLSocketFactory> sslSocketFactory;
-  stdcxx::shared_ptr<TServerSocket> serverSocket;
+  std::shared_ptr<TSSLSocketFactory> sslSocketFactory;
+  std::shared_ptr<TServerSocket> serverSocket;
 
   if (ssl) {
-    sslSocketFactory = stdcxx::shared_ptr<TSSLSocketFactory>(new TSSLSocketFactory());
+    sslSocketFactory = std::shared_ptr<TSSLSocketFactory>(new TSSLSocketFactory());
     sslSocketFactory->loadCertificate(certPath.c_str());
     sslSocketFactory->loadPrivateKey(keyPath.c_str());
     sslSocketFactory->ciphers("ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
     if (server_type != "nonblocking") {
-      serverSocket = stdcxx::shared_ptr<TServerSocket>(new TSSLServerSocket(port, sslSocketFactory));
+      serverSocket = std::shared_ptr<TServerSocket>(new TSSLServerSocket(port, sslSocketFactory));
     }
   } else {
     if (domain_socket != "") {
       if (abstract_namespace) {
         std::string abstract_socket("\0", 1);
         abstract_socket += domain_socket;
-        serverSocket = stdcxx::shared_ptr<TServerSocket>(new TServerSocket(abstract_socket));
+        serverSocket = std::shared_ptr<TServerSocket>(new TServerSocket(abstract_socket));
       } else {
         unlink(domain_socket.c_str());
-        serverSocket = stdcxx::shared_ptr<TServerSocket>(new TServerSocket(domain_socket));
+        serverSocket = std::shared_ptr<TServerSocket>(new TServerSocket(domain_socket));
       }
       port = 0;
     } else {
-      serverSocket = stdcxx::shared_ptr<TServerSocket>(new TServerSocket(port));
+      serverSocket = std::shared_ptr<TServerSocket>(new TServerSocket(port));
     }
   }
 
   // Factory
-  stdcxx::shared_ptr<TTransportFactory> transportFactory;
+  std::shared_ptr<TTransportFactory> transportFactory;
 
   if (transport_type == "http" && server_type != "nonblocking") {
-    transportFactory = stdcxx::make_shared<THttpServerTransportFactory>();
+    transportFactory = std::make_shared<THttpServerTransportFactory>();
   } else if (transport_type == "framed") {
-    transportFactory = stdcxx::make_shared<TFramedTransportFactory>();
+    transportFactory = std::make_shared<TFramedTransportFactory>();
   } else {
-    transportFactory = stdcxx::make_shared<TBufferedTransportFactory>();
+    transportFactory = std::make_shared<TBufferedTransportFactory>();
   }
 
   if (zlib) {
     // hmm.. doesn't seem to be a way to make it wrap the others...
-    transportFactory = stdcxx::make_shared<TZlibTransportFactory>();
+    transportFactory = std::make_shared<TZlibTransportFactory>();
   }
 
   // Server Info
@@ -754,27 +753,27 @@
 
   // Multiplexed Processor if needed
   if (boost::starts_with(protocol_type, "multi")) {
-    stdcxx::shared_ptr<SecondHandler> secondHandler(new SecondHandler());
-    stdcxx::shared_ptr<SecondServiceProcessor> secondProcessor(new SecondServiceProcessor(secondHandler));
+    std::shared_ptr<SecondHandler> secondHandler(new SecondHandler());
+    std::shared_ptr<SecondServiceProcessor> secondProcessor(new SecondServiceProcessor(secondHandler));
 
-    stdcxx::shared_ptr<TMultiplexedProcessor> multiplexedProcessor(new TMultiplexedProcessor());
+    std::shared_ptr<TMultiplexedProcessor> multiplexedProcessor(new TMultiplexedProcessor());
     multiplexedProcessor->registerDefault(testProcessor); // non-multi clients go to the default processor (multi:binary, multic:compact, ...)
     multiplexedProcessor->registerProcessor("ThriftTest", testProcessor);
     multiplexedProcessor->registerProcessor("SecondService", secondProcessor);
-    testProcessor = stdcxx::dynamic_pointer_cast<TProcessor>(multiplexedProcessor);
+    testProcessor = std::dynamic_pointer_cast<TProcessor>(multiplexedProcessor);
   }
 
   // Server
-  stdcxx::shared_ptr<apache::thrift::server::TServer> server;
+  std::shared_ptr<apache::thrift::server::TServer> server;
 
   if (server_type == "simple") {
     server.reset(new TSimpleServer(testProcessor, serverSocket, transportFactory, protocolFactory));
   } else if (server_type == "thread-pool") {
 
-    stdcxx::shared_ptr<PlatformThreadFactory> threadFactory
-        = stdcxx::shared_ptr<PlatformThreadFactory>(new PlatformThreadFactory());
+    std::shared_ptr<PlatformThreadFactory> threadFactory
+        = std::shared_ptr<PlatformThreadFactory>(new PlatformThreadFactory());
 
-    stdcxx::shared_ptr<ThreadManager> threadManager = ThreadManager::newSimpleThreadManager(workers);
+    std::shared_ptr<ThreadManager> threadManager = ThreadManager::newSimpleThreadManager(workers);
     threadManager->threadFactory(threadFactory);
     threadManager->start();
 
@@ -788,10 +787,10 @@
         new TThreadedServer(testProcessor, serverSocket, transportFactory, protocolFactory));
   } else if (server_type == "nonblocking") {
     if (transport_type == "http") {
-      stdcxx::shared_ptr<TestHandlerAsync> testHandlerAsync(new TestHandlerAsync(testHandler));
-      stdcxx::shared_ptr<TAsyncProcessor> testProcessorAsync(
+      std::shared_ptr<TestHandlerAsync> testHandlerAsync(new TestHandlerAsync(testHandler));
+      std::shared_ptr<TAsyncProcessor> testProcessorAsync(
           new ThriftTestAsyncProcessor(testHandlerAsync));
-      stdcxx::shared_ptr<TAsyncBufferProcessor> testBufferProcessor(
+      std::shared_ptr<TAsyncBufferProcessor> testBufferProcessor(
           new TAsyncProtocolProcessor(testProcessorAsync, protocolFactory));
 
       // not loading nonblockingServer into "server" because
@@ -800,7 +799,7 @@
       TEvhttpServer nonblockingServer(testBufferProcessor, port);
       nonblockingServer.serve();
     } else if (transport_type == "framed") {
-      stdcxx::shared_ptr<transport::TNonblockingServerTransport> nbSocket;
+      std::shared_ptr<transport::TNonblockingServerTransport> nbSocket;
       nbSocket.reset(
           ssl ? new transport::TNonblockingSSLServerSocket(port, sslSocketFactory)
               : new transport::TNonblockingServerSocket(port));
@@ -815,13 +814,13 @@
     if (protocol_type == "header") {
       // Tell the server to use the same protocol for input / output
       // if using header
-      server->setOutputProtocolFactory(stdcxx::shared_ptr<TProtocolFactory>());
+      server->setOutputProtocolFactory(std::shared_ptr<TProtocolFactory>());
     }
     
     apache::thrift::concurrency::PlatformThreadFactory factory;
     factory.setDetached(false);
-    stdcxx::shared_ptr<apache::thrift::concurrency::Runnable> serverThreadRunner(server);
-    stdcxx::shared_ptr<apache::thrift::concurrency::Thread> thread
+    std::shared_ptr<apache::thrift::concurrency::Runnable> serverThreadRunner(server);
+    std::shared_ptr<apache::thrift::concurrency::Thread> thread
         = factory.newThread(serverThreadRunner);
 
 #ifdef HAVE_SIGNAL_H
diff --git a/tutorial/cpp/CppClient.cpp b/tutorial/cpp/CppClient.cpp
index f10c725..5208411 100644
--- a/tutorial/cpp/CppClient.cpp
+++ b/tutorial/cpp/CppClient.cpp
@@ -22,7 +22,6 @@
 #include <thrift/protocol/TBinaryProtocol.h>
 #include <thrift/transport/TSocket.h>
 #include <thrift/transport/TTransportUtils.h>
-#include <thrift/stdcxx.h>
 
 #include "../gen-cpp/Calculator.h"
 
@@ -35,9 +34,9 @@
 using namespace shared;
 
 int main() {
-  stdcxx::shared_ptr<TTransport> socket(new TSocket("localhost", 9090));
-  stdcxx::shared_ptr<TTransport> transport(new TBufferedTransport(socket));
-  stdcxx::shared_ptr<TProtocol> protocol(new TBinaryProtocol(transport));
+  std::shared_ptr<TTransport> socket(new TSocket("localhost", 9090));
+  std::shared_ptr<TTransport> transport(new TBufferedTransport(socket));
+  std::shared_ptr<TProtocol> protocol(new TBinaryProtocol(transport));
   CalculatorClient client(protocol);
 
   try {
diff --git a/tutorial/cpp/CppServer.cpp b/tutorial/cpp/CppServer.cpp
index 80b100e..f7379d5 100644
--- a/tutorial/cpp/CppServer.cpp
+++ b/tutorial/cpp/CppServer.cpp
@@ -27,7 +27,6 @@
 #include <thrift/transport/TSocket.h>
 #include <thrift/transport/TTransportUtils.h>
 #include <thrift/TToString.h>
-#include <thrift/stdcxx.h>
 
 #include <iostream>
 #include <stdexcept>
@@ -117,7 +116,7 @@
   virtual ~CalculatorCloneFactory() {}
   virtual CalculatorIf* getHandler(const ::apache::thrift::TConnectionInfo& connInfo)
   {
-    stdcxx::shared_ptr<TSocket> sock = stdcxx::dynamic_pointer_cast<TSocket>(connInfo.transport);
+    std::shared_ptr<TSocket> sock = std::dynamic_pointer_cast<TSocket>(connInfo.transport);
     cout << "Incoming connection\n";
     cout << "\tSocketInfo: "  << sock->getSocketInfo() << "\n";
     cout << "\tPeerHost: "    << sock->getPeerHost() << "\n";
@@ -132,18 +131,18 @@
 
 int main() {
   TThreadedServer server(
-    stdcxx::make_shared<CalculatorProcessorFactory>(stdcxx::make_shared<CalculatorCloneFactory>()),
-    stdcxx::make_shared<TServerSocket>(9090), //port
-    stdcxx::make_shared<TBufferedTransportFactory>(),
-    stdcxx::make_shared<TBinaryProtocolFactory>());
+    std::make_shared<CalculatorProcessorFactory>(std::make_shared<CalculatorCloneFactory>()),
+    std::make_shared<TServerSocket>(9090), //port
+    std::make_shared<TBufferedTransportFactory>(),
+    std::make_shared<TBinaryProtocolFactory>());
 
   /*
   // if you don't need per-connection state, do the following instead
   TThreadedServer server(
-    stdcxx::make_shared<CalculatorProcessor>(stdcxx::make_shared<CalculatorHandler>()),
-    stdcxx::make_shared<TServerSocket>(9090), //port
-    stdcxx::make_shared<TBufferedTransportFactory>(),
-    stdcxx::make_shared<TBinaryProtocolFactory>());
+    std::make_shared<CalculatorProcessor>(std::make_shared<CalculatorHandler>()),
+    std::make_shared<TServerSocket>(9090), //port
+    std::make_shared<TBufferedTransportFactory>(),
+    std::make_shared<TBinaryProtocolFactory>());
   */
 
   /**
@@ -151,25 +150,25 @@
 
   // This server only allows one connection at a time, but spawns no threads
   TSimpleServer server(
-    stdcxx::make_shared<CalculatorProcessor>(stdcxx::make_shared<CalculatorHandler>()),
-    stdcxx::make_shared<TServerSocket>(9090),
-    stdcxx::make_shared<TBufferedTransportFactory>(),
-    stdcxx::make_shared<TBinaryProtocolFactory>());
+    std::make_shared<CalculatorProcessor>(std::make_shared<CalculatorHandler>()),
+    std::make_shared<TServerSocket>(9090),
+    std::make_shared<TBufferedTransportFactory>(),
+    std::make_shared<TBinaryProtocolFactory>());
 
   const int workerCount = 4;
 
-  stdcxx::shared_ptr<ThreadManager> threadManager =
+  std::shared_ptr<ThreadManager> threadManager =
     ThreadManager::newSimpleThreadManager(workerCount);
   threadManager->threadFactory(
-    stdcxx::make_shared<PlatformThreadFactory>());
+    std::make_shared<PlatformThreadFactory>());
   threadManager->start();
 
   // This server allows "workerCount" connection at a time, and reuses threads
   TThreadPoolServer server(
-    stdcxx::make_shared<CalculatorProcessorFactory>(stdcxx::make_shared<CalculatorCloneFactory>()),
-    stdcxx::make_shared<TServerSocket>(9090),
-    stdcxx::make_shared<TBufferedTransportFactory>(),
-    stdcxx::make_shared<TBinaryProtocolFactory>(),
+    std::make_shared<CalculatorProcessorFactory>(std::make_shared<CalculatorCloneFactory>()),
+    std::make_shared<TServerSocket>(9090),
+    std::make_shared<TBufferedTransportFactory>(),
+    std::make_shared<TBinaryProtocolFactory>(),
     threadManager);
   */