diff --git a/lib/cpp/src/protocol/TBinaryProtocol.cpp b/lib/cpp/src/protocol/TBinaryProtocol.cpp
index 9fb2ec3..481012c 100644
--- a/lib/cpp/src/protocol/TBinaryProtocol.cpp
+++ b/lib/cpp/src/protocol/TBinaryProtocol.cpp
@@ -4,121 +4,109 @@
 
 namespace facebook { namespace thrift { namespace protocol { 
 
-uint32_t TBinaryProtocol::writeMessageBegin(shared_ptr<TTransport> out,
-					    const std::string name,
+uint32_t TBinaryProtocol::writeMessageBegin(const std::string name,
 					    const TMessageType messageType,
-					    const int32_t seqid) const {
+					    const int32_t seqid) {
   return 
-    writeString(out, name) + 
-    writeByte(out, (int8_t)messageType) +
-    writeI32(out, seqid);
+    writeString(name) + 
+    writeByte((int8_t)messageType) +
+    writeI32(seqid);
 }
 
-uint32_t TBinaryProtocol::writeMessageEnd(shared_ptr<TTransport> out) const {
+uint32_t TBinaryProtocol::writeMessageEnd() {
   return 0;
 }
 
-uint32_t TBinaryProtocol::writeStructBegin(shared_ptr<TTransport> out,
-                                           const string& name) const {
+uint32_t TBinaryProtocol::writeStructBegin(const string& name) {
   return 0;
 }
 
-uint32_t TBinaryProtocol::writeStructEnd(shared_ptr<TTransport> out) const {
+uint32_t TBinaryProtocol::writeStructEnd() {
   return 0;
 }
 
-uint32_t TBinaryProtocol::writeFieldBegin(shared_ptr<TTransport> out,
-                                          const string& name,
+uint32_t TBinaryProtocol::writeFieldBegin(const string& name,
                                           const TType fieldType,
-                                          const int16_t fieldId) const {
+                                          const int16_t fieldId) {
   return
-    writeByte(out, (int8_t)fieldType) +
-    writeI16(out, fieldId);
+    writeByte((int8_t)fieldType) +
+    writeI16(fieldId);
 }
 
-uint32_t TBinaryProtocol::writeFieldEnd(shared_ptr<TTransport> out) const {
+uint32_t TBinaryProtocol::writeFieldEnd() {
   return 0;
 }
 
-uint32_t TBinaryProtocol::writeFieldStop(shared_ptr<TTransport> out) const {
+uint32_t TBinaryProtocol::writeFieldStop() {
   return
-    writeByte(out, (int8_t)T_STOP);
+    writeByte((int8_t)T_STOP);
 }  
                                
-uint32_t TBinaryProtocol::writeMapBegin(shared_ptr<TTransport> out,
-                                        const TType keyType,
+uint32_t TBinaryProtocol::writeMapBegin(const TType keyType,
                                         const TType valType,
-                                        const uint32_t size) const {
+                                        const uint32_t size) {
   return
-    writeByte(out, (int8_t)keyType) +
-    writeByte(out, (int8_t)valType) +
-    writeI32(out, (int32_t)size);
+    writeByte((int8_t)keyType) +
+    writeByte((int8_t)valType) +
+    writeI32((int32_t)size);
 }
 
-uint32_t TBinaryProtocol::writeMapEnd(shared_ptr<TTransport> out) const {
+uint32_t TBinaryProtocol::writeMapEnd() {
   return 0;
 }
 
-uint32_t TBinaryProtocol::writeListBegin(shared_ptr<TTransport> out,
-                                         const TType elemType,
-                                         const uint32_t size) const {
+uint32_t TBinaryProtocol::writeListBegin(const TType elemType,
+                                         const uint32_t size) {
   return
-    writeByte(out, (int8_t) elemType) +
-    writeI32(out, (int32_t)size);
+    writeByte((int8_t) elemType) +
+    writeI32((int32_t)size);
 }
 
-uint32_t TBinaryProtocol::writeListEnd(shared_ptr<TTransport> out) const {
+uint32_t TBinaryProtocol::writeListEnd() {
   return 0;
 }
 
-uint32_t TBinaryProtocol::writeSetBegin(shared_ptr<TTransport> out,
-                                        const TType elemType,
-                                        const uint32_t size) const {
+uint32_t TBinaryProtocol::writeSetBegin(const TType elemType,
+                                        const uint32_t size) {
   return
-    writeByte(out, (int8_t)elemType) +
-    writeI32(out, (int32_t)size);
+    writeByte((int8_t)elemType) +
+    writeI32((int32_t)size);
 }
 
-uint32_t TBinaryProtocol::writeSetEnd(shared_ptr<TTransport> out) const {
+uint32_t TBinaryProtocol::writeSetEnd() {
   return 0;
 }
 
-uint32_t TBinaryProtocol::writeBool(shared_ptr<TTransport> out,
-                                    const bool value) const {
+uint32_t TBinaryProtocol::writeBool(const bool value) {
   uint8_t tmp =  value ? 1 : 0;
-  out->write(&tmp, 1);
+  outputTransport_->write(&tmp, 1);
   return 1;
 }
 
-uint32_t TBinaryProtocol::writeByte(shared_ptr<TTransport> out,
-                                    const int8_t byte) const {
-  out->write((uint8_t*)&byte, 1);
+uint32_t TBinaryProtocol::writeByte(const int8_t byte) {
+  outputTransport_->write((uint8_t*)&byte, 1);
   return 1;
 }
 
-uint32_t TBinaryProtocol::writeI16(shared_ptr<TTransport> out,
-                                   const int16_t i16) const {
+uint32_t TBinaryProtocol::writeI16(const int16_t i16) {
   int16_t net = (int16_t)htons(i16);
-  out->write((uint8_t*)&net, 2);
+  outputTransport_->write((uint8_t*)&net, 2);
   return 2;
 }
 
-uint32_t TBinaryProtocol::writeI32(shared_ptr<TTransport> out,
-                                   const int32_t i32) const {
+uint32_t TBinaryProtocol::writeI32(const int32_t i32) {
   int32_t net = (int32_t)htonl(i32);
-  out->write((uint8_t*)&net, 4);
+  outputTransport_->write((uint8_t*)&net, 4);
   return 4;
 }
 
-uint32_t TBinaryProtocol::writeI64(shared_ptr<TTransport> out,
-                                   const int64_t i64) const {
+uint32_t TBinaryProtocol::writeI64(const int64_t i64) {
   int64_t net = (int64_t)htonll(i64);
-  out->write((uint8_t*)&net, 8);
+  outputTransport_->write((uint8_t*)&net, 8);
   return 8;
 }
   
-uint32_t TBinaryProtocol::writeDouble(shared_ptr<TTransport> out,
-                                      const double dub) const {
+uint32_t TBinaryProtocol::writeDouble(const double dub) {
   uint8_t b[8];
   uint8_t* d = (uint8_t*)&dub;
   b[0] = d[7];
@@ -129,15 +117,14 @@
   b[5] = d[2];
   b[6] = d[1];
   b[7] = d[0];
-  out->write((uint8_t*)b, 8);
+  outputTransport_->write((uint8_t*)b, 8);
   return 8;
 }
 
   
-uint32_t TBinaryProtocol::writeString(shared_ptr<TTransport> out,
-                                      const string& str) const {
-  uint32_t result = writeI32(out, str.size());
-  out->write((uint8_t*)str.data(), str.size());
+uint32_t TBinaryProtocol::writeString(const string& str) {
+  uint32_t result = writeI32(str.size());
+  outputTransport_->write((uint8_t*)str.data(), str.size());
   return result + str.size();
 }
 
@@ -145,159 +132,147 @@
  * Reading functions
  */
 
-uint32_t TBinaryProtocol::readMessageBegin(shared_ptr<TTransport> in,
-					   std::string& name,
+uint32_t TBinaryProtocol::readMessageBegin(std::string& name,
 					   TMessageType& messageType,
-					   int32_t& seqid) const {
+					   int32_t& seqid) {
 
   uint32_t result = 0;
   int8_t type;
-  result+= readString(in, name);
-  result+=  readByte(in, type);
+  result+= readString(name);
+  result+=  readByte(type);
   messageType = (TMessageType)type;
-  result+= readI32(in, seqid);
+  result+= readI32(seqid);
   return result;
 }
 
-uint32_t TBinaryProtocol::readMessageEnd(shared_ptr<TTransport> in)  const{
+uint32_t TBinaryProtocol::readMessageEnd() {
   return 0;
 }
 
-uint32_t TBinaryProtocol::readStructBegin(shared_ptr<TTransport> in,
-                                          string& name) const {
+uint32_t TBinaryProtocol::readStructBegin(string& name) {
   name = "";
   return 0;
 }
 
-uint32_t TBinaryProtocol::readStructEnd(shared_ptr<TTransport> in) const {
+uint32_t TBinaryProtocol::readStructEnd() {
   return 0;
 }
 
-uint32_t TBinaryProtocol::readFieldBegin(shared_ptr<TTransport> in,
-                                         string& name,
+uint32_t TBinaryProtocol::readFieldBegin(string& name,
                                          TType& fieldType,
-                                         int16_t& fieldId) const {
+                                         int16_t& fieldId) {
   uint32_t result = 0;
   int8_t type;
-  result += readByte(in, type);
+  result += readByte(type);
   fieldType = (TType)type;
   if (fieldType == T_STOP) {
     fieldId = 0;
     return result;
   }
-  result += readI16(in, fieldId);
+  result += readI16(fieldId);
   return result;
 }
   
-uint32_t TBinaryProtocol::readFieldEnd(shared_ptr<TTransport> in) const {
+uint32_t TBinaryProtocol::readFieldEnd() {
   return 0;
 }
  
-uint32_t TBinaryProtocol::readMapBegin(shared_ptr<TTransport> in,
-                                       TType& keyType,
+uint32_t TBinaryProtocol::readMapBegin(TType& keyType,
                                        TType& valType,
-                                       uint32_t& size) const {
+                                       uint32_t& size) {
   int8_t k, v;
   uint32_t result = 0;
   int32_t sizei;
-  result += readByte(in, k);
+  result += readByte(k);
   keyType = (TType)k;
-  result += readByte(in, v);
+  result += readByte(v);
   valType = (TType)v;
-  result += readI32(in, sizei);
+  result += readI32(sizei);
   // TODO(mcslee): check for negative size
   size = (uint32_t)sizei;
   return result;
 }
 
-uint32_t TBinaryProtocol::readMapEnd(shared_ptr<TTransport> in) const {
+uint32_t TBinaryProtocol::readMapEnd() {
   return 0;
 }
 
-uint32_t TBinaryProtocol::readListBegin(shared_ptr<TTransport> in,
-                                        TType& elemType,
-                                        uint32_t& size) const {
+uint32_t TBinaryProtocol::readListBegin(TType& elemType,
+                                        uint32_t& size) {
   int8_t e;
   uint32_t result = 0;
   int32_t sizei;
-  result += readByte(in, e);
+  result += readByte(e);
   elemType = (TType)e;
-  result += readI32(in, sizei);
+  result += readI32(sizei);
   // TODO(mcslee): check for negative size
   size = (uint32_t)sizei;
   return result;
 }
 
-uint32_t TBinaryProtocol::readListEnd(shared_ptr<TTransport> in) const {
+uint32_t TBinaryProtocol::readListEnd() {
   return 0;
 }
 
-uint32_t TBinaryProtocol::readSetBegin(shared_ptr<TTransport> in,
-                                       TType& elemType,
-                                       uint32_t& size) const {
+uint32_t TBinaryProtocol::readSetBegin(TType& elemType,
+                                       uint32_t& size) {
   int8_t e;
   uint32_t result = 0;
   int32_t sizei;
-  result += readByte(in, e);
+  result += readByte(e);
   elemType = (TType)e;
-  result += readI32(in, sizei);
+  result += readI32(sizei);
   // TODO(mcslee): check for negative size
   size = (uint32_t)sizei;
   return result;
 }
 
-uint32_t TBinaryProtocol::readSetEnd(shared_ptr<TTransport> in) const {
+uint32_t TBinaryProtocol::readSetEnd() {
   return 0;
 }
 
-uint32_t TBinaryProtocol::readBool(shared_ptr<TTransport> in,
-                                   bool& value) const {
+uint32_t TBinaryProtocol::readBool(bool& value) {
   uint8_t b[1];
-  in->readAll(b, 1);
+  inputTransport_->readAll(b, 1);
   value = *(int8_t*)b != 0;
   return 1;
 }
 
-uint32_t TBinaryProtocol::readByte(shared_ptr<TTransport> in,
-                                   int8_t& byte) const {
+uint32_t TBinaryProtocol::readByte(int8_t& byte) {
   uint8_t b[1];
-  in->readAll(b, 1);
+  inputTransport_->readAll(b, 1);
   byte = *(int8_t*)b;
   return 1;
 }
 
-uint32_t TBinaryProtocol::readI16(shared_ptr<TTransport> in,
-                                  int16_t& i16) const {
+uint32_t TBinaryProtocol::readI16(int16_t& i16) {
   uint8_t b[2];
-  in->readAll(b, 2);
+  inputTransport_->readAll(b, 2);
   i16 = *(int16_t*)b;
   i16 = (int16_t)ntohs(i16);
   return 2;
 }
 
-uint32_t TBinaryProtocol::readI32(shared_ptr<TTransport> in,
-                                  int32_t& i32) const {
+uint32_t TBinaryProtocol::readI32(int32_t& i32) {
   uint8_t b[4];
-  in->readAll(b, 4);
+  inputTransport_->readAll(b, 4);
   i32 = *(int32_t*)b;
   i32 = (int32_t)ntohl(i32);
   return 4;
 }
 
-uint32_t TBinaryProtocol::readI64(shared_ptr<TTransport> in,
-                                  int64_t& i64) const {
+uint32_t TBinaryProtocol::readI64(int64_t& i64) {
   uint8_t b[8];
-  in->readAll(b, 8);
+  inputTransport_->readAll(b, 8);
   i64 = *(int64_t*)b;
   i64 = (int64_t)ntohll(i64);
   return 8;
 }
 
-uint32_t TBinaryProtocol::readDouble(shared_ptr<TTransport> in,
-                                     double& dub) const {
+uint32_t TBinaryProtocol::readDouble(double& dub) {
   uint8_t b[8];
   uint8_t d[8];
-  in->readAll(b, 8);
+  inputTransport_->readAll(b, 8);
   d[0] = b[7];
   d[1] = b[6];
   d[2] = b[5];
@@ -310,17 +285,16 @@
   return 8;
 }
 
-uint32_t TBinaryProtocol::readString(shared_ptr<TTransport> in,
-                                     string& str) const {
+uint32_t TBinaryProtocol::readString(string& str) {
   uint32_t result;
   int32_t size;
-  result = readI32(in, size);
+  result = readI32(size);
 
   // TODO(mcslee): check for negative size
 
   // Use the heap here to prevent stack overflow for v. large strings
   uint8_t *b = new uint8_t[size];
-  in->readAll(b, size);
+  inputTransport_->readAll(b, size);
   str = string((char*)b, size);
   delete [] b;
 
diff --git a/lib/cpp/src/protocol/TBinaryProtocol.h b/lib/cpp/src/protocol/TBinaryProtocol.h
index 7f36a57..de9a836 100644
--- a/lib/cpp/src/protocol/TBinaryProtocol.h
+++ b/lib/cpp/src/protocol/TBinaryProtocol.h
@@ -17,139 +17,130 @@
  */
     class TBinaryProtocol : public TProtocol {
  public:
-  TBinaryProtocol() {}
+  TBinaryProtocol(shared_ptr<TTransport> in, shared_ptr<TTransport> out) :
+    TProtocol(in, out) {}
+
   ~TBinaryProtocol() {}
 
   /**
    * Writing functions.
    */
 
-  virtual uint32_t writeMessageBegin(shared_ptr<TTransport> out,
-				     const std::string name,
+  virtual uint32_t writeMessageBegin(const std::string name,
 				     const TMessageType messageType,
-				     const int32_t seqid) const;
+				     const int32_t seqid);
 
-  virtual uint32_t writeMessageEnd(shared_ptr<TTransport> out) const;
+  virtual uint32_t writeMessageEnd();
 
 
-  uint32_t writeStructBegin(shared_ptr<TTransport> out,
-			     const std::string& name) const;
+  uint32_t writeStructBegin(const std::string& name);
 
-  uint32_t writeStructEnd(shared_ptr<TTransport> out) const;
+  uint32_t writeStructEnd();
 
-  uint32_t writeFieldBegin(shared_ptr<TTransport> out,
-			    const std::string& name,
-			    const TType fieldType,
-			    const int16_t fieldId) const;
+  uint32_t writeFieldBegin(const std::string& name,
+                           const TType fieldType,
+                           const int16_t fieldId);
 
-  uint32_t writeFieldEnd(shared_ptr<TTransport> out) const;
+  uint32_t writeFieldEnd();
 
-  uint32_t writeFieldStop(shared_ptr<TTransport> out) const;
+  uint32_t writeFieldStop();
                                        
-  uint32_t writeMapBegin(shared_ptr<TTransport> out,
-			  const TType keyType,
-			  const TType valType,
-			  const uint32_t size) const;
+  uint32_t writeMapBegin(const TType keyType,
+                         const TType valType,
+                         const uint32_t size);
 
-  uint32_t writeMapEnd(shared_ptr<TTransport> out) const;
+  uint32_t writeMapEnd();
 
-  uint32_t writeListBegin(shared_ptr<TTransport> out,
-			   const TType elemType,
-			   const uint32_t size) const;
+  uint32_t writeListBegin(const TType elemType,
+                          const uint32_t size);
 
-  uint32_t writeListEnd(shared_ptr<TTransport> out) const;
+  uint32_t writeListEnd();
 
-  uint32_t writeSetBegin(shared_ptr<TTransport> out,
-			  const TType elemType,
-			  const uint32_t size) const;
+  uint32_t writeSetBegin(const TType elemType,
+                         const uint32_t size);
 
-  uint32_t writeSetEnd(shared_ptr<TTransport> out) const;
+  uint32_t writeSetEnd();
 
-  uint32_t writeBool(shared_ptr<TTransport> out,
-		      const bool value) const;
+  uint32_t writeBool(const bool value);
 
-  uint32_t writeByte(shared_ptr<TTransport> out,
-		      const int8_t byte) const;
+  uint32_t writeByte(const int8_t byte);
 
-  uint32_t writeI16(shared_ptr<TTransport> out,
-		     const int16_t i16) const;
+  uint32_t writeI16(const int16_t i16);
 
-  uint32_t writeI32(shared_ptr<TTransport> out,
-		     const int32_t i32) const;
+  uint32_t writeI32(const int32_t i32);
 
-  uint32_t writeI64(shared_ptr<TTransport> out,
-		     const int64_t i64) const;
+  uint32_t writeI64(const int64_t i64);
 
-  uint32_t writeDouble(shared_ptr<TTransport> out,
-                       const double dub) const;
+  uint32_t writeDouble(const double dub);
 
 
-  uint32_t writeString(shared_ptr<TTransport> out,
-			const std::string& str) const;
+  uint32_t writeString(const std::string& str);
 
   /**
    * Reading functions
    */
 
 
-  uint32_t readMessageBegin(shared_ptr<TTransport> in,
-			    std::string& name,
+  uint32_t readMessageBegin(std::string& name,
 			    TMessageType& messageType,
-			    int32_t& seqid) const;
+			    int32_t& seqid);
 
-  uint32_t readMessageEnd(shared_ptr<TTransport> in) const;
+  uint32_t readMessageEnd();
 
-  uint32_t readStructBegin(shared_ptr<TTransport> in,
-			    std::string& name) const;
+  uint32_t readStructBegin(std::string& name);
 
-  uint32_t readStructEnd(shared_ptr<TTransport> in) const;
+  uint32_t readStructEnd();
 
-  uint32_t readFieldBegin(shared_ptr<TTransport> in,
-			   std::string& name,
-			   TType& fieldType,
-			   int16_t& fieldId) const;
+  uint32_t readFieldBegin(std::string& name,
+			  TType& fieldType,
+			  int16_t& fieldId);
   
-  uint32_t readFieldEnd(shared_ptr<TTransport> in) const;
+  uint32_t readFieldEnd();
  
-  uint32_t readMapBegin(shared_ptr<TTransport> in,
-			 TType& keyType,
-			 TType& valType,
-			 uint32_t& size) const;
+  uint32_t readMapBegin(TType& keyType,
+			TType& valType,
+			uint32_t& size);
 
-  uint32_t readMapEnd(shared_ptr<TTransport> in) const;
+  uint32_t readMapEnd();
 
-  uint32_t readListBegin(shared_ptr<TTransport> in,
-			  TType& elemType,
-			  uint32_t& size) const;
+  uint32_t readListBegin(TType& elemType,
+                         uint32_t& size);
   
-  uint32_t readListEnd(shared_ptr<TTransport> in) const;
+  uint32_t readListEnd();
 
-  uint32_t readSetBegin(shared_ptr<TTransport> in,
-			 TType& elemType,
-			 uint32_t& size) const;
+  uint32_t readSetBegin(TType& elemType,
+			uint32_t& size);
 
-  uint32_t readSetEnd(shared_ptr<TTransport> in) const;
+  uint32_t readSetEnd();
 
-  uint32_t readBool(shared_ptr<TTransport> in,
-		      bool& value) const;
+  uint32_t readBool(bool& value);
 
-  uint32_t readByte(shared_ptr<TTransport> in,
-                    int8_t& byte) const;
+  uint32_t readByte(int8_t& byte);
 
-  uint32_t readI16(shared_ptr<TTransport> in,
-		    int16_t& i16) const;
+  uint32_t readI16(int16_t& i16);
 
-  uint32_t readI32(shared_ptr<TTransport> in,
-		    int32_t& i32) const;
+  uint32_t readI32(int32_t& i32);
 
-  uint32_t readI64(shared_ptr<TTransport> in,
-		    int64_t& i64) const;
+  uint32_t readI64(int64_t& i64);
 
-  uint32_t readDouble(shared_ptr<TTransport> in,
-                      double& dub) const;
+  uint32_t readDouble(double& dub);
 
-  uint32_t readString(shared_ptr<TTransport> in,
-		       std::string& str) const;
+  uint32_t readString(std::string& str);
+};
+
+/**
+ * Constructs binary protocol handlers
+ */
+class TBinaryProtocolFactory : public TProtocolFactory {
+ public:
+  TBinaryProtocolFactory() {}
+
+  virtual ~TBinaryProtocolFactory() {}
+
+  std::pair<boost::shared_ptr<TProtocol>, boost::shared_ptr<TProtocol> > getIOProtocols(boost::shared_ptr<TTransport> in, boost::shared_ptr<TTransport> out) {
+    boost::shared_ptr<TProtocol> prot(new TBinaryProtocol(in, out));
+    return std::make_pair(prot, prot);
+  }
 };
 
 }}} // facebook::thrift::protocol
diff --git a/lib/cpp/src/protocol/TProtocol.h b/lib/cpp/src/protocol/TProtocol.h
index 60d85dc..8077b27 100644
--- a/lib/cpp/src/protocol/TProtocol.h
+++ b/lib/cpp/src/protocol/TProtocol.h
@@ -82,170 +82,144 @@
    * Writing functions.
    */
 
-  virtual uint32_t writeMessageBegin(shared_ptr<TTransport> out,
-				     const std::string name,
+  virtual uint32_t writeMessageBegin(const std::string name,
 				     const TMessageType messageType,
-				     const int32_t seqid) const = 0;
+				     const int32_t seqid) = 0;
 
-  virtual uint32_t writeMessageEnd(shared_ptr<TTransport> out) const = 0;
+  virtual uint32_t writeMessageEnd() = 0;
 
 
-  virtual uint32_t writeStructBegin(shared_ptr<TTransport> out,
-				    const std::string& name) const = 0;
+  virtual uint32_t writeStructBegin(const std::string& name) = 0;
   
-  virtual uint32_t writeStructEnd(shared_ptr<TTransport> out) const = 0;
+  virtual uint32_t writeStructEnd() = 0;
   
-  virtual uint32_t writeFieldBegin(shared_ptr<TTransport> out,
-				   const std::string& name,
+  virtual uint32_t writeFieldBegin(const std::string& name,
 				   const TType fieldType,
-				   const int16_t fieldId) const = 0;
+				   const int16_t fieldId) = 0;
 
-  virtual uint32_t writeFieldEnd(shared_ptr<TTransport> out) const = 0;
+  virtual uint32_t writeFieldEnd() = 0;
 
-  virtual uint32_t writeFieldStop(shared_ptr<TTransport> out) const = 0;
+  virtual uint32_t writeFieldStop() = 0;
                                       
-  virtual uint32_t writeMapBegin(shared_ptr<TTransport> out,
-				 const TType keyType,
+  virtual uint32_t writeMapBegin(const TType keyType,
 				 const TType valType,
-				 const uint32_t size) const = 0;
+				 const uint32_t size) = 0;
 
-  virtual uint32_t writeMapEnd(shared_ptr<TTransport> out) const = 0;
+  virtual uint32_t writeMapEnd() = 0;
   
-  virtual uint32_t writeListBegin(shared_ptr<TTransport> out,
-				  const TType elemType,
-				  const uint32_t size) const = 0;
+  virtual uint32_t writeListBegin(const TType elemType,
+				  const uint32_t size) = 0;
 
-  virtual uint32_t writeListEnd(shared_ptr<TTransport> out) const = 0;
+  virtual uint32_t writeListEnd() = 0;
 
-  virtual uint32_t writeSetBegin(shared_ptr<TTransport> out,
-				 const TType elemType,
-				 const uint32_t size) const = 0;
+  virtual uint32_t writeSetBegin(const TType elemType,
+				 const uint32_t size) = 0;
 
-  virtual uint32_t writeSetEnd(shared_ptr<TTransport> out) const = 0;
+  virtual uint32_t writeSetEnd() = 0;
 
-  virtual uint32_t writeBool(shared_ptr<TTransport> out,
-			     const bool value) const = 0;
+  virtual uint32_t writeBool(const bool value) = 0;
 
-  virtual uint32_t writeByte(shared_ptr<TTransport> out,
-			     const int8_t byte) const = 0;
+  virtual uint32_t writeByte(const int8_t byte) = 0;
 
-  virtual uint32_t writeI16(shared_ptr<TTransport> out,
-			    const int16_t i16) const = 0;
+  virtual uint32_t writeI16(const int16_t i16) = 0;
 
-  virtual uint32_t writeI32(shared_ptr<TTransport> out,
-			    const int32_t i32) const = 0;
+  virtual uint32_t writeI32(const int32_t i32) = 0;
 
-  virtual uint32_t writeI64(shared_ptr<TTransport> out,
-			    const int64_t i64) const = 0;
+  virtual uint32_t writeI64(const int64_t i64) = 0;
 
-  virtual uint32_t writeDouble(shared_ptr<TTransport> out,
-                               const double dub) const = 0;
+  virtual uint32_t writeDouble(const double dub) = 0;
 
-  virtual uint32_t writeString(shared_ptr<TTransport> out,
-			       const std::string& str) const = 0;
+  virtual uint32_t writeString(const std::string& str) = 0;
 
   /**
    * Reading functions
    */
 
-  virtual uint32_t readMessageBegin(shared_ptr<TTransport> in,
-				    std::string& name,
+  virtual uint32_t readMessageBegin(std::string& name,
 				    TMessageType& messageType,
-				    int32_t& seqid) const = 0;
+				    int32_t& seqid) = 0;
   
-  virtual uint32_t readMessageEnd(shared_ptr<TTransport> in) const = 0;
+  virtual uint32_t readMessageEnd() = 0;
 
-  virtual uint32_t readStructBegin(shared_ptr<TTransport> in,
-				   std::string& name) const = 0;
+  virtual uint32_t readStructBegin(std::string& name) = 0;
 
-  virtual uint32_t readStructEnd(shared_ptr<TTransport> in) const = 0;
+  virtual uint32_t readStructEnd() = 0;
 
-  virtual uint32_t readFieldBegin(shared_ptr<TTransport> in,
-				  std::string& name,
+  virtual uint32_t readFieldBegin(std::string& name,
 				  TType& fieldType,
-				  int16_t& fieldId) const = 0;
+				  int16_t& fieldId) = 0;
   
-  virtual uint32_t readFieldEnd(shared_ptr<TTransport> in) const = 0;
+  virtual uint32_t readFieldEnd() = 0;
  
-  virtual uint32_t readMapBegin(shared_ptr<TTransport> in,
-				TType& keyType,
+  virtual uint32_t readMapBegin(TType& keyType,
 				TType& valType,
-				uint32_t& size) const = 0;
+				uint32_t& size) = 0;
 
-  virtual uint32_t readMapEnd(shared_ptr<TTransport> in) const = 0;
+  virtual uint32_t readMapEnd() = 0;
 
-  virtual uint32_t readListBegin(shared_ptr<TTransport> in,
-				 TType& elemType,
-				 uint32_t& size) const = 0;
+  virtual uint32_t readListBegin(TType& elemType,
+				 uint32_t& size) = 0;
 
-  virtual uint32_t readListEnd(shared_ptr<TTransport> in) const = 0;
+  virtual uint32_t readListEnd() = 0;
 
-  virtual uint32_t readSetBegin(shared_ptr<TTransport> in,
-				TType& elemType,
-				uint32_t& size) const = 0;
+  virtual uint32_t readSetBegin(TType& elemType,
+				uint32_t& size) = 0;
 
-  virtual uint32_t readSetEnd(shared_ptr<TTransport> in) const = 0;
+  virtual uint32_t readSetEnd() = 0;
 
-  virtual uint32_t readBool(shared_ptr<TTransport> in,
-			    bool& value) const = 0;
+  virtual uint32_t readBool(bool& value) = 0;
 
-  virtual uint32_t readByte(shared_ptr<TTransport> in,
-			    int8_t& byte) const = 0;
+  virtual uint32_t readByte(int8_t& byte) = 0;
 
-  virtual uint32_t readI16(shared_ptr<TTransport> in,
-			   int16_t& i16) const = 0;
+  virtual uint32_t readI16(int16_t& i16) = 0;
 
-  virtual uint32_t readI32(shared_ptr<TTransport> in,
-			   int32_t& i32) const = 0;
+  virtual uint32_t readI32(int32_t& i32) = 0;
 
-  virtual uint32_t readI64(shared_ptr<TTransport> in,
-			   int64_t& i64) const = 0;
+  virtual uint32_t readI64(int64_t& i64) = 0;
 
-  virtual uint32_t readDouble(shared_ptr<TTransport> in,
-			      double& dub) const = 0;
+  virtual uint32_t readDouble(double& dub) = 0;
 
-  virtual uint32_t readString(shared_ptr<TTransport> in,
-			      std::string& str) const = 0;
+  virtual uint32_t readString(std::string& str) = 0;
 
   /**
    * Method to arbitrarily skip over data.
    */
-  uint32_t skip(shared_ptr<TTransport> in, TType type) const {
+  uint32_t skip(TType type) {
     switch (type) {
     case T_BOOL:
       {
         bool boolv;
-        return readBool(in, boolv);
+        return readBool(boolv);
       }
     case T_BYTE:
       {
         int8_t bytev;
-        return readByte(in, bytev);
+        return readByte(bytev);
       }
     case T_I16:
       {
         int16_t i16;
-        return readI16(in, i16);
+        return readI16(i16);
       }
     case T_I32:
       {
         int32_t i32;
-        return readI32(in, i32);
+        return readI32(i32);
       }
     case T_I64:
       {
         int64_t i64;
-        return readI64(in, i64);
+        return readI64(i64);
       }
     case T_DOUBLE:
       {
         double dub;
-        return readDouble(in, dub);
+        return readDouble(dub);
       }
     case T_STRING:
       {
         std::string str;
-        return readString(in, str);
+        return readString(str);
       }
     case T_STRUCT:
       {
@@ -253,16 +227,16 @@
         std::string name;
         int16_t fid;
         TType ftype;
-        result += readStructBegin(in, name);
+        result += readStructBegin(name);
         while (true) {
-          result += readFieldBegin(in, name, ftype, fid);
+          result += readFieldBegin(name, ftype, fid);
           if (ftype == T_STOP) {
             break;
           }
-          result += skip(in, ftype);
-          result += readFieldEnd(in);
+          result += skip(ftype);
+          result += readFieldEnd();
         }
-        result += readStructEnd(in);
+        result += readStructEnd();
         return result;
       }
     case T_MAP:
@@ -271,12 +245,12 @@
         TType keyType;
         TType valType;
         uint32_t i, size;
-        result += readMapBegin(in, keyType, valType, size);
+        result += readMapBegin(keyType, valType, size);
         for (i = 0; i < size; i++) {
-          result += skip(in, keyType);
-          result += skip(in, valType);
+          result += skip(keyType);
+          result += skip(valType);
         }
-        result += readMapEnd(in);
+        result += readMapEnd();
         return result;
       }
     case T_SET:
@@ -284,11 +258,11 @@
         uint32_t result = 0;
         TType elemType;
         uint32_t i, size;
-        result += readSetBegin(in, elemType, size);
+        result += readSetBegin(elemType, size);
         for (i = 0; i < size; i++) {
-          result += skip(in, elemType);
+          result += skip(elemType);
         }
-        result += readSetEnd(in);
+        result += readSetEnd();
         return result;
       }
     case T_LIST:
@@ -296,11 +270,11 @@
         uint32_t result = 0;
         TType elemType;
         uint32_t i, size;
-        result += readListBegin(in, elemType, size);
+        result += readListBegin(elemType, size);
         for (i = 0; i < size; i++) {
-          result += skip(in, elemType);
+          result += skip(elemType);
         }
-        result += readListEnd(in);
+        result += readListEnd();
         return result;
       }
     default:
@@ -308,10 +282,39 @@
     }
   }
 
+  shared_ptr<TTransport> getInputTransport() {
+    return inputTransport_;
+  }
+
+  shared_ptr<TTransport> getOutputTransport() {
+    return outputTransport_;
+  }
+
  protected:
+  TProtocol(shared_ptr<TTransport> in, shared_ptr<TTransport> out) :
+    inputTransport_(in),
+    outputTransport_(out) {}
+    
+  shared_ptr<TTransport> inputTransport_;
+
+  shared_ptr<TTransport> outputTransport_;
+
+ private:
   TProtocol() {}
 };
 
+/**
+ * Constructs input and output protocol objects given transports.
+ */
+class TProtocolFactory {
+ public:
+  TProtocolFactory() {}
+
+  virtual ~TProtocolFactory() {}
+
+  virtual std::pair<boost::shared_ptr<TProtocol>, boost::shared_ptr<TProtocol> > getIOProtocols(boost::shared_ptr<TTransport> in, boost::shared_ptr<TTransport> out) = 0;
+};
+
 }}} // facebook::thrift::protocol
 
 #endif // #define _THRIFT_PROTOCOL_TPROTOCOL_H_ 1