lib/d/src/thrift/codegen/client.d - packaging/sources/thrift - Gitiles

 /*
  * 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.
  */
 module thrift.codegen.client;

 import std.algorithm : find;
 import std.array : empty, front;
 import std.conv : to;
 import std.traits : isSomeFunction, ParameterStorageClass,
   ParameterStorageClassTuple, ParameterTypeTuple, ReturnType;
 import thrift.codegen.base;
 import thrift.internal.codegen;
 import thrift.internal.ctfe;
 import thrift.protocol.base;

 /**
  * Thrift service client, which implements an interface by synchronously
  * calling a server over a TProtocol.
  *
  * TClientBase simply extends Interface with generic input/output protocol
  * properties to serve as a supertype for all TClients for the same service,
  * which might be instantiated with different concrete protocol types (there
  * is no covariance for template type parameters). If Interface is derived
  * from another interface BaseInterface, it also extends
  * TClientBase!BaseInterface.
  *
  * TClient is the class that actually implements TClientBase. Just as
  * TClientBase, it is also derived from TClient!BaseInterface for inheriting
  * services.
  *
  * TClient takes two optional template arguments which can be used for
  * specifying the actual TProtocol implementation used for optimization
  * purposes, as virtual calls can completely be eliminated then. If
  * OutputProtocol is not specified, it is assumed to be the same as
  * InputProtocol. The protocol properties defined by TClientBase are exposed
  * with their concrete type (return type covariance).
  *
  * In addition to implementing TClientBase!Interface, TClient offers the
  * following constructors:
  * ---
  * this(InputProtocol iprot, OutputProtocol oprot);
  * // Only if is(InputProtocol == OutputProtocol), to use the same protocol
  * // for both input and output:
  * this(InputProtocol prot);
  * ---
  *
  * The sequence id of the method calls starts at zero and is automatically
  * incremented.
  */
 interface TClientBase(Interface) if (isBaseService!Interface) : Interface {
   /**
    * The input protocol used by the client.
    */
   TProtocol inputProtocol() @property;

   /**
    * The output protocol used by the client.
    */
   TProtocol outputProtocol() @property;
 }

 /// Ditto
 interface TClientBase(Interface) if (isDerivedService!Interface) :
   TClientBase!(BaseService!Interface), Interface {}

 /// Ditto
 template TClient(Interface, InputProtocol = TProtocol, OutputProtocol = void) if (
   isService!Interface && isTProtocol!InputProtocol &&
   (isTProtocol!OutputProtocol || is(OutputProtocol == void))
 ) {
   mixin({
     static if (isDerivedService!Interface) {
       string code = "class TClient : TClient!(BaseService!Interface, " ~
         "InputProtocol, OutputProtocol), TClientBase!Interface {\n";
       code ~= q{
         this(IProt iprot, OProt oprot) {
           super(iprot, oprot);
         }

         static if (is(IProt == OProt)) {
           this(IProt prot) {
             super(prot);
           }
         }

         // DMD @@BUG@@: If these are not present in this class (would be)
         // inherited anyway, »not implemented« errors are raised.
         override IProt inputProtocol() @property {
           return super.inputProtocol;
         }
         override OProt outputProtocol() @property {
           return super.outputProtocol;
         }
       };
     } else {
       string code = "class TClient : TClientBase!Interface {";
       code ~= q{
         alias InputProtocol IProt;
         static if (isTProtocol!OutputProtocol) {
           alias OutputProtocol OProt;
         } else {
           static assert(is(OutputProtocol == void));
           alias InputProtocol OProt;
         }

         this(IProt iprot, OProt oprot) {
           iprot_ = iprot;
           oprot_ = oprot;
         }

         static if (is(IProt == OProt)) {
           this(IProt prot) {
             this(prot, prot);
           }
         }

         IProt inputProtocol() @property {
           return iprot_;
         }

         OProt outputProtocol() @property {
           return oprot_;
         }

         protected IProt iprot_;
         protected OProt oprot_;
         protected int seqid_;
       };
     }

     foreach (methodName; __traits(derivedMembers, Interface)) {
       static if (isSomeFunction!(mixin("Interface." ~ methodName))) {
         bool methodMetaFound;
         TMethodMeta methodMeta;
         static if (is(typeof(Interface.methodMeta) : TMethodMeta[])) {
           enum meta = find!`a.name == b`(Interface.methodMeta, methodName);
           if (!meta.empty) {
             methodMetaFound = true;
             methodMeta = meta.front;
           }
         }

         // Generate the code for sending.
         string[] paramList;
         string paramAssignCode;
         foreach (i, _; ParameterTypeTuple!(mixin("Interface." ~ methodName))) {
           // Use the param name speficied in the meta information if any –
           // just cosmetics in this case.
           string paramName;
           if (methodMetaFound && i < methodMeta.params.length) {
             paramName = methodMeta.params[i].name;
           } else {
             paramName = "param" ~ to!string(i + 1);
           }

           immutable storage = ParameterStorageClassTuple!(
             mixin("Interface." ~ methodName))[i];
           paramList ~= ((storage & ParameterStorageClass.ref_) ? "ref " : "") ~
             "ParameterTypeTuple!(Interface." ~ methodName ~ ")[" ~
             to!string(i) ~ "] " ~ paramName;
           paramAssignCode ~= "args." ~ paramName ~ " = &" ~ paramName ~ ";\n";
         }
         code ~= "ReturnType!(Interface." ~ methodName ~ ") " ~ methodName ~
           "(" ~ ctfeJoin(paramList) ~ ") {\n";

         code ~= "immutable methodName = `" ~ methodName ~ "`;\n";

         immutable paramStructType =
           "TPargsStruct!(Interface, `" ~ methodName ~ "`)";
         code ~= paramStructType ~ " args = " ~ paramStructType ~ "();\n";
         code ~= paramAssignCode;
         code ~= "oprot_.writeMessageBegin(TMessage(`" ~ methodName ~ "`, ";
         code ~= ((methodMetaFound && methodMeta.type == TMethodType.ONEWAY)
                  ? "TMessageType.ONEWAY" : "TMessageType.CALL");
         code ~= ", ++seqid_));\n";
         code ~= "args.write(oprot_);\n";
         code ~= "oprot_.writeMessageEnd();\n";
         code ~= "oprot_.transport.flush();\n";

         // If this is not a oneway method, generate the receiving code.
         if (!methodMetaFound || methodMeta.type != TMethodType.ONEWAY) {
           code ~= "TPresultStruct!(Interface, `" ~ methodName ~ "`) result;\n";

           if (!is(ReturnType!(mixin("Interface." ~ methodName)) == void)) {
             code ~= "ReturnType!(Interface." ~ methodName ~ ") _return;\n";
             code ~= "result.success = &_return;\n";
           }

           // TODO: The C++ implementation checks for matching method name here,
           // should we do as well?
           code ~= q{
             auto msg = iprot_.readMessageBegin();
             scope (exit) {
               iprot_.readMessageEnd();
               iprot_.transport.readEnd();
             }

             if (msg.type == TMessageType.EXCEPTION) {
               auto x = new TApplicationException(null);
               x.read(iprot_);
               iprot_.transport.readEnd();
               throw x;
             }
             if (msg.type != TMessageType.REPLY) {
               skip(iprot_, TType.STRUCT);
               iprot_.transport.readEnd();
             }
             if (msg.seqid != seqid_) {
               throw new TApplicationException(
                 methodName ~ " failed: Out of sequence response.",
                 TApplicationException.Type.BAD_SEQUENCE_ID
               );
             }
             result.read(iprot_);
           };

           if (methodMetaFound) {
             foreach (e; methodMeta.exceptions) {
               code ~= "if (result.isSet!`" ~ e.name ~ "`) throw result." ~
                 e.name ~ ";\n";
             }
           }

           if (!is(ReturnType!(mixin("Interface." ~ methodName)) == void)) {
             code ~= q{
               if (result.isSet!`success`) return _return;
               throw new TApplicationException(
                 methodName ~ " failed: Unknown result.",
                 TApplicationException.Type.MISSING_RESULT
               );
             };
           }
         }
         code ~= "}\n";
       }
     }

     code ~= "}\n";
     return code;
   }());
 }

 /**
  * TClient construction helper to avoid having to explicitly specify
  * the protocol types, i.e. to allow the constructor being called using IFTI
  * (see $(DMDBUG 6082, D Bugzilla enhancement requet 6082)).
  */
 TClient!(Interface, Prot) tClient(Interface, Prot)(Prot prot) if (
   isService!Interface && isTProtocol!Prot
 ) {
   return new TClient!(Interface, Prot)(prot);
 }

 /// Ditto
 TClient!(Interface, IProt, Oprot) tClient(Interface, IProt, OProt)
   (IProt iprot, OProt oprot) if (
   isService!Interface && isTProtocol!IProt && isTProtocol!OProt
 ) {
   return new TClient!(Interface, IProt, OProt)(iprot, oprot);
 }

 /**
  * Represents the arguments of a Thrift method call, as pointers to the (const)
  * parameter type to avoid copying.
  *
  * There should usually be no reason to use this struct directly without the
  * help of TClient, but it is documented publicly to help debugging in case
  * of CTFE errors.
  *
  * Consider this example:
  * ---
  * interface Foo {
  *   int bar(string a, bool b);
  *
  *   enum methodMeta = [
  *     TMethodMeta("bar", [TParamMeta("a", 1), TParamMeta("b", 2)])
  *   ];
  * }
  *
  * alias TPargsStruct!(Foo, "bar") FooBarPargs;
  * ---
  *
  * The definition of FooBarPargs is equivalent to (ignoring the necessary
  * metadata to assign the field IDs):
  * ---
  * struct FooBarPargs {
  *   const(string)* a;
  *   const(bool)* b;
  *
  *   void write(Protocol)(Protocol proto) const if (isTProtocol!Protocol);
  * }
  * ---
  */
 template TPargsStruct(Interface, string methodName) {
   static assert(is(typeof(mixin("Interface." ~ methodName))),
     "Could not find method '" ~ methodName ~ "' in '" ~ Interface.stringof ~ "'.");
   mixin({
     bool methodMetaFound;
     TMethodMeta methodMeta;
     static if (is(typeof(Interface.methodMeta) : TMethodMeta[])) {
       auto meta = find!`a.name == b`(Interface.methodMeta, methodName);
       if (!meta.empty) {
         methodMetaFound = true;
         methodMeta = meta.front;
       }
     }

     string memberCode;
     string[] fieldMetaCodes;
     foreach (i, _; ParameterTypeTuple!(mixin("Interface." ~ methodName))) {
       // If we have no meta information, just use param1, param2, etc. as
       // field names, it shouldn't really matter anyway. 1-based »indexing«
       // is used to match the common scheme in the Thrift world.
       string memberId;
       string memberName;
       if (methodMetaFound && i < methodMeta.params.length) {
         memberId = to!string(methodMeta.params[i].id);
         memberName = methodMeta.params[i].name;
       } else {
         memberId = to!string(i + 1);
         memberName = "param" ~ to!string(i + 1);
       }

       // Workaround for DMD @@BUG@@ 6056: make an intermediary alias for the
       // parameter type, and declare the member using const(memberNameType)*.
       memberCode ~= "alias ParameterTypeTuple!(Interface." ~ methodName ~
         ")[" ~ to!string(i) ~ "] " ~ memberName ~ "Type;\n";
       memberCode ~= "const(" ~ memberName ~ "Type)* " ~ memberName ~ ";\n";

       fieldMetaCodes ~= "TFieldMeta(`" ~ memberName ~ "`, " ~ memberId ~
         ", TReq.OPT_IN_REQ_OUT)";
     }

     string code = "struct TPargsStruct {\n";
     code ~= memberCode;
     version (TVerboseCodegen) {
       if (!methodMetaFound &&
         ParameterTypeTuple!(mixin("Interface." ~ methodName)).length > 0)
       {
         code ~= "pragma(msg, `[thrift.codegen.base.TPargsStruct] Warning: No " ~
           "meta information for method '" ~ methodName ~ "' in service '" ~
           Interface.stringof ~ "' found.`);\n";
       }
     }
     code ~= "void write(P)(P proto) const if (isTProtocol!P) {\n";
     code ~= "writeStruct!(typeof(this), P, [" ~ ctfeJoin(fieldMetaCodes) ~
       "], true)(this, proto);\n";
     code ~= "}\n";
     code ~= "}\n";
     return code;
   }());
 }

 /**
  * Represents the result of a Thrift method call, using a pointer to the return
  * value to avoid copying.
  *
  * There should usually be no reason to use this struct directly without the
  * help of TClient, but it is documented publicly to help debugging in case
  * of CTFE errors.
  *
  * Consider this example:
  * ---
  * interface Foo {
  *   int bar(string a);
  *
  *   alias .FooException FooException;
  *
  *   enum methodMeta = [
  *     TMethodMeta("bar",
  *       [TParamMeta("a", 1)],
  *       [TExceptionMeta("fooe", 1, "FooException")]
  *     )
  *   ];
  * }
  * alias TPresultStruct!(Foo, "bar") FooBarPresult;
  * ---
  *
  * The definition of FooBarPresult is equivalent to (ignoring the necessary
  * metadata to assign the field IDs):
  * ---
  * struct FooBarPresult {
  *   int* success;
  *   Foo.FooException fooe;
  *
  *   struct IsSetFlags {
  *     bool success;
  *   }
  *   IsSetFlags isSetFlags;
  *
  *   bool isSet(string fieldName)() const @property;
  *   void read(Protocol)(Protocol proto) if (isTProtocol!Protocol);
  * }
  * ---
  */
 template TPresultStruct(Interface, string methodName) {
   static assert(is(typeof(mixin("Interface." ~ methodName))),
     "Could not find method '" ~ methodName ~ "' in '" ~ Interface.stringof ~ "'.");

   mixin({
     string code = "struct TPresultStruct {\n";

     string[] fieldMetaCodes;

     alias ReturnType!(mixin("Interface." ~ methodName)) ResultType;
     static if (!is(ResultType == void)) {
       code ~= q{
         ReturnType!(mixin("Interface." ~ methodName))* success;
       };
       fieldMetaCodes ~= "TFieldMeta(`success`, 0, TReq.OPTIONAL)";

       static if (!isNullable!ResultType) {
         code ~= q{
           struct IsSetFlags {
             bool success;
           }
           IsSetFlags isSetFlags;
         };
         fieldMetaCodes ~= "TFieldMeta(`isSetFlags`, 0, TReq.IGNORE)";
       }
     }

     bool methodMetaFound;
     static if (is(typeof(Interface.methodMeta) : TMethodMeta[])) {
       auto meta = find!`a.name == b`(Interface.methodMeta, methodName);
       if (!meta.empty) {
         foreach (e; meta.front.exceptions) {
           code ~= "Interface." ~ e.type ~ " " ~ e.name ~ ";\n";
           fieldMetaCodes ~= "TFieldMeta(`" ~ e.name ~ "`, " ~ to!string(e.id) ~
             ", TReq.OPTIONAL)";
         }
         methodMetaFound = true;
       }
     }

     version (TVerboseCodegen) {
       if (!methodMetaFound &&
         ParameterTypeTuple!(mixin("Interface." ~ methodName)).length > 0)
       {
         code ~= "pragma(msg, `[thrift.codegen.base.TPresultStruct] Warning: No " ~
           "meta information for method '" ~ methodName ~ "' in service '" ~
           Interface.stringof ~ "' found.`);\n";
       }
     }

     code ~= q{
       bool isSet(string fieldName)() const @property if (
         is(MemberType!(typeof(this), fieldName))
       ) {
         static if (fieldName == "success") {
           static if (isNullable!(typeof(*success))) {
             return *success !is null;
           } else {
             return isSetFlags.success;
           }
         } else {
           // We are dealing with an exception member, which, being a nullable
           // type (exceptions are always classes), has no isSet flag.
           return __traits(getMember, this, fieldName) !is null;
         }
       }
     };

     code ~= "void read(P)(P proto) if (isTProtocol!P) {\n";
     code ~= "readStruct!(typeof(this), P, [" ~ ctfeJoin(fieldMetaCodes) ~
       "], true)(this, proto);\n";
     code ~= "}\n";
     code ~= "}\n";
     return code;
   }());
 }
	/*
	* 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.
	*/
	module thrift.codegen.client;

	import std.algorithm : find;
	import std.array : empty, front;
	import std.conv : to;
	import std.traits : isSomeFunction, ParameterStorageClass,
	ParameterStorageClassTuple, ParameterTypeTuple, ReturnType;
	import thrift.codegen.base;
	import thrift.internal.codegen;
	import thrift.internal.ctfe;
	import thrift.protocol.base;

	/**
	* Thrift service client, which implements an interface by synchronously
	* calling a server over a TProtocol.
	*
	* TClientBase simply extends Interface with generic input/output protocol
	* properties to serve as a supertype for all TClients for the same service,
	* which might be instantiated with different concrete protocol types (there
	* is no covariance for template type parameters). If Interface is derived
	* from another interface BaseInterface, it also extends
	* TClientBase!BaseInterface.
	*
	* TClient is the class that actually implements TClientBase. Just as
	* TClientBase, it is also derived from TClient!BaseInterface for inheriting
	* services.
	*
	* TClient takes two optional template arguments which can be used for
	* specifying the actual TProtocol implementation used for optimization
	* purposes, as virtual calls can completely be eliminated then. If
	* OutputProtocol is not specified, it is assumed to be the same as
	* InputProtocol. The protocol properties defined by TClientBase are exposed
	* with their concrete type (return type covariance).
	*
	* In addition to implementing TClientBase!Interface, TClient offers the
	* following constructors:
	* ---
	* this(InputProtocol iprot, OutputProtocol oprot);
	* // Only if is(InputProtocol == OutputProtocol), to use the same protocol
	* // for both input and output:
	* this(InputProtocol prot);
	* ---
	*
	* The sequence id of the method calls starts at zero and is automatically
	* incremented.
	*/
	interface TClientBase(Interface) if (isBaseService!Interface) : Interface {
	/**
	* The input protocol used by the client.
	*/
	TProtocol inputProtocol() @property;

	/**
	* The output protocol used by the client.
	*/
	TProtocol outputProtocol() @property;
	}

	/// Ditto
	interface TClientBase(Interface) if (isDerivedService!Interface) :
	TClientBase!(BaseService!Interface), Interface {}

	/// Ditto
	template TClient(Interface, InputProtocol = TProtocol, OutputProtocol = void) if (
	isService!Interface && isTProtocol!InputProtocol &&
	(isTProtocol!OutputProtocol \|\| is(OutputProtocol == void))
	) {
	mixin({
	static if (isDerivedService!Interface) {
	string code = "class TClient : TClient!(BaseService!Interface, " ~
	"InputProtocol, OutputProtocol), TClientBase!Interface {\n";
	code ~= q{
	this(IProt iprot, OProt oprot) {
	super(iprot, oprot);
	}

	static if (is(IProt == OProt)) {
	this(IProt prot) {
	super(prot);
	}
	}

	// DMD @@BUG@@: If these are not present in this class (would be)
	// inherited anyway, »not implemented« errors are raised.
	override IProt inputProtocol() @property {
	return super.inputProtocol;
	}
	override OProt outputProtocol() @property {
	return super.outputProtocol;
	}
	};
	} else {
	string code = "class TClient : TClientBase!Interface {";
	code ~= q{
	alias InputProtocol IProt;
	static if (isTProtocol!OutputProtocol) {
	alias OutputProtocol OProt;
	} else {
	static assert(is(OutputProtocol == void));
	alias InputProtocol OProt;
	}

	this(IProt iprot, OProt oprot) {
	iprot_ = iprot;
	oprot_ = oprot;
	}

	static if (is(IProt == OProt)) {
	this(IProt prot) {
	this(prot, prot);
	}
	}

	IProt inputProtocol() @property {
	return iprot_;
	}

	OProt outputProtocol() @property {
	return oprot_;
	}

	protected IProt iprot_;
	protected OProt oprot_;
	protected int seqid_;
	};
	}

	foreach (methodName; __traits(derivedMembers, Interface)) {
	static if (isSomeFunction!(mixin("Interface." ~ methodName))) {
	bool methodMetaFound;
	TMethodMeta methodMeta;
	static if (is(typeof(Interface.methodMeta) : TMethodMeta[])) {
	enum meta = find!`a.name == b`(Interface.methodMeta, methodName);
	if (!meta.empty) {
	methodMetaFound = true;
	methodMeta = meta.front;
	}
	}

	// Generate the code for sending.
	string[] paramList;
	string paramAssignCode;
	foreach (i, _; ParameterTypeTuple!(mixin("Interface." ~ methodName))) {
	// Use the param name speficied in the meta information if any –
	// just cosmetics in this case.
	string paramName;
	if (methodMetaFound && i < methodMeta.params.length) {
	paramName = methodMeta.params[i].name;
	} else {
	paramName = "param" ~ to!string(i + 1);
	}

	immutable storage = ParameterStorageClassTuple!(
	mixin("Interface." ~ methodName))[i];
	paramList ~= ((storage & ParameterStorageClass.ref_) ? "ref " : "") ~
	"ParameterTypeTuple!(Interface." ~ methodName ~ ")[" ~
	to!string(i) ~ "] " ~ paramName;
	paramAssignCode ~= "args." ~ paramName ~ " = &" ~ paramName ~ ";\n";
	}
	code ~= "ReturnType!(Interface." ~ methodName ~ ") " ~ methodName ~
	"(" ~ ctfeJoin(paramList) ~ ") {\n";

	code ~= "immutable methodName = `" ~ methodName ~ "`;\n";

	immutable paramStructType =
	"TPargsStruct!(Interface, `" ~ methodName ~ "`)";
	code ~= paramStructType ~ " args = " ~ paramStructType ~ "();\n";
	code ~= paramAssignCode;
	code ~= "oprot_.writeMessageBegin(TMessage(`" ~ methodName ~ "`, ";
	code ~= ((methodMetaFound && methodMeta.type == TMethodType.ONEWAY)
	? "TMessageType.ONEWAY" : "TMessageType.CALL");
	code ~= ", ++seqid_));\n";
	code ~= "args.write(oprot_);\n";
	code ~= "oprot_.writeMessageEnd();\n";
	code ~= "oprot_.transport.flush();\n";

	// If this is not a oneway method, generate the receiving code.
	if (!methodMetaFound \|\| methodMeta.type != TMethodType.ONEWAY) {
	code ~= "TPresultStruct!(Interface, `" ~ methodName ~ "`) result;\n";

	if (!is(ReturnType!(mixin("Interface." ~ methodName)) == void)) {
	code ~= "ReturnType!(Interface." ~ methodName ~ ") _return;\n";
	code ~= "result.success = &_return;\n";
	}

	// TODO: The C++ implementation checks for matching method name here,
	// should we do as well?
	code ~= q{
	auto msg = iprot_.readMessageBegin();
	scope (exit) {
	iprot_.readMessageEnd();
	iprot_.transport.readEnd();
	}

	if (msg.type == TMessageType.EXCEPTION) {
	auto x = new TApplicationException(null);
	x.read(iprot_);
	iprot_.transport.readEnd();
	throw x;
	}
	if (msg.type != TMessageType.REPLY) {
	skip(iprot_, TType.STRUCT);
	iprot_.transport.readEnd();
	}
	if (msg.seqid != seqid_) {
	throw new TApplicationException(
	methodName ~ " failed: Out of sequence response.",
	TApplicationException.Type.BAD_SEQUENCE_ID
	);
	}
	result.read(iprot_);
	};

	if (methodMetaFound) {
	foreach (e; methodMeta.exceptions) {
	code ~= "if (result.isSet!`" ~ e.name ~ "`) throw result." ~
	e.name ~ ";\n";
	}
	}

	if (!is(ReturnType!(mixin("Interface." ~ methodName)) == void)) {
	code ~= q{
	if (result.isSet!`success`) return _return;
	throw new TApplicationException(
	methodName ~ " failed: Unknown result.",
	TApplicationException.Type.MISSING_RESULT
	);
	};
	}
	}
	code ~= "}\n";
	}
	}

	code ~= "}\n";
	return code;
	}());
	}

	/**
	* TClient construction helper to avoid having to explicitly specify
	* the protocol types, i.e. to allow the constructor being called using IFTI
	* (see $(DMDBUG 6082, D Bugzilla enhancement requet 6082)).
	*/
	TClient!(Interface, Prot) tClient(Interface, Prot)(Prot prot) if (
	isService!Interface && isTProtocol!Prot
	) {
	return new TClient!(Interface, Prot)(prot);
	}

	/// Ditto
	TClient!(Interface, IProt, Oprot) tClient(Interface, IProt, OProt)
	(IProt iprot, OProt oprot) if (
	isService!Interface && isTProtocol!IProt && isTProtocol!OProt
	) {
	return new TClient!(Interface, IProt, OProt)(iprot, oprot);
	}

	/**
	* Represents the arguments of a Thrift method call, as pointers to the (const)
	* parameter type to avoid copying.
	*
	* There should usually be no reason to use this struct directly without the
	* help of TClient, but it is documented publicly to help debugging in case
	* of CTFE errors.
	*
	* Consider this example:
	* ---
	* interface Foo {
	* int bar(string a, bool b);
	*
	* enum methodMeta = [
	* TMethodMeta("bar", [TParamMeta("a", 1), TParamMeta("b", 2)])
	* ];
	* }
	*
	* alias TPargsStruct!(Foo, "bar") FooBarPargs;
	* ---
	*
	* The definition of FooBarPargs is equivalent to (ignoring the necessary
	* metadata to assign the field IDs):
	* ---
	* struct FooBarPargs {
	* const(string)* a;
	* const(bool)* b;
	*
	* void write(Protocol)(Protocol proto) const if (isTProtocol!Protocol);
	* }
	* ---
	*/
	template TPargsStruct(Interface, string methodName) {
	static assert(is(typeof(mixin("Interface." ~ methodName))),
	"Could not find method '" ~ methodName ~ "' in '" ~ Interface.stringof ~ "'.");
	mixin({
	bool methodMetaFound;
	TMethodMeta methodMeta;
	static if (is(typeof(Interface.methodMeta) : TMethodMeta[])) {
	auto meta = find!`a.name == b`(Interface.methodMeta, methodName);
	if (!meta.empty) {
	methodMetaFound = true;
	methodMeta = meta.front;
	}
	}

	string memberCode;
	string[] fieldMetaCodes;
	foreach (i, _; ParameterTypeTuple!(mixin("Interface." ~ methodName))) {
	// If we have no meta information, just use param1, param2, etc. as
	// field names, it shouldn't really matter anyway. 1-based »indexing«
	// is used to match the common scheme in the Thrift world.
	string memberId;
	string memberName;
	if (methodMetaFound && i < methodMeta.params.length) {
	memberId = to!string(methodMeta.params[i].id);
	memberName = methodMeta.params[i].name;
	} else {
	memberId = to!string(i + 1);
	memberName = "param" ~ to!string(i + 1);
	}

	// Workaround for DMD @@BUG@@ 6056: make an intermediary alias for the
	// parameter type, and declare the member using const(memberNameType)*.
	memberCode ~= "alias ParameterTypeTuple!(Interface." ~ methodName ~
	")[" ~ to!string(i) ~ "] " ~ memberName ~ "Type;\n";
	memberCode ~= "const(" ~ memberName ~ "Type)* " ~ memberName ~ ";\n";

	fieldMetaCodes ~= "TFieldMeta(`" ~ memberName ~ "`, " ~ memberId ~
	", TReq.OPT_IN_REQ_OUT)";
	}

	string code = "struct TPargsStruct {\n";
	code ~= memberCode;
	version (TVerboseCodegen) {
	if (!methodMetaFound &&
	ParameterTypeTuple!(mixin("Interface." ~ methodName)).length > 0)
	{
	code ~= "pragma(msg, `[thrift.codegen.base.TPargsStruct] Warning: No " ~
	"meta information for method '" ~ methodName ~ "' in service '" ~
	Interface.stringof ~ "' found.`);\n";
	}
	}
	code ~= "void write(P)(P proto) const if (isTProtocol!P) {\n";
	code ~= "writeStruct!(typeof(this), P, [" ~ ctfeJoin(fieldMetaCodes) ~
	"], true)(this, proto);\n";
	code ~= "}\n";
	code ~= "}\n";
	return code;
	}());
	}

	/**
	* Represents the result of a Thrift method call, using a pointer to the return
	* value to avoid copying.
	*
	* There should usually be no reason to use this struct directly without the
	* help of TClient, but it is documented publicly to help debugging in case
	* of CTFE errors.
	*
	* Consider this example:
	* ---
	* interface Foo {
	* int bar(string a);
	*
	* alias .FooException FooException;
	*
	* enum methodMeta = [
	* TMethodMeta("bar",
	* [TParamMeta("a", 1)],
	* [TExceptionMeta("fooe", 1, "FooException")]
	* )
	* ];
	* }
	* alias TPresultStruct!(Foo, "bar") FooBarPresult;
	* ---
	*
	* The definition of FooBarPresult is equivalent to (ignoring the necessary
	* metadata to assign the field IDs):
	* ---
	* struct FooBarPresult {
	* int* success;
	* Foo.FooException fooe;
	*
	* struct IsSetFlags {
	* bool success;
	* }
	* IsSetFlags isSetFlags;
	*
	* bool isSet(string fieldName)() const @property;
	* void read(Protocol)(Protocol proto) if (isTProtocol!Protocol);
	* }
	* ---
	*/
	template TPresultStruct(Interface, string methodName) {
	static assert(is(typeof(mixin("Interface." ~ methodName))),
	"Could not find method '" ~ methodName ~ "' in '" ~ Interface.stringof ~ "'.");

	mixin({
	string code = "struct TPresultStruct {\n";

	string[] fieldMetaCodes;

	alias ReturnType!(mixin("Interface." ~ methodName)) ResultType;
	static if (!is(ResultType == void)) {
	code ~= q{
	ReturnType!(mixin("Interface." ~ methodName))* success;
	};
	fieldMetaCodes ~= "TFieldMeta(`success`, 0, TReq.OPTIONAL)";

	static if (!isNullable!ResultType) {
	code ~= q{
	struct IsSetFlags {
	bool success;
	}
	IsSetFlags isSetFlags;
	};
	fieldMetaCodes ~= "TFieldMeta(`isSetFlags`, 0, TReq.IGNORE)";
	}
	}

	bool methodMetaFound;
	static if (is(typeof(Interface.methodMeta) : TMethodMeta[])) {
	auto meta = find!`a.name == b`(Interface.methodMeta, methodName);
	if (!meta.empty) {
	foreach (e; meta.front.exceptions) {
	code ~= "Interface." ~ e.type ~ " " ~ e.name ~ ";\n";
	fieldMetaCodes ~= "TFieldMeta(`" ~ e.name ~ "`, " ~ to!string(e.id) ~
	", TReq.OPTIONAL)";
	}
	methodMetaFound = true;
	}
	}

	version (TVerboseCodegen) {
	if (!methodMetaFound &&
	ParameterTypeTuple!(mixin("Interface." ~ methodName)).length > 0)
	{
	code ~= "pragma(msg, `[thrift.codegen.base.TPresultStruct] Warning: No " ~
	"meta information for method '" ~ methodName ~ "' in service '" ~
	Interface.stringof ~ "' found.`);\n";
	}
	}

	code ~= q{
	bool isSet(string fieldName)() const @property if (
	is(MemberType!(typeof(this), fieldName))
	) {
	static if (fieldName == "success") {
	static if (isNullable!(typeof(*success))) {
	return *success !is null;
	} else {
	return isSetFlags.success;
	}
	} else {
	// We are dealing with an exception member, which, being a nullable
	// type (exceptions are always classes), has no isSet flag.
	return __traits(getMember, this, fieldName) !is null;
	}
	}
	};

	code ~= "void read(P)(P proto) if (isTProtocol!P) {\n";
	code ~= "readStruct!(typeof(this), P, [" ~ ctfeJoin(fieldMetaCodes) ~
	"], true)(this, proto);\n";
	code ~= "}\n";
	code ~= "}\n";
	return code;
	}());
	}